pax_global_header00006660000000000000000000000064141013364040014506gustar00rootroot0000000000000052 comment=a0d6102ee789a3f9301fcd6249dbaca6856a7223 executing-0.8.0/000077500000000000000000000000001410133640400135065ustar00rootroot00000000000000executing-0.8.0/.github/000077500000000000000000000000001410133640400150465ustar00rootroot00000000000000executing-0.8.0/.github/workflows/000077500000000000000000000000001410133640400171035ustar00rootroot00000000000000executing-0.8.0/.github/workflows/test.yml000066400000000000000000000023431410133640400206070ustar00rootroot00000000000000name: Tests on: [push] jobs: test: runs-on: ubuntu-latest strategy: matrix: python-version: [2.7, 3.5, 3.6, 3.7, 3.8, 3.9, 3.10-dev, pypy2, pypy-3.6] steps: - uses: actions/checkout@v2 - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@v2 with: python-version: ${{ matrix.python-version }} - name: Install dependencies run: | python --version pip install -U pip pip install --upgrade coveralls asttokens pytest setuptools setuptools_scm pep517 pip install . - name: Test env: EXECUTING_SLOW_TESTS: 1 run: | coverage run --include=executing/executing.py -m unittest tests.test_main coverage run --include=executing/executing.py --append -m pytest tests/test_pytest.py coverage report -m - name: Coveralls Python uses: AndreMiras/coveralls-python-action@v20201129 with: parallel: true flag-name: test-${{ matrix.python-version }} coveralls_finish: needs: test runs-on: ubuntu-latest steps: - name: Coveralls Finished uses: AndreMiras/coveralls-python-action@v20201129 with: parallel-finished: true executing-0.8.0/.gitignore000066400000000000000000000024161410133640400155010ustar00rootroot00000000000000/executing/version.py # Created by .ignore support plugin (hsz.mobi) ### Python template # Byte-compiled / optimized / DLL files __pycache__/ *.py[cod] *$py.class # C extensions *.so # Distribution / packaging .Python build/ develop-eggs/ dist/ downloads/ eggs/ .eggs/ lib/ lib64/ parts/ sdist/ var/ wheels/ *.egg-info/ .installed.cfg *.egg MANIFEST # PyInstaller # Usually these files are written by a python script from a template # before PyInstaller builds the exe, so as to inject date/other infos into it. *.manifest *.spec # Installer logs pip-log.txt pip-delete-this-directory.txt # Unit test / coverage reports htmlcov/ .tox/ .coverage .coverage.* .cache nosetests.xml coverage.xml *.cover .hypothesis/ # Translations *.mo *.pot # Django stuff: *.log .static_storage/ .media/ local_settings.py # Flask stuff: instance/ .webassets-cache # Scrapy stuff: .scrapy # Sphinx documentation docs/_build/ # PyBuilder target/ # Jupyter Notebook .ipynb_checkpoints # pyenv .python-version # celery beat schedule file celerybeat-schedule # SageMath parsed files *.sage.py # Environments .env .venv env/ venv*/ ENV/ env.bak/ venv.bak/ # Spyder project settings .spyderproject .spyproject # Rope project settings .ropeproject # mkdocs documentation /site # mypy .mypy_cache/ executing-0.8.0/LICENSE.txt000066400000000000000000000020521410133640400153300ustar00rootroot00000000000000MIT License Copyright (c) 2019 Alex Hall Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. executing-0.8.0/MANIFEST.in000066400000000000000000000000241410133640400152400ustar00rootroot00000000000000include LICENSE.txt executing-0.8.0/README.md000066400000000000000000000162551410133640400147760ustar00rootroot00000000000000# executing [![Build Status](https://github.com/alexmojaki/executing/workflows/Tests/badge.svg?branch=master)](https://github.com/alexmojaki/executing/actions) [![Coverage Status](https://coveralls.io/repos/github/alexmojaki/executing/badge.svg?branch=master)](https://coveralls.io/github/alexmojaki/executing?branch=master) [![Supports Python versions 2.7 and 3.4+, including PyPy](https://img.shields.io/pypi/pyversions/executing.svg)](https://pypi.python.org/pypi/executing) This mini-package lets you get information about what a frame is currently doing, particularly the AST node being executed. * [Usage](#usage) * [Getting the AST node](#getting-the-ast-node) * [Getting the source code of the node](#getting-the-source-code-of-the-node) * [Getting the `__qualname__` of the current function](#getting-the-__qualname__-of-the-current-function) * [The Source class](#the-source-class) * [Installation](#installation) * [How does it work?](#how-does-it-work) * [Is it reliable?](#is-it-reliable) * [Which nodes can it identify?](#which-nodes-can-it-identify) * [Libraries that use this](#libraries-that-use-this) ## Usage ### Getting the AST node ```python import executing node = executing.Source.executing(frame).node ``` Then `node` will be an AST node (from the `ast` standard library module) or None if the node couldn't be identified (which may happen often and should always be checked). `node` will always be the same instance for multiple calls with frames at the same point of execution. If you have a traceback object, pass it directly to `Source.executing()` rather than the `tb_frame` attribute to get the correct node. ### Getting the source code of the node For this you will need to separately install the [`asttokens`](https://github.com/gristlabs/asttokens) library, then obtain an `ASTTokens` object: ```python executing.Source.executing(frame).source.asttokens() ``` or: ```python executing.Source.for_frame(frame).asttokens() ``` or use one of the convenience methods: ```python executing.Source.executing(frame).text() executing.Source.executing(frame).text_range() ``` ### Getting the `__qualname__` of the current function ```python executing.Source.executing(frame).code_qualname() ``` or: ```python executing.Source.for_frame(frame).code_qualname(frame.f_code) ``` ### The `Source` class Everything goes through the `Source` class. Only one instance of the class is created for each filename. Subclassing it to add more attributes on creation or methods is recommended. The classmethods such as `executing` will respect this. See the source code and docstrings for more detail. ## Installation pip install executing If you don't like that you can just copy the file `executing.py`, there are no dependencies (but of course you won't get updates). ## How does it work? Suppose the frame is executing this line: ```python self.foo(bar.x) ``` and in particular it's currently obtaining the attribute `self.foo`. Looking at the bytecode, specifically `frame.f_code.co_code[frame.f_lasti]`, we can tell that it's loading an attribute, but it's not obvious which one. We can narrow down the statement being executed using `frame.f_lineno` and find the two `ast.Attribute` nodes representing `self.foo` and `bar.x`. How do we find out which one it is, without recreating the entire compiler in Python? The trick is to modify the AST slightly for each candidate expression and observe the changes in the bytecode instructions. We change the AST to this: ```python (self.foo ** 'longuniqueconstant')(bar.x) ``` and compile it, and the bytecode will be almost the same but there will be two new instructions: LOAD_CONST 'longuniqueconstant' BINARY_POWER and just before that will be a `LOAD_ATTR` instruction corresponding to `self.foo`. Seeing that it's in the same position as the original instruction lets us know we've found our match. ## Is it reliable? Yes - if it identifies a node, you can trust that it's identified the correct one. The tests are very thorough - in addition to unit tests which check various situations directly, there are property tests against a large number of files (see the filenames printed in [this build](https://travis-ci.org/alexmojaki/executing/jobs/557970457)) with real code. Specifically, for each file, the tests: 1. Identify as many nodes as possible from all the bytecode instructions in the file, and assert that they are all distinct 2. Find all the nodes that should be identifiable, and assert that they were indeed identified somewhere In other words, it shows that there is a one-to-one mapping between the nodes and the instructions that can be handled. This leaves very little room for a bug to creep in. Furthermore, `executing` checks that the instructions compiled from the modified AST exactly match the original code save for a few small known exceptions. This accounts for all the quirks and optimisations in the interpreter. ## Which nodes can it identify? Currently it works in almost all cases for the following `ast` nodes: - `Call`, e.g. `self.foo(bar)` - `Attribute`, e.g. `point.x` - `Subscript`, e.g. `lst[1]` - `BinOp`, e.g. `x + y` (doesn't include `and` and `or`) - `UnaryOp`, e.g. `-n` (includes `not` but only works sometimes) - `Compare` e.g. `a < b` (not for chains such as `0 < p < 1`) The plan is to extend to more operations in the future. ## Libraries that use this ### My libraries - **[`stack_data`](https://github.com/alexmojaki/stack_data)**: Extracts data from stack frames and tracebacks, particularly to display more useful tracebacks than the default. Also uses another related library of mine: **[`pure_eval`](https://github.com/alexmojaki/pure_eval)**. - **[`snoop`](https://github.com/alexmojaki/snoop)**: A feature-rich and convenient debugging library. Uses `executing` to show the operation which caused an exception and to allow the `pp` function to display the source of its arguments. - **[`heartrate`](https://github.com/alexmojaki/heartrate)**: A simple real time visualisation of the execution of a Python program. Uses `executing` to highlight currently executing operations, particularly in each frame of the stack trace. - **[`sorcery`](https://github.com/alexmojaki/sorcery)**: Dark magic delights in Python. Uses `executing` to let special callables called spells know where they're being called from. ### Libraries I've contributed to - **[`IPython`](https://github.com/ipython/ipython/pull/12150)**: Highlights the executing node in tracebacks using `executing` via [`stack_data`](https://github.com/alexmojaki/stack_data). - **[`icecream`](https://github.com/gruns/icecream)**: 🍦 Sweet and creamy print debugging. Uses `executing` to identify where `ic` is called and print its arguments. - **[`sentry_sdk`](https://github.com/getsentry/sentry-python)**: Add the integration `sentry_sdk.integrations.executingExecutingIntegration()` to show the function `__qualname__` in each frame in sentry events. Highlighting the executing node is hopefully [coming soon](https://github.com/getsentry/sentry/pull/19924). - **[`varname`](https://github.com/pwwang/python-varname)**: Dark magics about variable names in python. Uses `executing` to find where its various magical functions like `varname` and `nameof` are called from. executing-0.8.0/executing/000077500000000000000000000000001410133640400155015ustar00rootroot00000000000000executing-0.8.0/executing/__init__.py000066400000000000000000000013361410133640400176150ustar00rootroot00000000000000""" Get information about what a frame is currently doing. Typical usage: import executing node = executing.Source.executing(frame).node # node will be an AST node or None """ from collections import namedtuple _VersionInfo = namedtuple('VersionInfo', ('major', 'minor', 'micro')) from .executing import Source, Executing, only, NotOneValueFound, cache, future_flags try: from .version import __version__ if "dev" in __version__: raise ValueError except Exception: # version.py is auto-generated with the git tag when building __version__ = "???" __version_info__ = _VersionInfo(-1, -1, -1) else: __version_info__ = _VersionInfo(*map(int, __version__.split('.'))) __all__ = ["Source"] executing-0.8.0/executing/executing.py000066400000000000000000001044161410133640400200540ustar00rootroot00000000000000""" MIT License Copyright (c) 2021 Alex Hall Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. """ import __future__ import ast import dis import functools import inspect import io import linecache import re import sys import types from collections import defaultdict, namedtuple from copy import deepcopy from itertools import islice from operator import attrgetter from threading import RLock function_node_types = (ast.FunctionDef,) PY3 = sys.version_info[0] == 3 if PY3: # noinspection PyUnresolvedReferences from functools import lru_cache # noinspection PyUnresolvedReferences from tokenize import detect_encoding from itertools import zip_longest # noinspection PyUnresolvedReferences,PyCompatibility from pathlib import Path cache = lru_cache(maxsize=None) text_type = str else: from lib2to3.pgen2.tokenize import detect_encoding, cookie_re as encoding_pattern from itertools import izip_longest as zip_longest class Path(object): pass def cache(func): d = {} @functools.wraps(func) def wrapper(*args): if args in d: return d[args] result = d[args] = func(*args) return result return wrapper # noinspection PyUnresolvedReferences text_type = unicode try: # noinspection PyUnresolvedReferences _get_instructions = dis.get_instructions except AttributeError: class Instruction(namedtuple('Instruction', 'offset argval opname starts_line')): lineno = None from dis import HAVE_ARGUMENT, EXTENDED_ARG, hasconst, opname, findlinestarts, hasname # Based on dis.disassemble from 2.7 # Left as similar as possible for easy diff def _get_instructions(co): code = co.co_code linestarts = dict(findlinestarts(co)) n = len(code) i = 0 extended_arg = 0 while i < n: offset = i c = code[i] op = ord(c) lineno = linestarts.get(i) argval = None i = i + 1 if op >= HAVE_ARGUMENT: oparg = ord(code[i]) + ord(code[i + 1]) * 256 + extended_arg extended_arg = 0 i = i + 2 if op == EXTENDED_ARG: extended_arg = oparg * 65536 if op in hasconst: argval = co.co_consts[oparg] elif op in hasname: argval = co.co_names[oparg] elif opname[op] == 'LOAD_FAST': argval = co.co_varnames[oparg] yield Instruction(offset, argval, opname[op], lineno) try: function_node_types += (ast.AsyncFunctionDef,) except AttributeError: pass def assert_(condition, message=""): """ Like an assert statement, but unaffected by -O :param condition: value that is expected to be truthy :type message: Any """ if not condition: raise AssertionError(str(message)) def get_instructions(co): lineno = co.co_firstlineno for inst in _get_instructions(co): lineno = inst.starts_line or lineno assert_(lineno) inst.lineno = lineno yield inst TESTING = 0 class NotOneValueFound(Exception): pass def only(it): if hasattr(it, '__len__'): if len(it) != 1: raise NotOneValueFound('Expected one value, found %s' % len(it)) # noinspection PyTypeChecker return list(it)[0] lst = tuple(islice(it, 2)) if len(lst) == 0: raise NotOneValueFound('Expected one value, found 0') if len(lst) > 1: raise NotOneValueFound('Expected one value, found several') return lst[0] class Source(object): """ The source code of a single file and associated metadata. The main method of interest is the classmethod `executing(frame)`. If you want an instance of this class, don't construct it. Ideally use the classmethod `for_frame(frame)`. If you don't have a frame, use `for_filename(filename [, module_globals])`. These methods cache instances by filename, so at most one instance exists per filename. Attributes: - filename - text - lines - tree: AST parsed from text, or None if text is not valid Python All nodes in the tree have an extra `parent` attribute Other methods of interest: - statements_at_line - asttokens - code_qualname """ def __init__(self, filename, lines): """ Don't call this constructor, see the class docstring. """ self.filename = filename text = ''.join(lines) if not isinstance(text, text_type): encoding = self.detect_encoding(text) # noinspection PyUnresolvedReferences text = text.decode(encoding) lines = [line.decode(encoding) for line in lines] self.text = text self.lines = [line.rstrip('\r\n') for line in lines] if PY3: ast_text = text else: # In python 2 it's a syntax error to parse unicode # with an encoding declaration, so we remove it but # leave empty lines in its place to keep line numbers the same ast_text = ''.join([ '\n' if i < 2 and encoding_pattern.match(line) else line for i, line in enumerate(lines) ]) self._nodes_by_line = defaultdict(list) self.tree = None self._qualnames = {} try: self.tree = ast.parse(ast_text, filename=filename) except SyntaxError: pass else: for node in ast.walk(self.tree): for child in ast.iter_child_nodes(node): child.parent = node if hasattr(node, "lineno"): if hasattr(node, "end_lineno") and isinstance(node, ast.expr): linenos = range(node.lineno, node.end_lineno + 1) else: linenos = [node.lineno] for lineno in linenos: self._nodes_by_line[lineno].append(node) visitor = QualnameVisitor() visitor.visit(self.tree) self._qualnames = visitor.qualnames @classmethod def for_frame(cls, frame, use_cache=True): """ Returns the `Source` object corresponding to the file the frame is executing in. """ return cls.for_filename(frame.f_code.co_filename, frame.f_globals or {}, use_cache) @classmethod def for_filename(cls, filename, module_globals=None, use_cache=True): if isinstance(filename, Path): filename = str(filename) source_cache = cls._class_local('__source_cache', {}) if use_cache: try: return source_cache[filename] except KeyError: pass if not use_cache: linecache.checkcache(filename) lines = tuple(linecache.getlines(filename, module_globals)) result = source_cache[filename] = cls._for_filename_and_lines(filename, lines) return result @classmethod def _for_filename_and_lines(cls, filename, lines): source_cache = cls._class_local('__source_cache_with_lines', {}) try: return source_cache[(filename, lines)] except KeyError: pass result = source_cache[(filename, lines)] = cls(filename, lines) return result @classmethod def lazycache(cls, frame): if hasattr(linecache, 'lazycache'): linecache.lazycache(frame.f_code.co_filename, frame.f_globals) @classmethod def executing(cls, frame_or_tb): """ Returns an `Executing` object representing the operation currently executing in the given frame or traceback object. """ if isinstance(frame_or_tb, types.TracebackType): # https://docs.python.org/3/reference/datamodel.html#traceback-objects # "tb_lineno gives the line number where the exception occurred; # tb_lasti indicates the precise instruction. # The line number and last instruction in the traceback may differ # from the line number of its frame object # if the exception occurred in a try statement with no matching except clause # or with a finally clause." tb = frame_or_tb frame = tb.tb_frame lineno = tb.tb_lineno lasti = tb.tb_lasti else: frame = frame_or_tb lineno = frame.f_lineno lasti = frame.f_lasti code = frame.f_code key = (code, id(code), lasti) executing_cache = cls._class_local('__executing_cache', {}) try: args = executing_cache[key] except KeyError: def find(source, retry_cache): node = stmts = decorator = None tree = source.tree if tree: try: stmts = source.statements_at_line(lineno) if stmts: if code.co_name == "" and re.search( r"') if isinstance(node, ast.Lambda): children = [node.body] else: children = node.body for child in children: self.visit(child) self.stack.pop() self.stack.pop() # Find lambdas in the function definition outside the body, # e.g. decorators or default arguments # Based on iter_child_nodes for field, child in ast.iter_fields(node): if field == 'body': continue if isinstance(child, ast.AST): self.visit(child) elif isinstance(child, list): for grandchild in child: if isinstance(grandchild, ast.AST): self.visit(grandchild) visit_AsyncFunctionDef = visit_FunctionDef def visit_Lambda(self, node): # noinspection PyTypeChecker self.visit_FunctionDef(node, '') def visit_ClassDef(self, node): self.add_qualname(node) self.generic_visit(node) self.stack.pop() future_flags = sum( getattr(__future__, fname).compiler_flag for fname in __future__.all_feature_names ) def compile_similar_to(source, matching_code): return compile( source, matching_code.co_filename, 'exec', flags=future_flags & matching_code.co_flags, dont_inherit=True, ) sentinel = 'io8urthglkjdghvljusketgIYRFYUVGHFRTBGVHKGF78678957647698' class NodeFinder(object): def __init__(self, frame, stmts, tree, lasti): assert_(stmts) self.frame = frame self.tree = tree self.code = code = frame.f_code self.is_pytest = any( 'pytest' in name.lower() for group in [code.co_names, code.co_varnames] for name in group ) if self.is_pytest: self.ignore_linenos = frozenset(assert_linenos(tree)) else: self.ignore_linenos = frozenset() self.decorator = None self.instruction = instruction = self.get_actual_current_instruction(lasti) op_name = instruction.opname extra_filter = lambda e: True if op_name.startswith('CALL_'): typ = ast.Call elif op_name.startswith(('BINARY_SUBSCR', 'SLICE+')): typ = ast.Subscript elif op_name.startswith('BINARY_'): typ = ast.BinOp op_type = dict( BINARY_POWER=ast.Pow, BINARY_MULTIPLY=ast.Mult, BINARY_MATRIX_MULTIPLY=getattr(ast, "MatMult", ()), BINARY_FLOOR_DIVIDE=ast.FloorDiv, BINARY_TRUE_DIVIDE=ast.Div, BINARY_MODULO=ast.Mod, BINARY_ADD=ast.Add, BINARY_SUBTRACT=ast.Sub, BINARY_LSHIFT=ast.LShift, BINARY_RSHIFT=ast.RShift, BINARY_AND=ast.BitAnd, BINARY_XOR=ast.BitXor, BINARY_OR=ast.BitOr, )[op_name] extra_filter = lambda e: isinstance(e.op, op_type) elif op_name.startswith('UNARY_'): typ = ast.UnaryOp op_type = dict( UNARY_POSITIVE=ast.UAdd, UNARY_NEGATIVE=ast.USub, UNARY_NOT=ast.Not, UNARY_INVERT=ast.Invert, )[op_name] extra_filter = lambda e: isinstance(e.op, op_type) elif op_name in ('LOAD_ATTR', 'LOAD_METHOD', 'LOOKUP_METHOD'): typ = ast.Attribute # `in` to handle private mangled attributes extra_filter = lambda e: e.attr in instruction.argval elif op_name in ('LOAD_NAME', 'LOAD_GLOBAL', 'LOAD_FAST', 'LOAD_DEREF', 'LOAD_CLASSDEREF'): typ = ast.Name if PY3 or instruction.argval: extra_filter = lambda e: e.id == instruction.argval elif op_name in ('COMPARE_OP', 'IS_OP', 'CONTAINS_OP'): typ = ast.Compare extra_filter = lambda e: len(e.ops) == 1 else: raise RuntimeError(op_name) with lock: exprs = { node for stmt in stmts for node in ast.walk(stmt) if isinstance(node, typ) if not (hasattr(node, "ctx") and not isinstance(node.ctx, ast.Load)) if extra_filter(node) if statement_containing_node(node) == stmt } matching = list(self.matching_nodes(exprs)) if not matching and typ == ast.Call: self.find_decorator(stmts) else: self.result = only(matching) def find_decorator(self, stmts): stmt = only(stmts) assert_(isinstance(stmt, (ast.ClassDef, function_node_types))) decorators = stmt.decorator_list assert_(decorators) line_instructions = [ inst for inst in self.clean_instructions(self.code) if inst.lineno == self.frame.f_lineno ] last_decorator_instruction_index = [ i for i, inst in enumerate(line_instructions) if inst.opname == "CALL_FUNCTION" ][-1] assert_( line_instructions[last_decorator_instruction_index + 1].opname.startswith( "STORE_" ) ) decorator_instructions = line_instructions[ last_decorator_instruction_index - len(decorators) + 1 : last_decorator_instruction_index + 1 ] assert_({inst.opname for inst in decorator_instructions} == {"CALL_FUNCTION"}) decorator_index = decorator_instructions.index(self.instruction) decorator = decorators[::-1][decorator_index] self.decorator = decorator self.result = stmt def clean_instructions(self, code): return [ inst for inst in get_instructions(code) if inst.opname not in ("EXTENDED_ARG", "NOP") if inst.lineno not in self.ignore_linenos ] def get_original_clean_instructions(self): result = self.clean_instructions(self.code) # pypy sometimes (when is not clear) # inserts JUMP_IF_NOT_DEBUG instructions in bytecode # If they're not present in our compiled instructions, # ignore them in the original bytecode if not any( inst.opname == "JUMP_IF_NOT_DEBUG" for inst in self.compile_instructions() ): result = [ inst for inst in result if inst.opname != "JUMP_IF_NOT_DEBUG" ] return result def matching_nodes(self, exprs): original_instructions = self.get_original_clean_instructions() original_index = only( i for i, inst in enumerate(original_instructions) if inst == self.instruction ) for expr_index, expr in enumerate(exprs): setter = get_setter(expr) # noinspection PyArgumentList replacement = ast.BinOp( left=expr, op=ast.Pow(), right=ast.Str(s=sentinel), ) ast.fix_missing_locations(replacement) setter(replacement) try: instructions = self.compile_instructions() finally: setter(expr) if sys.version_info >= (3, 10): try: handle_jumps(instructions, original_instructions) except Exception: # Give other candidates a chance if TESTING or expr_index < len(exprs) - 1: continue raise indices = [ i for i, instruction in enumerate(instructions) if instruction.argval == sentinel ] # There can be several indices when the bytecode is duplicated, # as happens in a finally block in 3.9+ # First we remove the opcodes caused by our modifications for index_num, sentinel_index in enumerate(indices): # Adjustment for removing sentinel instructions below # in past iterations sentinel_index -= index_num * 2 assert_(instructions.pop(sentinel_index).opname == 'LOAD_CONST') assert_(instructions.pop(sentinel_index).opname == 'BINARY_POWER') # Then we see if any of the instruction indices match for index_num, sentinel_index in enumerate(indices): sentinel_index -= index_num * 2 new_index = sentinel_index - 1 if new_index != original_index: continue original_inst = original_instructions[original_index] new_inst = instructions[new_index] # In Python 3.9+, changing 'not x in y' to 'not sentinel_transformation(x in y)' # changes a CONTAINS_OP(invert=1) to CONTAINS_OP(invert=0),,UNARY_NOT if ( original_inst.opname == new_inst.opname in ('CONTAINS_OP', 'IS_OP') and original_inst.arg != new_inst.arg and ( original_instructions[original_index + 1].opname != instructions[new_index + 1].opname == 'UNARY_NOT' )): # Remove the difference for the upcoming assert instructions.pop(new_index + 1) # Check that the modified instructions don't have anything unexpected # 3.10 is a bit too weird to assert this in all cases but things still work if sys.version_info < (3, 10): for inst1, inst2 in zip_longest( original_instructions, instructions ): assert_(inst1 and inst2 and opnames_match(inst1, inst2)) yield expr def compile_instructions(self): module_code = compile_similar_to(self.tree, self.code) code = only(self.find_codes(module_code)) return self.clean_instructions(code) def find_codes(self, root_code): checks = [ attrgetter('co_firstlineno'), attrgetter('co_name'), attrgetter('co_freevars'), attrgetter('co_cellvars'), ] if not self.is_pytest: checks += [ attrgetter('co_names'), attrgetter('co_varnames'), ] def matches(c): return all( f(c) == f(self.code) for f in checks ) code_options = [] if matches(root_code): code_options.append(root_code) def finder(code): for const in code.co_consts: if not inspect.iscode(const): continue if matches(const): code_options.append(const) finder(const) finder(root_code) return code_options def get_actual_current_instruction(self, lasti): """ Get the instruction corresponding to the current frame offset, skipping EXTENDED_ARG instructions """ # Don't use get_original_clean_instructions # because we need the actual instructions including # EXTENDED_ARG instructions = list(get_instructions(self.code)) index = only( i for i, inst in enumerate(instructions) if inst.offset == lasti ) while True: instruction = instructions[index] if instruction.opname != "EXTENDED_ARG": return instruction index += 1 def non_sentinel_instructions(instructions, start): """ Yields (index, instruction) pairs excluding the basic instructions introduced by the sentinel transformation """ skip_power = False for i, inst in islice(enumerate(instructions), start, None): if inst.argval == sentinel: assert_(inst.opname == "LOAD_CONST") skip_power = True continue elif skip_power: assert_(inst.opname == "BINARY_POWER") skip_power = False continue yield i, inst def walk_both_instructions(original_instructions, original_start, instructions, start): """ Yields matching indices and instructions from the new and original instructions, leaving out changes made by the sentinel transformation. """ original_iter = islice(enumerate(original_instructions), original_start, None) new_iter = non_sentinel_instructions(instructions, start) inverted_comparison = False while True: try: original_i, original_inst = next(original_iter) new_i, new_inst = next(new_iter) except StopIteration: return if ( inverted_comparison and original_inst.opname != new_inst.opname == "UNARY_NOT" ): new_i, new_inst = next(new_iter) inverted_comparison = ( original_inst.opname == new_inst.opname in ("CONTAINS_OP", "IS_OP") and original_inst.arg != new_inst.arg ) yield original_i, original_inst, new_i, new_inst def handle_jumps(instructions, original_instructions): """ Transforms instructions in place until it looks more like original_instructions, replacing JUMP instructions that aren't also present in original_instructions with the sections that they jump to until a raise or return. This is only needed in 3.10+ where optimisations lead to more drastic changes after the sentinel transformation. """ while True: for original_i, original_inst, new_i, new_inst in walk_both_instructions( original_instructions, 0, instructions, 0 ): if "JUMP" in new_inst.opname and "JUMP" not in original_inst.opname: # Find where the new instruction is jumping to, ignoring # instructions which have been copied in previous iterations start = only( i for i, inst in enumerate(instructions) if inst.offset == new_inst.argval and not getattr(inst, "_copied", False) ) # Replace the jump instruction with the jumped to section of instructions # That section may also be deleted if it's not similarly duplicated # in original_instructions instructions[new_i : new_i + 1] = handle_jump( original_instructions, original_i, instructions, start ) # Start the root while loop from the beginning, checking for other jumps break else: if not (opnames_match(original_inst, new_inst)): raise AssertionError else: # No mismatched jumps found, we're done return def handle_jump(original_instructions, original_start, instructions, start): """ Returns the section of instructions starting at `start` and ending with a RETURN_VALUE or RAISE_VARARGS instruction. There should be a matching section in original_instructions starting at original_start. If that section doesn't appear elsewhere in original_instructions, then also delete the returned section of instructions. """ for original_j, original_inst, new_j, new_inst in walk_both_instructions( original_instructions, original_start, instructions, start ): assert_(opnames_match(original_inst, new_inst)) if original_inst.opname in ("RETURN_VALUE", "RAISE_VARARGS"): inlined = deepcopy(instructions[start : new_j + 1]) for inl in inlined: inl._copied = True orig_section = original_instructions[original_start : original_j + 1] if not check_duplicates( original_start, orig_section, original_instructions ): instructions[start : new_j + 1] = [] return inlined def check_duplicates(original_i, orig_section, original_instructions): """ Returns True if a section of original_instructions starting somewhere other than original_i and matching orig_section is found, i.e. orig_section is duplicated. """ for dup_start in range(len(original_instructions)): if dup_start == original_i: continue dup_section = original_instructions[dup_start : dup_start + len(orig_section)] if len(dup_section) < len(orig_section): return False if all( opnames_match(orig_inst, dup_inst) and orig_inst.lineno == dup_inst.lineno for orig_inst, dup_inst in zip(orig_section, dup_section) ): return True def opnames_match(inst1, inst2): return ( inst1.opname == inst2.opname or "JUMP" in inst1.opname and "JUMP" in inst2.opname or (inst1.opname == "PRINT_EXPR" and inst2.opname == "POP_TOP") or ( inst1.opname in ("LOAD_METHOD", "LOOKUP_METHOD") and inst2.opname == "LOAD_ATTR" ) or (inst1.opname == "CALL_METHOD" and inst2.opname == "CALL_FUNCTION") ) def get_setter(node): parent = node.parent for name, field in ast.iter_fields(parent): if field is node: return lambda new_node: setattr(parent, name, new_node) elif isinstance(field, list): for i, item in enumerate(field): if item is node: def setter(new_node): field[i] = new_node return setter lock = RLock() @cache def statement_containing_node(node): while not isinstance(node, ast.stmt): node = node.parent return node def assert_linenos(tree): for node in ast.walk(tree): if ( hasattr(node, 'parent') and hasattr(node, 'lineno') and isinstance(statement_containing_node(node), ast.Assert) ): yield node.lineno def _extract_ipython_statement(stmts, tree): # IPython separates each statement in a cell to be executed separately # So NodeFinder should only compile one statement at a time or it # will find a code mismatch. stmt = list(stmts)[0] while not isinstance(stmt.parent, ast.Module): stmt = stmt.parent # use `ast.parse` instead of `ast.Module` for better portability # python3.8 changes the signature of `ast.Module` # Inspired by https://github.com/pallets/werkzeug/pull/1552/files tree = ast.parse("") tree.body = [stmt] ast.copy_location(tree, stmt) return tree executing-0.8.0/make_release.sh000077500000000000000000000011471410133640400164650ustar00rootroot00000000000000#!/usr/bin/env bash set -eux # Ensure that there are no uncommitted changes # which would mess up using the git tag as a version [ -z "$(git status --porcelain)" ] if [ -z "${1+x}" ] then set +x echo Provide a version argument echo "${0} .." exit 1 else if [[ ${1} =~ ^([0-9]+)(\.[0-9]+)?(\.[0-9]+)?$ ]]; then : else echo "Not a valid release tag." exit 1 fi fi tox -p auto export TAG="v${1}" git tag "${TAG}" git push origin master "${TAG}" rm -rf ./build ./dist python -m build --sdist --wheel . twine upload ./dist/*.whl dist/*.tar.gz executing-0.8.0/pyproject.toml000066400000000000000000000003331410133640400164210ustar00rootroot00000000000000[build-system] requires = ["setuptools", "wheel", "setuptools_scm[toml]"] build-backend = "setuptools.build_meta" [tool.setuptools_scm] write_to = "executing/version.py" write_to_template = "__version__ = '{version}'" executing-0.8.0/setup.cfg000066400000000000000000000017101410133640400153260ustar00rootroot00000000000000[metadata] name = executing author = Alex Hall author_email = alex.mojaki@gmail.com license = MIT description = Get the currently executing AST node of a frame, and other information long_description = file: README.md long_description_content_type = text/markdown url = https://github.com/alexmojaki/executing classifiers = License :: OSI Approved :: MIT License Programming Language :: Python Programming Language :: Python :: 2 Programming Language :: Python :: 2.7 Programming Language :: Python :: 3 Programming Language :: Python :: 3.4 Programming Language :: Python :: 3.5 Programming Language :: Python :: 3.6 Programming Language :: Python :: 3.7 Programming Language :: Python :: 3.8 Programming Language :: Python :: 3.9 [options] packages = executing zip_safe = False include_package_data = True setup_requires = setuptools; setuptools_scm[toml] [coverage:run] relative_files = True [bdist_wheel] universal=1 executing-0.8.0/setup.py000066400000000000000000000001051410133640400152140ustar00rootroot00000000000000from setuptools import setup if __name__ == "__main__": setup() executing-0.8.0/tests/000077500000000000000000000000001410133640400146505ustar00rootroot00000000000000executing-0.8.0/tests/__init__.py000066400000000000000000000000001410133640400167470ustar00rootroot00000000000000executing-0.8.0/tests/not_code.txt000066400000000000000000000000201410133640400171730ustar00rootroot00000000000000this isn't code executing-0.8.0/tests/sample_results/000077500000000000000000000000001410133640400177125ustar00rootroot00000000000000executing-0.8.0/tests/sample_results/2.7.json000066400000000000000000022116171410133640400211250ustar00rootroot00000000000000{ "bird.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOAD_ATTR", "standard_library.install_aliases" ], [ "CALL_FUNCTION", "standard_library.install_aliases()" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "warn_if_outdated" ], [ "LOAD_NAME", "__version__" ], [ "CALL_FUNCTION", "warn_if_outdated('birdseye', __version__)" ], [ "LOAD_NAME", "namedtuple" ], [ "CALL_FUNCTION", "namedtuple('CodeInfo', 'db_func traced_file arg_names')" ], [ "LOAD_NAME", "TreeTracerBase" ], [ "LOAD_NAME", "BirdsEye" ], [ "CALL_FUNCTION", "BirdsEye()" ], [ "LOAD_NAME", "NamedTuple" ], [ "LOAD_NAME", "int" ], [ "LOAD_NAME", "bool" ], [ "LOAD_NAME", "int" ], [ "LOAD_NAME", "str" ], [ "CALL_FUNCTION", "NamedTuple('HTMLPosition', [\n ('index', int),\n ('is_start', bool),\n ('depth', int),\n ('html', str),\n])" ], [ "LOAD_NAME", "eye" ], [ "LOAD_ATTR", "eye.enter_call" ], [ "LOAD_ATTR", "eye.enter_call.__code__" ], [ "LOAD_NAME", "eye" ], [ "LOAD_ATTR", "eye.exit_call" ], [ "LOAD_ATTR", "eye.exit_call.__code__" ], [ "LOAD_NAME", "eye" ], [ "LOAD_ATTR", "eye.after_expr" ], [ "LOAD_ATTR", "eye.after_expr.__code__" ], [ "LOAD_NAME", "eye" ], [ "LOAD_ATTR", "eye.after_stmt" ], [ "LOAD_ATTR", "eye.after_stmt.__code__" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "Iterable" ], [ "LOAD_NAME", "Iteration" ], [ "BINARY_SUBSCR", "Iterable[Iteration]" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "TypeRegistry" ], [ "CALL_FUNCTION", "TypeRegistry()" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "try_register_repr" ], [ "CALL_FUNCTION", "try_register_repr('pandas', 'Series')" ], [ "CALL_FUNCTION", "try_register_repr('pandas', 'Series')" ], [ "LOAD_NAME", "cached_property" ], [ "CALL_FUNCTION", "cached_property" ], [ "LOAD_NAME", "lru_cache" ], [ "CALL_FUNCTION", "lru_cache()" ], [ "CALL_FUNCTION", "lru_cache()" ], [ "LOAD_NAME", "False" ], [ "LOAD_NAME", "False" ], [ "LOAD_NAME", "retry_db" ], [ "CALL_FUNCTION", "retry_db" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "BirdsEye" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(BirdsEye, self)" ], [ "LOAD_ATTR", "super(BirdsEye, self).__init__" ], [ "CALL_FUNCTION", "super(BirdsEye, self).__init__()" ], [ "LOAD_FAST", "db_uri" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "num_samples" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "dict" ], [ "CALL_FUNCTION", "dict(\n attributes=50,\n dict=50,\n list=30,\n set=30,\n pandas_rows=20,\n pandas_cols=100,\n )" ], [ "LOAD_GLOBAL", "dict" ], [ "CALL_FUNCTION", "dict(\n attributes=50,\n dict=10,\n list=6,\n set=6,\n pandas_rows=6,\n pandas_cols=10,\n )" ], [ "CALL_FUNCTION", "dict(\n big=dict(\n attributes=50,\n dict=50,\n list=30,\n set=30,\n pandas_rows=20,\n pandas_cols=100,\n ),\n small=dict(\n attributes=50,\n dict=10,\n list=6,\n set=6,\n pandas_rows=6,\n pandas_cols=10,\n ),\n )" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "Database" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._db_uri" ], [ "CALL_FUNCTION", "Database(self._db_uri)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.walk" ], [ "LOAD_FAST", "root" ], [ "CALL_FUNCTION", "ast.walk(root)" ], [ "LOAD_GLOBAL", "tracer" ], [ "LOAD_ATTR", "tracer.loops" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "tracer.loops(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "CALL_FUNCTION", "isinstance(node, ast.expr)" ], [ "LOAD_GLOBAL", "is_interesting_expression" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "is_interesting_expression(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "BirdsEye" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(BirdsEye, self)" ], [ "LOAD_ATTR", "super(BirdsEye, self).compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "flags" ], [ "CALL_FUNCTION", "super(BirdsEye, self).compile(source, filename, flags)" ], [ "LOAD_GLOBAL", "ASTTokens" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.root" ], [ "CALL_FUNCTION", "ASTTokens(source, tree=traced_file.root)" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.For)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.body" ], [ "BINARY_SUBSCR", "node.parent.body[0]" ], [ "COMPARE_OP", "node is node.parent.body[0]" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._add_iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "self._add_iteration(node._loops, frame)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.While)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.test" ], [ "COMPARE_OP", "node is node.parent.test" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._add_iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "self._add_iteration(node._loops, frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_ATTR", "self.stack[frame].iteration" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "loops" ], [ "CALL_FUNCTION", "enumerate(loops)" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.loops" ], [ "LOAD_FAST", "loop_node" ], [ "LOAD_ATTR", "loop_node._tree_index" ], [ "BINARY_SUBSCR", "iteration.loops[loop_node._tree_index]" ], [ "LOAD_FAST", "i" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "loops" ], [ "CALL_FUNCTION", "len(loops)" ], [ "BINARY_SUBTRACT", "len(loops) - 1" ], [ "COMPARE_OP", "i == len(loops) - 1" ], [ "LOAD_FAST", "loop" ], [ "LOAD_ATTR", "loop.append" ], [ "LOAD_GLOBAL", "Iteration" ], [ "CALL_FUNCTION", "Iteration()" ], [ "CALL_FUNCTION", "loop.append(Iteration())" ], [ "LOAD_FAST", "loop" ], [ "LOAD_ATTR", "loop.last" ], [ "CALL_FUNCTION", "loop.last()" ], [ "LOAD_GLOBAL", "_tracing_recursively" ], [ "LOAD_DEREF", "frame" ], [ "CALL_FUNCTION", "_tracing_recursively(frame)" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._is_interesting_expression" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "BINARY_SUBSCR", "self._code_infos[frame.f_code]" ], [ "LOAD_ATTR", "self._code_infos[frame.f_code].traced_file" ], [ "LOAD_ATTR", "self._code_infos[frame.f_code].traced_file.is_ipython_cell" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Expr" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.Expr)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.parent" ], [ "LOAD_ATTR", "node.parent.parent.body" ], [ "BINARY_SUBSCR", "node.parent.parent.body[-1]" ], [ "COMPARE_OP", "node.parent is node.parent.parent.body[-1]" ], [ "LOAD_DEREF", "value" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "is_obvious_builtin" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_DEREF", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_ATTR", "self.stack[frame].expression_values" ], [ "LOAD_FAST", "node" ], [ "BINARY_SUBSCR", "self.stack[frame].expression_values[node]" ], [ "CALL_FUNCTION", "is_obvious_builtin(node, self.stack[frame].expression_values[node])" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_DEREF", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_FAST", "exc_value" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._exception_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_FAST", "exc_value" ], [ "CALL_FUNCTION", "self._exception_value(node, frame, exc_value)" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOAD_ATTR", "NodeValue.expression" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.num_samples" ], [ "LOAD_DEREF", "value" ], [ "LOAD_GLOBAL", "max" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "CALL_FUNCTION", "len(node._loops)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._is_first_loop_iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "frame" ], [ "CALL_FUNCTION", "self._is_first_loop_iteration(node, frame)" ], [ "UNARY_NOT", "not self._is_first_loop_iteration(node, frame)" ], [ "BINARY_MULTIPLY", "len(node._loops) * (not self._is_first_loop_iteration(node, frame))" ], [ "BINARY_SUBTRACT", "3 - len(node._loops) * (not self._is_first_loop_iteration(node, frame))" ], [ "CALL_FUNCTION", "max(1, 3 - len(node._loops) * (not self._is_first_loop_iteration(node, frame)))" ], [ "CALL_FUNCTION", "NodeValue.expression(\n self.num_samples,\n value,\n level=max(1, 3 - len(node._loops) * (not self._is_first_loop_iteration(node, frame))),\n )" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._set_node_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_FAST", "node_value" ], [ "CALL_FUNCTION", "self._set_node_value(node, frame, node_value)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._check_inner_call" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node_value" ], [ "CALL_FUNCTION", "self._check_inner_call(frame_info, node, node_value)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.comprehension)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.iter" ], [ "COMPARE_OP", "node is node.parent.iter" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.GeneratorExp" ], [ "CALL_FUNCTION", "isinstance(node.parent.parent, ast.GeneratorExp)" ], [ "UNARY_NOT", "not isinstance(node.parent.parent, ast.GeneratorExp)" ], [ "LOAD_FAST", "is_special_comprehension_iter" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._set_node_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOAD_ATTR", "NodeValue.covered" ], [ "CALL_FUNCTION", "NodeValue.covered()" ], [ "CALL_FUNCTION", "self._set_node_value(node.parent, frame, NodeValue.covered())" ], [ "LOAD_FAST", "exc_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "BINARY_ADD", "node._loops + (node.parent,)" ], [ "LOAD_GLOBAL", "ChangeValue" ], [ "LOAD_FAST", "comprehension_iter_proxy" ], [ "CALL_FUNCTION", "comprehension_iter_proxy()" ], [ "CALL_FUNCTION", "ChangeValue(comprehension_iter_proxy())" ], [ "LOAD_DEREF", "value" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._add_iteration" ], [ "LOAD_DEREF", "loops" ], [ "LOAD_DEREF", "frame" ], [ "CALL_FUNCTION", "self._add_iteration(loops, frame)" ], [ "LOAD_FAST", "item" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.inner_calls" ], [ "LOAD_ATTR", "frame_info.inner_calls.pop" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "frame_info.inner_calls.pop(node, None)" ], [ "LOAD_FAST", "inner_calls" ], [ "LOAD_FAST", "node_value" ], [ "LOAD_ATTR", "node_value.set_meta" ], [ "LOAD_FAST", "inner_calls" ], [ "CALL_FUNCTION", "node_value.set_meta('inner_calls', inner_calls)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_ATTR", "self.stack[frame].iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.loops" ], [ "LOAD_FAST", "loop_node" ], [ "LOAD_ATTR", "loop_node._tree_index" ], [ "BINARY_SUBSCR", "iteration.loops[loop_node._tree_index]" ], [ "LOAD_FAST", "loop" ], [ "LOAD_ATTR", "loop.last" ], [ "CALL_FUNCTION", "loop.last()" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.index" ], [ "COMPARE_OP", "iteration.index > 0" ], [ "LOAD_GLOBAL", "False" ], [ "LOAD_GLOBAL", "True" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_ATTR", "self.stack[frame].iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.loops" ], [ "LOAD_FAST", "loop_node" ], [ "LOAD_ATTR", "loop_node._tree_index" ], [ "BINARY_SUBSCR", "iteration.loops[loop_node._tree_index]" ], [ "LOAD_FAST", "loop" ], [ "LOAD_ATTR", "loop.recorded_node" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "loop.recorded_node(node)" ], [ "LOAD_FAST", "loop" ], [ "LOAD_ATTR", "loop.last" ], [ "CALL_FUNCTION", "loop.last()" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.vals" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOAD_ATTR", "NodeValue.exception" ], [ "LOAD_FAST", "exc_value" ], [ "CALL_FUNCTION", "NodeValue.exception(exc_value)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._set_node_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "self._set_node_value(node, frame, value)" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_GLOBAL", "_tracing_recursively" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "_tracing_recursively(frame)" ], [ "LOAD_FAST", "exc_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "exc_node" ], [ "COMPARE_OP", "node is exc_node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._exception_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "exc_value" ], [ "CALL_FUNCTION", "self._exception_value(node, frame, exc_value)" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOAD_ATTR", "NodeValue.covered" ], [ "CALL_FUNCTION", "NodeValue.covered()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._set_node_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "self._set_node_value(node, frame, value)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._check_inner_call" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "self._check_inner_call(self.stack[frame], node, value)" ], [ "LOAD_FAST", "enter_info" ], [ "LOAD_ATTR", "enter_info.current_frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_GLOBAL", "_tracing_recursively" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "_tracing_recursively(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_GLOBAL", "get_unfrozen_datetime" ], [ "CALL_FUNCTION", "get_unfrozen_datetime()" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_GLOBAL", "Iteration" ], [ "CALL_FUNCTION", "Iteration()" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "BINARY_SUBSCR", "self._code_infos[frame.f_code]" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "enter_info" ], [ "LOAD_ATTR", "enter_info.enter_node" ], [ "LOAD_ATTR", "enter_info.enter_node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Module" ], [ "CALL_FUNCTION", "isinstance(enter_info.enter_node.parent, ast.Module)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "LOAD_ATTR", "frame.f_locals.copy" ], [ "CALL_FUNCTION", "frame.f_locals.copy()" ], [ "LOAD_FAST", "code_info" ], [ "LOAD_ATTR", "code_info.arg_names" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "f_locals" ], [ "LOAD_ATTR", "f_locals.pop" ], [ "LOAD_FAST", "name" ], [ "CALL_FUNCTION", "f_locals.pop(name)" ], [ "LOAD_FAST", "f_locals" ], [ "LOAD_ATTR", "f_locals.items" ], [ "CALL_FUNCTION", "f_locals.items()" ], [ "LOAD_FAST", "it" ], [ "BINARY_SUBSCR", "it[0]" ], [ "BINARY_SUBSCR", "it[0][0]" ], [ "COMPARE_OP", "it[0][0] != '.'" ], [ "LOAD_FAST", "it" ], [ "BINARY_ADD", "[(name, f_locals.pop(name))\n for name in code_info.arg_names\n if name] + [\n\n # Local variables other than actual arguments. These are variables from\n # the enclosing scope. It's handy to treat them like arguments in the UI\n it for it in f_locals.items()\n if it[0][0] != '.' # Appears when using nested tuple arguments\n ]" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_ATTR", "json.dumps" ], [ "LOAD_FAST", "arguments" ], [ "LOAD_FAST", "k" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "cheap_repr(v)" ], [ "CALL_FUNCTION", "json.dumps([[k, cheap_repr(v)] for k, v in arguments])" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._call_id" ], [ "CALL_FUNCTION", "self._call_id()" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "defaultdict(list)" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_ATTR", "self.stack.get" ], [ "LOAD_FAST", "enter_info" ], [ "LOAD_ATTR", "enter_info.caller_frame" ], [ "CALL_FUNCTION", "self.stack.get(enter_info.caller_frame)" ], [ "LOAD_FAST", "prev" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "prev" ], [ "CALL_FUNCTION", "getattr(prev, 'inner_calls', None)" ], [ "LOAD_FAST", "inner_calls" ], [ "COMPARE_OP", "inner_calls is not None" ], [ "LOAD_FAST", "inner_calls" ], [ "LOAD_FAST", "enter_info" ], [ "LOAD_ATTR", "enter_info.call_node" ], [ "BINARY_SUBSCR", "inner_calls[enter_info.call_node]" ], [ "LOAD_ATTR", "inner_calls[enter_info.call_node].append" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.call_id" ], [ "CALL_FUNCTION", "inner_calls[enter_info.call_node].append(frame_info.call_id)" ], [ "LOAD_GLOBAL", "uuid4" ], [ "CALL_FUNCTION", "uuid4()" ], [ "LOAD_ATTR", "uuid4().hex" ], [ "LOAD_DEREF", "exit_info" ], [ "LOAD_ATTR", "exit_info.current_frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_GLOBAL", "_tracing_recursively" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "_tracing_recursively(frame)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.iteration" ], [ "LOAD_GLOBAL", "_deep_dict" ], [ "CALL_FUNCTION", "_deep_dict()" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._extract_node_values" ], [ "LOAD_DEREF", "top_iteration" ], [ "LOAD_DEREF", "node_values" ], [ "CALL_FUNCTION", "self._extract_node_values(top_iteration, (), node_values)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "BINARY_SUBSCR", "self._code_infos[frame.f_code]" ], [ "LOAD_ATTR", "self._code_infos[frame.f_code].db_func" ], [ "LOAD_DEREF", "exit_info" ], [ "LOAD_ATTR", "exit_info.exc_value" ], [ "LOAD_FAST", "exc" ], [ "LOAD_ATTR", "''.join" ], [ "LOAD_GLOBAL", "traceback" ], [ "LOAD_ATTR", "traceback.format_exception" ], [ "LOAD_GLOBAL", "type" ], [ "LOAD_FAST", "exc" ], [ "CALL_FUNCTION", "type(exc)" ], [ "LOAD_FAST", "exc" ], [ "LOAD_DEREF", "exit_info" ], [ "LOAD_ATTR", "exit_info.exc_tb" ], [ "CALL_FUNCTION", "traceback.format_exception(type(exc), exc, exit_info.exc_tb)" ], [ "CALL_FUNCTION", "''.join(traceback.format_exception(type(exc), exc, exit_info.exc_tb))" ], [ "LOAD_GLOBAL", "exception_string" ], [ "LOAD_FAST", "exc" ], [ "CALL_FUNCTION", "exception_string(exc)" ], [ "LOAD_GLOBAL", "retry_db" ], [ "CALL_FUNCTION", "retry_db" ], [ "LOAD_FAST", "add_call" ], [ "CALL_FUNCTION", "add_call()" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.call_id" ], [ "LOAD_DEREF", "self" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.db" ], [ "LOAD_ATTR", "self.db.Call" ], [ "LOAD_FAST", "Call" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.call_id" ], [ "LOAD_DEREF", "db_func" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.arguments" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_DEREF", "exit_info" ], [ "LOAD_ATTR", "exit_info.return_value" ], [ "CALL_FUNCTION", "cheap_repr(exit_info.return_value)" ], [ "LOAD_DEREF", "exception" ], [ "LOAD_DEREF", "traceback_str" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_ATTR", "json.dumps" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_DEREF", "node_values" ], [ "LOAD_DEREF", "top_iteration" ], [ "LOAD_ATTR", "top_iteration.extract_iterations" ], [ "CALL_FUNCTION", "top_iteration.extract_iterations()" ], [ "BINARY_SUBSCR", "top_iteration.extract_iterations()['loops']" ], [ "LOAD_GLOBAL", "type_registry" ], [ "LOAD_ATTR", "type_registry.names" ], [ "CALL_FUNCTION", "type_registry.names()" ], [ "LOAD_GLOBAL", "type_registry" ], [ "LOAD_ATTR", "type_registry.num_special_types" ], [ "CALL_FUNCTION", "dict(\n node_values=node_values,\n loop_iterations=top_iteration.extract_iterations()['loops'],\n type_names=type_registry.names(),\n num_special_types=type_registry.num_special_types,\n )" ], [ "LOAD_GLOBAL", "ProtocolEncoder" ], [ "CALL_FUNCTION", "json.dumps(\n dict(\n node_values=node_values,\n loop_iterations=top_iteration.extract_iterations()['loops'],\n type_names=type_registry.names(),\n num_special_types=type_registry.num_special_types,\n ),\n cls=ProtocolEncoder,\n separators=(',', ':')\n )" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.start_time" ], [ "CALL_FUNCTION", "Call(id=frame_info.call_id,\n function_id=db_func,\n arguments=frame_info.arguments,\n return_value=cheap_repr(exit_info.return_value),\n exception=exception,\n traceback=traceback_str,\n data=json.dumps(\n dict(\n node_values=node_values,\n loop_iterations=top_iteration.extract_iterations()['loops'],\n type_names=type_registry.names(),\n num_special_types=type_registry.num_special_types,\n ),\n cls=ProtocolEncoder,\n separators=(',', ':')\n ),\n start_time=frame_info.start_time)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.db" ], [ "LOAD_ATTR", "self.db.session_scope" ], [ "CALL_FUNCTION", "self.db.session_scope()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.add" ], [ "LOAD_FAST", "call" ], [ "CALL_FUNCTION", "session.add(call)" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.vals" ], [ "LOAD_ATTR", "iteration.vals.items" ], [ "CALL_FUNCTION", "iteration.vals.items()" ], [ "LOAD_FAST", "tree_index" ], [ "LOAD_FAST", "path" ], [ "BINARY_ADD", "(tree_index,) + path" ], [ "LOAD_FAST", "node_values" ], [ "LOAD_FAST", "full_path" ], [ "SLICE+2", "full_path[:-1]" ], [ "LOAD_FAST", "d" ], [ "LOAD_FAST", "path_k" ], [ "BINARY_SUBSCR", "d[path_k]" ], [ "LOAD_FAST", "node_value" ], [ "LOAD_FAST", "d" ], [ "LOAD_FAST", "full_path" ], [ "BINARY_SUBSCR", "full_path[-1]" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.loops" ], [ "LOAD_ATTR", "iteration.loops.values" ], [ "CALL_FUNCTION", "iteration.loops.values()" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "loop" ], [ "CALL_FUNCTION", "enumerate(loop)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._extract_node_values" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "path + (i,)" ], [ "LOAD_FAST", "node_values" ], [ "CALL_FUNCTION", "self._extract_node_values(iteration, path + (i,), node_values)" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "BirdsEye" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(BirdsEye, self)" ], [ "LOAD_ATTR", "super(BirdsEye, self).trace_function" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "super(BirdsEye, self).trace_function(func)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_ATTR", "self._code_infos.get" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_ATTR", "new_func.__code__" ], [ "CALL_FUNCTION", "self._code_infos.get(new_func.__code__)" ], [ "LOAD_FAST", "code_info" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.getsourcelines" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "inspect.getsourcelines(func)" ], [ "LOAD_FAST", "start_lineno" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "lines" ], [ "CALL_FUNCTION", "len(lines)" ], [ "BINARY_ADD", "start_lineno + len(lines)" ], [ "LOAD_GLOBAL", "safe_qualname" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "safe_qualname(func)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.getsourcefile" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "inspect.getsourcefile(func)" ], [ "LOAD_FAST", "source_file" ], [ "LOAD_ATTR", "source_file.startswith" ], [ "CALL_FUNCTION", "source_file.startswith('= 0" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.getsourcefile" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "inspect.getsourcefile(frame)" ], [ "LOAD_FAST", "filename" ], [ "COMPARE_OP", "filename is not None" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.abspath" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "os.path.abspath(filename)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "LOAD_ATTR", "frame.f_globals.get" ], [ "CALL_FUNCTION", "frame.f_globals.get('__name__')" ], [ "COMPARE_OP", "frame.f_globals.get('__name__') != '__main__'" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._treetrace_hidden_with_stmt" ], [ "LOAD_ATTR", "self._treetrace_hidden_with_stmt.__name__" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "COMPARE_OP", "self._treetrace_hidden_with_stmt.__name__ not in frame.f_globals" ], [ "LOAD_GLOBAL", "RuntimeError" ], [ "CALL_FUNCTION", "RuntimeError(\n 'To trace an imported module, you must import birdseye before '\n 'importing that module.')" ], [ "LOAD_GLOBAL", "read_source_file" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "read_source_file(filename)" ], [ "LOAD_ATTR", "read_source_file(filename).splitlines" ], [ "CALL_FUNCTION", "read_source_file(filename).splitlines()" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lineno" ], [ "BINARY_MULTIPLY", "[''] * frame.f_lineno" ], [ "LOAD_FAST", "lines" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lineno" ], [ "LOAD_ATTR", "'\\n'.join" ], [ "LOAD_FAST", "lines" ], [ "CALL_FUNCTION", "'\\n'.join(lines)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.exec_string" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "LOAD_FAST", "deep" ], [ "CALL_FUNCTION", "self.exec_string(source, filename, frame.f_globals, frame.f_locals, deep)" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.exit" ], [ "CALL_FUNCTION", "sys.exit(0)" ], [ "LOAD_FAST", "globs" ], [ "LOAD_FAST", "locs" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.compile" ], [ "LOAD_DEREF", "source" ], [ "LOAD_DEREF", "filename" ], [ "CALL_FUNCTION", "self.compile(source, filename)" ], [ "LOAD_FAST", "globs" ], [ "LOAD_ATTR", "globs.update" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._trace_methods_dict" ], [ "LOAD_DEREF", "traced_file" ], [ "CALL_FUNCTION", "self._trace_methods_dict(traced_file)" ], [ "CALL_FUNCTION", "globs.update(self._trace_methods_dict(traced_file))" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._trace" ], [ "LOAD_NAME", "FILE_SENTINEL_NAME" ], [ "LOAD_DEREF", "filename" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.code" ], [ "LOAD_DEREF", "source" ], [ "CALL_FUNCTION", "self._trace(FILE_SENTINEL_NAME, filename, traced_file, traced_file.code, 'module', source)" ], [ "LOAD_FAST", "deep" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.nodes" ], [ "LOAD_DEREF", "find_code" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.code" ], [ "CALL_FUNCTION", "find_code(traced_file.code)" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.code" ], [ "LOAD_FAST", "globs" ], [ "LOAD_FAST", "locs" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(node, ast.FunctionDef)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.lineno" ], [ "LOAD_FAST", "root_code" ], [ "LOAD_ATTR", "root_code.co_consts" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.iscode" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "inspect.iscode(code)" ], [ "UNARY_NOT", "not inspect.iscode(code)" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "LOAD_ATTR", "code.co_name.startswith" ], [ "CALL_FUNCTION", "code.co_name.startswith('<')" ], [ "LOAD_DEREF", "find_code" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "find_code(code)" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_firstlineno" ], [ "LOAD_DEREF", "nodes_by_lineno" ], [ "LOAD_ATTR", "nodes_by_lineno.get" ], [ "LOAD_FAST", "lineno" ], [ "CALL_FUNCTION", "nodes_by_lineno.get(lineno)" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._trace" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "LOAD_DEREF", "filename" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_FAST", "code" ], [ "LOAD_DEREF", "source" ], [ "LOAD_FAST", "lineno" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.last_token" ], [ "LOAD_ATTR", "node.last_token.end" ], [ "BINARY_SUBSCR", "node.last_token.end[0]" ], [ "BINARY_ADD", "node.last_token.end[0] + 1" ], [ "CALL_FUNCTION", "self._trace(\n code.co_name, filename, traced_file, code,\n typ='function',\n source=source,\n start_lineno=lineno,\n end_lineno=node.last_token.end[0] + 1,\n )" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_DEREF", "start_lineno" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.splitlines" ], [ "CALL_FUNCTION", "source.splitlines()" ], [ "CALL_FUNCTION", "len(source.splitlines())" ], [ "BINARY_ADD", "start_lineno + len(source.splitlines())" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._nodes_of_interest" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_DEREF", "start_lineno" ], [ "LOAD_FAST", "end_lineno" ], [ "CALL_FUNCTION", "self._nodes_of_interest(traced_file, start_lineno, end_lineno)" ], [ "CALL_FUNCTION", "list(self._nodes_of_interest(traced_file, start_lineno, end_lineno))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._nodes_html" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_DEREF", "start_lineno" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_FAST", "traced_file" ], [ "CALL_FUNCTION", "self._nodes_html(nodes, start_lineno, end_lineno, traced_file)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "nodes" ], [ "CALL_FUNCTION", "dict(\n # This maps each node to the loops enclosing that node\n node_loops={\n node._tree_index: [n._tree_index for n in node._loops]\n for node, _ in nodes\n if node._loops\n },\n )" ], [ "LOAD_FAST", "typ" ], [ "COMPARE_OP", "typ == 'function'" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.tokens" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_FAST", "nodes" ], [ "CALL_FUNCTION", "only(node\n for node, _ in nodes\n if isinstance(node, ast.FunctionDef)\n and node.first_token.start[0] == start_lineno)" ], [ "LOAD_GLOBAL", "source_without_decorators" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_FAST", "func_node" ], [ "CALL_FUNCTION", "source_without_decorators(tokens, func_node)" ], [ "LOAD_FAST", "data_dict" ], [ "LOAD_ATTR", "data_dict.update" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._node_ranges" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_FAST", "func_startpos" ], [ "CALL_FUNCTION", "self._node_ranges(nodes, tokens, func_startpos)" ], [ "CALL_FUNCTION", "list(self._node_ranges(nodes, tokens, func_startpos))" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._loop_ranges" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_FAST", "func_startpos" ], [ "CALL_FUNCTION", "self._loop_ranges(nodes, tokens, func_startpos)" ], [ "CALL_FUNCTION", "list(self._loop_ranges(nodes, tokens, func_startpos))" ], [ "CALL_FUNCTION", "data_dict.update(\n node_ranges=list(self._node_ranges(nodes, tokens, func_startpos)),\n loop_ranges=list(self._loop_ranges(nodes, tokens, func_startpos)),\n )" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_ATTR", "json.dumps" ], [ "LOAD_FAST", "data_dict" ], [ "LOAD_GLOBAL", "True" ], [ "CALL_FUNCTION", "json.dumps(data_dict, sort_keys=True)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._db_func" ], [ "LOAD_FAST", "data" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "html_body" ], [ "LOAD_FAST", "name" ], [ "LOAD_DEREF", "start_lineno" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "typ" ], [ "CALL_FUNCTION", "self._db_func(data, filename, html_body, name, start_lineno, source, typ)" ], [ "LOAD_GLOBAL", "CodeInfo" ], [ "LOAD_FAST", "db_func" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_FAST", "arg_names" ], [ "CALL_FUNCTION", "CodeInfo(db_func, traced_file, arg_names)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "n" ], [ "LOAD_ATTR", "n._tree_index" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(node, ast.FunctionDef)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.first_token" ], [ "LOAD_ATTR", "node.first_token.start" ], [ "BINARY_SUBSCR", "node.first_token.start[0]" ], [ "LOAD_DEREF", "start_lineno" ], [ "COMPARE_OP", "node.first_token.start[0] == start_lineno" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "classes" ], [ "COMPARE_OP", "'loop' not in classes" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.target" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.test" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_ATTR", "tokens.get_text_range" ], [ "LOAD_FAST", "target" ], [ "CALL_FUNCTION", "tokens.get_text_range(target)" ], [ "LOAD_FAST", "func_start" ], [ "LOAD_FAST", "func_start" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "CALL_FUNCTION", "dict(\n tree_index=node._tree_index,\n start=start,\n end=end\n )" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_ATTR", "tokens.get_text_range" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "tokens.get_text_range(node)" ], [ "LOAD_FAST", "func_start" ], [ "LOAD_FAST", "func_start" ], [ "LOAD_FAST", "start" ], [ "COMPARE_OP", "start < 0" ], [ "LOAD_FAST", "end" ], [ "COMPARE_OP", "end < 0" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(node, ast.FunctionDef)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._depth" ], [ "LOAD_FAST", "classes" ], [ "CALL_FUNCTION", "dict(\n tree_index=node._tree_index,\n start=start,\n end=end,\n depth=node._depth,\n classes=classes,\n )" ], [ "LOAD_FAST", "h" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "name" ], [ "BINARY_ADD", "filename + name" ], [ "LOAD_FAST", "html_body" ], [ "BINARY_ADD", "filename + name + html_body" ], [ "LOAD_FAST", "data" ], [ "BINARY_ADD", "filename + name + html_body + data" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "start_lineno" ], [ "CALL_FUNCTION", "str(start_lineno)" ], [ "BINARY_ADD", "filename + name + html_body + data + str(start_lineno)" ], [ "CALL_FUNCTION", "h(filename + name + html_body + data + str(start_lineno))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.db" ], [ "LOAD_ATTR", "self.db.Function" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.db" ], [ "LOAD_ATTR", "self.db.session_scope" ], [ "CALL_FUNCTION", "self.db.session_scope()" ], [ "LOAD_GLOBAL", "one_or_none" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_FAST", "Function" ], [ "CALL_FUNCTION", "session.query(Function)" ], [ "LOAD_ATTR", "session.query(Function).filter_by" ], [ "LOAD_FAST", "function_hash" ], [ "CALL_FUNCTION", "session.query(Function).filter_by(hash=function_hash)" ], [ "CALL_FUNCTION", "one_or_none(session.query(Function).filter_by(hash=function_hash))" ], [ "LOAD_FAST", "db_func" ], [ "LOAD_FAST", "Function" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "typ" ], [ "LOAD_FAST", "html_body" ], [ "LOAD_FAST", "start_lineno" ], [ "LOAD_FAST", "data" ], [ "LOAD_FAST", "h" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "h(source)" ], [ "LOAD_FAST", "function_hash" ], [ "CALL_FUNCTION", "Function(file=filename,\n name=name,\n type=typ,\n html_body=html_body,\n lineno=start_lineno,\n data=data,\n body_hash=h(source),\n hash=function_hash)" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.add" ], [ "LOAD_FAST", "db_func" ], [ "CALL_FUNCTION", "session.add(db_func)" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.commit" ], [ "CALL_FUNCTION", "session.commit()" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "db_func" ], [ "LOAD_ATTR", "db_func.id" ], [ "LOAD_GLOBAL", "int" ], [ "CALL_FUNCTION", "isinstance(db_func.id, int)" ], [ "LOAD_FAST", "db_func" ], [ "LOAD_ATTR", "db_func.id" ], [ "LOAD_GLOBAL", "hashlib" ], [ "LOAD_ATTR", "hashlib.sha256" ], [ "LOAD_FAST", "s" ], [ "LOAD_ATTR", "s.encode" ], [ "CALL_FUNCTION", "s.encode('utf8')" ], [ "CALL_FUNCTION", "hashlib.sha256(s.encode('utf8'))" ], [ "LOAD_ATTR", "hashlib.sha256(s.encode('utf8')).hexdigest" ], [ "CALL_FUNCTION", "hashlib.sha256(s.encode('utf8')).hexdigest()" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.nodes" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "CALL_FUNCTION", "isinstance(node, (ast.While, ast.For, ast.comprehension))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.GeneratorExp" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.GeneratorExp)" ], [ "UNARY_NOT", "not isinstance(node.parent, ast.GeneratorExp)" ], [ "LOAD_FAST", "classes" ], [ "LOAD_ATTR", "classes.append" ], [ "CALL_FUNCTION", "classes.append('loop')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "CALL_FUNCTION", "isinstance(node, ast.stmt)" ], [ "LOAD_FAST", "classes" ], [ "LOAD_ATTR", "classes.append" ], [ "CALL_FUNCTION", "classes.append('stmt')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "CALL_FUNCTION", "isinstance(node, ast.expr)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._is_interesting_expression" ], [ "LOAD_FAST", "classes" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.AST" ], [ "CALL_FUNCTION", "isinstance(node, ast.AST)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "hasattr(node, 'first_token')" ], [ "LOAD_FAST", "start_lineno" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.first_token" ], [ "LOAD_ATTR", "node.first_token.start" ], [ "BINARY_SUBSCR", "node.first_token.start[0]" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.tokens" ], [ "LOAD_ATTR", "traced_file.tokens.get_text_range" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "traced_file.tokens.get_text_range(node)" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "classes" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.root" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.walk" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.root" ], [ "CALL_FUNCTION", "ast.walk(traced_file.root)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.iter_child_nodes" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ast.iter_child_nodes(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._depth" ], [ "BINARY_ADD", "node._depth + 1" ], [ "LOAD_FAST", "child" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "positions" ], [ "LOAD_ATTR", "positions.extend" ], [ "LOAD_GLOBAL", "map" ], [ "LOAD_GLOBAL", "HTMLPosition" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "LOAD_GLOBAL", "True" ], [ "LOAD_GLOBAL", "False" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._depth" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._depth" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_ATTR", "' '.join" ], [ "LOAD_FAST", "classes" ], [ "CALL_FUNCTION", "' '.join(classes)" ], [ "BINARY_MODULO", "'' % (node._tree_index, ' '.join(classes))" ], [ "CALL_FUNCTION", "map(\n HTMLPosition,\n [start, end],\n [True, False], # is_start\n [node._depth, node._depth],\n ['' % (node._tree_index, ' '.join(classes)),\n ''])" ], [ "CALL_FUNCTION", "positions.extend(map(\n HTMLPosition,\n [start, end],\n [True, False], # is_start\n [node._depth, node._depth],\n ['' % (node._tree_index, ' '.join(classes)),\n '']))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._separate_comprehensions" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "n" ], [ "BINARY_SUBSCR", "n[0]" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_FAST", "positions" ], [ "LOAD_FAST", "traced_file" ], [ "CALL_FUNCTION", "self._separate_comprehensions(\n [n[0] for n in nodes],\n end_lineno, positions, traced_file)" ], [ "LOAD_FAST", "positions" ], [ "LOAD_ATTR", "positions.append" ], [ "LOAD_GLOBAL", "HTMLPosition" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.source" ], [ "CALL_FUNCTION", "len(traced_file.source)" ], [ "LOAD_GLOBAL", "False" ], [ "CALL_FUNCTION", "HTMLPosition(len(traced_file.source), False, 0, '')" ], [ "CALL_FUNCTION", "positions.append(HTMLPosition(len(traced_file.source), False, 0, ''))" ], [ "LOAD_FAST", "positions" ], [ "LOAD_ATTR", "positions.sort" ], [ "CALL_FUNCTION", "positions.sort()" ], [ "LOAD_FAST", "positions" ], [ "LOAD_FAST", "html_parts" ], [ "LOAD_ATTR", "html_parts.append" ], [ "LOAD_GLOBAL", "html" ], [ "LOAD_ATTR", "html.escape" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.source" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "position" ], [ "LOAD_ATTR", "position.index" ], [ "SLICE+3", "traced_file.source[start:position.index]" ], [ "CALL_FUNCTION", "html.escape(traced_file.source[start:position.index])" ], [ "CALL_FUNCTION", "html_parts.append(html.escape(traced_file.source[start:position.index]))" ], [ "LOAD_FAST", "html_parts" ], [ "LOAD_ATTR", "html_parts.append" ], [ "LOAD_FAST", "position" ], [ "LOAD_ATTR", "position.html" ], [ "CALL_FUNCTION", "html_parts.append(position.html)" ], [ "LOAD_FAST", "position" ], [ "LOAD_ATTR", "position.index" ], [ "LOAD_ATTR", "''.join" ], [ "LOAD_FAST", "html_parts" ], [ "CALL_FUNCTION", "''.join(html_parts)" ], [ "LOAD_ATTR", "'\\n'.join" ], [ "LOAD_FAST", "html_body" ], [ "LOAD_ATTR", "html_body.split" ], [ "CALL_FUNCTION", "html_body.split('\\n')" ], [ "LOAD_FAST", "start_lineno" ], [ "BINARY_SUBTRACT", "start_lineno - 1" ], [ "LOAD_FAST", "end_lineno" ], [ "BINARY_SUBTRACT", "end_lineno - 1" ], [ "SLICE+3", "html_body.split('\\n')[start_lineno - 1:end_lineno - 1]" ], [ "CALL_FUNCTION", "'\\n'.join(html_body.split('\\n')[start_lineno - 1:end_lineno - 1])" ], [ "LOAD_FAST", "html_body" ], [ "LOAD_ATTR", "html_body.strip" ], [ "CALL_FUNCTION", "html_body.strip('\\n')" ], [ "LOAD_GLOBAL", "group_by_key_func" ], [ "LOAD_GLOBAL", "of_type" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "LOAD_FAST", "nodes" ], [ "CALL_FUNCTION", "of_type((ast.comprehension, ast.While, ast.For), nodes)" ], [ "CALL_FUNCTION", "group_by_key_func(of_type((ast.comprehension, ast.While, ast.For), nodes),\n lambda c: c.first_token.start[0]\n )" ], [ "LOAD_FAST", "comprehensions" ], [ "LOAD_ATTR", "comprehensions.values" ], [ "CALL_FUNCTION", "comprehensions.values()" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_FAST", "comp_list" ], [ "CALL_FUNCTION", "sorted(comp_list, key=lambda c: c.first_token.startpos)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "comp" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "CALL_FUNCTION", "isinstance(comp, ast.comprehension)" ], [ "LOAD_FAST", "comp" ], [ "LOAD_FAST", "comp" ], [ "LOAD_ATTR", "comp.parent" ], [ "LOAD_ATTR", "comp.parent.generators" ], [ "BINARY_SUBSCR", "comp.parent.generators[0]" ], [ "COMPARE_OP", "comp is comp.parent.generators[0]" ], [ "LOAD_FAST", "get_start" ], [ "LOAD_FAST", "comp" ], [ "LOAD_ATTR", "comp.parent" ], [ "CALL_FUNCTION", "get_start(comp.parent)" ], [ "LOAD_FAST", "prev_start" ], [ "COMPARE_OP", "prev_start is not None" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "prev_start" ], [ "COMPARE_OP", "start < prev_start" ], [ "LOAD_FAST", "get_start" ], [ "LOAD_FAST", "comp" ], [ "CALL_FUNCTION", "get_start(comp)" ], [ "LOAD_FAST", "get_start" ], [ "LOAD_FAST", "comp" ], [ "CALL_FUNCTION", "get_start(comp)" ], [ "LOAD_FAST", "prev_start" ], [ "COMPARE_OP", "prev_start is not None" ], [ "LOAD_FAST", "positions" ], [ "LOAD_ATTR", "positions.append" ], [ "LOAD_GLOBAL", "HTMLPosition" ], [ "LOAD_FAST", "start" ], [ "LOAD_GLOBAL", "True" ], [ "CALL_FUNCTION", "HTMLPosition(start, True, 0, '\\n ')" ], [ "CALL_FUNCTION", "positions.append(HTMLPosition(start, True, 0, '\\n '))" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.first_token" ], [ "LOAD_ATTR", "c.first_token.start" ], [ "BINARY_SUBSCR", "c.first_token.start[0]" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.tokens" ], [ "LOAD_ATTR", "traced_file.tokens.get_text_range" ], [ "LOAD_FAST", "n" ], [ "CALL_FUNCTION", "traced_file.tokens.get_text_range(n)" ], [ "BINARY_SUBSCR", "traced_file.tokens.get_text_range(n)[0]" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.first_token" ], [ "LOAD_ATTR", "c.first_token.startpos" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "_deep_dict" ], [ "CALL_FUNCTION", "defaultdict(_deep_dict)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_GLOBAL", "_bad_codes" ], [ "COMPARE_OP", "frame.f_code in _bad_codes" ], [ "LOAD_GLOBAL", "True" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "IterationList" ], [ "CALL_FUNCTION", "defaultdict(IterationList)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "False" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.index" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.loops" ], [ "LOAD_ATTR", "self.loops.items" ], [ "CALL_FUNCTION", "self.loops.items()" ], [ "LOAD_FAST", "iteration_list" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.extract_iterations" ], [ "CALL_FUNCTION", "iteration.extract_iterations()" ], [ "LOAD_FAST", "tree_index" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "deque" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.side_len" ], [ "CALL_FUNCTION", "deque(maxlen=self.side_len)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "Counter" ], [ "CALL_FUNCTION", "Counter()" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.length" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.side_len" ], [ "COMPARE_OP", "self.length < self.side_len" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start" ], [ "LOAD_ATTR", "self.start.append" ], [ "LOAD_FAST", "iteration" ], [ "CALL_FUNCTION", "self.start.append(iteration)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "CALL_FUNCTION", "len(self.end)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.side_len" ], [ "COMPARE_OP", "len(self.end) >= self.side_len" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "BINARY_SUBSCR", "self.end[0]" ], [ "LOAD_ATTR", "self.end[0].keep" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start" ], [ "LOAD_ATTR", "self.start.append" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "BINARY_SUBSCR", "self.end[0]" ], [ "CALL_FUNCTION", "self.start.append(self.end[0])" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "LOAD_ATTR", "self.end.append" ], [ "LOAD_FAST", "iteration" ], [ "CALL_FUNCTION", "self.end.append(iteration)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.length" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "chain" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "CALL_FUNCTION", "chain(self.start, self.end)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "BINARY_SUBSCR", "self.end[-1]" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start" ], [ "BINARY_SUBSCR", "self.start[-1]" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.recorded" ], [ "LOAD_FAST", "node" ], [ "BINARY_SUBSCR", "self.recorded[node]" ], [ "COMPARE_OP", "self.recorded[node] >= 2" ], [ "LOAD_GLOBAL", "True" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.last" ], [ "CALL_FUNCTION", "self.last()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.recorded" ], [ "LOAD_FAST", "node" ], [ "LOAD_NAME", "type" ], [ "CALL_FUNCTION", "type(None)" ], [ "LOAD_NAME", "bool" ], [ "LOAD_NAME", "int" ], [ "LOAD_NAME", "float" ], [ "LOAD_NAME", "complex" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "long" ], [ "LOAD_NAME", "basic_types" ], [ "LOAD_NAME", "list" ], [ "LOAD_NAME", "dict" ], [ "LOAD_NAME", "tuple" ], [ "LOAD_NAME", "set" ], [ "LOAD_NAME", "frozenset" ], [ "LOAD_NAME", "str" ], [ "BINARY_ADD", "basic_types + (list, dict, tuple, set, frozenset, str)" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "unicode" ], [ "LOAD_NAME", "bytes" ], [ "LOAD_NAME", "len" ], [ "LOAD_NAME", "special_types" ], [ "CALL_FUNCTION", "len(special_types)" ], [ "LOAD_GLOBAL", "Lock" ], [ "CALL_FUNCTION", "Lock()" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "CALL_FUNCTION", "defaultdict(lambda: len(self.data))" ], [ "LOAD_DEREF", "self" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.special_types" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.data" ], [ "LOAD_FAST", "t" ], [ "BINARY_SUBSCR", "self.data[t]" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.data" ], [ "CALL_FUNCTION", "len(self.data)" ], [ "LOAD_GLOBAL", "correct_type" ], [ "LOAD_FAST", "item" ], [ "CALL_FUNCTION", "correct_type(item)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.lock" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.data" ], [ "LOAD_FAST", "t" ], [ "BINARY_SUBSCR", "self.data[t]" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.data" ], [ "LOAD_ATTR", "self.data.items" ], [ "CALL_FUNCTION", "self.data.items()" ], [ "CALL_FUNCTION", "dict((v, k) for k, v in self.data.items())" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "rev" ], [ "CALL_FUNCTION", "len(rev)" ], [ "CALL_FUNCTION", "range(len(rev))" ], [ "LOAD_GLOBAL", "safe_qualname" ], [ "LOAD_FAST", "rev" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "rev[i]" ], [ "CALL_FUNCTION", "safe_qualname(rev[i])" ], [ "LOAD_FAST", "v" ], [ "LOAD_FAST", "k" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_FAST", "val_repr" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "type_index" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.meta" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.meta" ], [ "LOAD_FAST", "key" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.children" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.children" ], [ "LOAD_ATTR", "self.children.append" ], [ "LOAD_FAST", "key" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOAD_ATTR", "NodeValue.expression" ], [ "LOAD_FAST", "samples" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "level" ], [ "CALL_FUNCTION", "NodeValue.expression(samples, value, level)" ], [ "CALL_FUNCTION", "self.children.append((key, NodeValue.expression(samples, value, level)))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.val_repr" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.type_index" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.meta" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.children" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.extend" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.children" ], [ "CALL_FUNCTION", "result.extend(self.children)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "cls" ], [ "CALL_FUNCTION", "cls('', -2)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_GLOBAL", "exception_string" ], [ "LOAD_FAST", "exc_value" ], [ "CALL_FUNCTION", "exception_string(exc_value)" ], [ "CALL_FUNCTION", "cls(exception_string(exc_value), -1)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "cheap_repr(val)" ], [ "LOAD_GLOBAL", "type_registry" ], [ "LOAD_FAST", "val" ], [ "BINARY_SUBSCR", "type_registry[val]" ], [ "CALL_FUNCTION", "cls(cheap_repr(val), type_registry[val])" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "TypeRegistry" ], [ "LOAD_ATTR", "TypeRegistry.basic_types" ], [ "LOAD_GLOBAL", "BirdsEye" ], [ "CALL_FUNCTION", "isinstance(val, (TypeRegistry.basic_types, BirdsEye))" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "QuerySet" ], [ "CALL_FUNCTION", "isinstance(val, QuerySet)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "len(val)" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.set_meta" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "result.set_meta('len', length)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "ModuleType" ], [ "CALL_FUNCTION", "isinstance(val, ModuleType)" ], [ "LOAD_GLOBAL", "min" ], [ "LOAD_FAST", "level" ], [ "CALL_FUNCTION", "min(level, 2)" ], [ "LOAD_GLOBAL", "partial" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.add_child" ], [ "LOAD_FAST", "samples" ], [ "LOAD_FAST", "level" ], [ "BINARY_SUBTRACT", "level - 1" ], [ "CALL_FUNCTION", "partial(result.add_child, samples, level - 1)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Series" ], [ "LOAD_GLOBAL", "ndarray" ], [ "CALL_FUNCTION", "isinstance(val, (Series, ndarray))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "ndarray" ], [ "CALL_FUNCTION", "isinstance(val, ndarray)" ], [ "LOAD_FAST", "attrs" ], [ "LOAD_ATTR", "attrs.append" ], [ "CALL_FUNCTION", "attrs.append('shape')" ], [ "LOAD_FAST", "attrs" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "val" ], [ "LOAD_FAST", "name" ], [ "CALL_FUNCTION", "getattr(val, name)" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "attr" ], [ "CALL_FUNCTION", "add_child(name, attr)" ], [ "LOAD_FAST", "level" ], [ "COMPARE_OP", "level >= 3" ], [ "LOAD_FAST", "level" ], [ "COMPARE_OP", "level >= 2" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Series" ], [ "CALL_FUNCTION", "isinstance(val, Series)" ], [ "LOAD_FAST", "samples" ], [ "LOAD_FAST", "sample_type" ], [ "BINARY_SUBSCR", "samples[sample_type]" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "DataFrame" ], [ "CALL_FUNCTION", "isinstance(val, DataFrame)" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.set_meta" ], [ "LOAD_FAST", "meta" ], [ "CALL_FUNCTION", "result.set_meta('dataframe', meta)" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['pandas_rows']" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['pandas_cols']" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_rows" ], [ "BINARY_ADD", "max_rows + 2" ], [ "COMPARE_OP", "length > max_rows + 2" ], [ "LOAD_FAST", "max_rows" ], [ "BINARY_FLOOR_DIVIDE", "max_rows // 2" ], [ "LOAD_FAST", "meta" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.columns" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "columns" ], [ "CALL_FUNCTION", "len(columns)" ], [ "LOAD_FAST", "num_cols" ], [ "LOAD_FAST", "max_cols" ], [ "BINARY_ADD", "max_cols + 2" ], [ "COMPARE_OP", "num_cols > max_cols + 2" ], [ "LOAD_FAST", "max_cols" ], [ "BINARY_FLOOR_DIVIDE", "max_cols // 2" ], [ "LOAD_FAST", "meta" ], [ "LOAD_GLOBAL", "set" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "num_cols" ], [ "LOAD_FAST", "max_cols" ], [ "CALL_FUNCTION", "_sample_indices(num_cols, max_cols)" ], [ "CALL_FUNCTION", "set(_sample_indices(num_cols, max_cols))" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_GLOBAL", "zip" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.columns" ], [ "LOAD_ATTR", "val.columns.format" ], [ "LOAD_GLOBAL", "False" ], [ "CALL_FUNCTION", "val.columns.format(sparsify=False)" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.columns" ], [ "CALL_FUNCTION", "zip(val.columns.format(sparsify=False),\n val.columns)" ], [ "CALL_FUNCTION", "enumerate(zip(val.columns.format(sparsify=False),\n val.columns))" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "indices" ], [ "COMPARE_OP", "i in indices" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_FAST", "formatted_name" ], [ "LOAD_FAST", "val" ], [ "LOAD_FAST", "label" ], [ "BINARY_SUBSCR", "val[label]" ], [ "CALL_FUNCTION", "add_child(formatted_name, val[label])" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Series" ], [ "CALL_FUNCTION", "isinstance(val, Series)" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['pandas_rows']" ], [ "CALL_FUNCTION", "_sample_indices(length, samples['pandas_rows'])" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.index" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "SLICE+3", "val.index[i:i + 1]" ], [ "LOAD_ATTR", "val.index[i:i + 1].format" ], [ "LOAD_GLOBAL", "False" ], [ "CALL_FUNCTION", "val.index[i:i + 1].format(sparsify=False)" ], [ "BINARY_SUBSCR", "val.index[i:i + 1].format(sparsify=False)[0]" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.iloc" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "val.iloc[i]" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_FAST", "k" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child(k, v)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "level" ], [ "COMPARE_OP", "level <= 0" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "bytes" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "unicode" ], [ "LOAD_GLOBAL", "xrange" ], [ "CALL_FUNCTION", "isinstance(val,\n (str, bytes, range)\n if PY3 else\n (str, unicode, xrange))" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Sequence" ], [ "LOAD_GLOBAL", "ndarray" ], [ "CALL_FUNCTION", "isinstance(val, (Sequence, ndarray))" ], [ "LOAD_FAST", "length" ], [ "COMPARE_OP", "length is not None" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['list']" ], [ "CALL_FUNCTION", "_sample_indices(length, samples['list'])" ], [ "LOAD_FAST", "val" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "val[i]" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "i" ], [ "CALL_FUNCTION", "str(i)" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child(str(i), v)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Mapping" ], [ "CALL_FUNCTION", "isinstance(val, Mapping)" ], [ "LOAD_GLOBAL", "islice" ], [ "LOAD_GLOBAL", "_safe_iter" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "iteritems" ], [ "CALL_FUNCTION", "_safe_iter(val, iteritems)" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['dict']" ], [ "CALL_FUNCTION", "islice(_safe_iter(val, iteritems), samples['dict'])" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "k" ], [ "CALL_FUNCTION", "cheap_repr(k)" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child(cheap_repr(k), v)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Set" ], [ "CALL_FUNCTION", "isinstance(val, Set)" ], [ "LOAD_GLOBAL", "_safe_iter" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "_safe_iter(val)" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['set']" ], [ "LOAD_FAST", "length" ], [ "COMPARE_OP", "length is None" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "num_items" ], [ "BINARY_ADD", "num_items + 2" ], [ "COMPARE_OP", "length > num_items + 2" ], [ "LOAD_GLOBAL", "islice" ], [ "LOAD_FAST", "vals" ], [ "LOAD_FAST", "num_items" ], [ "CALL_FUNCTION", "islice(vals, num_items)" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "vals" ], [ "CALL_FUNCTION", "enumerate(vals)" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_FAST", "i" ], [ "BINARY_MODULO", "'<%s>' % i" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child('<%s>' % i, v)" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "getattr(val, '__dict__', None)" ], [ "LOAD_FAST", "d" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_GLOBAL", "islice" ], [ "LOAD_GLOBAL", "_safe_iter" ], [ "LOAD_FAST", "d" ], [ "CALL_FUNCTION", "_safe_iter(d)" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['attributes']" ], [ "CALL_FUNCTION", "islice(_safe_iter(d),\n samples['attributes'])" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "sorted(islice(_safe_iter(d),\n samples['attributes']),\n key=str)" ], [ "LOAD_FAST", "d" ], [ "LOAD_FAST", "k" ], [ "BINARY_SUBSCR", "d[k]" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "TracedFile" ], [ "CALL_FUNCTION", "isinstance(v, TracedFile)" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "k" ], [ "CALL_FUNCTION", "str(k)" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child(str(k), v)" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "type" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "type(val)" ], [ "CALL_FUNCTION", "getattr(type(val), '__slots__', None)" ], [ "CALL_FUNCTION", "sorted(getattr(type(val), '__slots__', None) or ())" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "val" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "getattr(val, s)" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "str(s)" ], [ "LOAD_FAST", "attr" ], [ "CALL_FUNCTION", "add_child(str(s), attr)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "x" ], [ "LOAD_FAST", "f" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "f(val)" ], [ "LOAD_FAST", "x" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_ADD", "max_length + 2" ], [ "COMPARE_OP", "length <= max_length + 2" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "range(length)" ], [ "LOAD_GLOBAL", "chain" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_FLOOR_DIVIDE", "max_length // 2" ], [ "CALL_FUNCTION", "range(max_length // 2)" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_FLOOR_DIVIDE", "max_length // 2" ], [ "BINARY_SUBTRACT", "length - max_length // 2" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "range(length - max_length // 2,\n length)" ], [ "CALL_FUNCTION", "chain(range(max_length // 2),\n range(length - max_length // 2,\n length))" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "len(x)" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "n == 0" ], [ "LOAD_GLOBAL", "repr" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "repr(x)" ], [ "LOAD_FAST", "helper" ], [ "LOAD_ATTR", "helper.level" ], [ "BINARY_SUBTRACT", "helper.level - 1" ], [ "LOAD_GLOBAL", "_repr_series_one_line" ], [ "LOAD_ATTR", "_repr_series_one_line.maxparts" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "n" ], [ "LOAD_FAST", "maxparts" ], [ "CALL_FUNCTION", "_sample_indices(n, maxparts)" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.index" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "SLICE+3", "x.index[i:i + 1]" ], [ "LOAD_ATTR", "x.index[i:i + 1].format" ], [ "LOAD_GLOBAL", "False" ], [ "CALL_FUNCTION", "x.index[i:i + 1].format(sparsify=False)" ], [ "BINARY_SUBSCR", "x.index[i:i + 1].format(sparsify=False)[0]" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.iloc" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "x.iloc[i]" ], [ "LOAD_FAST", "pieces" ], [ "LOAD_ATTR", "pieces.append" ], [ "LOAD_FAST", "k" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "v" ], [ "LOAD_FAST", "newlevel" ], [ "CALL_FUNCTION", "cheap_repr(v, newlevel)" ], [ "BINARY_MODULO", "'%s = %s' % (k, cheap_repr(v, newlevel))" ], [ "CALL_FUNCTION", "pieces.append('%s = %s' % (k, cheap_repr(v, newlevel)))" ], [ "LOAD_FAST", "n" ], [ "LOAD_FAST", "maxparts" ], [ "BINARY_ADD", "maxparts + 2" ], [ "COMPARE_OP", "n > maxparts + 2" ], [ "LOAD_FAST", "pieces" ], [ "LOAD_ATTR", "pieces.insert" ], [ "LOAD_FAST", "maxparts" ], [ "BINARY_FLOOR_DIVIDE", "maxparts // 2" ], [ "CALL_FUNCTION", "pieces.insert(maxparts // 2, '...')" ], [ "LOAD_ATTR", "'; '.join" ], [ "LOAD_FAST", "pieces" ], [ "CALL_FUNCTION", "'; '.join(pieces)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "CALL_FUNCTION", "isinstance(node, ast.expr)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Num" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Str" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "ast" ], [ "CALL_FUNCTION", "getattr(ast, 'NameConstant', ())" ], [ "CALL_FUNCTION", "isinstance(node, (ast.Num, ast.Str, getattr(ast, 'NameConstant', ())))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "getattr(node, 'ctx', None)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Store" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Del" ], [ "CALL_FUNCTION", "isinstance(getattr(node, 'ctx', None),\n (ast.Store, ast.Del))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.UnaryOp" ], [ "CALL_FUNCTION", "isinstance(node, ast.UnaryOp)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.op" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.UAdd" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.USub" ], [ "CALL_FUNCTION", "isinstance(node.op, (ast.UAdd, ast.USub))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.operand" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Num" ], [ "CALL_FUNCTION", "isinstance(node.operand, ast.Num)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.List" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Tuple" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Dict" ], [ "CALL_FUNCTION", "isinstance(node, (ast.List, ast.Tuple, ast.Dict))" ], [ "LOAD_GLOBAL", "any" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.iter_child_nodes" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ast.iter_child_nodes(node)" ], [ "CALL_FUNCTION", "any(is_interesting_expression(n) for n in ast.iter_child_nodes(node))" ], [ "UNARY_NOT", "not any(is_interesting_expression(n) for n in ast.iter_child_nodes(node))" ], [ "UNARY_NOT", "not (isinstance(node, (ast.Num, ast.Str, getattr(ast, 'NameConstant', ()))) or\n isinstance(getattr(node, 'ctx', None),\n (ast.Store, ast.Del)) or\n (isinstance(node, ast.UnaryOp) and\n isinstance(node.op, (ast.UAdd, ast.USub)) and\n isinstance(node.operand, ast.Num)) or\n (isinstance(node, (ast.List, ast.Tuple, ast.Dict)) and\n not any(is_interesting_expression(n) for n in ast.iter_child_nodes(node))))" ], [ "LOAD_GLOBAL", "is_interesting_expression" ], [ "LOAD_FAST", "n" ], [ "CALL_FUNCTION", "is_interesting_expression(n)" ], [ "LOAD_GLOBAL", "cast" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "__builtins__" ], [ "CALL_FUNCTION", "cast(dict, __builtins__)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Name" ], [ "CALL_FUNCTION", "isinstance(node, ast.Name)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.id" ], [ "LOAD_FAST", "builtins" ], [ "COMPARE_OP", "node.id in builtins" ], [ "LOAD_FAST", "builtins" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.id" ], [ "BINARY_SUBSCR", "builtins[node.id]" ], [ "LOAD_FAST", "value" ], [ "COMPARE_OP", "builtins[node.id] is value" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "ast" ], [ "CALL_FUNCTION", "getattr(ast, 'NameConstant', ())" ], [ "CALL_FUNCTION", "isinstance(node, getattr(ast, 'NameConstant', ()))" ] ], "configuration.py": [ [ "LOAD_NAME", "ctypes" ], [ "LOAD_ATTR", "ctypes.windll" ], [ "LOAD_ATTR", "ctypes.windll.kernel32" ], [ "LOAD_NAME", "kernel32" ], [ "LOAD_ATTR", "kernel32.SetConsoleMode" ], [ "LOAD_NAME", "kernel32" ], [ "LOAD_ATTR", "kernel32.GetStdHandle" ], [ "CALL_FUNCTION", "kernel32.GetStdHandle(-11)" ], [ "CALL_FUNCTION", "kernel32.SetConsoleMode(kernel32.GetStdHandle(-11), 7)" ], [ "LOAD_NAME", "True" ], [ "LOAD_NAME", "Exception" ], [ "LOAD_NAME", "os" ], [ "LOAD_ATTR", "os.name" ], [ "COMPARE_OP", "os.name != 'nt'" ], [ "LOAD_NAME", "True" ], [ "LOAD_NAME", "False" ], [ "LOAD_NAME", "True" ], [ "LOAD_NAME", "DefaultFormatter" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "object" ], [ "LOAD_FAST", "builtins" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_GLOBAL", "builtins_module" ], [ "LOAD_FAST", "snoop" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.snoop" ], [ "CALL_FUNCTION", "setattr(builtins_module, snoop, package.snoop)" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_GLOBAL", "builtins_module" ], [ "LOAD_FAST", "pp" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.pp" ], [ "CALL_FUNCTION", "setattr(builtins_module, pp, package.pp)" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_GLOBAL", "builtins_module" ], [ "LOAD_FAST", "spy" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.spy" ], [ "CALL_FUNCTION", "setattr(builtins_module, spy, package.spy)" ], [ "LOAD_GLOBAL", "Config" ], [ "LOAD_FAST", "out" ], [ "LOAD_FAST", "prefix" ], [ "LOAD_FAST", "columns" ], [ "LOAD_FAST", "overwrite" ], [ "LOAD_FAST", "color" ], [ "LOAD_FAST", "enabled" ], [ "LOAD_FAST", "watch_extras" ], [ "LOAD_FAST", "replace_watch_extras" ], [ "LOAD_FAST", "formatter_class" ], [ "CALL_FUNCTION", "Config(\n out=out,\n prefix=prefix,\n columns=columns,\n overwrite=overwrite,\n color=color,\n enabled=enabled,\n watch_extras=watch_extras,\n replace_watch_extras=replace_watch_extras,\n formatter_class=formatter_class,\n )" ], [ "LOAD_FAST", "config" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.snoop" ], [ "LOAD_FAST", "config" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.pp" ], [ "LOAD_FAST", "config" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.spy" ], [ "LOAD_NAME", "False" ], [ "LOAD_NAME", "True" ], [ "LOAD_NAME", "DefaultFormatter" ], [ "LOAD_GLOBAL", "can_color" ], [ "LOAD_FAST", "color" ], [ "COMPARE_OP", "color is None" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "out" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.stderr" ], [ "CALL_FUNCTION", "getattr(out or sys.stderr, 'isatty', lambda: False)" ], [ "LOAD_GLOBAL", "bool" ], [ "LOAD_FAST", "isatty" ], [ "CALL_FUNCTION", "isatty()" ], [ "CALL_FUNCTION", "bool(isatty())" ], [ "LOAD_GLOBAL", "False" ], [ "LOAD_GLOBAL", "get_write_function" ], [ "LOAD_FAST", "out" ], [ "LOAD_FAST", "overwrite" ], [ "CALL_FUNCTION", "get_write_function(out, overwrite)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "formatter_class" ], [ "LOAD_FAST", "prefix" ], [ "LOAD_FAST", "columns" ], [ "LOAD_FAST", "color" ], [ "CALL_FUNCTION", "formatter_class(prefix, columns, color)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "enabled" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "PP" ], [ "LOAD_DEREF", "self" ], [ "CALL_FUNCTION", "PP(self)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "Tracer" ], [ "LOAD_FAST", "ConfiguredTracer" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "Spy" ], [ "LOAD_DEREF", "self" ], [ "CALL_FUNCTION", "Spy(self)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "threading" ], [ "LOAD_ATTR", "threading.local" ], [ "CALL_FUNCTION", "threading.local()" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "replace_watch_extras" ], [ "COMPARE_OP", "replace_watch_extras is not None" ], [ "LOAD_GLOBAL", "ensure_tuple" ], [ "LOAD_FAST", "replace_watch_extras" ], [ "CALL_FUNCTION", "ensure_tuple(replace_watch_extras)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "len_shape_watch" ], [ "LOAD_GLOBAL", "dtype_watch" ], [ "LOAD_GLOBAL", "ensure_tuple" ], [ "LOAD_FAST", "watch_extras" ], [ "CALL_FUNCTION", "ensure_tuple(watch_extras)" ], [ "BINARY_ADD", "(len_shape_watch, dtype_watch) + ensure_tuple(watch_extras)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "False" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "value" ], [ "LOAD_ATTR", "value.shape" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.ismethod" ], [ "LOAD_FAST", "shape" ], [ "CALL_FUNCTION", "inspect.ismethod(shape)" ], [ "LOAD_ATTR", "'{}.shape'.format" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "'{}.shape'.format(source)" ], [ "LOAD_FAST", "shape" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "value" ], [ "LOAD_GLOBAL", "QuerySet" ], [ "CALL_FUNCTION", "isinstance(value, QuerySet)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "len(value)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "value" ], [ "LOAD_GLOBAL", "six" ], [ "LOAD_ATTR", "six.string_types" ], [ "CALL_FUNCTION", "isinstance(value, six.string_types)" ], [ "LOAD_FAST", "length" ], [ "COMPARE_OP", "length < 50" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "value" ], [ "LOAD_GLOBAL", "Mapping" ], [ "LOAD_GLOBAL", "Set" ], [ "LOAD_GLOBAL", "Sequence" ], [ "CALL_FUNCTION", "isinstance(value, (Mapping, Set, Sequence))" ], [ "LOAD_FAST", "length" ], [ "COMPARE_OP", "length == 0" ], [ "LOAD_ATTR", "'len({})'.format" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "'len({})'.format(source)" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "value" ], [ "LOAD_ATTR", "value.dtype" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.ismethod" ], [ "LOAD_FAST", "dtype" ], [ "CALL_FUNCTION", "inspect.ismethod(dtype)" ], [ "LOAD_ATTR", "'{}.dtype'.format" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "'{}.dtype'.format(source)" ], [ "LOAD_FAST", "dtype" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_DEREF", "output" ], [ "LOAD_GLOBAL", "six" ], [ "LOAD_ATTR", "six.string_types" ], [ "CALL_FUNCTION", "isinstance(output, six.string_types)" ], [ "LOAD_GLOBAL", "is_pathlike" ], [ "LOAD_DEREF", "output" ], [ "CALL_FUNCTION", "is_pathlike(output)" ], [ "LOAD_FAST", "is_path" ], [ "LOAD_GLOBAL", "FileWriter" ], [ "LOAD_DEREF", "output" ], [ "LOAD_FAST", "overwrite" ], [ "CALL_FUNCTION", "FileWriter(output, overwrite)" ], [ "LOAD_ATTR", "FileWriter(output, overwrite).write" ], [ "LOAD_GLOBAL", "callable" ], [ "LOAD_DEREF", "output" ], [ "CALL_FUNCTION", "callable(output)" ], [ "LOAD_DEREF", "output" ], [ "LOAD_FAST", "write" ], [ "LOAD_DEREF", "output" ], [ "LOAD_FAST", "stream" ], [ "COMPARE_OP", "stream is None" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.stderr" ], [ "LOAD_FAST", "stream" ], [ "LOAD_ATTR", "stream.write" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "stream.write(s)" ], [ "LOAD_GLOBAL", "UnicodeEncodeError" ], [ "LOAD_FAST", "stream" ], [ "LOAD_ATTR", "stream.write" ], [ "LOAD_GLOBAL", "shitcode" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "shitcode(s)" ], [ "CALL_FUNCTION", "stream.write(shitcode(s))" ], [ "LOAD_GLOBAL", "six" ], [ "LOAD_ATTR", "six.text_type" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "six.text_type(path)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "overwrite" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "open" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.path" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.overwrite" ], [ "CALL_FUNCTION", "open(self.path, 'w' if self.overwrite else 'a', encoding='utf-8')" ], [ "LOAD_FAST", "f" ], [ "LOAD_ATTR", "f.write" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "f.write(s)" ], [ "LOAD_GLOBAL", "False" ], [ "LOAD_FAST", "self" ] ], "db.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOAD_ATTR", "standard_library.install_aliases" ], [ "CALL_FUNCTION", "standard_library.install_aliases()" ], [ "LOAD_NAME", "RESERVED_WORDS" ], [ "LOAD_ATTR", "RESERVED_WORDS.add" ], [ "CALL_FUNCTION", "RESERVED_WORDS.add('function')" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "retry" ], [ "LOAD_NAME", "InterfaceError" ], [ "LOAD_NAME", "OperationalError" ], [ "LOAD_NAME", "InternalError" ], [ "LOAD_NAME", "ProgrammingError" ], [ "CALL_FUNCTION", "retry(3, (InterfaceError, OperationalError, InternalError, ProgrammingError))" ], [ "LOAD_NAME", "False" ], [ "LOAD_NAME", "contextmanager" ], [ "CALL_FUNCTION", "contextmanager" ], [ "LOAD_FAST", "db_uri" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.environ" ], [ "LOAD_ATTR", "os.environ.get" ], [ "CALL_FUNCTION", "os.environ.get('BIRDSEYE_DB')" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.join" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.expanduser" ], [ "CALL_FUNCTION", "os.path.expanduser('~')" ], [ "CALL_FUNCTION", "os.path.join(os.path.expanduser('~'),\n '.birdseye.db')" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "False" ], [ "CALL_FUNCTION", "dict(\n pool_recycle=280,\n echo=False, # for convenience when debugging\n )" ], [ "LOAD_GLOBAL", "create_engine" ], [ "LOAD_FAST", "db_uri" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_KW", "create_engine(db_uri, **kwargs)" ], [ "LOAD_GLOBAL", "ArgumentError" ], [ "LOAD_FAST", "db_uri" ], [ "BINARY_ADD", "'sqlite:///' + db_uri" ], [ "LOAD_GLOBAL", "create_engine" ], [ "LOAD_FAST", "db_uri" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_KW", "create_engine(db_uri, **kwargs)" ], [ "LOAD_FAST", "engine" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "sessionmaker" ], [ "LOAD_FAST", "engine" ], [ "CALL_FUNCTION", "sessionmaker(bind=engine)" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "object" ], [ "LOAD_GLOBAL", "declarative_base" ], [ "LOAD_FAST", "Base" ], [ "CALL_FUNCTION", "declarative_base(cls=Base)" ], [ "LOAD_FAST", "Base" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "object" ], [ "LOAD_FAST", "engine" ], [ "LOAD_ATTR", "engine.name" ], [ "COMPARE_OP", "engine.name == 'mysql'" ], [ "LOAD_GLOBAL", "LONGTEXT" ], [ "LOAD_GLOBAL", "Text" ], [ "LOAD_FAST", "Base" ], [ "LOAD_FAST", "Base" ], [ "LOAD_FAST", "Call" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "Function" ], [ "LOAD_FAST", "self" ], [ "LOAD_DEREF", "KeyValue" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "KeyValueStore" ], [ "CALL_FUNCTION", "KeyValueStore()" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "_skip_version_check" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.table_exists" ], [ "LOAD_FAST", "Function" ], [ "CALL_FUNCTION", "self.table_exists(Function)" ], [ "LOAD_FAST", "Base" ], [ "LOAD_ATTR", "Base.metadata" ], [ "LOAD_ATTR", "Base.metadata.create_all" ], [ "LOAD_FAST", "engine" ], [ "CALL_FUNCTION", "Base.metadata.create_all(engine)" ], [ "LOAD_GLOBAL", "DB_VERSION" ], [ "LOAD_FAST", "kv" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.table_exists" ], [ "LOAD_DEREF", "KeyValue" ], [ "CALL_FUNCTION", "self.table_exists(KeyValue)" ], [ "UNARY_NOT", "not self.table_exists(KeyValue)" ], [ "LOAD_GLOBAL", "int" ], [ "LOAD_FAST", "kv" ], [ "LOAD_ATTR", "kv.version" ], [ "CALL_FUNCTION", "int(kv.version)" ], [ "LOAD_GLOBAL", "DB_VERSION" ], [ "COMPARE_OP", "int(kv.version) < DB_VERSION" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.exit" ], [ "CALL_FUNCTION", "sys.exit('The birdseye database schema is out of date. '\n 'Run \"python -m birdseye.clear_db\" to delete the existing tables.')" ], [ "LOAD_NAME", "declared_attr" ], [ "CALL_FUNCTION", "declared_attr" ], [ "LOAD_FAST", "cls" ], [ "LOAD_ATTR", "cls.__name__" ], [ "LOAD_ATTR", "cls.__name__.lower" ], [ "CALL_FUNCTION", "cls.__name__.lower()" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "String" ], [ "CALL_FUNCTION", "String(50)" ], [ "LOAD_NAME", "True" ], [ "CALL_FUNCTION", "Column(String(50), primary_key=True)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "__getitem__" ], [ "LOAD_NAME", "__setitem__" ], [ "LOAD_DEREF", "db_self" ], [ "LOAD_ATTR", "db_self.session_scope" ], [ "CALL_FUNCTION", "db_self.session_scope()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session\n .query" ], [ "LOAD_DEREF", "KeyValue" ], [ "LOAD_ATTR", "KeyValue.value" ], [ "CALL_FUNCTION", "session\n .query(KeyValue.value)" ], [ "LOAD_ATTR", "session\n .query(KeyValue.value)\n .filter_by" ], [ "LOAD_FAST", "item" ], [ "CALL_FUNCTION", "session\n .query(KeyValue.value)\n .filter_by(key=item)" ], [ "LOAD_ATTR", "session\n .query(KeyValue.value)\n .filter_by(key=item)\n .scalar" ], [ "CALL_FUNCTION", "session\n .query(KeyValue.value)\n .filter_by(key=item)\n .scalar()" ], [ "LOAD_DEREF", "db_self" ], [ "LOAD_ATTR", "db_self.session_scope" ], [ "CALL_FUNCTION", "db_self.session_scope()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_DEREF", "KeyValue" ], [ "CALL_FUNCTION", "session.query(KeyValue)" ], [ "LOAD_ATTR", "session.query(KeyValue).filter_by" ], [ "LOAD_FAST", "key" ], [ "CALL_FUNCTION", "session.query(KeyValue).filter_by(key=key)" ], [ "LOAD_ATTR", "session.query(KeyValue).filter_by(key=key).delete" ], [ "CALL_FUNCTION", "session.query(KeyValue).filter_by(key=key).delete()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.add" ], [ "LOAD_DEREF", "KeyValue" ], [ "LOAD_FAST", "key" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "str(value)" ], [ "CALL_FUNCTION", "KeyValue(key=key, value=str(value))" ], [ "CALL_FUNCTION", "session.add(KeyValue(key=key, value=str(value)))" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "String" ], [ "CALL_FUNCTION", "String(length=32)" ], [ "LOAD_NAME", "True" ], [ "CALL_FUNCTION", "Column(String(length=32), primary_key=True)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Integer" ], [ "LOAD_NAME", "ForeignKey" ], [ "CALL_FUNCTION", "ForeignKey('function.id')" ], [ "LOAD_NAME", "True" ], [ "CALL_FUNCTION", "Column(Integer, ForeignKey('function.id'), index=True)" ], [ "LOAD_NAME", "relationship" ], [ "LOAD_NAME", "backref" ], [ "CALL_FUNCTION", "backref('calls', lazy='dynamic')" ], [ "CALL_FUNCTION", "relationship('Function', backref=backref('calls', lazy='dynamic'))" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_DEREF", "LongText" ], [ "CALL_FUNCTION", "Column(LongText)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "DateTime" ], [ "LOAD_NAME", "True" ], [ "CALL_FUNCTION", "Column(DateTime, index=True)" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "id" ], [ "LOAD_NAME", "function_id" ], [ "LOAD_NAME", "return_value" ], [ "LOAD_NAME", "traceback" ], [ "LOAD_NAME", "exception" ], [ "LOAD_NAME", "start_time" ], [ "LOAD_NAME", "arguments" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._pretty_time" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start_time" ], [ "CALL_FUNCTION", "self._pretty_time(self.start_time)" ], [ "LOAD_FAST", "dt" ], [ "LOAD_GLOBAL", "Markup" ], [ "LOAD_FAST", "dt" ], [ "LOAD_ATTR", "dt.strftime" ], [ "CALL_FUNCTION", "dt.strftime('%Y-%m-%d %H:%M:%S')" ], [ "LOAD_GLOBAL", "naturaltime" ], [ "LOAD_FAST", "dt" ], [ "CALL_FUNCTION", "naturaltime(dt)" ], [ "BINARY_MODULO", "'%s (%s)' % (\n dt.strftime('%Y-%m-%d %H:%M:%S'),\n naturaltime(dt))" ], [ "CALL_FUNCTION", "Markup('%s (%s)' % (\n dt.strftime('%Y-%m-%d %H:%M:%S'),\n naturaltime(dt)))" ], [ "LOAD_GLOBAL", "Markup" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.success" ], [ "BINARY_MODULO", "'' % (\n ('ok', 'green') if self.success else\n ('remove', 'red'))" ], [ "CALL_FUNCTION", "Markup('' % (\n ('ok', 'green') if self.success else\n ('remove', 'red')))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.exception" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.traceback" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.return_value" ], [ "COMPARE_OP", "self.return_value == 'None'" ], [ "LOAD_GLOBAL", "False" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.traceback" ], [ "UNARY_NOT", "not self.traceback" ], [ "LOAD_GLOBAL", "True" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.success" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.return_value" ], [ "CALL_FUNCTION", "str(self.return_value)" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.exception" ], [ "CALL_FUNCTION", "str(self.exception)" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_ATTR", "json.loads" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.arguments" ], [ "CALL_FUNCTION", "json.loads(self.arguments)" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_ATTR", "json.loads" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.data" ], [ "CALL_FUNCTION", "json.loads(self.data)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.arguments_list" ], [ "LOAD_GLOBAL", "select_attrs" ], [ "LOAD_FAST", "call" ], [ "CALL_FUNCTION", "select_attrs(call, 'id function_id return_value traceback '\n 'exception start_time')" ], [ "CALL_FUNCTION_KW", "dict(arguments=call.arguments_list,\n **select_attrs(call, 'id function_id return_value traceback '\n 'exception start_time'))" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Integer" ], [ "LOAD_NAME", "Sequence" ], [ "CALL_FUNCTION", "Sequence('function_id_seq')" ], [ "LOAD_NAME", "True" ], [ "CALL_FUNCTION", "Column(Integer, Sequence('function_id_seq'), primary_key=True)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_DEREF", "LongText" ], [ "CALL_FUNCTION", "Column(LongText)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Integer" ], [ "CALL_FUNCTION", "Column(Integer)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_DEREF", "LongText" ], [ "CALL_FUNCTION", "Column(LongText)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "String" ], [ "CALL_FUNCTION", "String(length=64)" ], [ "LOAD_NAME", "True" ], [ "CALL_FUNCTION", "Column(String(length=64), index=True)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "String" ], [ "CALL_FUNCTION", "String(length=64)" ], [ "LOAD_NAME", "True" ], [ "CALL_FUNCTION", "Column(String(length=64), index=True)" ], [ "LOAD_NAME", "UniqueConstraint" ], [ "CALL_FUNCTION", "UniqueConstraint('hash',\n name='everything_unique')" ], [ "LOAD_NAME", "Index" ], [ "CALL_FUNCTION", "Index('idx_file', 'file', mysql_length=256)" ], [ "LOAD_NAME", "Index" ], [ "CALL_FUNCTION", "Index('idx_name', 'name', mysql_length=32)" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "file" ], [ "LOAD_NAME", "name" ], [ "LOAD_NAME", "lineno" ], [ "LOAD_NAME", "hash" ], [ "LOAD_NAME", "body_hash" ], [ "LOAD_NAME", "type" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_ATTR", "json.loads" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.data" ], [ "CALL_FUNCTION", "json.loads(self.data)" ], [ "LOAD_GLOBAL", "select_attrs" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "select_attrs(func, 'file name lineno hash body_hash type')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.engine" ], [ "LOAD_ATTR", "self.engine.dialect" ], [ "LOAD_ATTR", "self.engine.dialect.has_table" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.engine" ], [ "LOAD_FAST", "table" ], [ "LOAD_ATTR", "table.__name__" ], [ "CALL_FUNCTION", "self.engine.dialect.has_table(self.engine, table.__name__)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.session_scope" ], [ "CALL_FUNCTION", "self.session_scope()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.Function" ], [ "LOAD_ATTR", "self.Function.file" ], [ "CALL_FUNCTION", "session.query(self.Function.file)" ], [ "LOAD_ATTR", "session.query(self.Function.file).distinct" ], [ "CALL_FUNCTION", "session.query(self.Function.file).distinct()" ], [ "LOAD_GLOBAL", "is_ipython_cell" ], [ "LOAD_FAST", "f" ], [ "BINARY_SUBSCR", "f[0]" ], [ "CALL_FUNCTION", "is_ipython_cell(f[0])" ], [ "LOAD_FAST", "f" ], [ "BINARY_SUBSCR", "f[0]" ], [ "LOAD_FAST", "paths" ], [ "LOAD_ATTR", "paths.sort" ], [ "CALL_FUNCTION", "paths.sort()" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "paths" ], [ "COMPARE_OP", "IPYTHON_FILE_PATH in paths" ], [ "LOAD_FAST", "paths" ], [ "LOAD_ATTR", "paths.remove" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "CALL_FUNCTION", "paths.remove(IPYTHON_FILE_PATH)" ], [ "LOAD_FAST", "paths" ], [ "LOAD_ATTR", "paths.insert" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "CALL_FUNCTION", "paths.insert(0, IPYTHON_FILE_PATH)" ], [ "LOAD_FAST", "paths" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.Call" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.Function" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._KeyValue" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.table_exists" ], [ "LOAD_FAST", "model" ], [ "CALL_FUNCTION", "self.table_exists(model)" ], [ "LOAD_FAST", "model" ], [ "LOAD_ATTR", "model.__table__" ], [ "LOAD_ATTR", "model.__table__.drop" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.engine" ], [ "CALL_FUNCTION", "model.__table__.drop(self.engine)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.Session" ], [ "CALL_FUNCTION", "self.Session()" ], [ "LOAD_FAST", "session" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.commit" ], [ "CALL_FUNCTION", "session.commit()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.rollback" ], [ "CALL_FUNCTION", "session.rollback()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.close" ], [ "CALL_FUNCTION", "session.close()" ], [ "LOAD_GLOBAL", "functools" ], [ "LOAD_ATTR", "functools.wraps" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "LOAD_GLOBAL", "retry_db" ], [ "LOAD_FAST", "wrapper" ], [ "CALL_FUNCTION", "retry_db(wrapper)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.session_scope" ], [ "CALL_FUNCTION", "self.session_scope()" ], [ "LOAD_DEREF", "func" ], [ "LOAD_FAST", "session" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "func(session, *args, **kwargs)" ] ], "executing.py": [ [ "LOAD_NAME", "sys" ], [ "LOAD_ATTR", "sys.version_info" ], [ "BINARY_SUBSCR", "sys.version_info[0]" ], [ "COMPARE_OP", "sys.version_info[0] == 3" ], [ "LOAD_NAME", "PY3" ], [ "LOAD_NAME", "lru_cache" ], [ "CALL_FUNCTION", "lru_cache(maxsize=None)" ], [ "LOAD_NAME", "str" ], [ "LOAD_NAME", "unicode" ], [ "LOAD_NAME", "dis" ], [ "LOAD_ATTR", "dis.get_instructions" ], [ "LOAD_NAME", "AttributeError" ], [ "LOAD_NAME", "namedtuple" ], [ "CALL_FUNCTION", "namedtuple('Instruction', 'offset argval opname')" ], [ "LOAD_NAME", "Exception" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.NodeVisitor" ], [ "LOAD_NAME", "sum" ], [ "LOAD_NAME", "__future__" ], [ "LOAD_ATTR", "__future__.all_feature_names" ], [ "CALL_FUNCTION", "sum(\n getattr(__future__, fname).compiler_flag\n for fname in __future__.all_feature_names\n)" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "RLock" ], [ "CALL_FUNCTION", "RLock()" ], [ "LOAD_NAME", "cache" ], [ "CALL_FUNCTION", "cache" ], [ "LOAD_GLOBAL", "functools" ], [ "LOAD_ATTR", "functools.wraps" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "LOAD_FAST", "wrapper" ], [ "LOAD_FAST", "args" ], [ "LOAD_DEREF", "d" ], [ "COMPARE_OP", "args in d" ], [ "LOAD_DEREF", "d" ], [ "LOAD_FAST", "args" ], [ "BINARY_SUBSCR", "d[args]" ], [ "LOAD_DEREF", "func" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION_VAR", "func(*args)" ], [ "LOAD_DEREF", "d" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "co" ], [ "LOAD_ATTR", "co.co_code" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "len(code)" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "i < n" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "code[i]" ], [ "LOAD_GLOBAL", "ord" ], [ "LOAD_FAST", "c" ], [ "CALL_FUNCTION", "ord(c)" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "LOAD_FAST", "op" ], [ "LOAD_GLOBAL", "HAVE_ARGUMENT" ], [ "COMPARE_OP", "op >= HAVE_ARGUMENT" ], [ "LOAD_GLOBAL", "ord" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "code[i]" ], [ "CALL_FUNCTION", "ord(code[i])" ], [ "LOAD_GLOBAL", "ord" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "code[i + 1]" ], [ "CALL_FUNCTION", "ord(code[i + 1])" ], [ "BINARY_MULTIPLY", "ord(code[i + 1]) * 256" ], [ "BINARY_ADD", "ord(code[i]) + ord(code[i + 1]) * 256" ], [ "LOAD_FAST", "extended_arg" ], [ "BINARY_ADD", "ord(code[i]) + ord(code[i + 1]) * 256 + extended_arg" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 2" ], [ "LOAD_FAST", "op" ], [ "LOAD_GLOBAL", "EXTENDED_ARG" ], [ "COMPARE_OP", "op == EXTENDED_ARG" ], [ "LOAD_FAST", "oparg" ], [ "BINARY_MULTIPLY", "oparg * 65536" ], [ "LOAD_FAST", "op" ], [ "LOAD_GLOBAL", "hasconst" ], [ "COMPARE_OP", "op in hasconst" ], [ "LOAD_FAST", "co" ], [ "LOAD_ATTR", "co.co_consts" ], [ "LOAD_FAST", "oparg" ], [ "BINARY_SUBSCR", "co.co_consts[oparg]" ], [ "LOAD_GLOBAL", "Instruction" ], [ "LOAD_FAST", "offset" ], [ "LOAD_FAST", "argval" ], [ "LOAD_GLOBAL", "opname" ], [ "LOAD_FAST", "op" ], [ "BINARY_SUBSCR", "opname[op]" ], [ "CALL_FUNCTION", "Instruction(offset, argval, opname[op])" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "it" ], [ "LOAD_GLOBAL", "Sized" ], [ "CALL_FUNCTION", "isinstance(it, Sized)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "len(it)" ], [ "COMPARE_OP", "len(it) != 1" ], [ "LOAD_GLOBAL", "NotOneValueFound" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "len(it)" ], [ "BINARY_MODULO", "'Expected one value, found %s' % len(it)" ], [ "CALL_FUNCTION", "NotOneValueFound('Expected one value, found %s' % len(it))" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "list(it)" ], [ "BINARY_SUBSCR", "list(it)[0]" ], [ "LOAD_GLOBAL", "tuple" ], [ "LOAD_GLOBAL", "islice" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "islice(it, 2)" ], [ "CALL_FUNCTION", "tuple(islice(it, 2))" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "lst" ], [ "CALL_FUNCTION", "len(lst)" ], [ "COMPARE_OP", "len(lst) == 0" ], [ "LOAD_GLOBAL", "NotOneValueFound" ], [ "CALL_FUNCTION", "NotOneValueFound('Expected one value, found 0')" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "lst" ], [ "CALL_FUNCTION", "len(lst)" ], [ "COMPARE_OP", "len(lst) > 1" ], [ "LOAD_GLOBAL", "NotOneValueFound" ], [ "CALL_FUNCTION", "NotOneValueFound('Expected one value, found several')" ], [ "LOAD_FAST", "lst" ], [ "BINARY_SUBSCR", "lst[0]" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "cache" ], [ "CALL_FUNCTION", "cache" ], [ "LOAD_NAME", "cache" ], [ "CALL_FUNCTION", "cache" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "text" ], [ "LOAD_GLOBAL", "text_type" ], [ "CALL_FUNCTION", "isinstance(text, text_type)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.decode_source" ], [ "LOAD_FAST", "text" ], [ "CALL_FUNCTION", "self.decode_source(text)" ], [ "LOAD_FAST", "text" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_FAST", "text" ], [ "LOAD_ATTR", "''.join" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "text" ], [ "LOAD_ATTR", "text.splitlines" ], [ "LOAD_GLOBAL", "True" ], [ "CALL_FUNCTION", "text.splitlines(True)" ], [ "CALL_FUNCTION", "enumerate(text.splitlines(True))" ], [ "LOAD_FAST", "i" ], [ "COMPARE_OP", "i < 2" ], [ "LOAD_GLOBAL", "encoding_pattern" ], [ "LOAD_ATTR", "encoding_pattern.match" ], [ "LOAD_FAST", "line" ], [ "CALL_FUNCTION", "encoding_pattern.match(line)" ], [ "LOAD_FAST", "line" ], [ "CALL_FUNCTION", "''.join([\n '\\n' if i < 2 and encoding_pattern.match(line)\n else line\n for i, line in enumerate(text.splitlines(True))\n ])" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "defaultdict(list)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "text" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.parse" ], [ "LOAD_FAST", "ast_text" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "ast.parse(ast_text, filename=filename)" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "SyntaxError" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.walk" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tree" ], [ "CALL_FUNCTION", "ast.walk(self.tree)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.iter_child_nodes" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ast.iter_child_nodes(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "hasattr(node, 'lineno')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._nodes_by_line" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.lineno" ], [ "BINARY_SUBSCR", "self._nodes_by_line[node.lineno]" ], [ "LOAD_ATTR", "self._nodes_by_line[node.lineno].append" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "self._nodes_by_line[node.lineno].append(node)" ], [ "LOAD_GLOBAL", "QualnameVisitor" ], [ "CALL_FUNCTION", "QualnameVisitor()" ], [ "LOAD_FAST", "visitor" ], [ "LOAD_ATTR", "visitor.visit" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tree" ], [ "CALL_FUNCTION", "visitor.visit(self.tree)" ], [ "LOAD_FAST", "visitor" ], [ "LOAD_ATTR", "visitor.qualnames" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "cls" ], [ "LOAD_ATTR", "cls.for_filename" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_filename" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "CALL_FUNCTION", "cls.for_filename(frame.f_code.co_filename, frame.f_globals or {})" ], [ "LOAD_FAST", "cls" ], [ "LOAD_ATTR", "cls._class_local" ], [ "CALL_FUNCTION", "cls._class_local('__source_cache', {})" ], [ "LOAD_FAST", "source_cache" ], [ "LOAD_FAST", "filename" ], [ "BINARY_SUBSCR", "source_cache[filename]" ], [ "LOAD_GLOBAL", "KeyError" ], [ "LOAD_GLOBAL", "linecache" ], [ "LOAD_ATTR", "linecache.getlines" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "module_globals" ], [ "CALL_FUNCTION", "linecache.getlines(filename, module_globals)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_FAST", "filename" ], [ "LOAD_ATTR", "''.join" ], [ "LOAD_FAST", "lines" ], [ "CALL_FUNCTION", "''.join(lines)" ], [ "CALL_FUNCTION", "cls(filename, ''.join(lines))" ], [ "LOAD_FAST", "source_cache" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_GLOBAL", "linecache" ], [ "CALL_FUNCTION", "hasattr(linecache, 'lazycache')" ], [ "LOAD_GLOBAL", "linecache" ], [ "LOAD_ATTR", "linecache.lazycache" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_filename" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "CALL_FUNCTION", "linecache.lazycache(frame.f_code.co_filename, frame.f_globals)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lasti" ], [ "LOAD_FAST", "cls" ], [ "LOAD_ATTR", "cls._class_local" ], [ "CALL_FUNCTION", "cls._class_local('__executing_cache', {})" ], [ "LOAD_FAST", "executing_cache" ], [ "LOAD_FAST", "key" ], [ "BINARY_SUBSCR", "executing_cache[key]" ], [ "LOAD_GLOBAL", "KeyError" ], [ "LOAD_FAST", "cls" ], [ "LOAD_ATTR", "cls.for_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "cls.for_frame(frame)" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.tree" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.statements_at_line" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lineno" ], [ "CALL_FUNCTION", "source.statements_at_line(frame.f_lineno)" ], [ "LOAD_GLOBAL", "NodeFinder" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "stmts" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.tree" ], [ "CALL_FUNCTION", "NodeFinder(frame, stmts, source.tree)" ], [ "LOAD_ATTR", "NodeFinder(frame, stmts, source.tree).result" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_GLOBAL", "statement_containing_node" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "statement_containing_node(node)" ], [ "LOAD_FAST", "new_stmts" ], [ "LOAD_FAST", "stmts" ], [ "COMPARE_OP", "new_stmts <= stmts" ], [ "LOAD_FAST", "new_stmts" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "stmts" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "executing_cache" ], [ "LOAD_FAST", "key" ], [ "LOAD_GLOBAL", "Executing" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION_VAR", "Executing(frame, *args)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_ATTR", "cls.__dict__" ], [ "LOAD_ATTR", "cls.__dict__.get" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "default" ], [ "CALL_FUNCTION", "cls.__dict__.get(name, default)" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_FAST", "cls" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "setattr(cls, name, result)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._nodes_by_line" ], [ "LOAD_FAST", "lineno" ], [ "BINARY_SUBSCR", "self._nodes_by_line[lineno]" ], [ "LOAD_GLOBAL", "statement_containing_node" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "statement_containing_node(node)" ], [ "LOAD_FAST", "ASTTokens" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.text" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tree" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.filename" ], [ "CALL_FUNCTION", "ASTTokens(\n self.text,\n tree=self.tree,\n filename=self.filename,\n )" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "source" ], [ "LOAD_GLOBAL", "bytes" ], [ "CALL_FUNCTION", "isinstance(source, bytes)" ], [ "LOAD_GLOBAL", "detect_encoding" ], [ "LOAD_GLOBAL", "io" ], [ "LOAD_ATTR", "io.BytesIO" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "io.BytesIO(source)" ], [ "LOAD_ATTR", "io.BytesIO(source).readline" ], [ "CALL_FUNCTION", "detect_encoding(io.BytesIO(source).readline)" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.decode" ], [ "LOAD_FAST", "encoding" ], [ "CALL_FUNCTION", "source.decode(encoding)" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_filename" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.filename" ], [ "COMPARE_OP", "code.co_filename == self.filename" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._qualnames" ], [ "LOAD_ATTR", "self._qualnames.get" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_firstlineno" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "CALL_FUNCTION", "self._qualnames.get((code.co_name, code.co_firstlineno), code.co_name)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "stmts" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.source" ], [ "LOAD_ATTR", "self.source.code_qualname" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_code" ], [ "CALL_FUNCTION", "self.source.code_qualname(self.frame.f_code)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.source" ], [ "LOAD_ATTR", "self.source.asttokens" ], [ "CALL_FUNCTION", "self.source.asttokens()" ], [ "LOAD_ATTR", "self.source.asttokens().get_text" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.node" ], [ "CALL_FUNCTION", "self.source.asttokens().get_text(self.node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.source" ], [ "LOAD_ATTR", "self.source.asttokens" ], [ "CALL_FUNCTION", "self.source.asttokens()" ], [ "LOAD_ATTR", "self.source.asttokens().get_text_range" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.node" ], [ "CALL_FUNCTION", "self.source.asttokens().get_text_range(self.node)" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "QualnameVisitor" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(QualnameVisitor, self)" ], [ "LOAD_ATTR", "super(QualnameVisitor, self).__init__" ], [ "CALL_FUNCTION", "super(QualnameVisitor, self).__init__()" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.name" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_ATTR", "self.stack.append" ], [ "LOAD_FAST", "name" ], [ "CALL_FUNCTION", "self.stack.append(name)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.qualnames" ], [ "LOAD_ATTR", "self.qualnames.setdefault" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.lineno" ], [ "LOAD_ATTR", "\".\".join" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "CALL_FUNCTION", "\".\".join(self.stack)" ], [ "CALL_FUNCTION", "self.qualnames.setdefault((name, node.lineno), \".\".join(self.stack))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_ATTR", "self.stack.append" ], [ "CALL_FUNCTION", "self.stack.append('')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Lambda" ], [ "CALL_FUNCTION", "isinstance(node, ast.Lambda)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.body" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.body" ], [ "LOAD_FAST", "children" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.visit" ], [ "LOAD_FAST", "child" ], [ "CALL_FUNCTION", "self.visit(child)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_ATTR", "self.stack.pop" ], [ "CALL_FUNCTION", "self.stack.pop()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_ATTR", "self.stack.pop" ], [ "CALL_FUNCTION", "self.stack.pop()" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.iter_fields" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ast.iter_fields(node)" ], [ "LOAD_FAST", "field" ], [ "COMPARE_OP", "field == 'body'" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.AST" ], [ "CALL_FUNCTION", "isinstance(child, ast.AST)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.visit" ], [ "LOAD_FAST", "child" ], [ "CALL_FUNCTION", "self.visit(child)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "isinstance(child, list)" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "grandchild" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.AST" ], [ "CALL_FUNCTION", "isinstance(grandchild, ast.AST)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.visit" ], [ "LOAD_FAST", "grandchild" ], [ "CALL_FUNCTION", "self.visit(grandchild)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.visit_FunctionDef" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "self.visit_FunctionDef(node, '')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_ATTR", "self.stack.append" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.name" ], [ "CALL_FUNCTION", "self.stack.append(node.name)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.generic_visit" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "self.generic_visit(node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_ATTR", "self.stack.pop" ], [ "CALL_FUNCTION", "self.stack.pop()" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "__future__" ], [ "LOAD_FAST", "fname" ], [ "CALL_FUNCTION", "getattr(__future__, fname)" ], [ "LOAD_ATTR", "getattr(__future__, fname).compiler_flag" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "matching_code" ], [ "LOAD_ATTR", "matching_code.co_filename" ], [ "LOAD_GLOBAL", "future_flags" ], [ "LOAD_FAST", "matching_code" ], [ "LOAD_ATTR", "matching_code.co_flags" ], [ "BINARY_AND", "future_flags & matching_code.co_flags" ], [ "LOAD_GLOBAL", "True" ], [ "CALL_FUNCTION", "compile(\n source,\n matching_code.co_filename,\n 'exec',\n flags=future_flags & matching_code.co_flags,\n dont_inherit=True,\n )" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "tree" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_code" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lasti" ], [ "BINARY_SUBSCR", "frame.f_code.co_code[frame.f_lasti]" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_GLOBAL", "ord" ], [ "LOAD_FAST", "b" ], [ "CALL_FUNCTION", "ord(b)" ], [ "LOAD_GLOBAL", "dis" ], [ "LOAD_ATTR", "dis.opname" ], [ "LOAD_FAST", "b" ], [ "BINARY_SUBSCR", "dis.opname[b]" ], [ "LOAD_FAST", "op_name" ], [ "LOAD_ATTR", "op_name.startswith" ], [ "CALL_FUNCTION", "op_name.startswith('CALL_')" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Call" ], [ "LOAD_FAST", "op_name" ], [ "COMPARE_OP", "op_name == 'BINARY_SUBSCR'" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Subscript" ], [ "LOAD_FAST", "op_name" ], [ "LOAD_ATTR", "op_name.startswith" ], [ "CALL_FUNCTION", "op_name.startswith('BINARY_')" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.BinOp" ], [ "LOAD_FAST", "op_name" ], [ "LOAD_ATTR", "op_name.startswith" ], [ "CALL_FUNCTION", "op_name.startswith('UNARY_')" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.UnaryOp" ], [ "LOAD_FAST", "op_name" ], [ "COMPARE_OP", "op_name in ('LOAD_ATTR', 'LOAD_METHOD', 'LOOKUP_METHOD')" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Attribute" ], [ "LOAD_FAST", "op_name" ], [ "COMPARE_OP", "op_name == 'COMPARE_OP'" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Compare" ], [ "LOAD_GLOBAL", "RuntimeError" ], [ "LOAD_FAST", "op_name" ], [ "CALL_FUNCTION", "RuntimeError(op_name)" ], [ "LOAD_GLOBAL", "lock" ], [ "LOAD_FAST", "stmts" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.matching_nodes" ], [ "LOAD_FAST", "exprs" ], [ "CALL_FUNCTION", "self.matching_nodes(exprs)" ], [ "CALL_FUNCTION", "list(self.matching_nodes(exprs))" ], [ "CALL_FUNCTION", "only(list(self.matching_nodes(exprs)))" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.walk" ], [ "LOAD_FAST", "stmt" ], [ "CALL_FUNCTION", "ast.walk(stmt)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "typ" ], [ "CALL_FUNCTION", "isinstance(node, typ)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "hasattr(node, \"ctx\")" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.ctx" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Load" ], [ "CALL_FUNCTION", "isinstance(node.ctx, ast.Load)" ], [ "UNARY_NOT", "not isinstance(node.ctx, ast.Load)" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "exprs" ], [ "CALL_FUNCTION", "enumerate(exprs)" ], [ "LOAD_GLOBAL", "get_setter" ], [ "LOAD_FAST", "expr" ], [ "CALL_FUNCTION", "get_setter(expr)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.BinOp" ], [ "LOAD_FAST", "expr" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Pow" ], [ "CALL_FUNCTION", "ast.Pow()" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Str" ], [ "LOAD_GLOBAL", "sentinel" ], [ "CALL_FUNCTION", "ast.Str(s=sentinel)" ], [ "CALL_FUNCTION", "ast.BinOp(\n left=expr,\n op=ast.Pow(),\n right=ast.Str(s=sentinel),\n )" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.fix_missing_locations" ], [ "LOAD_FAST", "replacement" ], [ "CALL_FUNCTION", "ast.fix_missing_locations(replacement)" ], [ "LOAD_FAST", "setter" ], [ "LOAD_FAST", "replacement" ], [ "CALL_FUNCTION", "setter(replacement)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.compile_instructions" ], [ "CALL_FUNCTION", "self.compile_instructions()" ], [ "LOAD_GLOBAL", "SyntaxError" ], [ "LOAD_FAST", "setter" ], [ "LOAD_FAST", "expr" ], [ "CALL_FUNCTION", "setter(expr)" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "instructions" ], [ "CALL_FUNCTION", "enumerate(instructions)" ], [ "LOAD_FAST", "instruction" ], [ "LOAD_ATTR", "instruction.argval" ], [ "LOAD_GLOBAL", "sentinel" ], [ "COMPARE_OP", "instruction.argval == sentinel" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "indices" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_FAST", "indices" ], [ "CALL_FUNCTION", "only(indices)" ], [ "BINARY_SUBTRACT", "only(indices) - 1" ], [ "LOAD_FAST", "instructions" ], [ "LOAD_FAST", "arg_index" ], [ "BINARY_SUBSCR", "instructions[arg_index]" ], [ "LOAD_ATTR", "instructions[arg_index].opname" ], [ "COMPARE_OP", "instructions[arg_index].opname == 'EXTENDED_ARG'" ], [ "LOAD_FAST", "instructions" ], [ "LOAD_FAST", "arg_index" ], [ "BINARY_SUBSCR", "instructions[arg_index]" ], [ "LOAD_ATTR", "instructions[arg_index].offset" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_lasti" ], [ "COMPARE_OP", "instructions[arg_index].offset == self.frame.f_lasti" ], [ "LOAD_FAST", "expr" ], [ "LOAD_GLOBAL", "compile_similar_to" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tree" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_code" ], [ "CALL_FUNCTION", "compile_similar_to(self.tree, self.frame.f_code)" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_GLOBAL", "find_codes" ], [ "LOAD_FAST", "module_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_code" ], [ "CALL_FUNCTION", "find_codes(module_code, self.frame.f_code)" ], [ "CALL_FUNCTION", "only(find_codes(module_code, self.frame.f_code))" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "get_instructions" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "get_instructions(code)" ], [ "CALL_FUNCTION", "list(get_instructions(code))" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.iter_fields" ], [ "LOAD_DEREF", "parent" ], [ "CALL_FUNCTION", "ast.iter_fields(parent)" ], [ "LOAD_DEREF", "field" ], [ "LOAD_FAST", "node" ], [ "COMPARE_OP", "field is node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_DEREF", "field" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "isinstance(field, list)" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_DEREF", "field" ], [ "CALL_FUNCTION", "enumerate(field)" ], [ "LOAD_FAST", "item" ], [ "LOAD_FAST", "node" ], [ "COMPARE_OP", "item is node" ], [ "LOAD_FAST", "setter" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_DEREF", "parent" ], [ "LOAD_DEREF", "name" ], [ "LOAD_FAST", "new_node" ], [ "CALL_FUNCTION", "setattr(parent, name, new_node)" ], [ "LOAD_FAST", "new_node" ], [ "LOAD_DEREF", "field" ], [ "LOAD_DEREF", "i" ], [ "LOAD_DEREF", "matches" ], [ "LOAD_FAST", "root_code" ], [ "CALL_FUNCTION", "matches(root_code)" ], [ "LOAD_DEREF", "code_options" ], [ "LOAD_ATTR", "code_options.append" ], [ "LOAD_FAST", "root_code" ], [ "CALL_FUNCTION", "code_options.append(root_code)" ], [ "LOAD_DEREF", "finder" ], [ "LOAD_FAST", "root_code" ], [ "CALL_FUNCTION", "finder(root_code)" ], [ "LOAD_DEREF", "code_options" ], [ "LOAD_GLOBAL", "all" ], [ "LOAD_GLOBAL", "attrgetter" ], [ "CALL_FUNCTION", "attrgetter('co_firstlineno')" ], [ "LOAD_GLOBAL", "attrgetter" ], [ "CALL_FUNCTION", "attrgetter('co_name')" ], [ "LOAD_GLOBAL", "code_names" ], [ "CALL_FUNCTION", "all(\n f(c) == f(matching)\n for f in [\n attrgetter('co_firstlineno'),\n attrgetter('co_name'),\n code_names,\n ]\n )" ], [ "LOAD_FAST", "f" ], [ "LOAD_DEREF", "c" ], [ "CALL_FUNCTION", "f(c)" ], [ "LOAD_FAST", "f" ], [ "LOAD_DEREF", "matching" ], [ "CALL_FUNCTION", "f(matching)" ], [ "COMPARE_OP", "f(c) == f(matching)" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_consts" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.iscode" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "inspect.iscode(const)" ], [ "LOAD_DEREF", "matches" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "matches(const)" ], [ "LOAD_DEREF", "code_options" ], [ "LOAD_ATTR", "code_options.append" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "code_options.append(const)" ], [ "LOAD_DEREF", "finder" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "finder(const)" ], [ "LOAD_GLOBAL", "frozenset" ], [ "CALL_FUNCTION", "frozenset()" ], [ "LOAD_ATTR", "frozenset().union" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_names" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_varnames" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_freevars" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_cellvars" ], [ "CALL_FUNCTION", "frozenset().union(\n code.co_names,\n code.co_varnames,\n code.co_freevars,\n code.co_cellvars,\n )" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "CALL_FUNCTION", "isinstance(node, ast.stmt)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_FAST", "node" ] ], "import_hook.py": [ [ "LOAD_NAME", "object" ], [ "LOAD_FAST", "spec" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "deep" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "eye" ], [ "LOAD_ATTR", "eye.exec_string" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.source" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._spec" ], [ "LOAD_ATTR", "self._spec.origin" ], [ "LOAD_FAST", "module" ], [ "LOAD_ATTR", "module.__dict__" ], [ "LOAD_FAST", "module" ], [ "LOAD_ATTR", "module.__dict__" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.deep" ], [ "CALL_FUNCTION", "eye.exec_string(\n source=self.source,\n filename=self._spec.origin,\n globs=module.__dict__,\n locs=module.__dict__,\n deep=self.deep,\n )" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._spec" ], [ "LOAD_ATTR", "self._spec.loader" ], [ "LOAD_ATTR", "self._spec.loader.get_filename" ], [ "LOAD_FAST", "fullname" ], [ "CALL_FUNCTION", "self._spec.loader.get_filename(fullname)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._spec" ], [ "LOAD_ATTR", "self._spec.loader" ], [ "LOAD_ATTR", "self._spec.loader.is_package" ], [ "LOAD_FAST", "fullname" ], [ "CALL_FUNCTION", "self._spec.loader.is_package(fullname)" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.meta_path" ], [ "LOAD_FAST", "finder" ], [ "LOAD_FAST", "self" ], [ "COMPARE_OP", "finder is self" ], [ "LOAD_FAST", "finder" ], [ "LOAD_ATTR", "finder.__module__" ], [ "COMPARE_OP", "'pytest' in finder.__module__" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "finder" ], [ "CALL_FUNCTION", "hasattr(finder, 'find_spec')" ], [ "LOAD_FAST", "finder" ], [ "LOAD_ATTR", "finder.find_spec" ], [ "LOAD_FAST", "fullname" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "target" ], [ "CALL_FUNCTION", "finder.find_spec(fullname, path, target=target)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "finder" ], [ "CALL_FUNCTION", "hasattr(finder, 'load_module')" ], [ "LOAD_GLOBAL", "spec_from_loader" ], [ "LOAD_FAST", "fullname" ], [ "LOAD_FAST", "finder" ], [ "CALL_FUNCTION", "spec_from_loader(fullname, finder)" ], [ "LOAD_FAST", "spec" ], [ "COMPARE_OP", "spec is not None" ], [ "LOAD_FAST", "spec" ], [ "LOAD_ATTR", "spec.origin" ], [ "COMPARE_OP", "spec.origin != 'builtin'" ], [ "LOAD_FAST", "spec" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._find_plain_spec" ], [ "LOAD_FAST", "fullname" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "target" ], [ "CALL_FUNCTION", "self._find_plain_spec(fullname, path, target)" ], [ "LOAD_FAST", "spec" ], [ "COMPARE_OP", "spec is None" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "spec" ], [ "LOAD_ATTR", "spec.loader" ], [ "CALL_FUNCTION", "hasattr(spec.loader, 'get_source')" ], [ "LOAD_GLOBAL", "callable" ], [ "LOAD_FAST", "spec" ], [ "LOAD_ATTR", "spec.loader" ], [ "LOAD_ATTR", "spec.loader.get_source" ], [ "CALL_FUNCTION", "callable(spec.loader.get_source)" ], [ "UNARY_NOT", "not (hasattr(spec.loader, 'get_source') and\n callable(spec.loader.get_source))" ], [ "LOAD_FAST", "fullname" ], [ "COMPARE_OP", "fullname != 'org'" ], [ "LOAD_GLOBAL", "logging" ], [ "LOAD_ATTR", "logging.debug" ], [ "LOAD_FAST", "fullname" ], [ "CALL_FUNCTION", "logging.debug('Failed finding spec for %s', fullname)" ], [ "LOAD_FAST", "spec" ], [ "LOAD_ATTR", "spec.loader" ], [ "LOAD_ATTR", "spec.loader.get_source" ], [ "LOAD_FAST", "fullname" ], [ "CALL_FUNCTION", "spec.loader.get_source(fullname)" ], [ "LOAD_GLOBAL", "ImportError" ], [ "LOAD_GLOBAL", "logging" ], [ "LOAD_ATTR", "logging.debug" ], [ "LOAD_FAST", "fullname" ], [ "CALL_FUNCTION", "logging.debug('Loader for %s was unable to find the sources',\n fullname)" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_GLOBAL", "logging" ], [ "LOAD_ATTR", "logging.exception" ], [ "LOAD_FAST", "fullname" ], [ "CALL_FUNCTION", "logging.exception('Loader for %s raised an error', fullname)" ], [ "LOAD_FAST", "source" ], [ "UNARY_NOT", "not source" ], [ "LOAD_FAST", "source" ], [ "COMPARE_OP", "'birdseye' not in source" ], [ "LOAD_GLOBAL", "should_trace" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "should_trace(source)" ], [ "LOAD_FAST", "trace_stmt" ], [ "LOAD_GLOBAL", "BirdsEyeLoader" ], [ "LOAD_FAST", "spec" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "deep" ], [ "CALL_FUNCTION", "BirdsEyeLoader(spec, source, deep)" ], [ "LOAD_GLOBAL", "spec_from_loader" ], [ "LOAD_FAST", "fullname" ], [ "LOAD_FAST", "loader" ], [ "CALL_FUNCTION", "spec_from_loader(fullname, loader)" ], [ "LOAD_GLOBAL", "False" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.parse" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "ast.parse(source)" ], [ "LOAD_ATTR", "ast.parse(source).body" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Import" ], [ "CALL_FUNCTION", "isinstance(stmt, ast.Import)" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_ATTR", "stmt.names" ], [ "LOAD_FAST", "alias" ], [ "LOAD_ATTR", "alias.name" ], [ "LOAD_ATTR", "alias.name.startswith" ], [ "CALL_FUNCTION", "alias.name.startswith('birdseye.trace_module')" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_FAST", "alias" ], [ "LOAD_ATTR", "alias.name" ], [ "LOAD_ATTR", "alias.name.endswith" ], [ "CALL_FUNCTION", "alias.name.endswith('deep')" ], [ "LOAD_GLOBAL", "True" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.ImportFrom" ], [ "CALL_FUNCTION", "isinstance(stmt, ast.ImportFrom)" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_ATTR", "stmt.module" ], [ "COMPARE_OP", "stmt.module == 'birdseye'" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_ATTR", "stmt.names" ], [ "LOAD_FAST", "alias" ], [ "LOAD_ATTR", "alias.name" ], [ "LOAD_ATTR", "alias.name.startswith" ], [ "CALL_FUNCTION", "alias.name.startswith('trace_module')" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_FAST", "alias" ], [ "LOAD_ATTR", "alias.name" ], [ "LOAD_ATTR", "alias.name.endswith" ], [ "CALL_FUNCTION", "alias.name.endswith('deep')" ], [ "LOAD_GLOBAL", "True" ], [ "LOAD_FAST", "deep" ], [ "LOAD_FAST", "trace_stmt" ] ], "ipython.py": [ [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "BytesIO" ], [ "LOAD_NAME", "StringIO" ], [ "LOAD_NAME", "stream_proxy" ], [ "LOAD_NAME", "sys" ], [ "LOAD_ATTR", "sys.stderr" ], [ "CALL_FUNCTION", "stream_proxy(sys.stderr)" ], [ "LOAD_NAME", "sys" ], [ "LOAD_NAME", "stream_proxy" ], [ "LOAD_NAME", "sys" ], [ "LOAD_ATTR", "sys.stdout" ], [ "CALL_FUNCTION", "stream_proxy(sys.stdout)" ], [ "LOAD_NAME", "sys" ], [ "LOAD_NAME", "Environment" ], [ "LOAD_NAME", "PackageLoader" ], [ "CALL_FUNCTION", "PackageLoader('birdseye', 'templates')" ], [ "LOAD_NAME", "select_autoescape" ], [ "CALL_FUNCTION", "select_autoescape(['html', 'xml'])" ], [ "CALL_FUNCTION", "Environment(\n loader=PackageLoader('birdseye', 'templates'),\n autoescape=select_autoescape(['html', 'xml'])\n)" ], [ "LOAD_NAME", "magics_class" ], [ "LOAD_NAME", "Magics" ], [ "CALL_FUNCTION", "magics_class" ], [ "LOAD_GLOBAL", "LocalProxy" ], [ "LOAD_FAST", "p" ], [ "CALL_FUNCTION", "LocalProxy(p)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.currentframe" ], [ "CALL_FUNCTION", "inspect.currentframe()" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_GLOBAL", "ThreadingMixIn" ], [ "LOAD_ATTR", "ThreadingMixIn.process_request_thread" ], [ "LOAD_ATTR", "ThreadingMixIn.process_request_thread.__code__" ], [ "COMPARE_OP", "frame.f_code == ThreadingMixIn.process_request_thread.__code__" ], [ "LOAD_GLOBAL", "fake_stream" ], [ "CALL_FUNCTION", "fake_stream()" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_GLOBAL", "thread_proxies" ], [ "LOAD_ATTR", "thread_proxies.get" ], [ "LOAD_GLOBAL", "currentThread" ], [ "CALL_FUNCTION", "currentThread()" ], [ "LOAD_ATTR", "currentThread().ident" ], [ "LOAD_DEREF", "original" ], [ "CALL_FUNCTION", "thread_proxies.get(currentThread().ident,\n original)" ], [ "LOAD_FAST", "show_server_output" ], [ "LOAD_GLOBAL", "fake_stream" ], [ "CALL_FUNCTION", "fake_stream()" ], [ "LOAD_GLOBAL", "thread_proxies" ], [ "LOAD_GLOBAL", "currentThread" ], [ "CALL_FUNCTION", "currentThread()" ], [ "LOAD_ATTR", "currentThread().ident" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_ATTR", "server.app" ], [ "LOAD_ATTR", "server.app.run" ], [ "LOAD_GLOBAL", "True" ], [ "LOAD_FAST", "port" ], [ "LOAD_FAST", "bind_host" ], [ "LOAD_GLOBAL", "False" ], [ "CALL_FUNCTION", "server.app.run(\n debug=True,\n port=port,\n host=bind_host,\n use_reloader=False,\n )" ], [ "LOAD_GLOBAL", "socket" ], [ "LOAD_ATTR", "socket.error" ], [ "LOAD_NAME", "Unicode" ], [ "LOAD_NAME", "True" ], [ "CALL_FUNCTION", "Unicode(\n u'', config=True,\n help='If set, a server will not be automatically started by %%eye. '\n 'The iframe containing birdseye output will use this value as the base '\n 'of its URL.'\n )" ], [ "LOAD_NAME", "Int" ], [ "LOAD_NAME", "True" ], [ "CALL_FUNCTION", "Int(\n 7777, config=True,\n help='Port number for the server started by %%eye.'\n )" ], [ "LOAD_NAME", "Unicode" ], [ "LOAD_NAME", "True" ], [ "CALL_FUNCTION", "Unicode(\n '127.0.0.1', config=True,\n help='Host that the server started by %%eye listens on. '\n 'Set to 0.0.0.0 to make it accessible anywhere.'\n )" ], [ "LOAD_NAME", "Bool" ], [ "LOAD_NAME", "False" ], [ "LOAD_NAME", "True" ], [ "CALL_FUNCTION", "Bool(\n False, config=True,\n help='Set to True to show stdout and stderr from the server started by %%eye.'\n )" ], [ "LOAD_NAME", "Unicode" ], [ "LOAD_NAME", "True" ], [ "CALL_FUNCTION", "Unicode(\n u'', config=True,\n help='The database URL that the server started by %%eye reads from. '\n 'Equivalent to the environment variable BIRDSEYE_DB.'\n )" ], [ "LOAD_NAME", "cell_magic" ], [ "CALL_FUNCTION", "cell_magic" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.server_url" ], [ "LOAD_GLOBAL", "Database" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.db_url" ], [ "CALL_FUNCTION", "Database(self.db_url)" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_ATTR", "server.db" ], [ "LOAD_ATTR", "server.db.Function" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_ATTR", "server.db" ], [ "LOAD_ATTR", "server.db.Call" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_ATTR", "server.db" ], [ "LOAD_ATTR", "server.db.Session" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_GLOBAL", "Thread" ], [ "LOAD_GLOBAL", "run_server" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.port" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.bind_host" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.show_server_output" ], [ "CALL_FUNCTION", "Thread(\n target=run_server,\n args=(\n self.port,\n self.bind_host,\n self.show_server_output,\n ),\n )" ], [ "LOAD_ATTR", "Thread(\n target=run_server,\n args=(\n self.port,\n self.bind_host,\n self.show_server_output,\n ),\n ).start" ], [ "CALL_FUNCTION", "Thread(\n target=run_server,\n args=(\n self.port,\n self.bind_host,\n self.show_server_output,\n ),\n ).start()" ], [ "LOAD_GLOBAL", "Database" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.db_url" ], [ "CALL_FUNCTION", "Database(self.db_url)" ], [ "LOAD_GLOBAL", "eye" ], [ "LOAD_GLOBAL", "eye" ], [ "LOAD_ATTR", "eye.exec_ipython_cell" ], [ "LOAD_FAST", "cell" ], [ "LOAD_FAST", "callback" ], [ "CALL_FUNCTION", "eye.exec_ipython_cell(cell, callback)" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "call_id" ], [ "COMPARE_OP", "call_id is None" ], [ "LOAD_GLOBAL", "HTML" ], [ "LOAD_GLOBAL", "templates_env" ], [ "LOAD_ATTR", "templates_env.get_template" ], [ "CALL_FUNCTION", "templates_env.get_template('ipython_iframe.html')" ], [ "LOAD_ATTR", "templates_env.get_template('ipython_iframe.html').render" ], [ "LOAD_FAST", "call_id" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.server_url" ], [ "LOAD_ATTR", "self.server_url.rstrip" ], [ "CALL_FUNCTION", "self.server_url.rstrip('/')" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.port" ], [ "LOAD_GLOBAL", "uuid4" ], [ "CALL_FUNCTION", "uuid4()" ], [ "LOAD_ATTR", "uuid4().hex" ], [ "CALL_FUNCTION", "templates_env.get_template('ipython_iframe.html').render(\n call_id=call_id,\n url=self.server_url.rstrip('/'),\n port=self.port,\n container_id=uuid4().hex,\n )" ], [ "CALL_FUNCTION", "HTML(templates_env.get_template('ipython_iframe.html').render(\n call_id=call_id,\n url=self.server_url.rstrip('/'),\n port=self.port,\n container_id=uuid4().hex,\n ))" ], [ "LOAD_GLOBAL", "display" ], [ "LOAD_FAST", "html" ], [ "CALL_FUNCTION", "display(html)" ] ], "server.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOAD_ATTR", "standard_library.install_aliases" ], [ "CALL_FUNCTION", "standard_library.install_aliases()" ], [ "LOAD_NAME", "Flask" ], [ "CALL_FUNCTION", "Flask('birdseye')" ], [ "LOAD_NAME", "True" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.jinja_env" ], [ "LOAD_NAME", "Humanize" ], [ "LOAD_NAME", "app" ], [ "CALL_FUNCTION", "Humanize(app)" ], [ "LOAD_NAME", "PathConverter" ], [ "LOAD_NAME", "FileConverter" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.url_map" ], [ "LOAD_ATTR", "app.url_map.converters" ], [ "LOAD_NAME", "Database" ], [ "CALL_FUNCTION", "Database()" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.Session" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.Function" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.Call" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION", "app.route('/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION", "app.route('/file/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/file/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION", "app.route('/file//__function__/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/file//__function__/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION", "app.route('/api/file//__function__//latest_call/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/api/file//__function__//latest_call/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION", "app.route('/call/')" ], [ "CALL_FUNCTION", "app.route('/call/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION", "app.route('/ipython_call/')" ], [ "CALL_FUNCTION", "app.route('/ipython_call/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION", "app.route('/ipython_iframe/')" ], [ "CALL_FUNCTION", "app.route('/ipython_iframe/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION", "app.route('/kill', methods=['POST'])" ], [ "CALL_FUNCTION", "app.route('/kill', methods=['POST'])" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION", "app.route('/api/call/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/api/call/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION", "app.route('/api/calls_by_body_hash/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/api/calls_by_body_hash/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION", "app.route('/api/body_hashes_present/', methods=['POST'])" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/api/body_hashes_present/', methods=['POST'])" ], [ "LOAD_NAME", "sys" ], [ "LOAD_ATTR", "sys.argv" ], [ "SLICE+1", "sys.argv[1:]" ], [ "LOAD_NAME", "__name__" ], [ "COMPARE_OP", "__name__ == '__main__'" ], [ "LOAD_NAME", "main" ], [ "CALL_FUNCTION", "main()" ], [ "LOAD_GLOBAL", "db" ], [ "LOAD_ATTR", "db.all_file_paths" ], [ "CALL_FUNCTION", "db.all_file_paths()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_columns" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.basic_columns" ], [ "BINARY_ADD", "Call.basic_columns + Function.basic_columns" ], [ "CALL_FUNCTION_VAR", "session.query(*(Call.basic_columns + Function.basic_columns))" ], [ "LOAD_ATTR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_FUNCTION", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)" ], [ "LOAD_ATTR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .order_by" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.start_time" ], [ "LOAD_ATTR", "Call.start_time.desc" ], [ "CALL_FUNCTION", "Call.start_time.desc()" ], [ "CALL_FUNCTION", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .order_by(Call.start_time.desc())" ], [ "SLICE+2", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .order_by(Call.start_time.desc())[:100]" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "CALL_FUNCTION", "OrderedDict()" ], [ "LOAD_FAST", "recent_calls" ], [ "LOAD_GLOBAL", "is_ipython_cell" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.file" ], [ "CALL_FUNCTION", "is_ipython_cell(row.file)" ], [ "LOAD_FAST", "files" ], [ "LOAD_ATTR", "files.setdefault" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.file" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "CALL_FUNCTION", "OrderedDict()" ], [ "CALL_FUNCTION", "files.setdefault(\n row.file, OrderedDict()\n )" ], [ "LOAD_ATTR", "files.setdefault(\n row.file, OrderedDict()\n ).setdefault" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.name" ], [ "LOAD_FAST", "row" ], [ "CALL_FUNCTION", "files.setdefault(\n row.file, OrderedDict()\n ).setdefault(\n row.name, row\n )" ], [ "LOAD_FAST", "all_paths" ], [ "LOAD_FAST", "files" ], [ "LOAD_ATTR", "files.setdefault" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "CALL_FUNCTION", "OrderedDict()" ], [ "CALL_FUNCTION", "files.setdefault(\n path, OrderedDict()\n )" ], [ "LOAD_GLOBAL", "partial" ], [ "LOAD_GLOBAL", "short_path" ], [ "LOAD_FAST", "all_paths" ], [ "CALL_FUNCTION", "partial(short_path, all_paths=all_paths)" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "short" ], [ "LOAD_FAST", "files" ], [ "CALL_FUNCTION", "render_template('index.html',\n short=short,\n files=files)" ], [ "LOAD_GLOBAL", "fix_abs_path" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "fix_abs_path(path)" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_columns" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.basic_columns" ], [ "BINARY_ADD", "Call.basic_columns + Function.basic_columns" ], [ "CALL_FUNCTION_VAR", "session.query(*(Call.basic_columns + Function.basic_columns))" ], [ "LOAD_ATTR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_FUNCTION", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)" ], [ "LOAD_ATTR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path)" ], [ "LOAD_ATTR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path)\n .subquery" ], [ "CALL_FUNCTION", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path)\n .subquery('filtered_calls')" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.name" ], [ "LOAD_GLOBAL", "sqlalchemy" ], [ "LOAD_ATTR", "sqlalchemy.func" ], [ "LOAD_ATTR", "sqlalchemy.func.max" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.start_time" ], [ "CALL_FUNCTION", "sqlalchemy.func.max(filtered_calls.c.start_time)" ], [ "LOAD_ATTR", "sqlalchemy.func.max(filtered_calls.c.start_time).label" ], [ "CALL_FUNCTION", "sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')" ], [ "CALL_FUNCTION", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n )" ], [ "LOAD_ATTR", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n ).group_by" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.name" ], [ "CALL_FUNCTION", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n ).group_by(\n filtered_calls.c.name,\n )" ], [ "LOAD_ATTR", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n ).group_by(\n filtered_calls.c.name,\n ).subquery" ], [ "CALL_FUNCTION", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n ).group_by(\n filtered_calls.c.name,\n ).subquery('latest_calls')" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_FAST", "filtered_calls" ], [ "CALL_FUNCTION", "session.query(filtered_calls)" ], [ "LOAD_ATTR", "session.query(filtered_calls).join" ], [ "LOAD_FAST", "latest_calls" ], [ "LOAD_GLOBAL", "sqlalchemy" ], [ "LOAD_ATTR", "sqlalchemy.and_" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.name" ], [ "LOAD_FAST", "latest_calls" ], [ "LOAD_ATTR", "latest_calls.c" ], [ "LOAD_ATTR", "latest_calls.c.name" ], [ "COMPARE_OP", "filtered_calls.c.name == latest_calls.c.name" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.start_time" ], [ "LOAD_FAST", "latest_calls" ], [ "LOAD_ATTR", "latest_calls.c" ], [ "LOAD_ATTR", "latest_calls.c.maxtime" ], [ "COMPARE_OP", "filtered_calls.c.start_time == latest_calls.c.maxtime" ], [ "CALL_FUNCTION", "sqlalchemy.and_(\n filtered_calls.c.name == latest_calls.c.name,\n filtered_calls.c.start_time == latest_calls.c.maxtime,\n )" ], [ "CALL_FUNCTION", "session.query(filtered_calls).join(\n latest_calls,\n sqlalchemy.and_(\n filtered_calls.c.name == latest_calls.c.name,\n filtered_calls.c.start_time == latest_calls.c.maxtime,\n )\n )" ], [ "LOAD_ATTR", "session.query(filtered_calls).join(\n latest_calls,\n sqlalchemy.and_(\n filtered_calls.c.name == latest_calls.c.name,\n filtered_calls.c.start_time == latest_calls.c.maxtime,\n )\n ).order_by" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.start_time" ], [ "LOAD_ATTR", "filtered_calls.c.start_time.desc" ], [ "CALL_FUNCTION", "filtered_calls.c.start_time.desc()" ], [ "CALL_FUNCTION", "session.query(filtered_calls).join(\n latest_calls,\n sqlalchemy.and_(\n filtered_calls.c.name == latest_calls.c.name,\n filtered_calls.c.start_time == latest_calls.c.maxtime,\n )\n ).order_by(filtered_calls.c.start_time.desc())" ], [ "LOAD_GLOBAL", "group_by_attr" ], [ "LOAD_FAST", "query" ], [ "CALL_FUNCTION", "group_by_attr(query, 'type')" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.name" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.type" ], [ "CALL_FUNCTION", "session.query(Function.name, Function.type)" ], [ "LOAD_ATTR", "session.query(Function.name, Function.type)\n .filter_by" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "session.query(Function.name, Function.type)\n .filter_by(file=path)" ], [ "LOAD_ATTR", "session.query(Function.name, Function.type)\n .filter_by(file=path)\n .distinct" ], [ "CALL_FUNCTION", "session.query(Function.name, Function.type)\n .filter_by(file=path)\n .distinct()" ], [ "CALL_FUNCTION", "sorted(session.query(Function.name, Function.type)\n .filter_by(file=path)\n .distinct())" ], [ "LOAD_FAST", "query" ], [ "LOAD_FAST", "all_funcs" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.name" ], [ "LOAD_FAST", "func_names" ], [ "COMPARE_OP", "func.name not in func_names" ], [ "LOAD_FAST", "funcs" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.type" ], [ "BINARY_SUBSCR", "funcs[func.type]" ], [ "LOAD_ATTR", "funcs[func.type].append" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "funcs[func.type].append(func)" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "funcs" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "COMPARE_OP", "path == IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "basename" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "basename(path)" ], [ "CALL_FUNCTION", "render_template('file.html',\n funcs=funcs,\n is_ipython=path == IPYTHON_FILE_PATH,\n full_path=path,\n short_path=basename(path))" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.name" ], [ "LOAD_GLOBAL", "fix_abs_path" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "fix_abs_path(path)" ], [ "LOAD_GLOBAL", "get_calls" ], [ "LOAD_FAST", "session" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "func_name" ], [ "CALL_FUNCTION", "get_calls(session, path, func_name, 200)" ], [ "LOAD_FAST", "query" ], [ "LOAD_FAST", "query" ], [ "BINARY_SUBSCR", "query[0]" ], [ "LOAD_FAST", "query" ], [ "LOAD_GLOBAL", "withattrs" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_FUNCTION", "Call()" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row._asdict" ], [ "CALL_FUNCTION", "row._asdict()" ], [ "CALL_FUNCTION_KW", "withattrs(Call(), **row._asdict())" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_FUNCTION", "session.query(Function)" ], [ "LOAD_ATTR", "session.query(Function).filter_by" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "func_name" ], [ "CALL_FUNCTION", "session.query(Function).filter_by(file=path, name=func_name)" ], [ "BINARY_SUBSCR", "session.query(Function).filter_by(file=path, name=func_name)[0]" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "func" ], [ "LOAD_GLOBAL", "basename" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "basename(path)" ], [ "LOAD_FAST", "calls" ], [ "CALL_FUNCTION", "render_template('function.html',\n func=func,\n short_path=basename(path),\n calls=calls)" ], [ "LOAD_GLOBAL", "fix_abs_path" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "fix_abs_path(path)" ], [ "LOAD_GLOBAL", "get_calls" ], [ "LOAD_FAST", "session" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "func_name" ], [ "CALL_FUNCTION", "get_calls(session, path, func_name, 1)" ], [ "BINARY_SUBSCR", "get_calls(session, path, func_name, 1)[0]" ], [ "LOAD_GLOBAL", "jsonify" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.id" ], [ "LOAD_GLOBAL", "url_for" ], [ "LOAD_GLOBAL", "call_view" ], [ "LOAD_ATTR", "call_view.__name__" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.id" ], [ "CALL_FUNCTION", "url_for(call_view.__name__,\n call_id=call.id)" ], [ "CALL_FUNCTION", "dict(\n id=call.id,\n url=url_for(call_view.__name__,\n call_id=call.id),\n )" ], [ "CALL_FUNCTION", "jsonify(dict(\n id=call.id,\n url=url_for(call_view.__name__,\n call_id=call.id),\n ))" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_columns" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.basic_columns" ], [ "BINARY_ADD", "Call.basic_columns + Function.basic_columns" ], [ "CALL_FUNCTION_VAR", "session.query(*(Call.basic_columns + Function.basic_columns))" ], [ "LOAD_ATTR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_FUNCTION", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)" ], [ "LOAD_ATTR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "func_name" ], [ "CALL_FUNCTION", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path, name=func_name)" ], [ "LOAD_ATTR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path, name=func_name)\n .order_by" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.start_time" ], [ "LOAD_ATTR", "Call.start_time.desc" ], [ "CALL_FUNCTION", "Call.start_time.desc()" ], [ "CALL_FUNCTION", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path, name=func_name)\n .order_by(Call.start_time.desc())" ], [ "LOAD_FAST", "limit" ], [ "SLICE+2", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path, name=func_name)\n .order_by(Call.start_time.desc())[:limit]" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_FUNCTION", "session.query(Call)" ], [ "LOAD_ATTR", "session.query(Call).filter_by" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION", "session.query(Call).filter_by(id=call_id)" ], [ "LOAD_ATTR", "session.query(Call).filter_by(id=call_id).one" ], [ "CALL_FUNCTION", "session.query(Call).filter_by(id=call_id).one()" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.function" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "template" ], [ "LOAD_GLOBAL", "basename" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.file" ], [ "CALL_FUNCTION", "basename(func.file)" ], [ "LOAD_FAST", "call" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "render_template(template,\n short_path=basename(func.file),\n call=call,\n func=func)" ], [ "LOAD_GLOBAL", "base_call_view" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION", "base_call_view(call_id, 'call.html')" ], [ "LOAD_GLOBAL", "base_call_view" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION", "base_call_view(call_id, 'ipython_call.html')" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION", "render_template('ipython_iframe.html',\n container_id='1234',\n port=7777,\n call_id=call_id)" ], [ "LOAD_GLOBAL", "request" ], [ "LOAD_ATTR", "request.environ" ], [ "LOAD_ATTR", "request.environ.get" ], [ "CALL_FUNCTION", "request.environ.get('werkzeug.server.shutdown')" ], [ "LOAD_FAST", "func" ], [ "COMPARE_OP", "func is None" ], [ "LOAD_GLOBAL", "RuntimeError" ], [ "CALL_FUNCTION", "RuntimeError('Not running with the Werkzeug Server')" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "func()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_FUNCTION", "session.query(Call)" ], [ "LOAD_ATTR", "session.query(Call).filter_by" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION", "session.query(Call).filter_by(id=call_id)" ], [ "LOAD_ATTR", "session.query(Call).filter_by(id=call_id).one" ], [ "CALL_FUNCTION", "session.query(Call).filter_by(id=call_id).one()" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.function" ], [ "LOAD_GLOBAL", "DecentJSONEncoder" ], [ "CALL_FUNCTION", "DecentJSONEncoder()" ], [ "LOAD_ATTR", "DecentJSONEncoder().encode" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.parsed_data" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_dict" ], [ "LOAD_FAST", "call" ], [ "CALL_FUNCTION", "Call.basic_dict(call)" ], [ "CALL_FUNCTION_KW", "dict(data=call.parsed_data, **Call.basic_dict(call))" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.parsed_data" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.basic_dict" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "Function.basic_dict(func)" ], [ "CALL_FUNCTION_KW", "dict(data=func.parsed_data, **Function.basic_dict(func))" ], [ "CALL_FUNCTION", "dict(\n call=dict(data=call.parsed_data, **Call.basic_dict(call)),\n function=dict(data=func.parsed_data, **Function.basic_dict(func)))" ], [ "CALL_FUNCTION", "DecentJSONEncoder().encode(dict(\n call=dict(data=call.parsed_data, **Call.basic_dict(call)),\n function=dict(data=func.parsed_data, **Function.basic_dict(func))))" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_columns" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.data" ], [ "BINARY_ADD", "Call.basic_columns + (Function.data,)" ], [ "CALL_FUNCTION_VAR", "session.query(*Call.basic_columns + (Function.data,))" ], [ "LOAD_ATTR", "session.query(*Call.basic_columns + (Function.data,))\n .join" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_FUNCTION", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)" ], [ "LOAD_ATTR", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by" ], [ "LOAD_FAST", "body_hash" ], [ "CALL_FUNCTION", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by(body_hash=body_hash)" ], [ "LOAD_ATTR", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by(body_hash=body_hash)\n .order_by" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.start_time" ], [ "LOAD_ATTR", "Call.start_time.desc" ], [ "CALL_FUNCTION", "Call.start_time.desc()" ], [ "CALL_FUNCTION", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by(body_hash=body_hash)\n .order_by(Call.start_time.desc())" ], [ "SLICE+2", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by(body_hash=body_hash)\n .order_by(Call.start_time.desc())[:200]" ], [ "LOAD_FAST", "query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_dict" ], [ "LOAD_GLOBAL", "withattrs" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_FUNCTION", "Call()" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row._asdict" ], [ "CALL_FUNCTION", "row._asdict()" ], [ "CALL_FUNCTION_KW", "withattrs(Call(), **row._asdict())" ], [ "CALL_FUNCTION", "Call.basic_dict(withattrs(Call(), **row._asdict()))" ], [ "LOAD_FAST", "query" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "function_data_set" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_ATTR", "json.loads" ], [ "LOAD_DEREF", "function_data" ], [ "CALL_FUNCTION", "json.loads(function_data)" ], [ "LOAD_FAST", "add" ], [ "LOAD_FAST", "ranges" ], [ "CALL_FUNCTION", "add('node_ranges', ranges)" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "add" ], [ "LOAD_FAST", "current_loop_ranges" ], [ "CALL_FUNCTION", "add('loop_ranges', current_loop_ranges)" ], [ "LOAD_FAST", "loop_ranges" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "current_loop_ranges" ], [ "COMPARE_OP", "loop_ranges in (set(), current_loop_ranges)" ], [ "LOAD_FAST", "current_loop_ranges" ], [ "LOAD_FAST", "ranges" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "CALL_FUNCTION", "dict(start=start, end=end)" ], [ "LOAD_FAST", "loop_ranges" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "CALL_FUNCTION", "dict(start=start, end=end)" ], [ "LOAD_GLOBAL", "DecentJSONEncoder" ], [ "CALL_FUNCTION", "DecentJSONEncoder()" ], [ "LOAD_ATTR", "DecentJSONEncoder().encode" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "calls" ], [ "LOAD_FAST", "ranges" ], [ "LOAD_FAST", "loop_ranges" ], [ "CALL_FUNCTION", "dict(\n calls=calls, ranges=ranges, loop_ranges=loop_ranges)" ], [ "CALL_FUNCTION", "DecentJSONEncoder().encode(dict(\n calls=calls, ranges=ranges, loop_ranges=loop_ranges))" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.data" ], [ "LOAD_DEREF", "function_data" ], [ "LOAD_FAST", "key" ], [ "BINARY_SUBSCR", "function_data[key]" ], [ "LOAD_FAST", "ranges_set" ], [ "LOAD_ATTR", "ranges_set.add" ], [ "LOAD_FAST", "node" ], [ "BINARY_SUBSCR", "node['start']" ], [ "LOAD_FAST", "node" ], [ "BINARY_SUBSCR", "node['end']" ], [ "CALL_FUNCTION", "ranges_set.add((node['start'], node['end']))" ], [ "LOAD_GLOBAL", "request" ], [ "LOAD_ATTR", "request.get_json" ], [ "CALL_FUNCTION", "request.get_json()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.body_hash" ], [ "LOAD_GLOBAL", "sqlalchemy" ], [ "LOAD_ATTR", "sqlalchemy.func" ], [ "LOAD_ATTR", "sqlalchemy.func.count" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.id" ], [ "CALL_FUNCTION", "sqlalchemy.func.count(Call.id)" ], [ "CALL_FUNCTION", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))" ], [ "LOAD_ATTR", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_FUNCTION", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)" ], [ "LOAD_ATTR", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)\n .filter" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.body_hash" ], [ "LOAD_ATTR", "Function.body_hash.in_" ], [ "LOAD_FAST", "hashes" ], [ "CALL_FUNCTION", "Function.body_hash.in_(hashes)" ], [ "CALL_FUNCTION", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)\n .filter(Function.body_hash.in_(hashes))" ], [ "LOAD_ATTR", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)\n .filter(Function.body_hash.in_(hashes))\n .group_by" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.body_hash" ], [ "CALL_FUNCTION", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)\n .filter(Function.body_hash.in_(hashes))\n .group_by(Function.body_hash)" ], [ "LOAD_GLOBAL", "DecentJSONEncoder" ], [ "CALL_FUNCTION", "DecentJSONEncoder()" ], [ "LOAD_ATTR", "DecentJSONEncoder().encode" ], [ "LOAD_FAST", "query" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "h" ], [ "LOAD_FAST", "count" ], [ "CALL_FUNCTION", "dict(hash=h, count=count)" ], [ "CALL_FUNCTION", "DecentJSONEncoder().encode([\n dict(hash=h, count=count)\n for h, count in query\n ])" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "argv" ], [ "CALL_FUNCTION", "len(argv)" ], [ "COMPARE_OP", "len(argv) == 1" ], [ "LOAD_FAST", "argv" ], [ "BINARY_SUBSCR", "argv[0]" ], [ "LOAD_ATTR", "argv[0].isdigit" ], [ "CALL_FUNCTION", "argv[0].isdigit()" ], [ "LOAD_FAST", "argv" ], [ "LOAD_ATTR", "argv.insert" ], [ "CALL_FUNCTION", "argv.insert(0, '--port')" ], [ "LOAD_GLOBAL", "argparse" ], [ "LOAD_ATTR", "argparse.ArgumentParser" ], [ "CALL_FUNCTION", "argparse.ArgumentParser(description=\"Bird's Eye: A graphical Python debugger\")" ], [ "LOAD_FAST", "parser" ], [ "LOAD_ATTR", "parser.add_argument" ], [ "LOAD_GLOBAL", "int" ], [ "CALL_FUNCTION", "parser.add_argument('-p', '--port', help='HTTP port, default is 7777', default=7777, type=int)" ], [ "LOAD_FAST", "parser" ], [ "LOAD_ATTR", "parser.add_argument" ], [ "CALL_FUNCTION", "parser.add_argument('--host', help=\"HTTP host, default is 'localhost'\", default='localhost')" ], [ "LOAD_FAST", "parser" ], [ "LOAD_ATTR", "parser.parse_args" ], [ "LOAD_FAST", "argv" ], [ "CALL_FUNCTION", "parser.parse_args(argv)" ], [ "LOAD_GLOBAL", "app" ], [ "LOAD_ATTR", "app.run" ], [ "LOAD_FAST", "args" ], [ "LOAD_ATTR", "args.port" ], [ "LOAD_FAST", "args" ], [ "LOAD_ATTR", "args.host" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.environ" ], [ "LOAD_ATTR", "os.environ.get" ], [ "CALL_FUNCTION", "os.environ.get('BIRDSEYE_RELOADER')" ], [ "COMPARE_OP", "os.environ.get('BIRDSEYE_RELOADER') == '1'" ], [ "CALL_FUNCTION", "app.run(\n port=args.port,\n host=args.host,\n use_reloader=os.environ.get('BIRDSEYE_RELOADER') == '1',\n )" ] ], "tests.py": [ [ "LOAD_NAME", "unittest" ], [ "LOAD_ATTR", "unittest.TestCase" ], [ "LOAD_NAME", "unittest" ], [ "LOAD_ATTR", "unittest.TestCase" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "TestFile" ], [ "CALL_FUNCTION", "TestFile()" ], [ "LOAD_ATTR", "TestFile().test_file" ], [ "CALL_FUNCTION", "TestFile().test_file()" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "Tester" ], [ "CALL_FUNCTION", "Tester()" ], [ "LOAD_NAME", "tester" ], [ "CALL_FUNCTION", "tester([1, 2, 3])" ], [ "COMPARE_OP", "tester([1, 2, 3]) == [1, 2, 3]" ], [ "LOAD_NAME", "tester" ], [ "LOAD_ATTR", "tester.asd" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester.asd is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_SUBSCR", "tester[19]" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester[19] is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_POWER", "tester ** 4" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester ** 4 is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_MULTIPLY", "tester * 3" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester * 3 is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_SUBTRACT", "tester - 2" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester - 2 is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_ADD", "tester + 1" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester + 1 is tester" ], [ "LOAD_NAME", "tester" ], [ "UNARY_NEGATIVE", "-tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "-tester is tester" ], [ "LOAD_NAME", "tester" ], [ "UNARY_POSITIVE", "+tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "+tester is tester" ], [ "LOAD_NAME", "tester" ], [ "UNARY_INVERT", "~tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "~tester is tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester < 7" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "(tester < 7) is tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester >= 78" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "(tester >= 78) is tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester != 79" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "(tester != 79) is tester" ], [ "LOAD_NAME", "tester" ], [ "LOAD_ATTR", "tester.foo" ], [ "LOAD_NAME", "False" ], [ "CALL_FUNCTION", "tester.foo(45, False)" ], [ "COMPARE_OP", "tester.foo(45, False) == 45" ], [ "LOAD_NAME", "__name__" ], [ "COMPARE_OP", "__name__ == '__main__'" ], [ "LOAD_NAME", "unittest" ], [ "LOAD_ATTR", "unittest.main" ], [ "CALL_FUNCTION", "unittest.main()" ], [ "LOAD_NAME", "True" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(1)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(2)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(3)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(9\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n 8)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n 99\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(33)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([4,\n 5, 6, [\n 7]])" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "LOAD_GLOBAL", "decorator_with_args" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('123')" ], [ "LOAD_GLOBAL", "int" ], [ "CALL_FUNCTION", "int()" ], [ "CALL_FUNCTION", "decorator_with_args(tester('123'), x=int())" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "tuple([1, 2])" ], [ "CALL_FUNCTION", "list(tuple([1, 2]))" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "CALL_FUNCTION", "tester(list(tuple([1, 2])), returns=empty_decorator)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "tuple(\n [3, 4])" ], [ "CALL_FUNCTION", "list(\n tuple(\n [3, 4]))" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "CALL_FUNCTION", "tester(\n list(\n tuple(\n [3, 4])),\n returns=empty_decorator)" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "LOAD_GLOBAL", "decorator_with_args" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "str()" ], [ "LOAD_GLOBAL", "int" ], [ "CALL_FUNCTION", "int()" ], [ "CALL_FUNCTION", "decorator_with_args(\n str(),\n x=int())" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "tuple([5, 6])" ], [ "CALL_FUNCTION", "list(tuple([5, 6]))" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "CALL_FUNCTION", "tester(list(tuple([5, 6])), returns=empty_decorator)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "tuple([7, 8])" ], [ "CALL_FUNCTION", "list(tuple([7, 8]))" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "CALL_FUNCTION", "tester(list(tuple([7, 8])), returns=empty_decorator)" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "LOAD_GLOBAL", "decorator_with_args" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('sdf')" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('123234')" ], [ "CALL_FUNCTION", "decorator_with_args(tester('sdf'), x=tester('123234'))" ], [ "CALL_FUNCTION", "decorator_with_args(tester('sdf'), x=tester('123234'))" ], [ "CALL_FUNCTION", "empty_decorator" ], [ "CALL_FUNCTION", "tester(list(tuple([7, 8])), returns=empty_decorator)" ], [ "CALL_FUNCTION", "tester(list(tuple([5, 6])), returns=empty_decorator)" ], [ "CALL_FUNCTION", "decorator_with_args(\n str(),\n x=int())" ], [ "CALL_FUNCTION", "empty_decorator" ], [ "CALL_FUNCTION", "tester(\n list(\n tuple(\n [3, 4])),\n returns=empty_decorator)" ], [ "CALL_FUNCTION", "tester(list(tuple([1, 2])), returns=empty_decorator)" ], [ "CALL_FUNCTION", "decorator_with_args(tester('123'), x=int())" ], [ "CALL_FUNCTION", "empty_decorator" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "str([{tester(x) for x in [1]}, {tester(y) for y in [1]}])" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "str([{tester(x) for x in [1]},\n {tester(x) for x in [1]}])" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "list(tester(x) for x in [1])" ], [ "CALL_FUNCTION", "str([{tester(x) for x in [1]}, list(tester(x) for x in [1])])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "y" ], [ "CALL_FUNCTION", "tester(y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertEqual" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(3)" ], [ "CALL_FUNCTION", "(lambda x: (tester(x), tester(x)))(tester(3))" ], [ "CALL_FUNCTION", "self.assertEqual(\n (lambda x: (tester(x), tester(x)))(tester(3)),\n (3, 3),\n )" ], [ "CALL_FUNCTION", "(lambda: (lambda: tester(1))())()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertEqual" ], [ "CALL_FUNCTION", "(lambda: [tester(x) for x in tester([1, 2])])()" ], [ "CALL_FUNCTION", "self.assertEqual(\n (lambda: [tester(x) for x in tester([1, 2])])(),\n [1, 2],\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "CALL_FUNCTION", "(lambda: tester(1))()" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(1)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x): {tester(b+x): {tester(c+x) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_FAST", "foo" ], [ "CALL_FUNCTION", "foo()" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "CALL_FUNCTION", "tester(a+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "CALL_FUNCTION", "tester(b+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "CALL_FUNCTION", "tester(c+x)" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x): {tester(b+x): {tester(c+x) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+y): {tester(b+y): {tester(c+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x+y): {tester(b+x+y): {tester(c+x+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_FAST", "bar" ], [ "CALL_FUNCTION", "bar()" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "CALL_FUNCTION", "tester(a+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "CALL_FUNCTION", "tester(b+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "CALL_FUNCTION", "tester(c+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+y" ], [ "CALL_FUNCTION", "tester(a+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+y" ], [ "CALL_FUNCTION", "tester(b+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+y" ], [ "CALL_FUNCTION", "tester(c+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+x+y" ], [ "CALL_FUNCTION", "tester(a+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+x+y" ], [ "CALL_FUNCTION", "tester(b+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+x+y" ], [ "CALL_FUNCTION", "tester(c+x+y)" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x): {tester(b+x): {tester(c+x) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+y): {tester(b+y): {tester(c+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x+y): {tester(b+x+y): {tester(c+x+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x+y+z): {tester(b+x+y+z): {tester(c+x+y+z) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "CALL_FUNCTION", "tester(a+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "CALL_FUNCTION", "tester(b+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "CALL_FUNCTION", "tester(c+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+y" ], [ "CALL_FUNCTION", "tester(a+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+y" ], [ "CALL_FUNCTION", "tester(b+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+y" ], [ "CALL_FUNCTION", "tester(c+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+x+y" ], [ "CALL_FUNCTION", "tester(a+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+x+y" ], [ "CALL_FUNCTION", "tester(b+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+x+y" ], [ "CALL_FUNCTION", "tester(c+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+x+y" ], [ "LOAD_DEREF", "z" ], [ "BINARY_ADD", "a+x+y+z" ], [ "CALL_FUNCTION", "tester(a+x+y+z)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+x+y" ], [ "LOAD_DEREF", "z" ], [ "BINARY_ADD", "b+x+y+z" ], [ "CALL_FUNCTION", "tester(b+x+y+z)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+x+y" ], [ "LOAD_DEREF", "z" ], [ "BINARY_ADD", "c+x+y+z" ], [ "CALL_FUNCTION", "tester(c+x+y+z)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "dict(x=tester)" ], [ "BINARY_SUBSCR", "dict(x=tester)['x']" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "dict(x=tester)['x'](tester)" ], [ "LOAD_GLOBAL", "False" ], [ "CALL_FUNCTION", "dict(x=tester)['x'](tester)(3, check_func=False)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertRaises" ], [ "LOAD_GLOBAL", "TypeError" ], [ "CALL_FUNCTION", "self.assertRaises(TypeError)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2, 3])" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(0)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(4)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(5)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "tester(ValueError)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(9)" ], [ "LOAD_GLOBAL", "TypeError" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(10)" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "str()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertRaises" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "Exception" ], [ "CALL_FUNCTION", "tester(Exception)" ], [ "CALL_FUNCTION", "self.assertRaises(tester(Exception))" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(0)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(0)" ], [ "LOAD_GLOBAL", "tester" ], [ "BINARY_TRUE_DIVIDE", "1 / 0" ], [ "CALL_FUNCTION", "tester(1 / 0)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "gen" ], [ "CALL_FUNCTION", "gen()" ], [ "CALL_FUNCTION", "list(gen())" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "gen2" ], [ "CALL_FUNCTION", "list(gen2)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(4)" ], [ "LOAD_GLOBAL", "time" ], [ "LOAD_ATTR", "time.time" ], [ "CALL_FUNCTION", "time.time()" ], [ "LOAD_GLOBAL", "range" ], [ "CALL_FUNCTION", "range(10000)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_ATTR", "Source.executing" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.currentframe" ], [ "CALL_FUNCTION", "inspect.currentframe()" ], [ "CALL_FUNCTION", "Source.executing(inspect.currentframe())" ], [ "LOAD_ATTR", "Source.executing(inspect.currentframe()).node" ], [ "LOAD_FAST", "node" ], [ "COMPARE_OP", "node is None" ], [ "LOAD_FAST", "new_node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertIs" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "new_node" ], [ "CALL_FUNCTION", "self.assertIs(node, new_node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertLess" ], [ "LOAD_GLOBAL", "time" ], [ "LOAD_ATTR", "time.time" ], [ "CALL_FUNCTION", "time.time()" ], [ "LOAD_FAST", "start" ], [ "BINARY_SUBTRACT", "time.time() - start" ], [ "CALL_FUNCTION", "self.assertLess(time.time() - start, 1)" ], [ "LOAD_GLOBAL", "True" ], [ "LOAD_FAST", "check" ], [ "CALL_FUNCTION", "check(u'# coding=utf8\\n\u00e9', 'utf8')" ], [ "LOAD_FAST", "check" ], [ "CALL_FUNCTION", "check(u'# coding=gbk\\n\u00e9', 'gbk')" ], [ "LOAD_FAST", "check" ], [ "LOAD_GLOBAL", "UnicodeDecodeError" ], [ "CALL_FUNCTION", "check(u'# coding=utf8\\n\u00e9', 'gbk', exception=UnicodeDecodeError)" ], [ "LOAD_FAST", "check" ], [ "LOAD_GLOBAL", "False" ], [ "CALL_FUNCTION", "check(u'# coding=gbk\\n\u00e9', 'utf8', matches=False)" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_FAST", "check" ], [ "CALL_FUNCTION", "check(u'\u00e9', 'utf8')" ], [ "LOAD_FAST", "check" ], [ "LOAD_GLOBAL", "SyntaxError" ], [ "CALL_FUNCTION", "check(u'\u00e9', 'gbk', exception=SyntaxError)" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.encode" ], [ "LOAD_FAST", "encoding" ], [ "CALL_FUNCTION", "source.encode(encoding)" ], [ "LOAD_FAST", "exception" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.assertRaises" ], [ "LOAD_FAST", "exception" ], [ "CALL_FUNCTION", "self.assertRaises(exception)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_ATTR", "Source.decode_source" ], [ "LOAD_FAST", "encoded" ], [ "CALL_FUNCTION", "Source.decode_source(encoded)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_ATTR", "Source.decode_source" ], [ "LOAD_FAST", "encoded" ], [ "CALL_FUNCTION", "Source.decode_source(encoded)" ], [ "LOAD_FAST", "matches" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.assertEqual" ], [ "LOAD_FAST", "decoded" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "self.assertEqual(decoded, source)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.assertNotEqual" ], [ "LOAD_FAST", "decoded" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "self.assertNotEqual(decoded, source)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('a')" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('''\n ab''')" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('''\n abc\n def\n '''\n )" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n '''\n 123\n 456\n '''\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n '''\n 345\n 456786\n '''\n )" ], [ "CALL_FUNCTION", "str([\n tester(\n '''\n 123\n 456\n '''\n ),\n tester(\n '''\n 345\n 456786\n '''\n ),\n ])" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n [\n '''\n 123\n 456\n '''\n '''\n 345\n 456786\n '''\n ,\n '''\n 123\n 456\n ''',\n '''\n 345\n 456786\n '''\n ]\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(1)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(2)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(3)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_ATTR", "Source.for_filename" ], [ "LOAD_GLOBAL", "__file__" ], [ "CALL_FUNCTION", "Source.for_filename(__file__)" ], [ "LOAD_ATTR", "Source.for_filename(__file__).code_qualname" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.__code__" ], [ "CALL_FUNCTION", "Source.for_filename(__file__).code_qualname(func.__code__)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertEqual" ], [ "LOAD_FAST", "qn" ], [ "LOAD_FAST", "qualname" ], [ "CALL_FUNCTION", "self.assertEqual(qn, qualname)" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_FAST", "check_actual_qualname" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertEqual" ], [ "LOAD_FAST", "qn" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.__qualname__" ], [ "CALL_FUNCTION", "self.assertEqual(qn, func.__qualname__)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertTrue" ], [ "LOAD_FAST", "qn" ], [ "LOAD_ATTR", "qn.endswith" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.__name__" ], [ "CALL_FUNCTION", "qn.endswith(func.__name__)" ], [ "CALL_FUNCTION", "self.assertTrue(qn.endswith(func.__name__))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assert_qualname" ], [ "LOAD_GLOBAL", "C" ], [ "LOAD_ATTR", "C.f" ], [ "CALL_FUNCTION", "self.assert_qualname(C.f, 'C.f')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assert_qualname" ], [ "LOAD_GLOBAL", "C" ], [ "LOAD_ATTR", "C.D" ], [ "LOAD_ATTR", "C.D.g" ], [ "CALL_FUNCTION", "self.assert_qualname(C.D.g, 'C.D.g')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assert_qualname" ], [ "LOAD_GLOBAL", "f" ], [ "CALL_FUNCTION", "self.assert_qualname(f, 'f')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assert_qualname" ], [ "LOAD_GLOBAL", "f" ], [ "CALL_FUNCTION", "f()" ], [ "CALL_FUNCTION", "self.assert_qualname(f(), 'f..g')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assert_qualname" ], [ "LOAD_GLOBAL", "C" ], [ "LOAD_ATTR", "C.D" ], [ "LOAD_ATTR", "C.D.h" ], [ "CALL_FUNCTION", "C.D.h()" ], [ "CALL_FUNCTION", "self.assert_qualname(C.D.h(), 'C.D.h..i..j')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assert_qualname" ], [ "LOAD_GLOBAL", "lamb" ], [ "CALL_FUNCTION", "self.assert_qualname(lamb, '')" ], [ "LOAD_GLOBAL", "lambda_maker" ], [ "CALL_FUNCTION", "lambda_maker()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assert_qualname" ], [ "LOAD_FAST", "foo" ], [ "CALL_FUNCTION", "self.assert_qualname(foo, 'lambda_maker..foo')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assert_qualname" ], [ "LOAD_FAST", "foo" ], [ "LOAD_ATTR", "foo.x" ], [ "CALL_FUNCTION", "self.assert_qualname(foo.x, 'lambda_maker..')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assert_qualname" ], [ "LOAD_FAST", "foo" ], [ "CALL_FUNCTION", "foo()" ], [ "CALL_FUNCTION", "self.assert_qualname(foo(), 'lambda_maker..foo..')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assert_qualname" ], [ "LOAD_FAST", "foo" ], [ "CALL_FUNCTION", "foo()" ], [ "CALL_FUNCTION", "foo()()" ], [ "LOAD_GLOBAL", "False" ], [ "CALL_FUNCTION", "self.assert_qualname(foo()(), 'lambda_maker..foo..', check_actual_qualname=False)" ], [ "LOAD_NAME", "list" ], [ "LOAD_NAME", "range" ], [ "CALL_FUNCTION", "range(66000)" ], [ "CALL_FUNCTION", "list(range(66000))" ], [ "BINARY_MODULO", "'tester(6)\\n%s\\ntester(9)' % list(range(66000))" ], [ "LOAD_NAME", "tempfile" ], [ "LOAD_ATTR", "tempfile.mkstemp" ], [ "CALL_FUNCTION", "tempfile.mkstemp()" ], [ "LOAD_NAME", "compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "compile(source, filename, 'exec')" ], [ "LOAD_NAME", "open" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "open(filename, 'w')" ], [ "LOAD_FAST", "outfile" ], [ "LOAD_ATTR", "outfile.write" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "outfile.write(source)" ], [ "LOAD_FAST", "code" ], [ "LOAD_GLOBAL", "range" ], [ "CALL_FUNCTION", "range(5)" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "n" ], [ "CALL_FUNCTION", "range(n)" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "n == 1" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertEqual" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_FAST", "gen" ], [ "CALL_FUNCTION", "only(gen)" ], [ "CALL_FUNCTION", "self.assertEqual(only(gen), 0)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertRaises" ], [ "LOAD_GLOBAL", "NotOneValueFound" ], [ "CALL_FUNCTION", "self.assertRaises(NotOneValueFound)" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_FAST", "gen" ], [ "CALL_FUNCTION", "only(gen)" ], [ "LOAD_FAST", "i" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.join" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.dirname" ], [ "LOAD_GLOBAL", "__file__" ], [ "CALL_FUNCTION", "os.path.dirname(__file__)" ], [ "CALL_FUNCTION", "os.path.join(os.path.dirname(__file__), 'not_code.txt', )" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_ATTR", "Source.for_filename" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "Source.for_filename(path)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertIsNone" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.tree" ], [ "CALL_FUNCTION", "self.assertIsNone(source.tree)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.currentframe" ], [ "CALL_FUNCTION", "inspect.currentframe()" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_ATTR", "Source.executing" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "Source.executing(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertEqual" ], [ "LOAD_FAST", "executing" ], [ "LOAD_ATTR", "executing.code_qualname" ], [ "CALL_FUNCTION", "executing.code_qualname()" ], [ "CALL_FUNCTION", "self.assertEqual(executing.code_qualname(), 'TestStuff.test_executing_methods')" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.version" ], [ "LOAD_ATTR", "sys.version.lower" ], [ "CALL_FUNCTION", "sys.version.lower()" ], [ "COMPARE_OP", "'pypy' not in sys.version.lower()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertEqual" ], [ "LOAD_FAST", "executing" ], [ "LOAD_ATTR", "executing.text" ], [ "CALL_FUNCTION", "executing.text()" ], [ "LOAD_FAST", "text" ], [ "CALL_FUNCTION", "self.assertEqual(executing.text(), text)" ], [ "LOAD_FAST", "executing" ], [ "LOAD_ATTR", "executing.text_range" ], [ "CALL_FUNCTION", "executing.text_range()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertEqual" ], [ "LOAD_FAST", "executing" ], [ "LOAD_ATTR", "executing.source" ], [ "LOAD_ATTR", "executing.source.text" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "SLICE+3", "executing.source.text[start:end]" ], [ "LOAD_FAST", "text" ], [ "CALL_FUNCTION", "self.assertEqual(executing.source.text[start:end], text)" ], [ "LOAD_GLOBAL", "C" ], [ "CALL_FUNCTION", "C()" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_FAST", "c" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.x" ], [ "LOAD_ATTR", "c.x.x" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.x" ], [ "LOAD_ATTR", "c.x.y" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.y" ], [ "LOAD_ATTR", "c.y.x" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.y" ], [ "LOAD_ATTR", "c.y.y" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.x" ], [ "LOAD_ATTR", "c.x.asd" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.y" ], [ "LOAD_ATTR", "c.y.qwe" ], [ "CALL_FUNCTION", "str((c.x.x, c.x.y, c.y.x, c.y.y, c.x.asd, c.y.qwe))" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_ATTR", "Source.for_frame" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.currentframe" ], [ "CALL_FUNCTION", "inspect.currentframe()" ], [ "CALL_FUNCTION", "Source.for_frame(inspect.currentframe())" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.text" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.filename" ], [ "CALL_FUNCTION", "compile(source.text, source.filename, 'exec')" ], [ "LOAD_GLOBAL", "get_instructions" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "get_instructions(code)" ], [ "LOAD_FAST", "instructions" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.starts_line" ], [ "COMPARE_OP", "inst.starts_line is not None" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.starts_line" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.opname" ], [ "LOAD_ATTR", "inst.opname.startswith" ], [ "CALL_FUNCTION", "inst.opname.startswith(\n ('BINARY_', 'UNARY_', 'LOAD_ATTR', 'LOAD_METHOD', 'LOOKUP_METHOD', 'COMPARE_OP'))" ], [ "LOAD_GLOBAL", "C" ], [ "CALL_FUNCTION", "C()" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.offset" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "frame" ], [ "LOAD_GLOBAL", "globals" ], [ "CALL_FUNCTION", "globals()" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "lineno" ], [ "LOAD_FAST", "frame" ], [ "LOAD_GLOBAL", "print" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.opname" ], [ "CALL_FUNCTION", "print(inst.opname)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_ATTR", "Source.executing" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "Source.executing(frame)" ], [ "LOAD_ATTR", "Source.executing(frame).node" ], [ "COMPARE_OP", "Source.executing(frame).node is not None" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_FAST", "i" ], [ "CALL_FUNCTION", "i()" ], [ "LOAD_FAST", "j" ], [ "LOAD_FAST", "g" ], [ "LOAD_FAST", "assign" ], [ "CALL_FUNCTION", "assign(lambda: 1)" ], [ "CALL_FUNCTION", "assign(lambda: 1)" ], [ "LOAD_FAST", "foo" ], [ "LOAD_FAST", "decorator" ], [ "LOAD_DEREF", "x" ], [ "LOAD_FAST", "func" ], [ "LOAD_FAST", "func" ], [ "LOAD_NAME", "True" ], [ "LOAD_NAME", "__add__" ], [ "LOAD_NAME", "__invert__" ], [ "LOAD_NAME", "__lt__" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.currentframe" ], [ "CALL_FUNCTION", "inspect.currentframe()" ], [ "LOAD_ATTR", "inspect.currentframe().f_back" ], [ "LOAD_ATTR", "inspect.currentframe().f_back.f_back" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_ATTR", "Source.lazycache" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "Source.lazycache(frame)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_ATTR", "Source.executing" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "Source.executing(frame)" ], [ "LOAD_ATTR", "Source.executing(frame).node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "typ" ], [ "CALL_FUNCTION", "isinstance(node, typ)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "typ" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.currentframe" ], [ "CALL_FUNCTION", "inspect.currentframe()" ], [ "LOAD_ATTR", "inspect.currentframe().f_back" ], [ "LOAD_ATTR", "inspect.currentframe().f_back.f_back" ], [ "LOAD_GLOBAL", "eval" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Expression" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ast.Expression(node)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_filename" ], [ "CALL_FUNCTION", "compile(ast.Expression(node), frame.f_code.co_filename, 'eval')" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "CALL_FUNCTION", "eval(\n compile(ast.Expression(node), frame.f_code.co_filename, 'eval'),\n frame.f_globals,\n frame.f_locals,\n )" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "value" ], [ "COMPARE_OP", "result == value" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Call" ], [ "CALL_FUNCTION", "self.get_node(ast.Call)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.check" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.args" ], [ "BINARY_SUBSCR", "call.args[0]" ], [ "LOAD_FAST", "arg" ], [ "CALL_FUNCTION", "self.check(call.args[0], arg)" ], [ "LOAD_FAST", "check_func" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.check" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.func" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "self.check(call.func, self)" ], [ "LOAD_FAST", "returns" ], [ "COMPARE_OP", "returns is None" ], [ "LOAD_FAST", "arg" ], [ "LOAD_FAST", "returns" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Attribute" ], [ "CALL_FUNCTION", "self.get_node(ast.Attribute)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.value" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "self.check(node.value, self)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.attr" ], [ "LOAD_FAST", "item" ], [ "COMPARE_OP", "node.attr == item" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Subscript" ], [ "CALL_FUNCTION", "self.get_node(ast.Subscript)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.value" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "self.check(node.value, self)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.slice" ], [ "LOAD_ATTR", "node.slice.value" ], [ "LOAD_FAST", "item" ], [ "CALL_FUNCTION", "self.check(node.slice.value, item)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.BinOp" ], [ "CALL_FUNCTION", "self.get_node(ast.BinOp)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.left" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "self.check(node.left, self)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.right" ], [ "LOAD_FAST", "other" ], [ "CALL_FUNCTION", "self.check(node.right, other)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.UnaryOp" ], [ "CALL_FUNCTION", "self.get_node(ast.UnaryOp)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.operand" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "self.check(node.operand, self)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Compare" ], [ "CALL_FUNCTION", "self.get_node(ast.Compare)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.left" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "self.check(node.left, self)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.comparators" ], [ "BINARY_SUBSCR", "node.comparators[0]" ], [ "LOAD_FAST", "other" ], [ "CALL_FUNCTION", "self.check(node.comparators[0], other)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "func" ], [ "LOAD_GLOBAL", "empty_decorator" ] ], "tracer.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOAD_ATTR", "standard_library.install_aliases" ], [ "CALL_FUNCTION", "standard_library.install_aliases()" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "NamedTuple" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "Union" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "BINARY_SUBSCR", "Union[ast.expr, ast.stmt]" ], [ "BINARY_SUBSCR", "Optional[Union[ast.expr, ast.stmt]]" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.AST" ], [ "LOAD_NAME", "FrameType" ], [ "LOAD_NAME", "FrameType" ], [ "CALL_FUNCTION", "NamedTuple('EnterCallInfo', [\n\n # Node from where the call was made\n ('call_node', Optional[Union[ast.expr, ast.stmt]]),\n\n # Node where the call begins\n ('enter_node', ast.AST),\n\n # Frame from which the call was made\n ('caller_frame', FrameType),\n\n # Frame of the call\n ('current_frame', FrameType)])" ], [ "LOAD_NAME", "NamedTuple" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "Union" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "BINARY_SUBSCR", "Union[ast.expr, ast.stmt]" ], [ "BINARY_SUBSCR", "Optional[Union[ast.expr, ast.stmt]]" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.Return" ], [ "BINARY_SUBSCR", "Optional[ast.Return]" ], [ "LOAD_NAME", "FrameType" ], [ "LOAD_NAME", "FrameType" ], [ "LOAD_NAME", "Any" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "Exception" ], [ "BINARY_SUBSCR", "Optional[Exception]" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "TracebackType" ], [ "BINARY_SUBSCR", "Optional[TracebackType]" ], [ "CALL_FUNCTION", "NamedTuple('ExitCallInfo', [\n\n # Node from where the call was made\n ('call_node', Optional[Union[ast.expr, ast.stmt]]),\n\n # Node where the call explicitly returned\n ('return_node', Optional[ast.Return]),\n\n # Frame from which the call was made\n ('caller_frame', FrameType),\n\n # Frame of the call\n ('current_frame', FrameType),\n\n # Node where the call explicitly returned\n ('return_value', Any),\n\n # Exception raised in the call causing it to end,\n # will propagate to the caller\n ('exc_value', Optional[Exception]),\n\n # Traceback corresponding to exc_value\n ('exc_tb', Optional[TracebackType])])" ], [ "LOAD_NAME", "namedtuple" ], [ "CALL_FUNCTION", "namedtuple('ChangeValue', 'value')" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.NodeTransformer" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "Union" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "BINARY_SUBSCR", "Union[ast.For, ast.While, ast.comprehension]" ], [ "LOAD_NAME", "False" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.PyCF_ONLY_AST" ], [ "LOAD_FAST", "flags" ], [ "BINARY_OR", "ast.PyCF_ONLY_AST | flags" ], [ "LOAD_GLOBAL", "True" ], [ "CALL_FUNCTION", "compile(source, filename, 'exec', ast.PyCF_ONLY_AST | flags, dont_inherit=True)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.set_basic_node_attributes" ], [ "CALL_FUNCTION", "self.set_basic_node_attributes()" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.parse_extra" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "tracer.parse_extra(self.root, source, filename)" ], [ "LOAD_FAST", "new_root" ], [ "COMPARE_OP", "new_root is not None" ], [ "LOAD_FAST", "new_root" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.set_basic_node_attributes" ], [ "CALL_FUNCTION", "self.set_basic_node_attributes()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.set_enter_call_nodes" ], [ "CALL_FUNCTION", "self.set_enter_call_nodes()" ], [ "LOAD_GLOBAL", "deepcopy" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "CALL_FUNCTION", "deepcopy(self.root)" ], [ "LOAD_GLOBAL", "_NodeVisitor" ], [ "CALL_FUNCTION", "_NodeVisitor()" ], [ "LOAD_ATTR", "_NodeVisitor().visit" ], [ "LOAD_FAST", "new_root" ], [ "CALL_FUNCTION", "_NodeVisitor().visit(new_root)" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "new_root" ], [ "LOAD_FAST", "filename" ], [ "LOAD_GLOBAL", "True" ], [ "LOAD_FAST", "flags" ], [ "CALL_FUNCTION", "compile(new_root, filename, \"exec\", dont_inherit=True, flags=flags)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.walk" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "CALL_FUNCTION", "ast.walk(self.root)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.iter_child_nodes" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ast.iter_child_nodes(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.nodes" ], [ "CALL_FUNCTION", "len(self.nodes)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.nodes" ], [ "LOAD_ATTR", "self.nodes.append" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "self.nodes.append(node)" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "LOAD_ATTR", "self.root.body" ], [ "CALL_FUNCTION", "enumerate(self.root.body)" ], [ "LOAD_GLOBAL", "is_future_import" ], [ "LOAD_FAST", "stmt" ], [ "CALL_FUNCTION", "is_future_import(stmt)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "LOAD_ATTR", "self.root.body" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "SLICE+2", "self.root.body[:i + 1]" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.walk" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "ast.walk(s)" ], [ "LOAD_GLOBAL", "True" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.nodes" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Module" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(node, (ast.Module, ast.FunctionDef))" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.body" ], [ "LOAD_GLOBAL", "is_future_import" ], [ "LOAD_FAST", "stmt" ], [ "CALL_FUNCTION", "is_future_import(stmt)" ], [ "LOAD_GLOBAL", "True" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_NAME", "lru_cache" ], [ "CALL_FUNCTION", "lru_cache()" ], [ "CALL_FUNCTION", "lru_cache()" ], [ "LOAD_NAME", "False" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "defaultdict(list)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "TracedFile" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "flags" ], [ "CALL_FUNCTION", "TracedFile(self, source, filename, flags)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._treetrace_hidden_with_stmt" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._treetrace_hidden_before_expr" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._treetrace_hidden_after_expr" ], [ "LOAD_GLOBAL", "partial" ], [ "LOAD_FAST", "f" ], [ "LOAD_DEREF", "traced_file" ], [ "CALL_FUNCTION", "partial(f, traced_file)" ], [ "LOAD_FAST", "f" ], [ "LOAD_ATTR", "f.__name__" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_DEREF", "func" ], [ "LOAD_GLOBAL", "FunctionType" ], [ "CALL_FUNCTION", "isinstance(func, FunctionType)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError('You can only trace user-defined functions. '\n 'The birdseye decorator must be applied first, '\n 'at the bottom of the list.')" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.iscoroutinefunction" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "inspect.iscoroutinefunction(func)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.isasyncgenfunction" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "inspect.isasyncgenfunction(func)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError('You cannot trace async functions')" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_GLOBAL", "is_lambda" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "is_lambda(func)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError('You cannot trace lambdas')" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.getsourcefile" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "inspect.getsourcefile(func)" ], [ "LOAD_GLOBAL", "is_ipython_cell" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "is_ipython_cell(filename)" ], [ "LOAD_FAST", "get_ipython" ], [ "CALL_FUNCTION", "get_ipython()" ], [ "LOAD_ATTR", "get_ipython().compile" ], [ "LOAD_ATTR", "get_ipython().compile.flags" ], [ "LOAD_ATTR", "''.join" ], [ "LOAD_FAST", "linecache" ], [ "LOAD_ATTR", "linecache.cache" ], [ "LOAD_FAST", "filename" ], [ "BINARY_SUBSCR", "linecache.cache[filename]" ], [ "BINARY_SUBSCR", "linecache.cache[filename][2]" ], [ "CALL_FUNCTION", "''.join(linecache.cache[filename][2])" ], [ "LOAD_GLOBAL", "read_source_file" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "read_source_file(filename)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "flags" ], [ "CALL_FUNCTION", "self.compile(source, filename, flags)" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__dict__" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError('The birdseye decorator must be applied first, '\n 'at the bottom of the list.')" ], [ "LOAD_DEREF", "find_code" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.code" ], [ "CALL_FUNCTION", "find_code(traced_file.code)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_DEREF", "code_options" ], [ "CALL_FUNCTION", "len(code_options)" ], [ "COMPARE_OP", "len(code_options) > 1" ], [ "LOAD_GLOBAL", "is_lambda" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "is_lambda(func)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError(\"Failed to trace lambda. Convert the function to a def.\")" ], [ "LOAD_DEREF", "code_options" ], [ "BINARY_SUBSCR", "code_options[0]" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__globals__" ], [ "LOAD_ATTR", "func.__globals__.update" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._trace_methods_dict" ], [ "LOAD_FAST", "traced_file" ], [ "CALL_FUNCTION", "self._trace_methods_dict(traced_file)" ], [ "CALL_FUNCTION", "func.__globals__.update(self._trace_methods_dict(traced_file))" ], [ "LOAD_GLOBAL", "FunctionType" ], [ "LOAD_FAST", "new_func_code" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__globals__" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__name__" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__defaults__" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__closure__" ], [ "CALL_FUNCTION", "FunctionType(new_func_code, func.__globals__, func.__name__, func.__defaults__, func.__closure__)" ], [ "LOAD_GLOBAL", "update_wrapper" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "update_wrapper(new_func, func)" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "getattr(func, '__kwdefaults__', None)" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_FAST", "root_code" ], [ "LOAD_ATTR", "root_code.co_consts" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.iscode" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "inspect.iscode(const)" ], [ "LOAD_FAST", "const" ], [ "LOAD_ATTR", "const.co_firstlineno" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__code__" ], [ "LOAD_ATTR", "func.__code__.co_firstlineno" ], [ "COMPARE_OP", "const.co_firstlineno == func.__code__.co_firstlineno" ], [ "LOAD_FAST", "const" ], [ "LOAD_ATTR", "const.co_name" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__code__" ], [ "LOAD_ATTR", "func.__code__.co_name" ], [ "COMPARE_OP", "const.co_name == func.__code__.co_name" ], [ "LOAD_FAST", "matches" ], [ "LOAD_DEREF", "code_options" ], [ "LOAD_ATTR", "code_options.append" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "code_options.append(const)" ], [ "LOAD_DEREF", "find_code" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "find_code(const)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.isclass" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "inspect.isclass(func)" ], [ "LOAD_GLOBAL", "TypeError" ], [ "CALL_FUNCTION", "TypeError('Decorating classes is no longer supported')" ], [ "LOAD_FAST", "func" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.trace_function" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "self.trace_function(func)" ], [ "LOAD_FAST", "optional" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.trace_function" ], [ "LOAD_FAST", "decorator" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.trace_function" ], [ "LOAD_DEREF", "actual_func" ], [ "CALL_FUNCTION", "self.trace_function(actual_func)" ], [ "LOAD_GLOBAL", "wraps" ], [ "LOAD_DEREF", "actual_func" ], [ "CALL_FUNCTION", "wraps(actual_func)" ], [ "CALL_FUNCTION", "wraps(actual_func)" ], [ "LOAD_FAST", "wrapper" ], [ "LOAD_FAST", "kwargs" ], [ "LOAD_ATTR", "kwargs.pop" ], [ "LOAD_GLOBAL", "False" ], [ "CALL_FUNCTION", "kwargs.pop('trace_call', False)" ], [ "LOAD_FAST", "trace_call" ], [ "LOAD_DEREF", "traced" ], [ "LOAD_DEREF", "actual_func" ], [ "LOAD_FAST", "f" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "f(*args, **kwargs)" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys._getframe" ], [ "CALL_FUNCTION", "sys._getframe(2)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.secondary_to_main_frames" ], [ "LOAD_ATTR", "self.secondary_to_main_frames.get" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "self.secondary_to_main_frames.get(frame)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "COMPARE_OP", "frame.f_code.co_name in ('', '', '')" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_GLOBAL", "ancestors" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ancestors(node)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Lambda" ], [ "CALL_FUNCTION", "isinstance(node, (ast.FunctionDef, ast.Lambda))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.ClassDef" ], [ "CALL_FUNCTION", "isinstance(node, ast.ClassDef)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "COMPARE_OP", "frame.f_code.co_name in ('', '')" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.secondary_to_main_frames" ], [ "LOAD_FAST", "original_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.main_to_secondary_frames" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.main_to_secondary_frames[frame]" ], [ "LOAD_ATTR", "self.main_to_secondary_frames[frame].append" ], [ "LOAD_FAST", "original_frame" ], [ "CALL_FUNCTION", "self.main_to_secondary_frames[frame].append(original_frame)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.nodes" ], [ "LOAD_FAST", "_tree_index" ], [ "BINARY_SUBSCR", "traced_file.nodes[_tree_index]" ], [ "LOAD_GLOBAL", "cast" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "cast(ast.stmt, node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._main_frame" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "self._main_frame(node)" ], [ "LOAD_GLOBAL", "_StmtContext" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "_StmtContext(self, node, frame)" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.nodes" ], [ "LOAD_FAST", "_tree_index" ], [ "BINARY_SUBSCR", "traced_file.nodes[_tree_index]" ], [ "LOAD_GLOBAL", "cast" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "cast(ast.expr, node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._main_frame" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "self._main_frame(node)" ], [ "LOAD_FAST", "frame" ], [ "COMPARE_OP", "frame is None" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_stack" ], [ "LOAD_ATTR", "frame_info.expression_stack.append" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "frame_info.expression_stack.append(node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.before_expr" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "self.before_expr(node, frame)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._main_frame" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "self._main_frame(node)" ], [ "LOAD_FAST", "frame" ], [ "COMPARE_OP", "frame is None" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._after_expr" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "self._after_expr(node, frame, value, None, None)" ], [ "LOAD_FAST", "result" ], [ "COMPARE_OP", "result is not None" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "ChangeValue" ], [ "CALL_FUNCTION", "isinstance(result, ChangeValue)" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.value" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_stack" ], [ "LOAD_ATTR", "frame_info.expression_stack.pop" ], [ "CALL_FUNCTION", "frame_info.expression_stack.pop()" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_values" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.after_expr" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "exc_value" ], [ "LOAD_FAST", "exc_tb" ], [ "CALL_FUNCTION", "self.after_expr(node, frame, value, exc_value, exc_tb)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._get_caller_stuff" ], [ "LOAD_FAST", "current_frame" ], [ "CALL_FUNCTION", "self._get_caller_stuff(current_frame)" ], [ "LOAD_GLOBAL", "FrameInfo" ], [ "CALL_FUNCTION", "FrameInfo()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "current_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.enter_call" ], [ "LOAD_GLOBAL", "EnterCallInfo" ], [ "LOAD_FAST", "call_node" ], [ "LOAD_FAST", "enter_node" ], [ "LOAD_FAST", "caller_frame" ], [ "LOAD_FAST", "current_frame" ], [ "CALL_FUNCTION", "EnterCallInfo(call_node, enter_node, caller_frame, current_frame)" ], [ "CALL_FUNCTION", "self.enter_call(EnterCallInfo(call_node, enter_node, caller_frame, current_frame))" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.secondary_to_main_frames" ], [ "LOAD_ATTR", "self.secondary_to_main_frames.get" ], [ "LOAD_FAST", "caller_frame" ], [ "CALL_FUNCTION", "self.secondary_to_main_frames.get(caller_frame)" ], [ "LOAD_FAST", "main_frame" ], [ "LOAD_FAST", "main_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "caller_frame" ], [ "BINARY_SUBSCR", "self.stack[caller_frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_stack" ], [ "LOAD_FAST", "expression_stack" ], [ "LOAD_FAST", "expression_stack" ], [ "BINARY_SUBSCR", "expression_stack[-1]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.statement_stack" ], [ "BINARY_SUBSCR", "frame_info.statement_stack[-1]" ], [ "LOAD_FAST", "caller_frame" ], [ "LOAD_FAST", "call_node" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "False" ], [ "CALL_FUNCTION", "getattr(node, '_visit_ignore', False)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "CALL_FUNCTION", "isinstance(node, ast.expr)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "hasattr(node, \"ctx\")" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.ctx" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Load" ], [ "CALL_FUNCTION", "isinstance(node.ctx, ast.Load)" ], [ "UNARY_NOT", "not isinstance(node.ctx, ast.Load)" ], [ "UNARY_NOT", "not (hasattr(node, \"ctx\") and not isinstance(node.ctx, ast.Load))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "ast" ], [ "CALL_FUNCTION", "getattr(ast, 'Starred', ())" ], [ "CALL_FUNCTION", "isinstance(node, getattr(ast, 'Starred', ()))" ], [ "UNARY_NOT", "not isinstance(node, getattr(ast, 'Starred', ()))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.visit_expr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "self.visit_expr(node)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "CALL_FUNCTION", "isinstance(node, ast.stmt)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.visit_stmt" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "self.visit_stmt(node)" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "_NodeVisitor" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self)" ], [ "LOAD_ATTR", "super(_NodeVisitor, self).generic_visit" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self).generic_visit(node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._create_simple_marker_call" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "TreeTracerBase" ], [ "LOAD_ATTR", "TreeTracerBase._treetrace_hidden_before_expr" ], [ "CALL_FUNCTION", "self._create_simple_marker_call(node, TreeTracerBase._treetrace_hidden_before_expr)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.copy_location" ], [ "LOAD_FAST", "before_marker" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ast.copy_location(before_marker, node)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Call" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Name" ], [ "LOAD_GLOBAL", "TreeTracerBase" ], [ "LOAD_ATTR", "TreeTracerBase._treetrace_hidden_after_expr" ], [ "LOAD_ATTR", "TreeTracerBase._treetrace_hidden_after_expr.__name__" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Load" ], [ "CALL_FUNCTION", "ast.Load()" ], [ "CALL_FUNCTION", "ast.Name(id=TreeTracerBase._treetrace_hidden_after_expr.__name__,\n ctx=ast.Load())" ], [ "LOAD_FAST", "before_marker" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "_NodeVisitor" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self)" ], [ "LOAD_ATTR", "super(_NodeVisitor, self).generic_visit" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self).generic_visit(node)" ], [ "CALL_FUNCTION", "ast.Call(\n func=ast.Name(id=TreeTracerBase._treetrace_hidden_after_expr.__name__,\n ctx=ast.Load()),\n args=[\n before_marker,\n super(_NodeVisitor, self).generic_visit(node),\n ],\n keywords=[],\n )" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.copy_location" ], [ "LOAD_FAST", "after_marker" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ast.copy_location(after_marker, node)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.fix_missing_locations" ], [ "LOAD_FAST", "after_marker" ], [ "CALL_FUNCTION", "ast.fix_missing_locations(after_marker)" ], [ "LOAD_FAST", "after_marker" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._create_simple_marker_call" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "_NodeVisitor" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self)" ], [ "LOAD_ATTR", "super(_NodeVisitor, self).generic_visit" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self).generic_visit(node)" ], [ "LOAD_GLOBAL", "TreeTracerBase" ], [ "LOAD_ATTR", "TreeTracerBase._treetrace_hidden_with_stmt" ], [ "CALL_FUNCTION", "self._create_simple_marker_call(\n super(_NodeVisitor, self).generic_visit(node),\n TreeTracerBase._treetrace_hidden_with_stmt)" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.With" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.withitem" ], [ "LOAD_FAST", "context_expr" ], [ "CALL_FUNCTION", "ast.withitem(context_expr=context_expr)" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ast.With(\n items=[ast.withitem(context_expr=context_expr)],\n body=[node],\n )" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.With" ], [ "LOAD_FAST", "context_expr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ast.With(\n context_expr=context_expr,\n body=[node],\n )" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.copy_location" ], [ "LOAD_FAST", "wrapped" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ast.copy_location(wrapped, node)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.fix_missing_locations" ], [ "LOAD_FAST", "wrapped" ], [ "CALL_FUNCTION", "ast.fix_missing_locations(wrapped)" ], [ "LOAD_FAST", "wrapped" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Call" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Name" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.__name__" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Load" ], [ "CALL_FUNCTION", "ast.Load()" ], [ "CALL_FUNCTION", "ast.Name(id=func.__name__,\n ctx=ast.Load())" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Num" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "CALL_FUNCTION", "ast.Num(node._tree_index)" ], [ "CALL_FUNCTION", "ast.Call(\n func=ast.Name(id=func.__name__,\n ctx=ast.Load()),\n args=[ast.Num(node._tree_index)],\n keywords=[],\n )" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tracer" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "False" ], [ "CALL_FUNCTION", "getattr(node, '_enter_call_node', False)" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer._enter_call" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "tracer._enter_call(node, frame)" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "tracer.stack[frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.statement_stack" ], [ "LOAD_ATTR", "frame_info.statement_stack.append" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "frame_info.statement_stack.append(node)" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.before_stmt" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "tracer.before_stmt(node, frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tracer" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "tracer.stack[frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.statement_stack" ], [ "LOAD_ATTR", "frame_info.statement_stack.pop" ], [ "CALL_FUNCTION", "frame_info.statement_stack.pop()" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.exc_value" ], [ "COMPARE_OP", "exc_val is not frame_info.exc_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_stack" ], [ "LOAD_FAST", "expression_stack" ], [ "LOAD_FAST", "expression_stack" ], [ "BINARY_SUBSCR", "expression_stack[-1]" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer._after_expr" ], [ "LOAD_FAST", "exc_node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "exc_tb" ], [ "CALL_FUNCTION", "tracer._after_expr(exc_node, frame, None, exc_val, exc_tb)" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.after_stmt" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "exc_tb" ], [ "LOAD_FAST", "exc_node" ], [ "CALL_FUNCTION", "tracer.after_stmt(node, frame, exc_val, exc_tb, exc_node)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Return" ], [ "CALL_FUNCTION", "isinstance(node, ast.Return)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.return_node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Module" ], [ "CALL_FUNCTION", "isinstance(parent, (ast.FunctionDef, ast.Module))" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.body" ], [ "BINARY_SUBSCR", "parent.body[-1]" ], [ "COMPARE_OP", "node is parent.body[-1]" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_FAST", "exiting" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer._get_caller_stuff" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "tracer._get_caller_stuff(frame)" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_ATTR", "return_node.value" ], [ "LOAD_FAST", "exc_val" ], [ "UNARY_NOT", "not exc_val" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_values" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_ATTR", "return_node.value" ], [ "BINARY_SUBSCR", "frame_info.expression_values[return_node.value]" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.exit_call" ], [ "LOAD_GLOBAL", "ExitCallInfo" ], [ "LOAD_FAST", "call_node" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_FAST", "caller_frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "return_value" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "exc_tb" ], [ "CALL_FUNCTION", "ExitCallInfo(call_node,\n return_node,\n caller_frame,\n frame,\n return_value,\n exc_val,\n exc_tb\n )" ], [ "CALL_FUNCTION", "tracer.exit_call(ExitCallInfo(call_node,\n return_node,\n caller_frame,\n frame,\n return_value,\n exc_val,\n exc_tb\n ))" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.stack" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tracer" ], [ "LOAD_ATTR", "self.tracer.main_to_secondary_frames" ], [ "LOAD_ATTR", "self.tracer.main_to_secondary_frames.pop" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "self.tracer.main_to_secondary_frames.pop(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tracer" ], [ "LOAD_ATTR", "self.tracer.secondary_to_main_frames" ], [ "LOAD_FAST", "secondary_frame" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "True" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "True" ], [ "LOAD_DEREF", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(parent, ast.FunctionDef)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "CALL_FUNCTION", "isinstance(parent, ast.For)" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.iter" ], [ "LOAD_DEREF", "node" ], [ "COMPARE_OP", "parent.iter is not node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "CALL_FUNCTION", "isinstance(parent, ast.While)" ], [ "LOAD_DEREF", "node" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.orelse" ], [ "COMPARE_OP", "node not in parent.orelse" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "CALL_FUNCTION", "isinstance(parent, ast.comprehension)" ], [ "LOAD_DEREF", "node" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.ifs" ], [ "COMPARE_OP", "node in parent.ifs" ], [ "LOAD_FAST", "is_containing_loop" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.append" ], [ "LOAD_FAST", "parent" ], [ "CALL_FUNCTION", "result.append(parent)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.ListComp" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.GeneratorExp" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.DictComp" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.SetComp" ], [ "CALL_FUNCTION", "isinstance(parent, (ast.ListComp,\n ast.GeneratorExp,\n ast.DictComp,\n ast.SetComp))" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.generators" ], [ "LOAD_DEREF", "node" ], [ "LOAD_FAST", "generators" ], [ "COMPARE_OP", "node in generators" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "takewhile" ], [ "LOAD_FAST", "generators" ], [ "CALL_FUNCTION", "takewhile(lambda n: n != node, generators)" ], [ "CALL_FUNCTION", "list(takewhile(lambda n: n != node, generators))" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.extend" ], [ "LOAD_GLOBAL", "reversed" ], [ "LOAD_FAST", "generators" ], [ "CALL_FUNCTION", "reversed(generators)" ], [ "CALL_FUNCTION", "result.extend(reversed(generators))" ], [ "LOAD_FAST", "parent" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.reverse" ], [ "CALL_FUNCTION", "result.reverse()" ], [ "LOAD_GLOBAL", "tuple" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "tuple(result)" ], [ "LOAD_FAST", "n" ], [ "LOAD_DEREF", "node" ], [ "COMPARE_OP", "n != node" ] ], "tracer2.py": [ [ "LOAD_NAME", "find_repr_function" ], [ "LOAD_NAME", "six" ], [ "LOAD_ATTR", "six.text_type" ], [ "CALL_FUNCTION", "find_repr_function(six.text_type)" ], [ "LOAD_NAME", "find_repr_function" ], [ "LOAD_NAME", "six" ], [ "LOAD_ATTR", "six.binary_type" ], [ "CALL_FUNCTION", "find_repr_function(six.binary_type)" ], [ "LOAD_NAME", "find_repr_function" ], [ "LOAD_NAME", "object" ], [ "CALL_FUNCTION", "find_repr_function(object)" ], [ "LOAD_NAME", "find_repr_function" ], [ "LOAD_NAME", "int" ], [ "CALL_FUNCTION", "find_repr_function(int)" ], [ "LOAD_NAME", "cheap_repr" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "threading" ], [ "LOAD_ATTR", "threading.local" ], [ "CALL_FUNCTION", "threading.local()" ], [ "LOAD_NAME", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.dirname" ], [ "LOAD_ATTR", "(lambda: 0).__code__" ], [ "LOAD_ATTR", "(lambda: 0).__code__.co_filename" ], [ "CALL_FUNCTION", "os.path.dirname((lambda: 0).__code__.co_filename)" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.dirname" ], [ "LOAD_NAME", "birdseye" ], [ "LOAD_ATTR", "birdseye.__file__" ], [ "CALL_FUNCTION", "os.path.dirname(birdseye.__file__)" ], [ "LOAD_NAME", "type" ], [ "LOAD_NAME", "six" ], [ "LOAD_ATTR", "six.add_metaclass" ], [ "LOAD_NAME", "TracerMeta" ], [ "CALL_FUNCTION", "six.add_metaclass(TracerMeta)" ], [ "LOAD_NAME", "object" ], [ "CALL_FUNCTION", "six.add_metaclass(TracerMeta)" ], [ "LOAD_NAME", "object" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lineno" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "CALL_FUNCTION", "OrderedDict()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_ATTR", "Source.for_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "Source.for_frame(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_flags" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.CO_GENERATOR" ], [ "BINARY_AND", "frame.f_code.co_flags & inspect.CO_GENERATOR" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "False" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "is_comprehension_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "is_comprehension_frame(frame)" ], [ "LOAD_GLOBAL", "re" ], [ "LOAD_ATTR", "re.match" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "CALL_FUNCTION", "re.match(r'<(\\w+)comp>', frame.f_code.co_name)" ], [ "LOAD_ATTR", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group" ], [ "CALL_FUNCTION", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group(1)" ], [ "LOAD_ATTR", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group(1).title" ], [ "CALL_FUNCTION", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group(1).title()" ], [ "BINARY_ADD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group(1).title()\n + u' comprehension'" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_lineno" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.local_reprs" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.get_local_reprs" ], [ "LOAD_FAST", "watch" ], [ "LOAD_FAST", "watch_extras" ], [ "CALL_FUNCTION", "self.get_local_reprs(watch, watch_extras)" ], [ "CALL_FUNCTION", "OrderedDict(\n (source, my_cheap_repr(value))\n for source, value in\n self.get_local_reprs(watch, watch_extras)\n )" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.comprehension_type" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.local_reprs" ], [ "LOAD_ATTR", "self.local_reprs.items" ], [ "CALL_FUNCTION", "self.local_reprs.items()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.comprehension_variables" ], [ "LOAD_ATTR", "self.comprehension_variables.setdefault" ], [ "LOAD_FAST", "name" ], [ "CALL_FUNCTION", "self.comprehension_variables.setdefault(name, [])" ], [ "LOAD_FAST", "values" ], [ "UNARY_NOT", "not values" ], [ "LOAD_FAST", "values" ], [ "BINARY_SUBSCR", "values[-1]" ], [ "LOAD_FAST", "value_repr" ], [ "COMPARE_OP", "values[-1] != value_repr" ], [ "LOAD_FAST", "values" ], [ "LOAD_ATTR", "values.append" ], [ "LOAD_FAST", "value_repr" ], [ "CALL_FUNCTION", "values.append(value_repr)" ], [ "LOAD_GLOBAL", "truncate_list" ], [ "LOAD_FAST", "values" ], [ "CALL_FUNCTION", "truncate_list(values, 11)" ], [ "LOAD_FAST", "values" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event in ('return', 'exception')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.comprehension_variables" ], [ "LOAD_ATTR", "self.comprehension_variables.items" ], [ "CALL_FUNCTION", "self.comprehension_variables.items()" ], [ "LOAD_FAST", "name" ], [ "LOAD_ATTR", "', '.join" ], [ "LOAD_FAST", "values" ], [ "CALL_FUNCTION", "', '.join(values)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.local_reprs" ], [ "LOAD_ATTR", "self.local_reprs.items" ], [ "CALL_FUNCTION", "self.local_reprs.items()" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "old_local_reprs" ], [ "COMPARE_OP", "name not in old_local_reprs" ], [ "LOAD_FAST", "old_local_reprs" ], [ "LOAD_FAST", "name" ], [ "BINARY_SUBSCR", "old_local_reprs[name]" ], [ "LOAD_FAST", "value_repr" ], [ "COMPARE_OP", "old_local_reprs[name] != value_repr" ], [ "LOAD_FAST", "variables" ], [ "LOAD_ATTR", "variables.append" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "value_repr" ], [ "CALL_FUNCTION", "variables.append((name, value_repr))" ], [ "LOAD_FAST", "variables" ], [ "LOAD_FAST", "source" ], [ "LOAD_GLOBAL", "my_cheap_repr" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "my_cheap_repr(value)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_varnames" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_cellvars" ], [ "BINARY_ADD", "code.co_varnames + code.co_cellvars" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_freevars" ], [ "BINARY_ADD", "code.co_varnames + code.co_cellvars + code.co_freevars" ], [ "LOAD_GLOBAL", "tuple" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "LOAD_ATTR", "frame.f_locals.keys" ], [ "CALL_FUNCTION", "frame.f_locals.keys()" ], [ "CALL_FUNCTION", "tuple(frame.f_locals.keys())" ], [ "BINARY_ADD", "code.co_varnames + code.co_cellvars + code.co_freevars + tuple(frame.f_locals.keys())" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "LOAD_ATTR", "frame.f_locals.items" ], [ "CALL_FUNCTION", "frame.f_locals.items()" ], [ "CALL_FUNCTION", "sorted(\n frame.f_locals.items(),\n key=lambda key_value: vars_order.index(key_value[0])\n )" ], [ "LOAD_FAST", "watch" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_FAST", "variable" ], [ "LOAD_ATTR", "variable.items" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "variable.items(frame)" ], [ "CALL_FUNCTION", "sorted(variable.items(frame))" ], [ "LOAD_FAST", "result_items" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "watch_extras" ], [ "LOAD_FAST", "extra" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "extra(source, value)" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_FAST", "pair" ], [ "COMPARE_OP", "pair is not None" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "pair" ], [ "CALL_FUNCTION", "len(pair)" ], [ "COMPARE_OP", "len(pair) == 2" ], [ "LOAD_FAST", "pair" ], [ "LOAD_DEREF", "vars_order" ], [ "LOAD_ATTR", "vars_order.index" ], [ "LOAD_FAST", "key_value" ], [ "BINARY_SUBSCR", "key_value[0]" ], [ "CALL_FUNCTION", "vars_order.index(key_value[0])" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "TracerMeta" ], [ "LOAD_FAST", "mcs" ], [ "CALL_FUNCTION", "super(TracerMeta, mcs)" ], [ "LOAD_ATTR", "super(TracerMeta, mcs).__new__" ], [ "LOAD_FAST", "mcs" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "super(TracerMeta, mcs).__new__(mcs, *args, **kwargs)" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "result()" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "no_args_decorator" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION", "no_args_decorator(args, kwargs)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_ATTR", "cls.default" ], [ "LOAD_FAST", "args" ], [ "BINARY_SUBSCR", "args[0]" ], [ "CALL_FUNCTION", "cls.default(args[0])" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "TracerMeta" ], [ "LOAD_FAST", "cls" ], [ "CALL_FUNCTION", "super(TracerMeta, cls)" ], [ "LOAD_ATTR", "super(TracerMeta, cls).__call__" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "super(TracerMeta, cls).__call__(*args, **kwargs)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.default" ], [ "LOAD_ATTR", "self.default.__enter__" ], [ "CALL_FUNCTION", "self.default.__enter__(context=1)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.default" ], [ "LOAD_ATTR", "self.default.__exit__" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION_VAR", "self.default.__exit__(*args, context=1)" ], [ "LOAD_GLOBAL", "ensure_tuple" ], [ "LOAD_FAST", "watch" ], [ "CALL_FUNCTION", "ensure_tuple(watch)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "BaseVariable" ], [ "CALL_FUNCTION", "isinstance(v, BaseVariable)" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "CommonVariable" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "CommonVariable(v)" ], [ "LOAD_GLOBAL", "ensure_tuple" ], [ "LOAD_FAST", "watch_explode" ], [ "CALL_FUNCTION", "ensure_tuple(watch_explode)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "BaseVariable" ], [ "CALL_FUNCTION", "isinstance(v, BaseVariable)" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "Exploding" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "Exploding(v)" ], [ "BINARY_ADD", "[\n v if isinstance(v, BaseVariable) else CommonVariable(v)\n for v in ensure_tuple(watch)\n ] + [\n v if isinstance(v, BaseVariable) else Exploding(v)\n for v in ensure_tuple(watch_explode)\n ]" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "ArgDefaultDict" ], [ "LOAD_GLOBAL", "FrameInfo" ], [ "CALL_FUNCTION", "ArgDefaultDict(FrameInfo)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "depth" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.depth" ], [ "COMPARE_OP", "self.depth >= 1" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "iscoroutinefunction" ], [ "LOAD_DEREF", "function" ], [ "CALL_FUNCTION", "iscoroutinefunction(function)" ], [ "LOAD_GLOBAL", "NotImplementedError" ], [ "CALL_FUNCTION", "NotImplementedError(\"coroutines are not supported, sorry!\")" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.target_codes" ], [ "LOAD_ATTR", "self.target_codes.add" ], [ "LOAD_DEREF", "function" ], [ "LOAD_ATTR", "function.__code__" ], [ "CALL_FUNCTION", "self.target_codes.add(function.__code__)" ], [ "LOAD_GLOBAL", "functools" ], [ "LOAD_ATTR", "functools.wraps" ], [ "LOAD_DEREF", "function" ], [ "CALL_FUNCTION", "functools.wraps(function)" ], [ "CALL_FUNCTION", "functools.wraps(function)" ], [ "LOAD_GLOBAL", "functools" ], [ "LOAD_ATTR", "functools.wraps" ], [ "LOAD_DEREF", "function" ], [ "CALL_FUNCTION", "functools.wraps(function)" ], [ "CALL_FUNCTION", "functools.wraps(function)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.isgeneratorfunction" ], [ "LOAD_DEREF", "function" ], [ "CALL_FUNCTION", "inspect.isgeneratorfunction(function)" ], [ "LOAD_FAST", "generator_wrapper" ], [ "LOAD_FAST", "simple_wrapper" ], [ "LOAD_DEREF", "self" ], [ "LOAD_DEREF", "function" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "function(*args, **kwargs)" ], [ "LOAD_DEREF", "function" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "function(*args, **kwargs)" ], [ "LOAD_FAST", "gen" ], [ "LOAD_ATTR", "gen.send" ], [ "LOAD_GLOBAL", "True" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "method" ], [ "LOAD_FAST", "incoming" ], [ "CALL_FUNCTION", "method(incoming)" ], [ "LOAD_GLOBAL", "StopIteration" ], [ "LOAD_FAST", "gen" ], [ "LOAD_ATTR", "gen.send" ], [ "LOAD_FAST", "outgoing" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_FAST", "gen" ], [ "LOAD_ATTR", "gen.throw" ], [ "LOAD_FAST", "e" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.enabled" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys._getframe" ], [ "LOAD_FAST", "context" ], [ "BINARY_ADD", "context + 1" ], [ "CALL_FUNCTION", "sys._getframe(context + 1)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._is_internal_frame" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_FUNCTION", "self._is_internal_frame(calling_frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.trace" ], [ "LOAD_FAST", "calling_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.target_frames" ], [ "LOAD_ATTR", "self.target_frames.add" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_FUNCTION", "self.target_frames.add(calling_frame)" ], [ "LOAD_FAST", "calling_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.trace" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_FUNCTION", "self.trace(calling_frame, 'enter', None)" ], [ "LOAD_GLOBAL", "thread_global" ], [ "LOAD_ATTR", "thread_global.__dict__" ], [ "LOAD_ATTR", "thread_global.__dict__.setdefault" ], [ "CALL_FUNCTION", "thread_global.__dict__.setdefault('original_trace_functions', [])" ], [ "LOAD_FAST", "stack" ], [ "LOAD_ATTR", "stack.append" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.gettrace" ], [ "CALL_FUNCTION", "sys.gettrace()" ], [ "CALL_FUNCTION", "stack.append(sys.gettrace())" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.settrace" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.trace" ], [ "CALL_FUNCTION", "sys.settrace(self.trace)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.enabled" ], [ "LOAD_GLOBAL", "thread_global" ], [ "LOAD_ATTR", "thread_global.original_trace_functions" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.settrace" ], [ "LOAD_FAST", "stack" ], [ "LOAD_ATTR", "stack.pop" ], [ "CALL_FUNCTION", "stack.pop()" ], [ "CALL_FUNCTION", "sys.settrace(stack.pop())" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys._getframe" ], [ "LOAD_FAST", "context" ], [ "BINARY_ADD", "context + 1" ], [ "CALL_FUNCTION", "sys._getframe(context + 1)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.trace" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_FUNCTION", "self.trace(calling_frame, 'exit', None)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.target_frames" ], [ "LOAD_ATTR", "self.target_frames.discard" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_FUNCTION", "self.target_frames.discard(calling_frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame_infos" ], [ "LOAD_ATTR", "self.frame_infos.pop" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_FUNCTION", "self.frame_infos.pop(calling_frame, None)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_filename" ], [ "LOAD_ATTR", "frame.f_code.co_filename.startswith" ], [ "LOAD_GLOBAL", "internal_directories" ], [ "CALL_FUNCTION", "frame.f_code.co_filename.startswith(internal_directories)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.target_codes" ], [ "COMPARE_OP", "frame.f_code in self.target_codes" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.target_frames" ], [ "COMPARE_OP", "frame in self.target_frames" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._is_traced_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "self._is_traced_frame(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.depth" ], [ "COMPARE_OP", "self.depth == 1" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._is_internal_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "self._is_internal_frame(frame)" ], [ "LOAD_GLOBAL", "is_comprehension_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "is_comprehension_frame(frame)" ], [ "UNARY_NOT", "not is_comprehension_frame(frame)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_GLOBAL", "True" ], [ "LOAD_GLOBAL", "is_comprehension_frame" ], [ "LOAD_FAST", "candidate" ], [ "CALL_FUNCTION", "is_comprehension_frame(candidate)" ], [ "LOAD_FAST", "candidate" ], [ "LOAD_ATTR", "candidate.f_back" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._is_traced_frame" ], [ "LOAD_FAST", "candidate" ], [ "CALL_FUNCTION", "self._is_traced_frame(candidate)" ], [ "LOAD_FAST", "candidate" ], [ "LOAD_ATTR", "candidate.f_back" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.depth" ], [ "COMPARE_OP", "i >= self.depth" ], [ "LOAD_FAST", "candidate" ], [ "COMPARE_OP", "candidate is None" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._is_internal_frame" ], [ "LOAD_FAST", "candidate" ], [ "CALL_FUNCTION", "self._is_internal_frame(candidate)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.thread_local" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_ATTR", "thread_local.__dict__" ], [ "LOAD_ATTR", "thread_local.__dict__.setdefault" ], [ "CALL_FUNCTION", "thread_local.__dict__.setdefault('depth', -1)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame_infos" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.frame_infos[frame]" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event in ('call', 'enter')" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.last_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.last_frame" ], [ "LOAD_FAST", "frame" ], [ "COMPARE_OP", "self.config.last_frame is not frame" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.last_line_no" ], [ "LOAD_GLOBAL", "Event" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "event" ], [ "LOAD_FAST", "arg" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_ATTR", "thread_local.depth" ], [ "LOAD_FAST", "line_no" ], [ "CALL_FUNCTION", "Event(frame_info, event, arg, thread_local.depth, line_no=line_no)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.formatter" ], [ "LOAD_ATTR", "self.config.formatter.format_line_only" ], [ "LOAD_FAST", "trace_event" ], [ "CALL_FUNCTION", "self.config.formatter.format_line_only(trace_event)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.write" ], [ "LOAD_FAST", "line" ], [ "CALL_FUNCTION", "self.config.write(line)" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event == 'exception'" ], [ "LOAD_GLOBAL", "True" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_GLOBAL", "Event" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "event" ], [ "LOAD_FAST", "arg" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_ATTR", "thread_local.depth" ], [ "CALL_FUNCTION", "Event(frame_info, event, arg, thread_local.depth)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "COMPARE_OP", "frame.f_code.co_name == ''" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event not in ('return', 'exception')" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.update_variables" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.watch" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.watch_extras" ], [ "LOAD_FAST", "event" ], [ "CALL_FUNCTION", "frame_info.update_variables(\n self.watch,\n self.config.watch_extras,\n event,\n )" ], [ "LOAD_FAST", "trace_event" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event in ('return', 'exit')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame_infos" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.formatter" ], [ "LOAD_ATTR", "self.config.formatter.format" ], [ "LOAD_FAST", "trace_event" ], [ "CALL_FUNCTION", "self.config.formatter.format(trace_event)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.write" ], [ "LOAD_FAST", "formatted" ], [ "CALL_FUNCTION", "self.config.write(formatted)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.trace" ], [ "LOAD_FAST", "config" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "NO_ASTTOKENS" ], [ "LOAD_GLOBAL", "Exception" ], [ "CALL_FUNCTION", "Exception(\"birdseye doesn't support this version of Python\")" ], [ "LOAD_GLOBAL", "ImportError" ], [ "LOAD_GLOBAL", "Exception" ], [ "CALL_FUNCTION", "Exception(\"You must install birdseye separately to use spy: pip install birdseye\")" ], [ "LOAD_GLOBAL", "no_args_decorator" ], [ "LOAD_DEREF", "args" ], [ "LOAD_DEREF", "kwargs" ], [ "CALL_FUNCTION", "no_args_decorator(args, kwargs)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._trace" ], [ "LOAD_DEREF", "args" ], [ "BINARY_SUBSCR", "args[0]" ], [ "CALL_FUNCTION", "self._trace(args[0])" ], [ "LOAD_FAST", "decorator" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._trace" ], [ "LOAD_FAST", "func" ], [ "LOAD_DEREF", "args" ], [ "LOAD_DEREF", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "self._trace(func, *args, **kwargs)" ], [ "LOAD_FAST", "eye" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "eye(func)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.snoop" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "self.config.snoop(*args, **kwargs)" ], [ "LOAD_DEREF", "traced" ], [ "CALL_FUNCTION", "self.config.snoop(*args, **kwargs)(traced)" ], [ "LOAD_GLOBAL", "functools" ], [ "LOAD_ATTR", "functools.wraps" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "LOAD_FAST", "wrapper" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.enabled" ], [ "LOAD_DEREF", "traced" ], [ "LOAD_DEREF", "func" ], [ "LOAD_FAST", "final_func" ], [ "LOAD_FAST", "func_args" ], [ "LOAD_FAST", "func_kwargs" ], [ "CALL_FUNCTION_VAR_KW", "final_func(*func_args, **func_kwargs)" ] ], "utils.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOAD_ATTR", "standard_library.install_aliases" ], [ "CALL_FUNCTION", "standard_library.install_aliases()" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "type" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "version_info" ], [ "LOAD_ATTR", "version_info.major" ], [ "COMPARE_OP", "version_info.major == 2" ], [ "LOAD_NAME", "PY2" ], [ "UNARY_NOT", "not PY2" ], [ "LOAD_NAME", "TypeVar" ], [ "CALL_FUNCTION", "TypeVar('T')" ], [ "LOAD_NAME", "TypeVar" ], [ "CALL_FUNCTION", "TypeVar('RT')" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "unicode" ], [ "LOAD_NAME", "str" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "type" ], [ "LOAD_NAME", "json" ], [ "LOAD_ATTR", "json.JSONEncoder" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_GLOBAL", "ntpath" ], [ "LOAD_ATTR", "ntpath.split" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "ntpath.split(path)" ], [ "LOAD_FAST", "tail" ], [ "LOAD_GLOBAL", "ntpath" ], [ "LOAD_ATTR", "ntpath.basename" ], [ "LOAD_FAST", "head" ], [ "CALL_FUNCTION", "ntpath.basename(head)" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.commonprefix" ], [ "LOAD_FAST", "paths" ], [ "CALL_FUNCTION", "os.path.commonprefix(paths)" ], [ "LOAD_GLOBAL", "ntpath" ], [ "LOAD_ATTR", "ntpath.split" ], [ "LOAD_FAST", "prefix" ], [ "CALL_FUNCTION", "ntpath.split(prefix)" ], [ "BINARY_SUBSCR", "ntpath.split(prefix)[0]" ], [ "LOAD_FAST", "paths" ], [ "BINARY_SUBSCR", "paths[0]" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "prefix" ], [ "CALL_FUNCTION", "len(prefix)" ], [ "BINARY_SUBSCR", "paths[0][len(prefix)]" ], [ "LOAD_FAST", "first_char_after" ], [ "COMPARE_OP", "first_char_after in r'\\/'" ], [ "LOAD_FAST", "first_char_after" ], [ "LOAD_FAST", "prefix" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "COMPARE_OP", "path == IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "all_paths" ], [ "LOAD_FAST", "f" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "COMPARE_OP", "f != IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "f" ], [ "LOAD_GLOBAL", "common_ancestor" ], [ "LOAD_FAST", "all_paths" ], [ "CALL_FUNCTION", "common_ancestor(all_paths)" ], [ "LOAD_FAST", "prefix" ], [ "COMPARE_OP", "prefix in r'\\/'" ], [ "LOAD_GLOBAL", "strip_required_prefix" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "prefix" ], [ "CALL_FUNCTION", "strip_required_prefix(path, prefix)" ], [ "LOAD_GLOBAL", "path_leaf" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "path_leaf(path)" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "COMPARE_OP", "path == IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.sep" ], [ "COMPARE_OP", "os.path.sep == '/'" ], [ "LOAD_FAST", "path" ], [ "LOAD_ATTR", "path.startswith" ], [ "CALL_FUNCTION", "path.startswith('/')" ], [ "UNARY_NOT", "not path.startswith('/')" ], [ "LOAD_FAST", "path" ], [ "BINARY_ADD", "'/' + path" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "type" ], [ "LOAD_FAST", "obj" ], [ "CALL_FUNCTION", "type(obj)" ], [ "LOAD_FAST", "t" ], [ "LOAD_GLOBAL", "types" ], [ "LOAD_ATTR", "types.InstanceType" ], [ "COMPARE_OP", "t is types.InstanceType" ], [ "LOAD_FAST", "obj" ], [ "LOAD_ATTR", "obj.__class__" ], [ "LOAD_FAST", "t" ], [ "LOAD_FAST", "iterable" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_DEREF", "type_or_tuple" ], [ "CALL_FUNCTION", "isinstance(x, type_or_tuple)" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "next" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "next(it)" ], [ "LOAD_GLOBAL", "StopIteration" ], [ "LOAD_GLOBAL", "raise_from" ], [ "LOAD_GLOBAL", "RuntimeError" ], [ "LOAD_FAST", "e" ], [ "CALL_FUNCTION", "raise_from(RuntimeError, e)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "expression" ], [ "CALL_FUNCTION", "hasattr(expression, 'one_or_none')" ], [ "LOAD_FAST", "expression" ], [ "LOAD_ATTR", "expression.one_or_none" ], [ "CALL_FUNCTION", "expression.one_or_none()" ], [ "LOAD_FAST", "expression" ], [ "LOAD_ATTR", "expression.all" ], [ "CALL_FUNCTION", "expression.all()" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "len(result)" ], [ "COMPARE_OP", "len(result) == 0" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "len(result)" ], [ "COMPARE_OP", "len(result) == 1" ], [ "LOAD_FAST", "result" ], [ "BINARY_SUBSCR", "result[0]" ], [ "LOAD_GLOBAL", "Exception" ], [ "CALL_FUNCTION", "Exception(\"There is more than one item returned for the supplied filter\")" ], [ "LOAD_FAST", "lst" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "isinstance(x, list)" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.extend" ], [ "LOAD_GLOBAL", "flatten_list" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "flatten_list(x)" ], [ "CALL_FUNCTION", "result.extend(flatten_list(x))" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.append" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "result.append(x)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "f" ], [ "LOAD_ATTR", "f.__code__" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_GLOBAL", "False" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "LOAD_ATTR", "(lambda: 0).__code__" ], [ "LOAD_ATTR", "(lambda: 0).__code__.co_name" ], [ "COMPARE_OP", "code.co_name == (lambda: 0).__code__.co_name" ], [ "LOAD_FAST", "o" ], [ "LOAD_ATTR", "o.as_json" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "ProtocolEncoder" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(ProtocolEncoder, self)" ], [ "LOAD_ATTR", "super(ProtocolEncoder, self).default" ], [ "LOAD_FAST", "o" ], [ "CALL_FUNCTION", "super(ProtocolEncoder, self).default(o)" ], [ "LOAD_FAST", "method" ], [ "CALL_FUNCTION", "method()" ], [ "LOAD_GLOBAL", "io" ], [ "LOAD_ATTR", "io.open" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "io.open(filename, 'rb')" ], [ "LOAD_GLOBAL", "detect_encoding" ], [ "LOAD_FAST", "fp" ], [ "LOAD_ATTR", "fp.readline" ], [ "CALL_FUNCTION", "detect_encoding(fp.readline)" ], [ "LOAD_FAST", "fp" ], [ "LOAD_ATTR", "fp.seek" ], [ "CALL_FUNCTION", "fp.seek(0)" ], [ "LOAD_GLOBAL", "io" ], [ "LOAD_ATTR", "io.TextIOWrapper" ], [ "LOAD_FAST", "fp" ], [ "LOAD_FAST", "encoding" ], [ "LOAD_GLOBAL", "True" ], [ "CALL_FUNCTION", "io.TextIOWrapper(fp, encoding, line_buffering=True)" ], [ "LOAD_FAST", "text" ], [ "LOAD_FAST", "text" ], [ "LOAD_FAST", "fp" ], [ "LOAD_ATTR", "fp.close" ], [ "CALL_FUNCTION", "fp.close()" ], [ "LOAD_FAST", "filename" ], [ "LOAD_ATTR", "filename.endswith" ], [ "CALL_FUNCTION", "filename.endswith('.pyc')" ], [ "LOAD_FAST", "filename" ], [ "SLICE+2", "filename[:-1]" ], [ "LOAD_GLOBAL", "open_with_encoding_check" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "open_with_encoding_check(filename)" ], [ "LOAD_ATTR", "''.join" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "f" ], [ "CALL_FUNCTION", "enumerate(f)" ], [ "LOAD_FAST", "i" ], [ "COMPARE_OP", "i < 2" ], [ "LOAD_FAST", "cookie_re" ], [ "LOAD_ATTR", "cookie_re.match" ], [ "LOAD_FAST", "line" ], [ "CALL_FUNCTION", "cookie_re.match(line)" ], [ "LOAD_FAST", "line" ], [ "CALL_FUNCTION", "''.join([\n '\\n' if i < 2 and cookie_re.match(line)\n else line\n for i, line in enumerate(f)\n ])" ], [ "LOAD_GLOBAL", "safe_next" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_ATTR", "tokens.get_tokens" ], [ "LOAD_FAST", "function_node" ], [ "CALL_FUNCTION", "tokens.get_tokens(function_node)" ], [ "CALL_FUNCTION", "safe_next(t for t in tokens.get_tokens(function_node)\n if t.string == 'def' and t.type == token.NAME)" ], [ "LOAD_FAST", "def_token" ], [ "LOAD_ATTR", "def_token.startpos" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_ATTR", "tokens.text" ], [ "LOAD_FAST", "startpos" ], [ "LOAD_FAST", "function_node" ], [ "LOAD_ATTR", "function_node.last_token" ], [ "LOAD_ATTR", "function_node.last_token.endpos" ], [ "SLICE+3", "tokens.text[startpos:function_node.last_token.endpos]" ], [ "LOAD_ATTR", "tokens.text[startpos:function_node.last_token.endpos].rstrip" ], [ "CALL_FUNCTION", "tokens.text[startpos:function_node.last_token.endpos].rstrip()" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.startswith" ], [ "CALL_FUNCTION", "source.startswith('def')" ], [ "LOAD_FAST", "startpos" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "t" ], [ "LOAD_ATTR", "t.string" ], [ "COMPARE_OP", "t.string == 'def'" ], [ "LOAD_FAST", "t" ], [ "LOAD_ATTR", "t.type" ], [ "LOAD_GLOBAL", "token" ], [ "LOAD_ATTR", "token.NAME" ], [ "COMPARE_OP", "t.type == token.NAME" ], [ "LOAD_FAST", "t" ], [ "LOAD_FAST", "args" ], [ "LOAD_GLOBAL", "print" ], [ "LOAD_FAST", "arg" ], [ "CALL_FUNCTION", "print(arg)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION", "len(args)" ], [ "COMPARE_OP", "len(args) == 1" ], [ "LOAD_FAST", "args" ], [ "BINARY_SUBSCR", "args[0]" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "filename" ], [ "LOAD_ATTR", "filename.startswith" ], [ "CALL_FUNCTION", "filename.startswith(' max_length" ], [ "LOAD_FAST", "max_length" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "middle" ], [ "CALL_FUNCTION", "len(middle)" ], [ "BINARY_SUBTRACT", "max_length - len(middle)" ], [ "BINARY_FLOOR_DIVIDE", "(max_length - len(middle)) // 2" ], [ "LOAD_FAST", "max_length" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "middle" ], [ "CALL_FUNCTION", "len(middle)" ], [ "BINARY_SUBTRACT", "max_length - len(middle)" ], [ "LOAD_FAST", "left" ], [ "BINARY_SUBTRACT", "max_length - len(middle) - left" ], [ "LOAD_FAST", "seq" ], [ "LOAD_FAST", "left" ], [ "SLICE+2", "seq[:left]" ], [ "LOAD_FAST", "middle" ], [ "BINARY_ADD", "seq[:left] + middle" ], [ "LOAD_FAST", "seq" ], [ "LOAD_FAST", "right" ], [ "UNARY_NEGATIVE", "-right" ], [ "SLICE+1", "seq[-right:]" ], [ "BINARY_ADD", "seq[:left] + middle + seq[-right:]" ], [ "LOAD_FAST", "seq" ], [ "LOAD_GLOBAL", "truncate" ], [ "LOAD_FAST", "string" ], [ "LOAD_FAST", "max_length" ], [ "CALL_FUNCTION", "truncate(string, max_length, '...')" ], [ "LOAD_GLOBAL", "truncate" ], [ "LOAD_FAST", "lst" ], [ "LOAD_FAST", "max_length" ], [ "CALL_FUNCTION", "truncate(lst, max_length, ['...'])" ], [ "LOAD_FAST", "split" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "six" ], [ "LOAD_ATTR", "six.string_types" ], [ "CALL_FUNCTION", "isinstance(x, six.string_types)" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.replace" ], [ "CALL_FUNCTION", "x.replace(',', ' ')" ], [ "LOAD_ATTR", "x.replace(',', ' ').split" ], [ "CALL_FUNCTION", "x.replace(',', ' ').split()" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "set" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "isinstance(x, (list, set, tuple))" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "tuple" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tuple(x)" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.basename" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_filename" ], [ "CALL_FUNCTION", "os.path.basename(code.co_filename)" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.endswith" ], [ "CALL_FUNCTION", "result.endswith('.pyc')" ], [ "LOAD_FAST", "result" ], [ "SLICE+2", "result[:-1]" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "COMPARE_OP", "frame.f_code.co_name in ('', '', '')" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "code('{}.x')" ], [ "LOAD_GLOBAL", "SyntaxError" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "code('({})')" ], [ "LOAD_GLOBAL", "True" ], [ "LOAD_FAST", "without_parens" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "code('({}).x')" ], [ "COMPARE_OP", "without_parens != code('({}).x')" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "s" ], [ "LOAD_ATTR", "s.format" ], [ "LOAD_DEREF", "source" ], [ "CALL_FUNCTION", "s.format(source)" ], [ "CALL_FUNCTION", "compile(s.format(source), '', 'eval')" ], [ "LOAD_ATTR", "compile(s.format(source), '', 'eval').co_code" ], [ "LOAD_GLOBAL", "needs_parentheses" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "needs_parentheses(source)" ], [ "LOAD_ATTR", "'({})'.format" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "'({})'.format(source)" ], [ "LOAD_FAST", "source" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "REPR_TARGET_LENGTH" ], [ "CALL_FUNCTION", "cheap_repr(x, target_length=REPR_TARGET_LENGTH)" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "ArgDefaultDict" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(ArgDefaultDict, self)" ], [ "LOAD_ATTR", "super(ArgDefaultDict, self).__init__" ], [ "CALL_FUNCTION", "super(ArgDefaultDict, self).__init__()" ], [ "LOAD_FAST", "factory" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.factory" ], [ "LOAD_FAST", "key" ], [ "CALL_FUNCTION", "self.factory(key)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "key" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "lst" ], [ "CALL_FUNCTION", "len(lst)" ], [ "COMPARE_OP", "len(lst) == 1" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "CALL_FUNCTION", "str(i + 1)" ], [ "BINARY_ADD", "' ' + str(i + 1)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_GLOBAL", "os" ], [ "CALL_FUNCTION", "hasattr(os, 'PathLike')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.PathLike" ], [ "CALL_FUNCTION", "isinstance(x, os.PathLike)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "hasattr(x, '__fspath__')" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "hasattr(x, 'open')" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.__class__" ], [ "LOAD_ATTR", "x.__class__.__name__" ], [ "LOAD_ATTR", "x.__class__.__name__.lower" ], [ "CALL_FUNCTION", "x.__class__.__name__.lower()" ], [ "COMPARE_OP", "'path' in x.__class__.__name__.lower()" ], [ "LOAD_GLOBAL", "False" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION", "len(args)" ], [ "COMPARE_OP", "len(args) == 1" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.isfunction" ], [ "LOAD_FAST", "args" ], [ "BINARY_SUBSCR", "args[0]" ], [ "CALL_FUNCTION", "inspect.isfunction(args[0])" ], [ "LOAD_FAST", "kwargs" ], [ "UNARY_NOT", "not kwargs" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_ADD", "max_length + 2" ], [ "COMPARE_OP", "length <= max_length + 2" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "range(length)" ], [ "LOAD_GLOBAL", "chain" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_FLOOR_DIVIDE", "max_length // 2" ], [ "CALL_FUNCTION", "range(max_length // 2)" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_FLOOR_DIVIDE", "max_length // 2" ], [ "BINARY_SUBTRACT", "length - max_length // 2" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "range(length - max_length // 2,\n length)" ], [ "CALL_FUNCTION", "chain(range(max_length // 2),\n range(length - max_length // 2,\n length))" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "len(x)" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "n == 0" ], [ "LOAD_GLOBAL", "repr" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "repr(x)" ], [ "LOAD_FAST", "helper" ], [ "LOAD_ATTR", "helper.level" ], [ "BINARY_SUBTRACT", "helper.level - 1" ], [ "LOAD_GLOBAL", "_repr_series_one_line" ], [ "LOAD_ATTR", "_repr_series_one_line.maxparts" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "n" ], [ "LOAD_FAST", "maxparts" ], [ "CALL_FUNCTION", "_sample_indices(n, maxparts)" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.index" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "SLICE+3", "x.index[i:i + 1]" ], [ "LOAD_ATTR", "x.index[i:i + 1].format" ], [ "LOAD_GLOBAL", "False" ], [ "CALL_FUNCTION", "x.index[i:i + 1].format(sparsify=False)" ], [ "BINARY_SUBSCR", "x.index[i:i + 1].format(sparsify=False)[0]" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.iloc" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "x.iloc[i]" ], [ "LOAD_FAST", "pieces" ], [ "LOAD_ATTR", "pieces.append" ], [ "LOAD_FAST", "k" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "v" ], [ "LOAD_FAST", "newlevel" ], [ "CALL_FUNCTION", "cheap_repr(v, newlevel)" ], [ "BINARY_MODULO", "'%s = %s' % (k, cheap_repr(v, newlevel))" ], [ "CALL_FUNCTION", "pieces.append('%s = %s' % (k, cheap_repr(v, newlevel)))" ], [ "LOAD_FAST", "n" ], [ "LOAD_FAST", "maxparts" ], [ "BINARY_ADD", "maxparts + 2" ], [ "COMPARE_OP", "n > maxparts + 2" ], [ "LOAD_FAST", "pieces" ], [ "LOAD_ATTR", "pieces.insert" ], [ "LOAD_FAST", "maxparts" ], [ "BINARY_FLOOR_DIVIDE", "maxparts // 2" ], [ "CALL_FUNCTION", "pieces.insert(maxparts // 2, '...')" ], [ "LOAD_ATTR", "'; '.join" ], [ "LOAD_FAST", "pieces" ], [ "CALL_FUNCTION", "'; '.join(pieces)" ] ] }executing-0.8.0/tests/sample_results/3.10.json000066400000000000000000021507701410133640400212020ustar00rootroot00000000000000{ "bird.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOAD_METHOD", "standard_library.install_aliases" ], [ "CALL_METHOD", "standard_library.install_aliases()" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "warn_if_outdated" ], [ "LOAD_NAME", "__version__" ], [ "CALL_FUNCTION", "warn_if_outdated('birdseye', __version__)" ], [ "LOAD_NAME", "namedtuple" ], [ "CALL_FUNCTION", "namedtuple('CodeInfo', 'db_func traced_file arg_names')" ], [ "LOAD_NAME", "TreeTracerBase" ], [ "LOAD_NAME", "BirdsEye" ], [ "CALL_FUNCTION", "BirdsEye()" ], [ "LOAD_NAME", "NamedTuple" ], [ "LOAD_NAME", "int" ], [ "LOAD_NAME", "bool" ], [ "LOAD_NAME", "int" ], [ "LOAD_NAME", "str" ], [ "CALL_FUNCTION", "NamedTuple('HTMLPosition', [\n ('index', int),\n ('is_start', bool),\n ('depth', int),\n ('html', str),\n])" ], [ "LOAD_NAME", "eye" ], [ "LOAD_ATTR", "eye.enter_call" ], [ "LOAD_ATTR", "eye.enter_call.__code__" ], [ "LOAD_NAME", "eye" ], [ "LOAD_ATTR", "eye.exit_call" ], [ "LOAD_ATTR", "eye.exit_call.__code__" ], [ "LOAD_NAME", "eye" ], [ "LOAD_ATTR", "eye.after_expr" ], [ "LOAD_ATTR", "eye.after_expr.__code__" ], [ "LOAD_NAME", "eye" ], [ "LOAD_ATTR", "eye.after_stmt" ], [ "LOAD_ATTR", "eye.after_stmt.__code__" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "Iterable" ], [ "LOAD_NAME", "Iteration" ], [ "BINARY_SUBSCR", "Iterable[Iteration]" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "TypeRegistry" ], [ "CALL_FUNCTION", "TypeRegistry()" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "try_register_repr" ], [ "CALL_FUNCTION", "try_register_repr('pandas', 'Series')" ], [ "CALL_FUNCTION", "try_register_repr('pandas', 'Series')" ], [ "LOAD_NAME", "cached_property" ], [ "CALL_FUNCTION", "cached_property" ], [ "LOAD_NAME", "lru_cache" ], [ "CALL_FUNCTION", "lru_cache()" ], [ "CALL_FUNCTION", "lru_cache()" ], [ "LOAD_NAME", "retry_db" ], [ "CALL_FUNCTION", "retry_db" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "BirdsEye" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(BirdsEye, self)" ], [ "LOAD_METHOD", "super(BirdsEye, self).__init__" ], [ "CALL_METHOD", "super(BirdsEye, self).__init__()" ], [ "LOAD_FAST", "db_uri" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "num_samples" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "dict" ], [ "CALL_FUNCTION_KW", "dict(\n attributes=50,\n dict=50,\n list=30,\n set=30,\n pandas_rows=20,\n pandas_cols=100,\n )" ], [ "LOAD_GLOBAL", "dict" ], [ "CALL_FUNCTION_KW", "dict(\n attributes=50,\n dict=10,\n list=6,\n set=6,\n pandas_rows=6,\n pandas_cols=10,\n )" ], [ "CALL_FUNCTION_KW", "dict(\n big=dict(\n attributes=50,\n dict=50,\n list=30,\n set=30,\n pandas_rows=20,\n pandas_cols=100,\n ),\n small=dict(\n attributes=50,\n dict=10,\n list=6,\n set=6,\n pandas_rows=6,\n pandas_cols=10,\n ),\n )" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "Database" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._db_uri" ], [ "CALL_FUNCTION", "Database(self._db_uri)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.walk" ], [ "LOAD_FAST", "root" ], [ "CALL_METHOD", "ast.walk(root)" ], [ "LOAD_GLOBAL", "tracer" ], [ "LOAD_METHOD", "tracer.loops" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "tracer.loops(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "CALL_FUNCTION", "isinstance(node, ast.expr)" ], [ "LOAD_GLOBAL", "is_interesting_expression" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "is_interesting_expression(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "BirdsEye" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(BirdsEye, self)" ], [ "LOAD_METHOD", "super(BirdsEye, self).compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "flags" ], [ "CALL_METHOD", "super(BirdsEye, self).compile(source, filename, flags)" ], [ "LOAD_GLOBAL", "ASTTokens" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.root" ], [ "CALL_FUNCTION_KW", "ASTTokens(source, tree=traced_file.root)" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "CONTAINS_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.For)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.body" ], [ "BINARY_SUBSCR", "node.parent.body[0]" ], [ "IS_OP", "node is node.parent.body[0]" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._add_iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self._add_iteration(node._loops, frame)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.While)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.test" ], [ "IS_OP", "node is node.parent.test" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._add_iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self._add_iteration(node._loops, frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_ATTR", "self.stack[frame].iteration" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "loops" ], [ "CALL_FUNCTION", "enumerate(loops)" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.loops" ], [ "LOAD_FAST", "loop_node" ], [ "LOAD_ATTR", "loop_node._tree_index" ], [ "BINARY_SUBSCR", "iteration.loops[loop_node._tree_index]" ], [ "LOAD_FAST", "i" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "loops" ], [ "CALL_FUNCTION", "len(loops)" ], [ "BINARY_SUBTRACT", "len(loops) - 1" ], [ "COMPARE_OP", "i == len(loops) - 1" ], [ "LOAD_FAST", "loop" ], [ "LOAD_METHOD", "loop.append" ], [ "LOAD_GLOBAL", "Iteration" ], [ "CALL_FUNCTION", "Iteration()" ], [ "CALL_METHOD", "loop.append(Iteration())" ], [ "LOAD_FAST", "loop" ], [ "LOAD_METHOD", "loop.last" ], [ "CALL_METHOD", "loop.last()" ], [ "LOAD_GLOBAL", "_tracing_recursively" ], [ "LOAD_DEREF", "frame" ], [ "CALL_FUNCTION", "_tracing_recursively(frame)" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "CONTAINS_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._is_interesting_expression" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "BINARY_SUBSCR", "self._code_infos[frame.f_code]" ], [ "LOAD_ATTR", "self._code_infos[frame.f_code].traced_file" ], [ "LOAD_ATTR", "self._code_infos[frame.f_code].traced_file.is_ipython_cell" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Expr" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.Expr)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.parent" ], [ "LOAD_ATTR", "node.parent.parent.body" ], [ "BINARY_SUBSCR", "node.parent.parent.body[-1]" ], [ "IS_OP", "node.parent is node.parent.parent.body[-1]" ], [ "LOAD_DEREF", "value" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "is_obvious_builtin" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_DEREF", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_ATTR", "self.stack[frame].expression_values" ], [ "LOAD_FAST", "node" ], [ "BINARY_SUBSCR", "self.stack[frame].expression_values[node]" ], [ "CALL_FUNCTION", "is_obvious_builtin(node, self.stack[frame].expression_values[node])" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_DEREF", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_FAST", "exc_value" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self._exception_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_FAST", "exc_value" ], [ "CALL_METHOD", "self._exception_value(node, frame, exc_value)" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOAD_ATTR", "NodeValue.expression" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.num_samples" ], [ "LOAD_DEREF", "value" ], [ "LOAD_GLOBAL", "max" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "CALL_FUNCTION", "len(node._loops)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self._is_first_loop_iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "frame" ], [ "CALL_METHOD", "self._is_first_loop_iteration(node, frame)" ], [ "UNARY_NOT", "not self._is_first_loop_iteration(node, frame)" ], [ "BINARY_MULTIPLY", "len(node._loops) * (not self._is_first_loop_iteration(node, frame))" ], [ "BINARY_SUBTRACT", "3 - len(node._loops) * (not self._is_first_loop_iteration(node, frame))" ], [ "CALL_FUNCTION", "max(1, 3 - len(node._loops) * (not self._is_first_loop_iteration(node, frame)))" ], [ "CALL_FUNCTION_KW", "NodeValue.expression(\n self.num_samples,\n value,\n level=max(1, 3 - len(node._loops) * (not self._is_first_loop_iteration(node, frame))),\n )" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self._set_node_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_FAST", "node_value" ], [ "CALL_METHOD", "self._set_node_value(node, frame, node_value)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self._check_inner_call" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node_value" ], [ "CALL_METHOD", "self._check_inner_call(frame_info, node, node_value)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.comprehension)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.iter" ], [ "IS_OP", "node is node.parent.iter" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.GeneratorExp" ], [ "CALL_FUNCTION", "isinstance(node.parent.parent, ast.GeneratorExp)" ], [ "UNARY_NOT", "not isinstance(node.parent.parent, ast.GeneratorExp)" ], [ "LOAD_FAST", "is_special_comprehension_iter" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self._set_node_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOAD_METHOD", "NodeValue.covered" ], [ "CALL_METHOD", "NodeValue.covered()" ], [ "CALL_METHOD", "self._set_node_value(node.parent, frame, NodeValue.covered())" ], [ "LOAD_FAST", "exc_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "BINARY_ADD", "node._loops + (node.parent,)" ], [ "LOAD_GLOBAL", "ChangeValue" ], [ "LOAD_FAST", "comprehension_iter_proxy" ], [ "CALL_FUNCTION", "comprehension_iter_proxy()" ], [ "CALL_FUNCTION", "ChangeValue(comprehension_iter_proxy())" ], [ "LOAD_DEREF", "value" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self._add_iteration" ], [ "LOAD_DEREF", "loops" ], [ "LOAD_DEREF", "frame" ], [ "CALL_METHOD", "self._add_iteration(loops, frame)" ], [ "LOAD_FAST", "item" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.inner_calls" ], [ "LOAD_METHOD", "frame_info.inner_calls.pop" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "frame_info.inner_calls.pop(node, None)" ], [ "LOAD_FAST", "inner_calls" ], [ "LOAD_FAST", "node_value" ], [ "LOAD_METHOD", "node_value.set_meta" ], [ "LOAD_FAST", "inner_calls" ], [ "CALL_METHOD", "node_value.set_meta('inner_calls', inner_calls)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_ATTR", "self.stack[frame].iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.loops" ], [ "LOAD_FAST", "loop_node" ], [ "LOAD_ATTR", "loop_node._tree_index" ], [ "BINARY_SUBSCR", "iteration.loops[loop_node._tree_index]" ], [ "LOAD_FAST", "loop" ], [ "LOAD_METHOD", "loop.last" ], [ "CALL_METHOD", "loop.last()" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.index" ], [ "COMPARE_OP", "iteration.index > 0" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_ATTR", "self.stack[frame].iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.loops" ], [ "LOAD_FAST", "loop_node" ], [ "LOAD_ATTR", "loop_node._tree_index" ], [ "BINARY_SUBSCR", "iteration.loops[loop_node._tree_index]" ], [ "LOAD_FAST", "loop" ], [ "LOAD_METHOD", "loop.recorded_node" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "loop.recorded_node(node)" ], [ "LOAD_FAST", "loop" ], [ "LOAD_METHOD", "loop.last" ], [ "CALL_METHOD", "loop.last()" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.vals" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOAD_METHOD", "NodeValue.exception" ], [ "LOAD_FAST", "exc_value" ], [ "CALL_METHOD", "NodeValue.exception(exc_value)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._set_node_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "value" ], [ "CALL_METHOD", "self._set_node_value(node, frame, value)" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "CONTAINS_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_GLOBAL", "_tracing_recursively" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "_tracing_recursively(frame)" ], [ "LOAD_FAST", "exc_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "exc_node" ], [ "IS_OP", "node is exc_node" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._exception_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "exc_value" ], [ "CALL_METHOD", "self._exception_value(node, frame, exc_value)" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOAD_METHOD", "NodeValue.covered" ], [ "CALL_METHOD", "NodeValue.covered()" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._set_node_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "value" ], [ "CALL_METHOD", "self._set_node_value(node, frame, value)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._check_inner_call" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "value" ], [ "CALL_METHOD", "self._check_inner_call(self.stack[frame], node, value)" ], [ "LOAD_FAST", "enter_info" ], [ "LOAD_ATTR", "enter_info.current_frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "CONTAINS_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_GLOBAL", "_tracing_recursively" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "_tracing_recursively(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_GLOBAL", "get_unfrozen_datetime" ], [ "CALL_FUNCTION", "get_unfrozen_datetime()" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_GLOBAL", "Iteration" ], [ "CALL_FUNCTION", "Iteration()" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "BINARY_SUBSCR", "self._code_infos[frame.f_code]" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "enter_info" ], [ "LOAD_ATTR", "enter_info.enter_node" ], [ "LOAD_ATTR", "enter_info.enter_node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Module" ], [ "CALL_FUNCTION", "isinstance(enter_info.enter_node.parent, ast.Module)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "LOAD_METHOD", "frame.f_locals.copy" ], [ "CALL_METHOD", "frame.f_locals.copy()" ], [ "LOAD_FAST", "code_info" ], [ "LOAD_ATTR", "code_info.arg_names" ], [ "LOAD_DEREF", "f_locals" ], [ "LOAD_METHOD", "f_locals.items" ], [ "CALL_METHOD", "f_locals.items()" ], [ "BINARY_ADD", "[(name, f_locals.pop(name))\n for name in code_info.arg_names\n if name] + [\n\n # Local variables other than actual arguments. These are variables from\n # the enclosing scope. It's handy to treat them like arguments in the UI\n it for it in f_locals.items()\n if it[0][0] != '.' # Appears when using nested tuple arguments\n ]" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_METHOD", "json.dumps" ], [ "LOAD_FAST", "arguments" ], [ "CALL_METHOD", "json.dumps([[k, cheap_repr(v)] for k, v in arguments])" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._call_id" ], [ "CALL_METHOD", "self._call_id()" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "defaultdict(list)" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_METHOD", "self.stack.get" ], [ "LOAD_FAST", "enter_info" ], [ "LOAD_ATTR", "enter_info.caller_frame" ], [ "CALL_METHOD", "self.stack.get(enter_info.caller_frame)" ], [ "LOAD_FAST", "prev" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "prev" ], [ "CALL_FUNCTION", "getattr(prev, 'inner_calls', None)" ], [ "LOAD_FAST", "inner_calls" ], [ "IS_OP", "inner_calls is not None" ], [ "LOAD_FAST", "inner_calls" ], [ "LOAD_FAST", "enter_info" ], [ "LOAD_ATTR", "enter_info.call_node" ], [ "BINARY_SUBSCR", "inner_calls[enter_info.call_node]" ], [ "LOAD_METHOD", "inner_calls[enter_info.call_node].append" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.call_id" ], [ "CALL_METHOD", "inner_calls[enter_info.call_node].append(frame_info.call_id)" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "name" ], [ "LOAD_DEREF", "f_locals" ], [ "LOAD_METHOD", "f_locals.pop" ], [ "LOAD_FAST", "name" ], [ "CALL_METHOD", "f_locals.pop(name)" ], [ "LOAD_FAST", "it" ], [ "BINARY_SUBSCR", "it[0]" ], [ "BINARY_SUBSCR", "it[0][0]" ], [ "COMPARE_OP", "it[0][0] != '.'" ], [ "LOAD_FAST", "it" ], [ "LOAD_FAST", "k" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "cheap_repr(v)" ], [ "LOAD_GLOBAL", "uuid4" ], [ "CALL_FUNCTION", "uuid4()" ], [ "LOAD_ATTR", "uuid4().hex" ], [ "LOAD_DEREF", "exit_info" ], [ "LOAD_ATTR", "exit_info.current_frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "CONTAINS_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_GLOBAL", "_tracing_recursively" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "_tracing_recursively(frame)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.iteration" ], [ "LOAD_GLOBAL", "_deep_dict" ], [ "CALL_FUNCTION", "_deep_dict()" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self._extract_node_values" ], [ "LOAD_DEREF", "top_iteration" ], [ "LOAD_DEREF", "node_values" ], [ "CALL_METHOD", "self._extract_node_values(top_iteration, (), node_values)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "BINARY_SUBSCR", "self._code_infos[frame.f_code]" ], [ "LOAD_ATTR", "self._code_infos[frame.f_code].db_func" ], [ "LOAD_DEREF", "exit_info" ], [ "LOAD_ATTR", "exit_info.exc_value" ], [ "LOAD_FAST", "exc" ], [ "LOAD_METHOD", "''.join" ], [ "LOAD_GLOBAL", "traceback" ], [ "LOAD_METHOD", "traceback.format_exception" ], [ "LOAD_GLOBAL", "type" ], [ "LOAD_FAST", "exc" ], [ "CALL_FUNCTION", "type(exc)" ], [ "LOAD_FAST", "exc" ], [ "LOAD_DEREF", "exit_info" ], [ "LOAD_ATTR", "exit_info.exc_tb" ], [ "CALL_METHOD", "traceback.format_exception(type(exc), exc, exit_info.exc_tb)" ], [ "CALL_METHOD", "''.join(traceback.format_exception(type(exc), exc, exit_info.exc_tb))" ], [ "LOAD_GLOBAL", "exception_string" ], [ "LOAD_FAST", "exc" ], [ "CALL_FUNCTION", "exception_string(exc)" ], [ "LOAD_GLOBAL", "retry_db" ], [ "CALL_FUNCTION", "retry_db" ], [ "LOAD_FAST", "add_call" ], [ "CALL_FUNCTION", "add_call()" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.call_id" ], [ "LOAD_DEREF", "self" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.db" ], [ "LOAD_ATTR", "self.db.Call" ], [ "LOAD_FAST", "Call" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.call_id" ], [ "LOAD_DEREF", "db_func" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.arguments" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_DEREF", "exit_info" ], [ "LOAD_ATTR", "exit_info.return_value" ], [ "CALL_FUNCTION", "cheap_repr(exit_info.return_value)" ], [ "LOAD_DEREF", "exception" ], [ "LOAD_DEREF", "traceback_str" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_ATTR", "json.dumps" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_DEREF", "node_values" ], [ "LOAD_DEREF", "top_iteration" ], [ "LOAD_METHOD", "top_iteration.extract_iterations" ], [ "CALL_METHOD", "top_iteration.extract_iterations()" ], [ "BINARY_SUBSCR", "top_iteration.extract_iterations()['loops']" ], [ "LOAD_GLOBAL", "type_registry" ], [ "LOAD_METHOD", "type_registry.names" ], [ "CALL_METHOD", "type_registry.names()" ], [ "LOAD_GLOBAL", "type_registry" ], [ "LOAD_ATTR", "type_registry.num_special_types" ], [ "CALL_FUNCTION_KW", "dict(\n node_values=node_values,\n loop_iterations=top_iteration.extract_iterations()['loops'],\n type_names=type_registry.names(),\n num_special_types=type_registry.num_special_types,\n )" ], [ "LOAD_GLOBAL", "ProtocolEncoder" ], [ "CALL_FUNCTION_KW", "json.dumps(\n dict(\n node_values=node_values,\n loop_iterations=top_iteration.extract_iterations()['loops'],\n type_names=type_registry.names(),\n num_special_types=type_registry.num_special_types,\n ),\n cls=ProtocolEncoder,\n separators=(',', ':')\n )" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.start_time" ], [ "CALL_FUNCTION_KW", "Call(id=frame_info.call_id,\n function_id=db_func,\n arguments=frame_info.arguments,\n return_value=cheap_repr(exit_info.return_value),\n exception=exception,\n traceback=traceback_str,\n data=json.dumps(\n dict(\n node_values=node_values,\n loop_iterations=top_iteration.extract_iterations()['loops'],\n type_names=type_registry.names(),\n num_special_types=type_registry.num_special_types,\n ),\n cls=ProtocolEncoder,\n separators=(',', ':')\n ),\n start_time=frame_info.start_time)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.db" ], [ "LOAD_METHOD", "self.db.session_scope" ], [ "CALL_METHOD", "self.db.session_scope()" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.add" ], [ "LOAD_FAST", "call" ], [ "CALL_METHOD", "session.add(call)" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.vals" ], [ "LOAD_METHOD", "iteration.vals.items" ], [ "CALL_METHOD", "iteration.vals.items()" ], [ "LOAD_FAST", "tree_index" ], [ "LOAD_FAST", "path" ], [ "BINARY_ADD", "(tree_index,) + path" ], [ "LOAD_FAST", "node_values" ], [ "LOAD_FAST", "full_path" ], [ "BINARY_SUBSCR", "full_path[:-1]" ], [ "LOAD_FAST", "d" ], [ "LOAD_FAST", "path_k" ], [ "BINARY_SUBSCR", "d[path_k]" ], [ "LOAD_FAST", "node_value" ], [ "LOAD_FAST", "d" ], [ "LOAD_FAST", "full_path" ], [ "BINARY_SUBSCR", "full_path[-1]" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.loops" ], [ "LOAD_METHOD", "iteration.loops.values" ], [ "CALL_METHOD", "iteration.loops.values()" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "loop" ], [ "CALL_FUNCTION", "enumerate(loop)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._extract_node_values" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "path + (i,)" ], [ "LOAD_FAST", "node_values" ], [ "CALL_METHOD", "self._extract_node_values(iteration, path + (i,), node_values)" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "BirdsEye" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(BirdsEye, self)" ], [ "LOAD_METHOD", "super(BirdsEye, self).trace_function" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "super(BirdsEye, self).trace_function(func)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_METHOD", "self._code_infos.get" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_ATTR", "new_func.__code__" ], [ "CALL_METHOD", "self._code_infos.get(new_func.__code__)" ], [ "LOAD_FAST", "code_info" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.getsourcelines" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "inspect.getsourcelines(func)" ], [ "LOAD_FAST", "start_lineno" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "lines" ], [ "CALL_FUNCTION", "len(lines)" ], [ "BINARY_ADD", "start_lineno + len(lines)" ], [ "LOAD_GLOBAL", "safe_qualname" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "safe_qualname(func)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.getsourcefile" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "inspect.getsourcefile(func)" ], [ "LOAD_FAST", "source_file" ], [ "LOAD_METHOD", "source_file.startswith" ], [ "CALL_METHOD", "source_file.startswith('= 0" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.getsourcefile" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "inspect.getsourcefile(frame)" ], [ "LOAD_FAST", "filename" ], [ "IS_OP", "filename is not None" ], [ "LOAD_FAST", "context" ], [ "COMPARE_OP", "context >= 0" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_METHOD", "os.path.abspath" ], [ "LOAD_FAST", "filename" ], [ "CALL_METHOD", "os.path.abspath(filename)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "LOAD_METHOD", "frame.f_globals.get" ], [ "CALL_METHOD", "frame.f_globals.get('__name__')" ], [ "COMPARE_OP", "frame.f_globals.get('__name__') != '__main__'" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._treetrace_hidden_with_stmt" ], [ "LOAD_ATTR", "self._treetrace_hidden_with_stmt.__name__" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "CONTAINS_OP", "self._treetrace_hidden_with_stmt.__name__ not in frame.f_globals" ], [ "LOAD_GLOBAL", "RuntimeError" ], [ "CALL_FUNCTION", "RuntimeError(\n 'To trace an imported module, you must import birdseye before '\n 'importing that module.')" ], [ "LOAD_GLOBAL", "read_source_file" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "read_source_file(filename)" ], [ "LOAD_METHOD", "read_source_file(filename).splitlines" ], [ "CALL_METHOD", "read_source_file(filename).splitlines()" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lineno" ], [ "BINARY_MULTIPLY", "[''] * frame.f_lineno" ], [ "LOAD_FAST", "lines" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lineno" ], [ "LOAD_METHOD", "'\\n'.join" ], [ "LOAD_FAST", "lines" ], [ "CALL_METHOD", "'\\n'.join(lines)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.exec_string" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "LOAD_FAST", "deep" ], [ "CALL_METHOD", "self.exec_string(source, filename, frame.f_globals, frame.f_locals, deep)" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_METHOD", "sys.exit" ], [ "CALL_METHOD", "sys.exit(0)" ], [ "LOAD_FAST", "globs" ], [ "LOAD_FAST", "locs" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self.compile" ], [ "LOAD_DEREF", "source" ], [ "LOAD_DEREF", "filename" ], [ "CALL_METHOD", "self.compile(source, filename)" ], [ "LOAD_FAST", "globs" ], [ "LOAD_METHOD", "globs.update" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self._trace_methods_dict" ], [ "LOAD_DEREF", "traced_file" ], [ "CALL_METHOD", "self._trace_methods_dict(traced_file)" ], [ "CALL_METHOD", "globs.update(self._trace_methods_dict(traced_file))" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self._trace" ], [ "LOAD_GLOBAL", "FILE_SENTINEL_NAME" ], [ "LOAD_DEREF", "filename" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.code" ], [ "LOAD_DEREF", "source" ], [ "CALL_METHOD", "self._trace(FILE_SENTINEL_NAME, filename, traced_file, traced_file.code, 'module', source)" ], [ "LOAD_FAST", "deep" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.nodes" ], [ "LOAD_DEREF", "find_code" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.code" ], [ "CALL_FUNCTION", "find_code(traced_file.code)" ], [ "LOAD_GLOBAL", "exec" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.code" ], [ "LOAD_FAST", "globs" ], [ "LOAD_FAST", "locs" ], [ "CALL_FUNCTION", "exec(traced_file.code, globs, locs)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(node, ast.FunctionDef)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.lineno" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "root_code" ], [ "LOAD_ATTR", "root_code.co_consts" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.iscode" ], [ "LOAD_FAST", "code" ], [ "CALL_METHOD", "inspect.iscode(code)" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "LOAD_METHOD", "code.co_name.startswith" ], [ "CALL_METHOD", "code.co_name.startswith('<')" ], [ "LOAD_DEREF", "find_code" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "find_code(code)" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_firstlineno" ], [ "LOAD_DEREF", "nodes_by_lineno" ], [ "LOAD_METHOD", "nodes_by_lineno.get" ], [ "LOAD_FAST", "lineno" ], [ "CALL_METHOD", "nodes_by_lineno.get(lineno)" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._trace" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "LOAD_DEREF", "filename" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_FAST", "code" ], [ "LOAD_DEREF", "source" ], [ "LOAD_FAST", "lineno" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.last_token" ], [ "LOAD_ATTR", "node.last_token.end" ], [ "BINARY_SUBSCR", "node.last_token.end[0]" ], [ "BINARY_ADD", "node.last_token.end[0] + 1" ], [ "CALL_FUNCTION_KW", "self._trace(\n code.co_name, filename, traced_file, code,\n typ='function',\n source=source,\n start_lineno=lineno,\n end_lineno=node.last_token.end[0] + 1,\n )" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_DEREF", "start_lineno" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "source" ], [ "LOAD_METHOD", "source.splitlines" ], [ "CALL_METHOD", "source.splitlines()" ], [ "CALL_FUNCTION", "len(source.splitlines())" ], [ "BINARY_ADD", "start_lineno + len(source.splitlines())" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._nodes_of_interest" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_DEREF", "start_lineno" ], [ "LOAD_FAST", "end_lineno" ], [ "CALL_METHOD", "self._nodes_of_interest(traced_file, start_lineno, end_lineno)" ], [ "CALL_FUNCTION", "list(self._nodes_of_interest(traced_file, start_lineno, end_lineno))" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._nodes_html" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_DEREF", "start_lineno" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_FAST", "traced_file" ], [ "CALL_METHOD", "self._nodes_html(nodes, start_lineno, end_lineno, traced_file)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "nodes" ], [ "CALL_FUNCTION_KW", "dict(\n # This maps each node to the loops enclosing that node\n node_loops={\n node._tree_index: [n._tree_index for n in node._loops]\n for node, _ in nodes\n if node._loops\n },\n )" ], [ "LOAD_FAST", "typ" ], [ "COMPARE_OP", "typ == 'function'" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.tokens" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_FAST", "nodes" ], [ "CALL_FUNCTION", "only(node\n for node, _ in nodes\n if isinstance(node, ast.FunctionDef)\n and node.first_token.start[0] == start_lineno)" ], [ "LOAD_GLOBAL", "source_without_decorators" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_FAST", "func_node" ], [ "CALL_FUNCTION", "source_without_decorators(tokens, func_node)" ], [ "LOAD_FAST", "data_dict" ], [ "LOAD_ATTR", "data_dict.update" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._node_ranges" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_FAST", "func_startpos" ], [ "CALL_METHOD", "self._node_ranges(nodes, tokens, func_startpos)" ], [ "CALL_FUNCTION", "list(self._node_ranges(nodes, tokens, func_startpos))" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._loop_ranges" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_FAST", "func_startpos" ], [ "CALL_METHOD", "self._loop_ranges(nodes, tokens, func_startpos)" ], [ "CALL_FUNCTION", "list(self._loop_ranges(nodes, tokens, func_startpos))" ], [ "CALL_FUNCTION_KW", "data_dict.update(\n node_ranges=list(self._node_ranges(nodes, tokens, func_startpos)),\n loop_ranges=list(self._loop_ranges(nodes, tokens, func_startpos)),\n )" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_ATTR", "json.dumps" ], [ "LOAD_FAST", "data_dict" ], [ "CALL_FUNCTION_KW", "json.dumps(data_dict, sort_keys=True)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._db_func" ], [ "LOAD_FAST", "data" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "html_body" ], [ "LOAD_FAST", "name" ], [ "LOAD_DEREF", "start_lineno" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "typ" ], [ "CALL_METHOD", "self._db_func(data, filename, html_body, name, start_lineno, source, typ)" ], [ "LOAD_GLOBAL", "CodeInfo" ], [ "LOAD_FAST", "db_func" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_FAST", "arg_names" ], [ "CALL_FUNCTION", "CodeInfo(db_func, traced_file, arg_names)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "n" ], [ "LOAD_ATTR", "n._tree_index" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(node, ast.FunctionDef)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.first_token" ], [ "LOAD_ATTR", "node.first_token.start" ], [ "BINARY_SUBSCR", "node.first_token.start[0]" ], [ "LOAD_DEREF", "start_lineno" ], [ "COMPARE_OP", "node.first_token.start[0] == start_lineno" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "classes" ], [ "CONTAINS_OP", "'loop' not in classes" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.target" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.test" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_METHOD", "tokens.get_text_range" ], [ "LOAD_FAST", "target" ], [ "CALL_METHOD", "tokens.get_text_range(target)" ], [ "LOAD_FAST", "func_start" ], [ "LOAD_FAST", "func_start" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "CALL_FUNCTION_KW", "dict(\n tree_index=node._tree_index,\n start=start,\n end=end\n )" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_METHOD", "tokens.get_text_range" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "tokens.get_text_range(node)" ], [ "LOAD_FAST", "func_start" ], [ "LOAD_FAST", "func_start" ], [ "LOAD_FAST", "start" ], [ "COMPARE_OP", "start < 0" ], [ "LOAD_FAST", "end" ], [ "COMPARE_OP", "end < 0" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(node, ast.FunctionDef)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._depth" ], [ "LOAD_FAST", "classes" ], [ "CALL_FUNCTION_KW", "dict(\n tree_index=node._tree_index,\n start=start,\n end=end,\n depth=node._depth,\n classes=classes,\n )" ], [ "LOAD_FAST", "h" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "name" ], [ "BINARY_ADD", "filename + name" ], [ "LOAD_FAST", "html_body" ], [ "BINARY_ADD", "filename + name + html_body" ], [ "LOAD_FAST", "data" ], [ "BINARY_ADD", "filename + name + html_body + data" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "start_lineno" ], [ "CALL_FUNCTION", "str(start_lineno)" ], [ "BINARY_ADD", "filename + name + html_body + data + str(start_lineno)" ], [ "CALL_FUNCTION", "h(filename + name + html_body + data + str(start_lineno))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.db" ], [ "LOAD_ATTR", "self.db.Function" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.db" ], [ "LOAD_METHOD", "self.db.session_scope" ], [ "CALL_METHOD", "self.db.session_scope()" ], [ "LOAD_GLOBAL", "one_or_none" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.query" ], [ "LOAD_FAST", "Function" ], [ "CALL_METHOD", "session.query(Function)" ], [ "LOAD_ATTR", "session.query(Function).filter_by" ], [ "LOAD_FAST", "function_hash" ], [ "CALL_FUNCTION_KW", "session.query(Function).filter_by(hash=function_hash)" ], [ "CALL_FUNCTION", "one_or_none(session.query(Function).filter_by(hash=function_hash))" ], [ "LOAD_FAST", "db_func" ], [ "LOAD_FAST", "Function" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "typ" ], [ "LOAD_FAST", "html_body" ], [ "LOAD_FAST", "start_lineno" ], [ "LOAD_FAST", "data" ], [ "LOAD_FAST", "h" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "h(source)" ], [ "LOAD_FAST", "function_hash" ], [ "CALL_FUNCTION_KW", "Function(file=filename,\n name=name,\n type=typ,\n html_body=html_body,\n lineno=start_lineno,\n data=data,\n body_hash=h(source),\n hash=function_hash)" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.add" ], [ "LOAD_FAST", "db_func" ], [ "CALL_METHOD", "session.add(db_func)" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.commit" ], [ "CALL_METHOD", "session.commit()" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "db_func" ], [ "LOAD_ATTR", "db_func.id" ], [ "LOAD_GLOBAL", "int" ], [ "CALL_FUNCTION", "isinstance(db_func.id, int)" ], [ "LOAD_FAST", "db_func" ], [ "LOAD_ATTR", "db_func.id" ], [ "LOAD_GLOBAL", "hashlib" ], [ "LOAD_METHOD", "hashlib.sha256" ], [ "LOAD_FAST", "s" ], [ "LOAD_METHOD", "s.encode" ], [ "CALL_METHOD", "s.encode('utf8')" ], [ "CALL_METHOD", "hashlib.sha256(s.encode('utf8'))" ], [ "LOAD_METHOD", "hashlib.sha256(s.encode('utf8')).hexdigest" ], [ "CALL_METHOD", "hashlib.sha256(s.encode('utf8')).hexdigest()" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.nodes" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "CALL_FUNCTION", "isinstance(node, (ast.While, ast.For, ast.comprehension))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.GeneratorExp" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.GeneratorExp)" ], [ "LOAD_FAST", "classes" ], [ "LOAD_METHOD", "classes.append" ], [ "CALL_METHOD", "classes.append('loop')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "CALL_FUNCTION", "isinstance(node, ast.stmt)" ], [ "LOAD_FAST", "classes" ], [ "LOAD_METHOD", "classes.append" ], [ "CALL_METHOD", "classes.append('stmt')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "CALL_FUNCTION", "isinstance(node, ast.expr)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._is_interesting_expression" ], [ "LOAD_FAST", "classes" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.AST" ], [ "CALL_FUNCTION", "isinstance(node, ast.AST)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "hasattr(node, 'first_token')" ], [ "LOAD_FAST", "start_lineno" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.first_token" ], [ "LOAD_ATTR", "node.first_token.start" ], [ "BINARY_SUBSCR", "node.first_token.start[0]" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.tokens" ], [ "LOAD_METHOD", "traced_file.tokens.get_text_range" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "traced_file.tokens.get_text_range(node)" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "classes" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.root" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.walk" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.root" ], [ "CALL_METHOD", "ast.walk(traced_file.root)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.iter_child_nodes" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.iter_child_nodes(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._depth" ], [ "BINARY_ADD", "node._depth + 1" ], [ "LOAD_FAST", "child" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "positions" ], [ "LOAD_METHOD", "positions.extend" ], [ "LOAD_GLOBAL", "map" ], [ "LOAD_GLOBAL", "HTMLPosition" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._depth" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._depth" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_METHOD", "' '.join" ], [ "LOAD_FAST", "classes" ], [ "CALL_METHOD", "' '.join(classes)" ], [ "BINARY_MODULO", "'' % (node._tree_index, ' '.join(classes))" ], [ "CALL_FUNCTION", "map(\n HTMLPosition,\n [start, end],\n [True, False], # is_start\n [node._depth, node._depth],\n ['' % (node._tree_index, ' '.join(classes)),\n ''])" ], [ "CALL_METHOD", "positions.extend(map(\n HTMLPosition,\n [start, end],\n [True, False], # is_start\n [node._depth, node._depth],\n ['' % (node._tree_index, ' '.join(classes)),\n '']))" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._separate_comprehensions" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_FAST", "positions" ], [ "LOAD_FAST", "traced_file" ], [ "CALL_METHOD", "self._separate_comprehensions(\n [n[0] for n in nodes],\n end_lineno, positions, traced_file)" ], [ "LOAD_FAST", "positions" ], [ "LOAD_METHOD", "positions.append" ], [ "LOAD_GLOBAL", "HTMLPosition" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.source" ], [ "CALL_FUNCTION", "len(traced_file.source)" ], [ "CALL_FUNCTION", "HTMLPosition(len(traced_file.source), False, 0, '')" ], [ "CALL_METHOD", "positions.append(HTMLPosition(len(traced_file.source), False, 0, ''))" ], [ "LOAD_FAST", "positions" ], [ "LOAD_METHOD", "positions.sort" ], [ "CALL_METHOD", "positions.sort()" ], [ "LOAD_FAST", "positions" ], [ "LOAD_FAST", "html_parts" ], [ "LOAD_METHOD", "html_parts.append" ], [ "LOAD_GLOBAL", "html" ], [ "LOAD_METHOD", "html.escape" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.source" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "position" ], [ "LOAD_ATTR", "position.index" ], [ "BINARY_SUBSCR", "traced_file.source[start:position.index]" ], [ "CALL_METHOD", "html.escape(traced_file.source[start:position.index])" ], [ "CALL_METHOD", "html_parts.append(html.escape(traced_file.source[start:position.index]))" ], [ "LOAD_FAST", "html_parts" ], [ "LOAD_METHOD", "html_parts.append" ], [ "LOAD_FAST", "position" ], [ "LOAD_ATTR", "position.html" ], [ "CALL_METHOD", "html_parts.append(position.html)" ], [ "LOAD_FAST", "position" ], [ "LOAD_ATTR", "position.index" ], [ "LOAD_METHOD", "''.join" ], [ "LOAD_FAST", "html_parts" ], [ "CALL_METHOD", "''.join(html_parts)" ], [ "LOAD_METHOD", "'\\n'.join" ], [ "LOAD_FAST", "html_body" ], [ "LOAD_METHOD", "html_body.split" ], [ "CALL_METHOD", "html_body.split('\\n')" ], [ "LOAD_FAST", "start_lineno" ], [ "BINARY_SUBTRACT", "start_lineno - 1" ], [ "LOAD_FAST", "end_lineno" ], [ "BINARY_SUBTRACT", "end_lineno - 1" ], [ "BINARY_SUBSCR", "html_body.split('\\n')[start_lineno - 1:end_lineno - 1]" ], [ "CALL_METHOD", "'\\n'.join(html_body.split('\\n')[start_lineno - 1:end_lineno - 1])" ], [ "LOAD_FAST", "html_body" ], [ "LOAD_METHOD", "html_body.strip" ], [ "CALL_METHOD", "html_body.strip('\\n')" ], [ "LOAD_FAST", "n" ], [ "BINARY_SUBSCR", "n[0]" ], [ "LOAD_GLOBAL", "group_by_key_func" ], [ "LOAD_GLOBAL", "of_type" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "LOAD_FAST", "nodes" ], [ "CALL_FUNCTION", "of_type((ast.comprehension, ast.While, ast.For), nodes)" ], [ "CALL_FUNCTION", "group_by_key_func(of_type((ast.comprehension, ast.While, ast.For), nodes),\n lambda c: c.first_token.start[0]\n )" ], [ "LOAD_FAST", "comprehensions" ], [ "LOAD_METHOD", "comprehensions.values" ], [ "CALL_METHOD", "comprehensions.values()" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_FAST", "comp_list" ], [ "CALL_FUNCTION_KW", "sorted(comp_list, key=lambda c: c.first_token.startpos)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "comp" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "CALL_FUNCTION", "isinstance(comp, ast.comprehension)" ], [ "LOAD_FAST", "comp" ], [ "LOAD_FAST", "comp" ], [ "LOAD_ATTR", "comp.parent" ], [ "LOAD_ATTR", "comp.parent.generators" ], [ "BINARY_SUBSCR", "comp.parent.generators[0]" ], [ "IS_OP", "comp is comp.parent.generators[0]" ], [ "LOAD_FAST", "get_start" ], [ "LOAD_FAST", "comp" ], [ "LOAD_ATTR", "comp.parent" ], [ "CALL_FUNCTION", "get_start(comp.parent)" ], [ "LOAD_FAST", "prev_start" ], [ "IS_OP", "prev_start is not None" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "prev_start" ], [ "COMPARE_OP", "start < prev_start" ], [ "LOAD_FAST", "get_start" ], [ "LOAD_FAST", "comp" ], [ "CALL_FUNCTION", "get_start(comp)" ], [ "LOAD_FAST", "get_start" ], [ "LOAD_FAST", "comp" ], [ "CALL_FUNCTION", "get_start(comp)" ], [ "LOAD_FAST", "prev_start" ], [ "IS_OP", "prev_start is not None" ], [ "LOAD_FAST", "positions" ], [ "LOAD_METHOD", "positions.append" ], [ "LOAD_GLOBAL", "HTMLPosition" ], [ "LOAD_FAST", "start" ], [ "CALL_FUNCTION", "HTMLPosition(start, True, 0, '\\n ')" ], [ "CALL_METHOD", "positions.append(HTMLPosition(start, True, 0, '\\n '))" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.first_token" ], [ "LOAD_ATTR", "c.first_token.start" ], [ "BINARY_SUBSCR", "c.first_token.start[0]" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.tokens" ], [ "LOAD_METHOD", "traced_file.tokens.get_text_range" ], [ "LOAD_FAST", "n" ], [ "CALL_METHOD", "traced_file.tokens.get_text_range(n)" ], [ "BINARY_SUBSCR", "traced_file.tokens.get_text_range(n)[0]" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.first_token" ], [ "LOAD_ATTR", "c.first_token.startpos" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "_deep_dict" ], [ "CALL_FUNCTION", "defaultdict(_deep_dict)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_GLOBAL", "_bad_codes" ], [ "CONTAINS_OP", "frame.f_code in _bad_codes" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "IterationList" ], [ "CALL_FUNCTION", "defaultdict(IterationList)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.index" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.loops" ], [ "LOAD_METHOD", "self.loops.items" ], [ "CALL_METHOD", "self.loops.items()" ], [ "LOAD_FAST", "tree_index" ], [ "LOAD_FAST", "iteration_list" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_METHOD", "iteration.extract_iterations" ], [ "CALL_METHOD", "iteration.extract_iterations()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "deque" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.side_len" ], [ "CALL_FUNCTION_KW", "deque(maxlen=self.side_len)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "Counter" ], [ "CALL_FUNCTION", "Counter()" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.length" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.side_len" ], [ "COMPARE_OP", "self.length < self.side_len" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start" ], [ "LOAD_METHOD", "self.start.append" ], [ "LOAD_FAST", "iteration" ], [ "CALL_METHOD", "self.start.append(iteration)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "CALL_FUNCTION", "len(self.end)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.side_len" ], [ "COMPARE_OP", "len(self.end) >= self.side_len" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "BINARY_SUBSCR", "self.end[0]" ], [ "LOAD_ATTR", "self.end[0].keep" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start" ], [ "LOAD_METHOD", "self.start.append" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "BINARY_SUBSCR", "self.end[0]" ], [ "CALL_METHOD", "self.start.append(self.end[0])" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "LOAD_METHOD", "self.end.append" ], [ "LOAD_FAST", "iteration" ], [ "CALL_METHOD", "self.end.append(iteration)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.length" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "chain" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "CALL_FUNCTION", "chain(self.start, self.end)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "BINARY_SUBSCR", "self.end[-1]" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start" ], [ "BINARY_SUBSCR", "self.start[-1]" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.recorded" ], [ "LOAD_FAST", "node" ], [ "BINARY_SUBSCR", "self.recorded[node]" ], [ "COMPARE_OP", "self.recorded[node] >= 2" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.last" ], [ "CALL_METHOD", "self.last()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.recorded" ], [ "LOAD_FAST", "node" ], [ "LOAD_NAME", "type" ], [ "CALL_FUNCTION", "type(None)" ], [ "LOAD_NAME", "bool" ], [ "LOAD_NAME", "int" ], [ "LOAD_NAME", "float" ], [ "LOAD_NAME", "complex" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "long" ], [ "LOAD_NAME", "basic_types" ], [ "LOAD_NAME", "list" ], [ "LOAD_NAME", "dict" ], [ "LOAD_NAME", "tuple" ], [ "LOAD_NAME", "set" ], [ "LOAD_NAME", "frozenset" ], [ "LOAD_NAME", "str" ], [ "BINARY_ADD", "basic_types + (list, dict, tuple, set, frozenset, str)" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "unicode" ], [ "LOAD_NAME", "bytes" ], [ "LOAD_NAME", "len" ], [ "LOAD_NAME", "special_types" ], [ "CALL_FUNCTION", "len(special_types)" ], [ "LOAD_GLOBAL", "Lock" ], [ "CALL_FUNCTION", "Lock()" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "CALL_FUNCTION", "defaultdict(lambda: len(self.data))" ], [ "LOAD_DEREF", "self" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.special_types" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.data" ], [ "LOAD_FAST", "t" ], [ "BINARY_SUBSCR", "self.data[t]" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.data" ], [ "CALL_FUNCTION", "len(self.data)" ], [ "LOAD_GLOBAL", "correct_type" ], [ "LOAD_FAST", "item" ], [ "CALL_FUNCTION", "correct_type(item)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.lock" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.data" ], [ "LOAD_FAST", "t" ], [ "BINARY_SUBSCR", "self.data[t]" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.data" ], [ "LOAD_METHOD", "self.data.items" ], [ "CALL_METHOD", "self.data.items()" ], [ "CALL_FUNCTION", "dict((v, k) for k, v in self.data.items())" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_DEREF", "rev" ], [ "CALL_FUNCTION", "len(rev)" ], [ "CALL_FUNCTION", "range(len(rev))" ], [ "LOAD_FAST", "v" ], [ "LOAD_FAST", "k" ], [ "LOAD_GLOBAL", "safe_qualname" ], [ "LOAD_DEREF", "rev" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "rev[i]" ], [ "CALL_FUNCTION", "safe_qualname(rev[i])" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_FAST", "val_repr" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "type_index" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.meta" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.meta" ], [ "LOAD_FAST", "key" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.children" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.children" ], [ "LOAD_METHOD", "self.children.append" ], [ "LOAD_FAST", "key" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOAD_METHOD", "NodeValue.expression" ], [ "LOAD_FAST", "samples" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "level" ], [ "CALL_METHOD", "NodeValue.expression(samples, value, level)" ], [ "CALL_METHOD", "self.children.append((key, NodeValue.expression(samples, value, level)))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.val_repr" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.type_index" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.meta" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.children" ], [ "LOAD_FAST", "result" ], [ "LOAD_METHOD", "result.extend" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.children" ], [ "CALL_METHOD", "result.extend(self.children)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "cls" ], [ "CALL_FUNCTION", "cls('', -2)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_GLOBAL", "exception_string" ], [ "LOAD_FAST", "exc_value" ], [ "CALL_FUNCTION", "exception_string(exc_value)" ], [ "CALL_FUNCTION", "cls(exception_string(exc_value), -1)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "cheap_repr(val)" ], [ "LOAD_GLOBAL", "type_registry" ], [ "LOAD_FAST", "val" ], [ "BINARY_SUBSCR", "type_registry[val]" ], [ "CALL_FUNCTION", "cls(cheap_repr(val), type_registry[val])" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "TypeRegistry" ], [ "LOAD_ATTR", "TypeRegistry.basic_types" ], [ "LOAD_GLOBAL", "BirdsEye" ], [ "CALL_FUNCTION", "isinstance(val, (TypeRegistry.basic_types, BirdsEye))" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "QuerySet" ], [ "CALL_FUNCTION", "isinstance(val, QuerySet)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "len(val)" ], [ "LOAD_FAST", "result" ], [ "LOAD_METHOD", "result.set_meta" ], [ "LOAD_FAST", "length" ], [ "CALL_METHOD", "result.set_meta('len', length)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "ModuleType" ], [ "CALL_FUNCTION", "isinstance(val, ModuleType)" ], [ "LOAD_GLOBAL", "min" ], [ "LOAD_FAST", "level" ], [ "CALL_FUNCTION", "min(level, 2)" ], [ "LOAD_GLOBAL", "partial" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.add_child" ], [ "LOAD_FAST", "samples" ], [ "LOAD_FAST", "level" ], [ "BINARY_SUBTRACT", "level - 1" ], [ "CALL_FUNCTION", "partial(result.add_child, samples, level - 1)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Series" ], [ "LOAD_GLOBAL", "ndarray" ], [ "CALL_FUNCTION", "isinstance(val, (Series, ndarray))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "ndarray" ], [ "CALL_FUNCTION", "isinstance(val, ndarray)" ], [ "LOAD_FAST", "attrs" ], [ "LOAD_METHOD", "attrs.append" ], [ "CALL_METHOD", "attrs.append('shape')" ], [ "LOAD_FAST", "attrs" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "val" ], [ "LOAD_FAST", "name" ], [ "CALL_FUNCTION", "getattr(val, name)" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "attr" ], [ "CALL_FUNCTION", "add_child(name, attr)" ], [ "LOAD_FAST", "level" ], [ "COMPARE_OP", "level >= 3" ], [ "LOAD_FAST", "level" ], [ "COMPARE_OP", "level >= 2" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Series" ], [ "CALL_FUNCTION", "isinstance(val, Series)" ], [ "LOAD_FAST", "samples" ], [ "LOAD_FAST", "sample_type" ], [ "BINARY_SUBSCR", "samples[sample_type]" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "DataFrame" ], [ "CALL_FUNCTION", "isinstance(val, DataFrame)" ], [ "LOAD_FAST", "result" ], [ "LOAD_METHOD", "result.set_meta" ], [ "LOAD_FAST", "meta" ], [ "CALL_METHOD", "result.set_meta('dataframe', meta)" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['pandas_rows']" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['pandas_cols']" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_rows" ], [ "BINARY_ADD", "max_rows + 2" ], [ "COMPARE_OP", "length > max_rows + 2" ], [ "LOAD_FAST", "max_rows" ], [ "BINARY_FLOOR_DIVIDE", "max_rows // 2" ], [ "LOAD_FAST", "meta" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.columns" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "columns" ], [ "CALL_FUNCTION", "len(columns)" ], [ "LOAD_FAST", "num_cols" ], [ "LOAD_FAST", "max_cols" ], [ "BINARY_ADD", "max_cols + 2" ], [ "COMPARE_OP", "num_cols > max_cols + 2" ], [ "LOAD_FAST", "max_cols" ], [ "BINARY_FLOOR_DIVIDE", "max_cols // 2" ], [ "LOAD_FAST", "meta" ], [ "LOAD_GLOBAL", "set" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "num_cols" ], [ "LOAD_FAST", "max_cols" ], [ "CALL_FUNCTION", "_sample_indices(num_cols, max_cols)" ], [ "CALL_FUNCTION", "set(_sample_indices(num_cols, max_cols))" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_GLOBAL", "zip" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.columns" ], [ "LOAD_ATTR", "val.columns.format" ], [ "CALL_FUNCTION_KW", "val.columns.format(sparsify=False)" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.columns" ], [ "CALL_FUNCTION", "zip(val.columns.format(sparsify=False),\n val.columns)" ], [ "CALL_FUNCTION", "enumerate(zip(val.columns.format(sparsify=False),\n val.columns))" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "indices" ], [ "CONTAINS_OP", "i in indices" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_FAST", "formatted_name" ], [ "LOAD_FAST", "val" ], [ "LOAD_FAST", "label" ], [ "BINARY_SUBSCR", "val[label]" ], [ "CALL_FUNCTION", "add_child(formatted_name, val[label])" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Series" ], [ "CALL_FUNCTION", "isinstance(val, Series)" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['pandas_rows']" ], [ "CALL_FUNCTION", "_sample_indices(length, samples['pandas_rows'])" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.index" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "val.index[i:i + 1]" ], [ "LOAD_ATTR", "val.index[i:i + 1].format" ], [ "CALL_FUNCTION_KW", "val.index[i:i + 1].format(sparsify=False)" ], [ "BINARY_SUBSCR", "val.index[i:i + 1].format(sparsify=False)[0]" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.iloc" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "val.iloc[i]" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_FAST", "k" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child(k, v)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "level" ], [ "COMPARE_OP", "level <= 0" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "bytes" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "unicode" ], [ "LOAD_GLOBAL", "xrange" ], [ "CALL_FUNCTION", "isinstance(val,\n (str, bytes, range)\n if PY3 else\n (str, unicode, xrange))" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Sequence" ], [ "LOAD_GLOBAL", "ndarray" ], [ "CALL_FUNCTION", "isinstance(val, (Sequence, ndarray))" ], [ "LOAD_FAST", "length" ], [ "IS_OP", "length is not None" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['list']" ], [ "CALL_FUNCTION", "_sample_indices(length, samples['list'])" ], [ "LOAD_FAST", "val" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "val[i]" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "i" ], [ "CALL_FUNCTION", "str(i)" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child(str(i), v)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Mapping" ], [ "CALL_FUNCTION", "isinstance(val, Mapping)" ], [ "LOAD_GLOBAL", "islice" ], [ "LOAD_GLOBAL", "_safe_iter" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "iteritems" ], [ "CALL_FUNCTION", "_safe_iter(val, iteritems)" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['dict']" ], [ "CALL_FUNCTION", "islice(_safe_iter(val, iteritems), samples['dict'])" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "k" ], [ "CALL_FUNCTION", "cheap_repr(k)" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child(cheap_repr(k), v)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Set" ], [ "CALL_FUNCTION", "isinstance(val, Set)" ], [ "LOAD_GLOBAL", "_safe_iter" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "_safe_iter(val)" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['set']" ], [ "LOAD_FAST", "length" ], [ "IS_OP", "length is None" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "num_items" ], [ "BINARY_ADD", "num_items + 2" ], [ "COMPARE_OP", "length > num_items + 2" ], [ "LOAD_GLOBAL", "islice" ], [ "LOAD_FAST", "vals" ], [ "LOAD_FAST", "num_items" ], [ "CALL_FUNCTION", "islice(vals, num_items)" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "vals" ], [ "CALL_FUNCTION", "enumerate(vals)" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_FAST", "i" ], [ "BINARY_MODULO", "'<%s>' % i" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child('<%s>' % i, v)" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "getattr(val, '__dict__', None)" ], [ "LOAD_FAST", "d" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_GLOBAL", "islice" ], [ "LOAD_GLOBAL", "_safe_iter" ], [ "LOAD_FAST", "d" ], [ "CALL_FUNCTION", "_safe_iter(d)" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['attributes']" ], [ "CALL_FUNCTION", "islice(_safe_iter(d),\n samples['attributes'])" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION_KW", "sorted(islice(_safe_iter(d),\n samples['attributes']),\n key=str)" ], [ "LOAD_FAST", "d" ], [ "LOAD_FAST", "k" ], [ "BINARY_SUBSCR", "d[k]" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "TracedFile" ], [ "CALL_FUNCTION", "isinstance(v, TracedFile)" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "k" ], [ "CALL_FUNCTION", "str(k)" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child(str(k), v)" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "type" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "type(val)" ], [ "CALL_FUNCTION", "getattr(type(val), '__slots__', None)" ], [ "CALL_FUNCTION", "sorted(getattr(type(val), '__slots__', None) or ())" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "val" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "getattr(val, s)" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "str(s)" ], [ "LOAD_FAST", "attr" ], [ "CALL_FUNCTION", "add_child(str(s), attr)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "x" ], [ "LOAD_FAST", "f" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "f(val)" ], [ "LOAD_FAST", "x" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_ADD", "max_length + 2" ], [ "COMPARE_OP", "length <= max_length + 2" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "range(length)" ], [ "LOAD_GLOBAL", "chain" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_FLOOR_DIVIDE", "max_length // 2" ], [ "CALL_FUNCTION", "range(max_length // 2)" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_FLOOR_DIVIDE", "max_length // 2" ], [ "BINARY_SUBTRACT", "length - max_length // 2" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "range(length - max_length // 2,\n length)" ], [ "CALL_FUNCTION", "chain(range(max_length // 2),\n range(length - max_length // 2,\n length))" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "len(x)" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "n == 0" ], [ "LOAD_GLOBAL", "repr" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "repr(x)" ], [ "LOAD_FAST", "helper" ], [ "LOAD_ATTR", "helper.level" ], [ "BINARY_SUBTRACT", "helper.level - 1" ], [ "LOAD_GLOBAL", "_repr_series_one_line" ], [ "LOAD_ATTR", "_repr_series_one_line.maxparts" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "n" ], [ "LOAD_FAST", "maxparts" ], [ "CALL_FUNCTION", "_sample_indices(n, maxparts)" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.index" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "x.index[i:i + 1]" ], [ "LOAD_ATTR", "x.index[i:i + 1].format" ], [ "CALL_FUNCTION_KW", "x.index[i:i + 1].format(sparsify=False)" ], [ "BINARY_SUBSCR", "x.index[i:i + 1].format(sparsify=False)[0]" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.iloc" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "x.iloc[i]" ], [ "LOAD_FAST", "pieces" ], [ "LOAD_METHOD", "pieces.append" ], [ "LOAD_FAST", "k" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "v" ], [ "LOAD_FAST", "newlevel" ], [ "CALL_FUNCTION", "cheap_repr(v, newlevel)" ], [ "BINARY_MODULO", "'%s = %s' % (k, cheap_repr(v, newlevel))" ], [ "CALL_METHOD", "pieces.append('%s = %s' % (k, cheap_repr(v, newlevel)))" ], [ "LOAD_FAST", "n" ], [ "LOAD_FAST", "maxparts" ], [ "BINARY_ADD", "maxparts + 2" ], [ "COMPARE_OP", "n > maxparts + 2" ], [ "LOAD_FAST", "pieces" ], [ "LOAD_METHOD", "pieces.insert" ], [ "LOAD_FAST", "maxparts" ], [ "BINARY_FLOOR_DIVIDE", "maxparts // 2" ], [ "CALL_METHOD", "pieces.insert(maxparts // 2, '...')" ], [ "LOAD_METHOD", "'; '.join" ], [ "LOAD_FAST", "pieces" ], [ "CALL_METHOD", "'; '.join(pieces)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "CALL_FUNCTION", "isinstance(node, ast.expr)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Num" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Str" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "ast" ], [ "CALL_FUNCTION", "getattr(ast, 'NameConstant', ())" ], [ "CALL_FUNCTION", "isinstance(node, (ast.Num, ast.Str, getattr(ast, 'NameConstant', ())))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "getattr(node, 'ctx', None)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Store" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Del" ], [ "CALL_FUNCTION", "isinstance(getattr(node, 'ctx', None),\n (ast.Store, ast.Del))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.UnaryOp" ], [ "CALL_FUNCTION", "isinstance(node, ast.UnaryOp)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.op" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.UAdd" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.USub" ], [ "CALL_FUNCTION", "isinstance(node.op, (ast.UAdd, ast.USub))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.operand" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Num" ], [ "CALL_FUNCTION", "isinstance(node.operand, ast.Num)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.List" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Tuple" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Dict" ], [ "CALL_FUNCTION", "isinstance(node, (ast.List, ast.Tuple, ast.Dict))" ], [ "LOAD_GLOBAL", "any" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.iter_child_nodes" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.iter_child_nodes(node)" ], [ "CALL_FUNCTION", "any(is_interesting_expression(n) for n in ast.iter_child_nodes(node))" ], [ "UNARY_NOT", "not any(is_interesting_expression(n) for n in ast.iter_child_nodes(node))" ], [ "UNARY_NOT", "not (isinstance(node, (ast.Num, ast.Str, getattr(ast, 'NameConstant', ()))) or\n isinstance(getattr(node, 'ctx', None),\n (ast.Store, ast.Del)) or\n (isinstance(node, ast.UnaryOp) and\n isinstance(node.op, (ast.UAdd, ast.USub)) and\n isinstance(node.operand, ast.Num)) or\n (isinstance(node, (ast.List, ast.Tuple, ast.Dict)) and\n not any(is_interesting_expression(n) for n in ast.iter_child_nodes(node))))" ], [ "LOAD_GLOBAL", "is_interesting_expression" ], [ "LOAD_FAST", "n" ], [ "CALL_FUNCTION", "is_interesting_expression(n)" ], [ "LOAD_GLOBAL", "cast" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "__builtins__" ], [ "CALL_FUNCTION", "cast(dict, __builtins__)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Name" ], [ "CALL_FUNCTION", "isinstance(node, ast.Name)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.id" ], [ "LOAD_FAST", "builtins" ], [ "CONTAINS_OP", "node.id in builtins" ], [ "LOAD_FAST", "builtins" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.id" ], [ "BINARY_SUBSCR", "builtins[node.id]" ], [ "LOAD_FAST", "value" ], [ "IS_OP", "builtins[node.id] is value" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "ast" ], [ "CALL_FUNCTION", "getattr(ast, 'NameConstant', ())" ], [ "CALL_FUNCTION", "isinstance(node, getattr(ast, 'NameConstant', ()))" ] ], "configuration.py": [ [ "LOAD_NAME", "ctypes" ], [ "LOAD_ATTR", "ctypes.windll" ], [ "LOAD_ATTR", "ctypes.windll.kernel32" ], [ "LOAD_NAME", "kernel32" ], [ "LOAD_METHOD", "kernel32.SetConsoleMode" ], [ "LOAD_NAME", "kernel32" ], [ "LOAD_METHOD", "kernel32.GetStdHandle" ], [ "CALL_METHOD", "kernel32.GetStdHandle(-11)" ], [ "CALL_METHOD", "kernel32.SetConsoleMode(kernel32.GetStdHandle(-11), 7)" ], [ "LOAD_NAME", "Exception" ], [ "LOAD_NAME", "os" ], [ "LOAD_ATTR", "os.name" ], [ "COMPARE_OP", "os.name != 'nt'" ], [ "LOAD_NAME", "DefaultFormatter" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "object" ], [ "LOAD_FAST", "builtins" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_GLOBAL", "builtins_module" ], [ "LOAD_FAST", "snoop" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.snoop" ], [ "CALL_FUNCTION", "setattr(builtins_module, snoop, package.snoop)" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_GLOBAL", "builtins_module" ], [ "LOAD_FAST", "pp" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.pp" ], [ "CALL_FUNCTION", "setattr(builtins_module, pp, package.pp)" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_GLOBAL", "builtins_module" ], [ "LOAD_FAST", "spy" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.spy" ], [ "CALL_FUNCTION", "setattr(builtins_module, spy, package.spy)" ], [ "LOAD_GLOBAL", "Config" ], [ "LOAD_FAST", "out" ], [ "LOAD_FAST", "prefix" ], [ "LOAD_FAST", "columns" ], [ "LOAD_FAST", "overwrite" ], [ "LOAD_FAST", "color" ], [ "LOAD_FAST", "enabled" ], [ "LOAD_FAST", "watch_extras" ], [ "LOAD_FAST", "replace_watch_extras" ], [ "LOAD_FAST", "formatter_class" ], [ "CALL_FUNCTION_KW", "Config(\n out=out,\n prefix=prefix,\n columns=columns,\n overwrite=overwrite,\n color=color,\n enabled=enabled,\n watch_extras=watch_extras,\n replace_watch_extras=replace_watch_extras,\n formatter_class=formatter_class,\n )" ], [ "LOAD_FAST", "config" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.snoop" ], [ "LOAD_FAST", "config" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.pp" ], [ "LOAD_FAST", "config" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.spy" ], [ "LOAD_NAME", "DefaultFormatter" ], [ "LOAD_GLOBAL", "can_color" ], [ "LOAD_FAST", "color" ], [ "IS_OP", "color is None" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "out" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.stderr" ], [ "CALL_FUNCTION", "getattr(out or sys.stderr, 'isatty', lambda: False)" ], [ "LOAD_GLOBAL", "bool" ], [ "LOAD_FAST", "isatty" ], [ "CALL_FUNCTION", "isatty()" ], [ "CALL_FUNCTION", "bool(isatty())" ], [ "LOAD_GLOBAL", "get_write_function" ], [ "LOAD_FAST", "out" ], [ "LOAD_FAST", "overwrite" ], [ "CALL_FUNCTION", "get_write_function(out, overwrite)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "formatter_class" ], [ "LOAD_FAST", "prefix" ], [ "LOAD_FAST", "columns" ], [ "LOAD_FAST", "color" ], [ "CALL_FUNCTION", "formatter_class(prefix, columns, color)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "enabled" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "PP" ], [ "LOAD_DEREF", "self" ], [ "CALL_FUNCTION", "PP(self)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "Tracer" ], [ "LOAD_FAST", "ConfiguredTracer" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "Spy" ], [ "LOAD_DEREF", "self" ], [ "CALL_FUNCTION", "Spy(self)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "threading" ], [ "LOAD_METHOD", "threading.local" ], [ "CALL_METHOD", "threading.local()" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "replace_watch_extras" ], [ "IS_OP", "replace_watch_extras is not None" ], [ "LOAD_GLOBAL", "ensure_tuple" ], [ "LOAD_FAST", "replace_watch_extras" ], [ "CALL_FUNCTION", "ensure_tuple(replace_watch_extras)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "len_shape_watch" ], [ "LOAD_GLOBAL", "dtype_watch" ], [ "LOAD_GLOBAL", "ensure_tuple" ], [ "LOAD_FAST", "watch_extras" ], [ "CALL_FUNCTION", "ensure_tuple(watch_extras)" ], [ "BINARY_ADD", "(len_shape_watch, dtype_watch) + ensure_tuple(watch_extras)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_CLASSDEREF", "self" ], [ "LOAD_FAST", "value" ], [ "LOAD_ATTR", "value.shape" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.ismethod" ], [ "LOAD_FAST", "shape" ], [ "CALL_METHOD", "inspect.ismethod(shape)" ], [ "LOAD_METHOD", "'{}.shape'.format" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "'{}.shape'.format(source)" ], [ "LOAD_FAST", "shape" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "value" ], [ "LOAD_GLOBAL", "QuerySet" ], [ "CALL_FUNCTION", "isinstance(value, QuerySet)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "len(value)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "value" ], [ "LOAD_GLOBAL", "six" ], [ "LOAD_ATTR", "six.string_types" ], [ "CALL_FUNCTION", "isinstance(value, six.string_types)" ], [ "LOAD_FAST", "length" ], [ "COMPARE_OP", "length < 50" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "value" ], [ "LOAD_GLOBAL", "Mapping" ], [ "LOAD_GLOBAL", "Set" ], [ "LOAD_GLOBAL", "Sequence" ], [ "CALL_FUNCTION", "isinstance(value, (Mapping, Set, Sequence))" ], [ "LOAD_FAST", "length" ], [ "COMPARE_OP", "length == 0" ], [ "LOAD_METHOD", "'len({})'.format" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "'len({})'.format(source)" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "value" ], [ "LOAD_ATTR", "value.dtype" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.ismethod" ], [ "LOAD_FAST", "dtype" ], [ "CALL_METHOD", "inspect.ismethod(dtype)" ], [ "LOAD_METHOD", "'{}.dtype'.format" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "'{}.dtype'.format(source)" ], [ "LOAD_FAST", "dtype" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_DEREF", "output" ], [ "LOAD_GLOBAL", "six" ], [ "LOAD_ATTR", "six.string_types" ], [ "CALL_FUNCTION", "isinstance(output, six.string_types)" ], [ "LOAD_GLOBAL", "is_pathlike" ], [ "LOAD_DEREF", "output" ], [ "CALL_FUNCTION", "is_pathlike(output)" ], [ "LOAD_FAST", "is_path" ], [ "LOAD_GLOBAL", "FileWriter" ], [ "LOAD_DEREF", "output" ], [ "LOAD_FAST", "overwrite" ], [ "CALL_FUNCTION", "FileWriter(output, overwrite)" ], [ "LOAD_ATTR", "FileWriter(output, overwrite).write" ], [ "LOAD_GLOBAL", "callable" ], [ "LOAD_DEREF", "output" ], [ "CALL_FUNCTION", "callable(output)" ], [ "LOAD_DEREF", "output" ], [ "LOAD_FAST", "write" ], [ "LOAD_FAST", "write" ], [ "LOAD_DEREF", "output" ], [ "LOAD_FAST", "stream" ], [ "IS_OP", "stream is None" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.stderr" ], [ "LOAD_FAST", "stream" ], [ "LOAD_METHOD", "stream.write" ], [ "LOAD_FAST", "s" ], [ "CALL_METHOD", "stream.write(s)" ], [ "LOAD_GLOBAL", "UnicodeEncodeError" ], [ "LOAD_FAST", "stream" ], [ "LOAD_METHOD", "stream.write" ], [ "LOAD_GLOBAL", "shitcode" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "shitcode(s)" ], [ "CALL_METHOD", "stream.write(shitcode(s))" ], [ "LOAD_GLOBAL", "six" ], [ "LOAD_METHOD", "six.text_type" ], [ "LOAD_FAST", "path" ], [ "CALL_METHOD", "six.text_type(path)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "overwrite" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "open" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.path" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.overwrite" ], [ "CALL_FUNCTION_KW", "open(self.path, 'w' if self.overwrite else 'a', encoding='utf-8')" ], [ "LOAD_FAST", "f" ], [ "LOAD_METHOD", "f.write" ], [ "LOAD_FAST", "s" ], [ "CALL_METHOD", "f.write(s)" ], [ "LOAD_FAST", "self" ] ], "db.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOAD_METHOD", "standard_library.install_aliases" ], [ "CALL_METHOD", "standard_library.install_aliases()" ], [ "LOAD_NAME", "RESERVED_WORDS" ], [ "LOAD_METHOD", "RESERVED_WORDS.add" ], [ "CALL_METHOD", "RESERVED_WORDS.add('function')" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "retry" ], [ "LOAD_NAME", "InterfaceError" ], [ "LOAD_NAME", "OperationalError" ], [ "LOAD_NAME", "InternalError" ], [ "LOAD_NAME", "ProgrammingError" ], [ "CALL_FUNCTION", "retry(3, (InterfaceError, OperationalError, InternalError, ProgrammingError))" ], [ "LOAD_NAME", "contextmanager" ], [ "CALL_FUNCTION", "contextmanager" ], [ "LOAD_FAST", "db_uri" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.environ" ], [ "LOAD_METHOD", "os.environ.get" ], [ "CALL_METHOD", "os.environ.get('BIRDSEYE_DB')" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_METHOD", "os.path.join" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_METHOD", "os.path.expanduser" ], [ "CALL_METHOD", "os.path.expanduser('~')" ], [ "CALL_METHOD", "os.path.join(os.path.expanduser('~'),\n '.birdseye.db')" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "dict" ], [ "CALL_FUNCTION_KW", "dict(\n pool_recycle=280,\n echo=False, # for convenience when debugging\n )" ], [ "LOAD_GLOBAL", "create_engine" ], [ "LOAD_FAST", "db_uri" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "create_engine(db_uri, **kwargs)" ], [ "LOAD_GLOBAL", "ArgumentError" ], [ "LOAD_FAST", "db_uri" ], [ "BINARY_ADD", "'sqlite:///' + db_uri" ], [ "LOAD_GLOBAL", "create_engine" ], [ "LOAD_FAST", "db_uri" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "create_engine(db_uri, **kwargs)" ], [ "LOAD_FAST", "engine" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "sessionmaker" ], [ "LOAD_FAST", "engine" ], [ "CALL_FUNCTION_KW", "sessionmaker(bind=engine)" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "object" ], [ "LOAD_GLOBAL", "declarative_base" ], [ "LOAD_FAST", "Base" ], [ "CALL_FUNCTION_KW", "declarative_base(cls=Base)" ], [ "LOAD_FAST", "Base" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "object" ], [ "LOAD_FAST", "engine" ], [ "LOAD_ATTR", "engine.name" ], [ "COMPARE_OP", "engine.name == 'mysql'" ], [ "LOAD_GLOBAL", "LONGTEXT" ], [ "LOAD_GLOBAL", "Text" ], [ "LOAD_FAST", "Base" ], [ "LOAD_FAST", "Base" ], [ "LOAD_FAST", "Call" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "Function" ], [ "LOAD_FAST", "self" ], [ "LOAD_DEREF", "KeyValue" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "KeyValueStore" ], [ "CALL_FUNCTION", "KeyValueStore()" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "_skip_version_check" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.table_exists" ], [ "LOAD_FAST", "Function" ], [ "CALL_METHOD", "self.table_exists(Function)" ], [ "LOAD_FAST", "Base" ], [ "LOAD_ATTR", "Base.metadata" ], [ "LOAD_METHOD", "Base.metadata.create_all" ], [ "LOAD_FAST", "engine" ], [ "CALL_METHOD", "Base.metadata.create_all(engine)" ], [ "LOAD_GLOBAL", "DB_VERSION" ], [ "LOAD_FAST", "kv" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.table_exists" ], [ "LOAD_DEREF", "KeyValue" ], [ "CALL_METHOD", "self.table_exists(KeyValue)" ], [ "LOAD_GLOBAL", "int" ], [ "LOAD_FAST", "kv" ], [ "LOAD_ATTR", "kv.version" ], [ "CALL_FUNCTION", "int(kv.version)" ], [ "LOAD_GLOBAL", "DB_VERSION" ], [ "COMPARE_OP", "int(kv.version) < DB_VERSION" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_METHOD", "sys.exit" ], [ "CALL_METHOD", "sys.exit('The birdseye database schema is out of date. '\n 'Run \"python -m birdseye.clear_db\" to delete the existing tables.')" ], [ "LOAD_NAME", "declared_attr" ], [ "CALL_FUNCTION", "declared_attr" ], [ "LOAD_FAST", "cls" ], [ "LOAD_ATTR", "cls.__name__" ], [ "LOAD_METHOD", "cls.__name__.lower" ], [ "CALL_METHOD", "cls.__name__.lower()" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "String" ], [ "CALL_FUNCTION", "String(50)" ], [ "CALL_FUNCTION_KW", "Column(String(50), primary_key=True)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "__getitem__" ], [ "LOAD_NAME", "__setitem__" ], [ "LOAD_DEREF", "db_self" ], [ "LOAD_METHOD", "db_self.session_scope" ], [ "CALL_METHOD", "db_self.session_scope()" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session\n .query" ], [ "LOAD_DEREF", "KeyValue" ], [ "LOAD_ATTR", "KeyValue.value" ], [ "CALL_METHOD", "session\n .query(KeyValue.value)" ], [ "LOAD_ATTR", "session\n .query(KeyValue.value)\n .filter_by" ], [ "LOAD_FAST", "item" ], [ "CALL_FUNCTION_KW", "session\n .query(KeyValue.value)\n .filter_by(key=item)" ], [ "LOAD_METHOD", "session\n .query(KeyValue.value)\n .filter_by(key=item)\n .scalar" ], [ "CALL_METHOD", "session\n .query(KeyValue.value)\n .filter_by(key=item)\n .scalar()" ], [ "LOAD_DEREF", "db_self" ], [ "LOAD_METHOD", "db_self.session_scope" ], [ "CALL_METHOD", "db_self.session_scope()" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.query" ], [ "LOAD_DEREF", "KeyValue" ], [ "CALL_METHOD", "session.query(KeyValue)" ], [ "LOAD_ATTR", "session.query(KeyValue).filter_by" ], [ "LOAD_FAST", "key" ], [ "CALL_FUNCTION_KW", "session.query(KeyValue).filter_by(key=key)" ], [ "LOAD_METHOD", "session.query(KeyValue).filter_by(key=key).delete" ], [ "CALL_METHOD", "session.query(KeyValue).filter_by(key=key).delete()" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.add" ], [ "LOAD_DEREF", "KeyValue" ], [ "LOAD_FAST", "key" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "str(value)" ], [ "CALL_FUNCTION_KW", "KeyValue(key=key, value=str(value))" ], [ "CALL_METHOD", "session.add(KeyValue(key=key, value=str(value)))" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "String" ], [ "CALL_FUNCTION_KW", "String(length=32)" ], [ "CALL_FUNCTION_KW", "Column(String(length=32), primary_key=True)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Integer" ], [ "LOAD_NAME", "ForeignKey" ], [ "CALL_FUNCTION", "ForeignKey('function.id')" ], [ "CALL_FUNCTION_KW", "Column(Integer, ForeignKey('function.id'), index=True)" ], [ "LOAD_NAME", "relationship" ], [ "LOAD_NAME", "backref" ], [ "CALL_FUNCTION_KW", "backref('calls', lazy='dynamic')" ], [ "CALL_FUNCTION_KW", "relationship('Function', backref=backref('calls', lazy='dynamic'))" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_CLASSDEREF", "LongText" ], [ "CALL_FUNCTION", "Column(LongText)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "DateTime" ], [ "CALL_FUNCTION_KW", "Column(DateTime, index=True)" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "id" ], [ "LOAD_NAME", "function_id" ], [ "LOAD_NAME", "return_value" ], [ "LOAD_NAME", "traceback" ], [ "LOAD_NAME", "exception" ], [ "LOAD_NAME", "start_time" ], [ "LOAD_NAME", "arguments" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._pretty_time" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start_time" ], [ "CALL_METHOD", "self._pretty_time(self.start_time)" ], [ "LOAD_FAST", "dt" ], [ "LOAD_GLOBAL", "Markup" ], [ "LOAD_FAST", "dt" ], [ "LOAD_METHOD", "dt.strftime" ], [ "CALL_METHOD", "dt.strftime('%Y-%m-%d %H:%M:%S')" ], [ "LOAD_GLOBAL", "naturaltime" ], [ "LOAD_FAST", "dt" ], [ "CALL_FUNCTION", "naturaltime(dt)" ], [ "BINARY_MODULO", "'%s (%s)' % (\n dt.strftime('%Y-%m-%d %H:%M:%S'),\n naturaltime(dt))" ], [ "CALL_FUNCTION", "Markup('%s (%s)' % (\n dt.strftime('%Y-%m-%d %H:%M:%S'),\n naturaltime(dt)))" ], [ "LOAD_GLOBAL", "Markup" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.success" ], [ "BINARY_MODULO", "'' % (\n ('ok', 'green') if self.success else\n ('remove', 'red'))" ], [ "CALL_FUNCTION", "Markup('' % (\n ('ok', 'green') if self.success else\n ('remove', 'red')))" ], [ "BINARY_MODULO", "'' % (\n ('ok', 'green') if self.success else\n ('remove', 'red'))" ], [ "CALL_FUNCTION", "Markup('' % (\n ('ok', 'green') if self.success else\n ('remove', 'red')))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.exception" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.traceback" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.return_value" ], [ "COMPARE_OP", "self.return_value == 'None'" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.traceback" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.success" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.return_value" ], [ "CALL_FUNCTION", "str(self.return_value)" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.exception" ], [ "CALL_FUNCTION", "str(self.exception)" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_METHOD", "json.loads" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.arguments" ], [ "CALL_METHOD", "json.loads(self.arguments)" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_METHOD", "json.loads" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.data" ], [ "CALL_METHOD", "json.loads(self.data)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.arguments_list" ], [ "LOAD_GLOBAL", "select_attrs" ], [ "LOAD_FAST", "call" ], [ "CALL_FUNCTION", "select_attrs(call, 'id function_id return_value traceback '\n 'exception start_time')" ], [ "CALL_FUNCTION_EX", "dict(arguments=call.arguments_list,\n **select_attrs(call, 'id function_id return_value traceback '\n 'exception start_time'))" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Integer" ], [ "LOAD_NAME", "Sequence" ], [ "CALL_FUNCTION", "Sequence('function_id_seq')" ], [ "CALL_FUNCTION_KW", "Column(Integer, Sequence('function_id_seq'), primary_key=True)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_CLASSDEREF", "LongText" ], [ "CALL_FUNCTION", "Column(LongText)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Integer" ], [ "CALL_FUNCTION", "Column(Integer)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_CLASSDEREF", "LongText" ], [ "CALL_FUNCTION", "Column(LongText)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "String" ], [ "CALL_FUNCTION_KW", "String(length=64)" ], [ "CALL_FUNCTION_KW", "Column(String(length=64), index=True)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "String" ], [ "CALL_FUNCTION_KW", "String(length=64)" ], [ "CALL_FUNCTION_KW", "Column(String(length=64), index=True)" ], [ "LOAD_NAME", "UniqueConstraint" ], [ "CALL_FUNCTION_KW", "UniqueConstraint('hash',\n name='everything_unique')" ], [ "LOAD_NAME", "Index" ], [ "CALL_FUNCTION_KW", "Index('idx_file', 'file', mysql_length=256)" ], [ "LOAD_NAME", "Index" ], [ "CALL_FUNCTION_KW", "Index('idx_name', 'name', mysql_length=32)" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "file" ], [ "LOAD_NAME", "name" ], [ "LOAD_NAME", "lineno" ], [ "LOAD_NAME", "hash" ], [ "LOAD_NAME", "body_hash" ], [ "LOAD_NAME", "type" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_METHOD", "json.loads" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.data" ], [ "CALL_METHOD", "json.loads(self.data)" ], [ "LOAD_GLOBAL", "select_attrs" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "select_attrs(func, 'file name lineno hash body_hash type')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.engine" ], [ "LOAD_ATTR", "self.engine.dialect" ], [ "LOAD_METHOD", "self.engine.dialect.has_table" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.engine" ], [ "LOAD_FAST", "table" ], [ "LOAD_ATTR", "table.__name__" ], [ "CALL_METHOD", "self.engine.dialect.has_table(self.engine, table.__name__)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.session_scope" ], [ "CALL_METHOD", "self.session_scope()" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.query" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.Function" ], [ "LOAD_ATTR", "self.Function.file" ], [ "CALL_METHOD", "session.query(self.Function.file)" ], [ "LOAD_METHOD", "session.query(self.Function.file).distinct" ], [ "CALL_METHOD", "session.query(self.Function.file).distinct()" ], [ "LOAD_FAST", "paths" ], [ "LOAD_METHOD", "paths.sort" ], [ "CALL_METHOD", "paths.sort()" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "paths" ], [ "CONTAINS_OP", "IPYTHON_FILE_PATH in paths" ], [ "LOAD_FAST", "paths" ], [ "LOAD_METHOD", "paths.remove" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "CALL_METHOD", "paths.remove(IPYTHON_FILE_PATH)" ], [ "LOAD_FAST", "paths" ], [ "LOAD_METHOD", "paths.insert" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "CALL_METHOD", "paths.insert(0, IPYTHON_FILE_PATH)" ], [ "LOAD_FAST", "paths" ], [ "LOAD_GLOBAL", "is_ipython_cell" ], [ "LOAD_FAST", "f" ], [ "BINARY_SUBSCR", "f[0]" ], [ "CALL_FUNCTION", "is_ipython_cell(f[0])" ], [ "LOAD_FAST", "f" ], [ "BINARY_SUBSCR", "f[0]" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.Call" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.Function" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._KeyValue" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.table_exists" ], [ "LOAD_FAST", "model" ], [ "CALL_METHOD", "self.table_exists(model)" ], [ "LOAD_FAST", "model" ], [ "LOAD_ATTR", "model.__table__" ], [ "LOAD_METHOD", "model.__table__.drop" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.engine" ], [ "CALL_METHOD", "model.__table__.drop(self.engine)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.Session" ], [ "CALL_METHOD", "self.Session()" ], [ "LOAD_FAST", "session" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.commit" ], [ "CALL_METHOD", "session.commit()" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.rollback" ], [ "CALL_METHOD", "session.rollback()" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.close" ], [ "CALL_METHOD", "session.close()" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.close" ], [ "CALL_METHOD", "session.close()" ], [ "LOAD_GLOBAL", "functools" ], [ "LOAD_METHOD", "functools.wraps" ], [ "LOAD_DEREF", "func" ], [ "CALL_METHOD", "functools.wraps(func)" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "LOAD_GLOBAL", "retry_db" ], [ "LOAD_FAST", "wrapper" ], [ "CALL_FUNCTION", "retry_db(wrapper)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self.session_scope" ], [ "CALL_METHOD", "self.session_scope()" ], [ "LOAD_DEREF", "func" ], [ "LOAD_FAST", "session" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "func(session, *args, **kwargs)" ] ], "executing.py": [ [ "LOAD_NAME", "sys" ], [ "LOAD_ATTR", "sys.version_info" ], [ "BINARY_SUBSCR", "sys.version_info[0]" ], [ "COMPARE_OP", "sys.version_info[0] == 3" ], [ "LOAD_NAME", "PY3" ], [ "LOAD_NAME", "lru_cache" ], [ "CALL_FUNCTION_KW", "lru_cache(maxsize=None)" ], [ "LOAD_NAME", "str" ], [ "LOAD_NAME", "unicode" ], [ "LOAD_NAME", "dis" ], [ "LOAD_ATTR", "dis.get_instructions" ], [ "LOAD_NAME", "AttributeError" ], [ "LOAD_NAME", "namedtuple" ], [ "CALL_FUNCTION", "namedtuple('Instruction', 'offset argval opname')" ], [ "LOAD_NAME", "Exception" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.NodeVisitor" ], [ "LOAD_NAME", "sum" ], [ "LOAD_NAME", "__future__" ], [ "LOAD_ATTR", "__future__.all_feature_names" ], [ "CALL_FUNCTION", "sum(\n getattr(__future__, fname).compiler_flag\n for fname in __future__.all_feature_names\n)" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "RLock" ], [ "CALL_FUNCTION", "RLock()" ], [ "LOAD_NAME", "cache" ], [ "CALL_FUNCTION", "cache" ], [ "LOAD_GLOBAL", "functools" ], [ "LOAD_METHOD", "functools.wraps" ], [ "LOAD_DEREF", "func" ], [ "CALL_METHOD", "functools.wraps(func)" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "LOAD_FAST", "wrapper" ], [ "LOAD_FAST", "args" ], [ "LOAD_DEREF", "d" ], [ "CONTAINS_OP", "args in d" ], [ "LOAD_DEREF", "d" ], [ "LOAD_FAST", "args" ], [ "BINARY_SUBSCR", "d[args]" ], [ "LOAD_DEREF", "func" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION_EX", "func(*args)" ], [ "LOAD_DEREF", "d" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "co" ], [ "LOAD_ATTR", "co.co_code" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "len(code)" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "i < n" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "code[i]" ], [ "LOAD_GLOBAL", "ord" ], [ "LOAD_FAST", "c" ], [ "CALL_FUNCTION", "ord(c)" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "LOAD_FAST", "op" ], [ "LOAD_GLOBAL", "HAVE_ARGUMENT" ], [ "COMPARE_OP", "op >= HAVE_ARGUMENT" ], [ "LOAD_GLOBAL", "ord" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "code[i]" ], [ "CALL_FUNCTION", "ord(code[i])" ], [ "LOAD_GLOBAL", "ord" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "code[i + 1]" ], [ "CALL_FUNCTION", "ord(code[i + 1])" ], [ "BINARY_MULTIPLY", "ord(code[i + 1]) * 256" ], [ "BINARY_ADD", "ord(code[i]) + ord(code[i + 1]) * 256" ], [ "LOAD_FAST", "extended_arg" ], [ "BINARY_ADD", "ord(code[i]) + ord(code[i + 1]) * 256 + extended_arg" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 2" ], [ "LOAD_FAST", "op" ], [ "LOAD_GLOBAL", "EXTENDED_ARG" ], [ "COMPARE_OP", "op == EXTENDED_ARG" ], [ "LOAD_FAST", "oparg" ], [ "BINARY_MULTIPLY", "oparg * 65536" ], [ "LOAD_FAST", "op" ], [ "LOAD_GLOBAL", "hasconst" ], [ "CONTAINS_OP", "op in hasconst" ], [ "LOAD_FAST", "co" ], [ "LOAD_ATTR", "co.co_consts" ], [ "LOAD_FAST", "oparg" ], [ "BINARY_SUBSCR", "co.co_consts[oparg]" ], [ "LOAD_GLOBAL", "Instruction" ], [ "LOAD_FAST", "offset" ], [ "LOAD_FAST", "argval" ], [ "LOAD_GLOBAL", "opname" ], [ "LOAD_FAST", "op" ], [ "BINARY_SUBSCR", "opname[op]" ], [ "CALL_FUNCTION", "Instruction(offset, argval, opname[op])" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "i < n" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "it" ], [ "LOAD_GLOBAL", "Sized" ], [ "CALL_FUNCTION", "isinstance(it, Sized)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "len(it)" ], [ "COMPARE_OP", "len(it) != 1" ], [ "LOAD_GLOBAL", "NotOneValueFound" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "len(it)" ], [ "BINARY_MODULO", "'Expected one value, found %s' % len(it)" ], [ "CALL_FUNCTION", "NotOneValueFound('Expected one value, found %s' % len(it))" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "list(it)" ], [ "BINARY_SUBSCR", "list(it)[0]" ], [ "LOAD_GLOBAL", "tuple" ], [ "LOAD_GLOBAL", "islice" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "islice(it, 2)" ], [ "CALL_FUNCTION", "tuple(islice(it, 2))" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "lst" ], [ "CALL_FUNCTION", "len(lst)" ], [ "COMPARE_OP", "len(lst) == 0" ], [ "LOAD_GLOBAL", "NotOneValueFound" ], [ "CALL_FUNCTION", "NotOneValueFound('Expected one value, found 0')" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "lst" ], [ "CALL_FUNCTION", "len(lst)" ], [ "COMPARE_OP", "len(lst) > 1" ], [ "LOAD_GLOBAL", "NotOneValueFound" ], [ "CALL_FUNCTION", "NotOneValueFound('Expected one value, found several')" ], [ "LOAD_FAST", "lst" ], [ "BINARY_SUBSCR", "lst[0]" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "cache" ], [ "CALL_FUNCTION", "cache" ], [ "LOAD_NAME", "cache" ], [ "CALL_FUNCTION", "cache" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "text" ], [ "LOAD_GLOBAL", "text_type" ], [ "CALL_FUNCTION", "isinstance(text, text_type)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.decode_source" ], [ "LOAD_FAST", "text" ], [ "CALL_METHOD", "self.decode_source(text)" ], [ "LOAD_FAST", "text" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_FAST", "text" ], [ "LOAD_METHOD", "''.join" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "text" ], [ "LOAD_METHOD", "text.splitlines" ], [ "CALL_METHOD", "text.splitlines(True)" ], [ "CALL_FUNCTION", "enumerate(text.splitlines(True))" ], [ "CALL_METHOD", "''.join([\n '\\n' if i < 2 and encoding_pattern.match(line)\n else line\n for i, line in enumerate(text.splitlines(True))\n ])" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "defaultdict(list)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "text" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.parse" ], [ "LOAD_FAST", "ast_text" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION_KW", "ast.parse(ast_text, filename=filename)" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "SyntaxError" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.walk" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tree" ], [ "CALL_METHOD", "ast.walk(self.tree)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.iter_child_nodes" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.iter_child_nodes(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "hasattr(node, 'lineno')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._nodes_by_line" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.lineno" ], [ "BINARY_SUBSCR", "self._nodes_by_line[node.lineno]" ], [ "LOAD_METHOD", "self._nodes_by_line[node.lineno].append" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self._nodes_by_line[node.lineno].append(node)" ], [ "LOAD_GLOBAL", "QualnameVisitor" ], [ "CALL_FUNCTION", "QualnameVisitor()" ], [ "LOAD_FAST", "visitor" ], [ "LOAD_METHOD", "visitor.visit" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tree" ], [ "CALL_METHOD", "visitor.visit(self.tree)" ], [ "LOAD_FAST", "visitor" ], [ "LOAD_ATTR", "visitor.qualnames" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "i" ], [ "COMPARE_OP", "i < 2" ], [ "LOAD_GLOBAL", "encoding_pattern" ], [ "LOAD_METHOD", "encoding_pattern.match" ], [ "LOAD_FAST", "line" ], [ "CALL_METHOD", "encoding_pattern.match(line)" ], [ "LOAD_FAST", "line" ], [ "LOAD_FAST", "cls" ], [ "LOAD_METHOD", "cls.for_filename" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_filename" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "CALL_METHOD", "cls.for_filename(frame.f_code.co_filename, frame.f_globals or {})" ], [ "LOAD_FAST", "cls" ], [ "LOAD_METHOD", "cls._class_local" ], [ "CALL_METHOD", "cls._class_local('__source_cache', {})" ], [ "LOAD_FAST", "source_cache" ], [ "LOAD_FAST", "filename" ], [ "BINARY_SUBSCR", "source_cache[filename]" ], [ "LOAD_GLOBAL", "KeyError" ], [ "LOAD_GLOBAL", "linecache" ], [ "LOAD_METHOD", "linecache.getlines" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "module_globals" ], [ "CALL_METHOD", "linecache.getlines(filename, module_globals)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_FAST", "filename" ], [ "LOAD_METHOD", "''.join" ], [ "LOAD_FAST", "lines" ], [ "CALL_METHOD", "''.join(lines)" ], [ "CALL_FUNCTION", "cls(filename, ''.join(lines))" ], [ "LOAD_FAST", "source_cache" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_GLOBAL", "linecache" ], [ "CALL_FUNCTION", "hasattr(linecache, 'lazycache')" ], [ "LOAD_GLOBAL", "linecache" ], [ "LOAD_METHOD", "linecache.lazycache" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_filename" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "CALL_METHOD", "linecache.lazycache(frame.f_code.co_filename, frame.f_globals)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lasti" ], [ "LOAD_FAST", "cls" ], [ "LOAD_METHOD", "cls._class_local" ], [ "CALL_METHOD", "cls._class_local('__executing_cache', {})" ], [ "LOAD_FAST", "executing_cache" ], [ "LOAD_FAST", "key" ], [ "BINARY_SUBSCR", "executing_cache[key]" ], [ "LOAD_GLOBAL", "KeyError" ], [ "LOAD_FAST", "cls" ], [ "LOAD_METHOD", "cls.for_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "cls.for_frame(frame)" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.tree" ], [ "LOAD_FAST", "source" ], [ "LOAD_METHOD", "source.statements_at_line" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lineno" ], [ "CALL_METHOD", "source.statements_at_line(frame.f_lineno)" ], [ "LOAD_GLOBAL", "NodeFinder" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "stmts" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.tree" ], [ "CALL_FUNCTION", "NodeFinder(frame, stmts, source.tree)" ], [ "LOAD_ATTR", "NodeFinder(frame, stmts, source.tree).result" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_GLOBAL", "statement_containing_node" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "statement_containing_node(node)" ], [ "LOAD_FAST", "new_stmts" ], [ "LOAD_FAST", "stmts" ], [ "COMPARE_OP", "new_stmts <= stmts" ], [ "LOAD_FAST", "new_stmts" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "stmts" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "executing_cache" ], [ "LOAD_FAST", "key" ], [ "LOAD_GLOBAL", "Executing" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION_EX", "Executing(frame, *args)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_ATTR", "cls.__dict__" ], [ "LOAD_METHOD", "cls.__dict__.get" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "default" ], [ "CALL_METHOD", "cls.__dict__.get(name, default)" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_FAST", "cls" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "setattr(cls, name, result)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._nodes_by_line" ], [ "LOAD_FAST", "lineno" ], [ "BINARY_SUBSCR", "self._nodes_by_line[lineno]" ], [ "LOAD_GLOBAL", "statement_containing_node" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "statement_containing_node(node)" ], [ "LOAD_FAST", "ASTTokens" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.text" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tree" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.filename" ], [ "CALL_FUNCTION_KW", "ASTTokens(\n self.text,\n tree=self.tree,\n filename=self.filename,\n )" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "source" ], [ "LOAD_GLOBAL", "bytes" ], [ "CALL_FUNCTION", "isinstance(source, bytes)" ], [ "LOAD_GLOBAL", "detect_encoding" ], [ "LOAD_GLOBAL", "io" ], [ "LOAD_METHOD", "io.BytesIO" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "io.BytesIO(source)" ], [ "LOAD_ATTR", "io.BytesIO(source).readline" ], [ "CALL_FUNCTION", "detect_encoding(io.BytesIO(source).readline)" ], [ "LOAD_FAST", "source" ], [ "LOAD_METHOD", "source.decode" ], [ "LOAD_FAST", "encoding" ], [ "CALL_METHOD", "source.decode(encoding)" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_filename" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.filename" ], [ "COMPARE_OP", "code.co_filename == self.filename" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._qualnames" ], [ "LOAD_METHOD", "self._qualnames.get" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_firstlineno" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "CALL_METHOD", "self._qualnames.get((code.co_name, code.co_firstlineno), code.co_name)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "stmts" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.source" ], [ "LOAD_METHOD", "self.source.code_qualname" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_code" ], [ "CALL_METHOD", "self.source.code_qualname(self.frame.f_code)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.source" ], [ "LOAD_METHOD", "self.source.asttokens" ], [ "CALL_METHOD", "self.source.asttokens()" ], [ "LOAD_METHOD", "self.source.asttokens().get_text" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.node" ], [ "CALL_METHOD", "self.source.asttokens().get_text(self.node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.source" ], [ "LOAD_METHOD", "self.source.asttokens" ], [ "CALL_METHOD", "self.source.asttokens()" ], [ "LOAD_METHOD", "self.source.asttokens().get_text_range" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.node" ], [ "CALL_METHOD", "self.source.asttokens().get_text_range(self.node)" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "QualnameVisitor" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(QualnameVisitor, self)" ], [ "LOAD_METHOD", "super(QualnameVisitor, self).__init__" ], [ "CALL_METHOD", "super(QualnameVisitor, self).__init__()" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.name" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_METHOD", "self.stack.append" ], [ "LOAD_FAST", "name" ], [ "CALL_METHOD", "self.stack.append(name)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.qualnames" ], [ "LOAD_METHOD", "self.qualnames.setdefault" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.lineno" ], [ "LOAD_METHOD", "\".\".join" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "CALL_METHOD", "\".\".join(self.stack)" ], [ "CALL_METHOD", "self.qualnames.setdefault((name, node.lineno), \".\".join(self.stack))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_METHOD", "self.stack.append" ], [ "CALL_METHOD", "self.stack.append('')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Lambda" ], [ "CALL_FUNCTION", "isinstance(node, ast.Lambda)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.body" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.body" ], [ "LOAD_FAST", "children" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.visit" ], [ "LOAD_FAST", "child" ], [ "CALL_METHOD", "self.visit(child)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_METHOD", "self.stack.pop" ], [ "CALL_METHOD", "self.stack.pop()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_METHOD", "self.stack.pop" ], [ "CALL_METHOD", "self.stack.pop()" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.iter_fields" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.iter_fields(node)" ], [ "LOAD_FAST", "field" ], [ "COMPARE_OP", "field == 'body'" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.AST" ], [ "CALL_FUNCTION", "isinstance(child, ast.AST)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.visit" ], [ "LOAD_FAST", "child" ], [ "CALL_METHOD", "self.visit(child)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "isinstance(child, list)" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "grandchild" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.AST" ], [ "CALL_FUNCTION", "isinstance(grandchild, ast.AST)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.visit" ], [ "LOAD_FAST", "grandchild" ], [ "CALL_METHOD", "self.visit(grandchild)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.visit_FunctionDef" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self.visit_FunctionDef(node, '')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_METHOD", "self.stack.append" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.name" ], [ "CALL_METHOD", "self.stack.append(node.name)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.generic_visit" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self.generic_visit(node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_METHOD", "self.stack.pop" ], [ "CALL_METHOD", "self.stack.pop()" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "__future__" ], [ "LOAD_FAST", "fname" ], [ "CALL_FUNCTION", "getattr(__future__, fname)" ], [ "LOAD_ATTR", "getattr(__future__, fname).compiler_flag" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "matching_code" ], [ "LOAD_ATTR", "matching_code.co_filename" ], [ "LOAD_GLOBAL", "future_flags" ], [ "LOAD_FAST", "matching_code" ], [ "LOAD_ATTR", "matching_code.co_flags" ], [ "BINARY_AND", "future_flags & matching_code.co_flags" ], [ "CALL_FUNCTION_KW", "compile(\n source,\n matching_code.co_filename,\n 'exec',\n flags=future_flags & matching_code.co_flags,\n dont_inherit=True,\n )" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "tree" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_code" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lasti" ], [ "BINARY_SUBSCR", "frame.f_code.co_code[frame.f_lasti]" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_GLOBAL", "ord" ], [ "LOAD_FAST", "b" ], [ "CALL_FUNCTION", "ord(b)" ], [ "LOAD_GLOBAL", "dis" ], [ "LOAD_ATTR", "dis.opname" ], [ "LOAD_FAST", "b" ], [ "BINARY_SUBSCR", "dis.opname[b]" ], [ "LOAD_FAST", "op_name" ], [ "LOAD_METHOD", "op_name.startswith" ], [ "CALL_METHOD", "op_name.startswith('CALL_')" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Call" ], [ "LOAD_FAST", "op_name" ], [ "COMPARE_OP", "op_name == 'BINARY_SUBSCR'" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Subscript" ], [ "LOAD_FAST", "op_name" ], [ "LOAD_METHOD", "op_name.startswith" ], [ "CALL_METHOD", "op_name.startswith('BINARY_')" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.BinOp" ], [ "LOAD_FAST", "op_name" ], [ "LOAD_METHOD", "op_name.startswith" ], [ "CALL_METHOD", "op_name.startswith('UNARY_')" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.UnaryOp" ], [ "LOAD_FAST", "op_name" ], [ "CONTAINS_OP", "op_name in ('LOAD_ATTR', 'LOAD_METHOD', 'LOOKUP_METHOD')" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Attribute" ], [ "LOAD_FAST", "op_name" ], [ "COMPARE_OP", "op_name == 'COMPARE_OP'" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Compare" ], [ "LOAD_GLOBAL", "RuntimeError" ], [ "LOAD_FAST", "op_name" ], [ "CALL_FUNCTION", "RuntimeError(op_name)" ], [ "LOAD_GLOBAL", "lock" ], [ "LOAD_FAST", "stmts" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.matching_nodes" ], [ "LOAD_FAST", "exprs" ], [ "CALL_METHOD", "self.matching_nodes(exprs)" ], [ "CALL_FUNCTION", "list(self.matching_nodes(exprs))" ], [ "CALL_FUNCTION", "only(list(self.matching_nodes(exprs)))" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.walk" ], [ "LOAD_FAST", "stmt" ], [ "CALL_METHOD", "ast.walk(stmt)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "typ" ], [ "CALL_FUNCTION", "isinstance(node, typ)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "hasattr(node, \"ctx\")" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.ctx" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Load" ], [ "CALL_FUNCTION", "isinstance(node.ctx, ast.Load)" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "exprs" ], [ "CALL_FUNCTION", "enumerate(exprs)" ], [ "LOAD_GLOBAL", "get_setter" ], [ "LOAD_FAST", "expr" ], [ "CALL_FUNCTION", "get_setter(expr)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.BinOp" ], [ "LOAD_FAST", "expr" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.Pow" ], [ "CALL_METHOD", "ast.Pow()" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Str" ], [ "LOAD_GLOBAL", "sentinel" ], [ "CALL_FUNCTION_KW", "ast.Str(s=sentinel)" ], [ "CALL_FUNCTION_KW", "ast.BinOp(\n left=expr,\n op=ast.Pow(),\n right=ast.Str(s=sentinel),\n )" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.fix_missing_locations" ], [ "LOAD_FAST", "replacement" ], [ "CALL_METHOD", "ast.fix_missing_locations(replacement)" ], [ "LOAD_FAST", "setter" ], [ "LOAD_FAST", "replacement" ], [ "CALL_FUNCTION", "setter(replacement)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.compile_instructions" ], [ "CALL_METHOD", "self.compile_instructions()" ], [ "LOAD_GLOBAL", "SyntaxError" ], [ "LOAD_FAST", "setter" ], [ "LOAD_FAST", "expr" ], [ "CALL_FUNCTION", "setter(expr)" ], [ "LOAD_FAST", "setter" ], [ "LOAD_FAST", "expr" ], [ "CALL_FUNCTION", "setter(expr)" ], [ "LOAD_FAST", "setter" ], [ "LOAD_FAST", "expr" ], [ "CALL_FUNCTION", "setter(expr)" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "instructions" ], [ "CALL_FUNCTION", "enumerate(instructions)" ], [ "LOAD_FAST", "indices" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_FAST", "indices" ], [ "CALL_FUNCTION", "only(indices)" ], [ "BINARY_SUBTRACT", "only(indices) - 1" ], [ "LOAD_FAST", "instructions" ], [ "LOAD_FAST", "arg_index" ], [ "BINARY_SUBSCR", "instructions[arg_index]" ], [ "LOAD_ATTR", "instructions[arg_index].opname" ], [ "COMPARE_OP", "instructions[arg_index].opname == 'EXTENDED_ARG'" ], [ "LOAD_FAST", "instructions" ], [ "LOAD_FAST", "arg_index" ], [ "BINARY_SUBSCR", "instructions[arg_index]" ], [ "LOAD_ATTR", "instructions[arg_index].opname" ], [ "COMPARE_OP", "instructions[arg_index].opname == 'EXTENDED_ARG'" ], [ "LOAD_FAST", "instructions" ], [ "LOAD_FAST", "arg_index" ], [ "BINARY_SUBSCR", "instructions[arg_index]" ], [ "LOAD_ATTR", "instructions[arg_index].offset" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_lasti" ], [ "COMPARE_OP", "instructions[arg_index].offset == self.frame.f_lasti" ], [ "LOAD_FAST", "expr" ], [ "LOAD_FAST", "instruction" ], [ "LOAD_ATTR", "instruction.argval" ], [ "LOAD_GLOBAL", "sentinel" ], [ "COMPARE_OP", "instruction.argval == sentinel" ], [ "LOAD_FAST", "i" ], [ "LOAD_GLOBAL", "compile_similar_to" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tree" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_code" ], [ "CALL_FUNCTION", "compile_similar_to(self.tree, self.frame.f_code)" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_GLOBAL", "find_codes" ], [ "LOAD_FAST", "module_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_code" ], [ "CALL_FUNCTION", "find_codes(module_code, self.frame.f_code)" ], [ "CALL_FUNCTION", "only(find_codes(module_code, self.frame.f_code))" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "get_instructions" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "get_instructions(code)" ], [ "CALL_FUNCTION", "list(get_instructions(code))" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.iter_fields" ], [ "LOAD_DEREF", "parent" ], [ "CALL_METHOD", "ast.iter_fields(parent)" ], [ "LOAD_DEREF", "field" ], [ "LOAD_FAST", "node" ], [ "IS_OP", "field is node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_DEREF", "field" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "isinstance(field, list)" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_DEREF", "field" ], [ "CALL_FUNCTION", "enumerate(field)" ], [ "LOAD_FAST", "item" ], [ "LOAD_FAST", "node" ], [ "IS_OP", "item is node" ], [ "LOAD_FAST", "setter" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_DEREF", "parent" ], [ "LOAD_DEREF", "name" ], [ "LOAD_FAST", "new_node" ], [ "CALL_FUNCTION", "setattr(parent, name, new_node)" ], [ "LOAD_FAST", "new_node" ], [ "LOAD_DEREF", "field" ], [ "LOAD_DEREF", "i" ], [ "LOAD_DEREF", "matches" ], [ "LOAD_FAST", "root_code" ], [ "CALL_FUNCTION", "matches(root_code)" ], [ "LOAD_DEREF", "code_options" ], [ "LOAD_METHOD", "code_options.append" ], [ "LOAD_FAST", "root_code" ], [ "CALL_METHOD", "code_options.append(root_code)" ], [ "LOAD_DEREF", "finder" ], [ "LOAD_FAST", "root_code" ], [ "CALL_FUNCTION", "finder(root_code)" ], [ "LOAD_DEREF", "code_options" ], [ "LOAD_GLOBAL", "all" ], [ "LOAD_GLOBAL", "attrgetter" ], [ "CALL_FUNCTION", "attrgetter('co_firstlineno')" ], [ "LOAD_GLOBAL", "attrgetter" ], [ "CALL_FUNCTION", "attrgetter('co_name')" ], [ "LOAD_GLOBAL", "code_names" ], [ "CALL_FUNCTION", "all(\n f(c) == f(matching)\n for f in [\n attrgetter('co_firstlineno'),\n attrgetter('co_name'),\n code_names,\n ]\n )" ], [ "LOAD_FAST", "f" ], [ "LOAD_DEREF", "c" ], [ "CALL_FUNCTION", "f(c)" ], [ "LOAD_FAST", "f" ], [ "LOAD_DEREF", "matching" ], [ "CALL_FUNCTION", "f(matching)" ], [ "COMPARE_OP", "f(c) == f(matching)" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_consts" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.iscode" ], [ "LOAD_FAST", "const" ], [ "CALL_METHOD", "inspect.iscode(const)" ], [ "LOAD_DEREF", "matches" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "matches(const)" ], [ "LOAD_DEREF", "code_options" ], [ "LOAD_METHOD", "code_options.append" ], [ "LOAD_FAST", "const" ], [ "CALL_METHOD", "code_options.append(const)" ], [ "LOAD_DEREF", "finder" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "finder(const)" ], [ "LOAD_GLOBAL", "frozenset" ], [ "CALL_FUNCTION", "frozenset()" ], [ "LOAD_METHOD", "frozenset().union" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_names" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_varnames" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_freevars" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_cellvars" ], [ "CALL_METHOD", "frozenset().union(\n code.co_names,\n code.co_varnames,\n code.co_freevars,\n code.co_cellvars,\n )" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "CALL_FUNCTION", "isinstance(node, ast.stmt)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "CALL_FUNCTION", "isinstance(node, ast.stmt)" ], [ "LOAD_FAST", "node" ] ], "import_hook.py": [ [ "LOAD_NAME", "object" ], [ "LOAD_FAST", "spec" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "deep" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "eye" ], [ "LOAD_ATTR", "eye.exec_string" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.source" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._spec" ], [ "LOAD_ATTR", "self._spec.origin" ], [ "LOAD_FAST", "module" ], [ "LOAD_ATTR", "module.__dict__" ], [ "LOAD_FAST", "module" ], [ "LOAD_ATTR", "module.__dict__" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.deep" ], [ "CALL_FUNCTION_KW", "eye.exec_string(\n source=self.source,\n filename=self._spec.origin,\n globs=module.__dict__,\n locs=module.__dict__,\n deep=self.deep,\n )" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._spec" ], [ "LOAD_ATTR", "self._spec.loader" ], [ "LOAD_METHOD", "self._spec.loader.get_filename" ], [ "LOAD_FAST", "fullname" ], [ "CALL_METHOD", "self._spec.loader.get_filename(fullname)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._spec" ], [ "LOAD_ATTR", "self._spec.loader" ], [ "LOAD_METHOD", "self._spec.loader.is_package" ], [ "LOAD_FAST", "fullname" ], [ "CALL_METHOD", "self._spec.loader.is_package(fullname)" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.meta_path" ], [ "LOAD_FAST", "finder" ], [ "LOAD_FAST", "self" ], [ "IS_OP", "finder is self" ], [ "LOAD_FAST", "finder" ], [ "LOAD_ATTR", "finder.__module__" ], [ "CONTAINS_OP", "'pytest' in finder.__module__" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "finder" ], [ "CALL_FUNCTION", "hasattr(finder, 'find_spec')" ], [ "LOAD_FAST", "finder" ], [ "LOAD_ATTR", "finder.find_spec" ], [ "LOAD_FAST", "fullname" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "target" ], [ "CALL_FUNCTION_KW", "finder.find_spec(fullname, path, target=target)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "finder" ], [ "CALL_FUNCTION", "hasattr(finder, 'load_module')" ], [ "LOAD_GLOBAL", "spec_from_loader" ], [ "LOAD_FAST", "fullname" ], [ "LOAD_FAST", "finder" ], [ "CALL_FUNCTION", "spec_from_loader(fullname, finder)" ], [ "LOAD_FAST", "spec" ], [ "IS_OP", "spec is not None" ], [ "LOAD_FAST", "spec" ], [ "LOAD_ATTR", "spec.origin" ], [ "COMPARE_OP", "spec.origin != 'builtin'" ], [ "LOAD_FAST", "spec" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._find_plain_spec" ], [ "LOAD_FAST", "fullname" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "target" ], [ "CALL_METHOD", "self._find_plain_spec(fullname, path, target)" ], [ "LOAD_FAST", "spec" ], [ "IS_OP", "spec is None" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "spec" ], [ "LOAD_ATTR", "spec.loader" ], [ "CALL_FUNCTION", "hasattr(spec.loader, 'get_source')" ], [ "LOAD_GLOBAL", "callable" ], [ "LOAD_FAST", "spec" ], [ "LOAD_ATTR", "spec.loader" ], [ "LOAD_ATTR", "spec.loader.get_source" ], [ "CALL_FUNCTION", "callable(spec.loader.get_source)" ], [ "LOAD_FAST", "fullname" ], [ "COMPARE_OP", "fullname != 'org'" ], [ "LOAD_GLOBAL", "logging" ], [ "LOAD_METHOD", "logging.debug" ], [ "LOAD_FAST", "fullname" ], [ "CALL_METHOD", "logging.debug('Failed finding spec for %s', fullname)" ], [ "LOAD_FAST", "spec" ], [ "LOAD_ATTR", "spec.loader" ], [ "LOAD_METHOD", "spec.loader.get_source" ], [ "LOAD_FAST", "fullname" ], [ "CALL_METHOD", "spec.loader.get_source(fullname)" ], [ "LOAD_GLOBAL", "ImportError" ], [ "LOAD_GLOBAL", "logging" ], [ "LOAD_METHOD", "logging.debug" ], [ "LOAD_FAST", "fullname" ], [ "CALL_METHOD", "logging.debug('Loader for %s was unable to find the sources',\n fullname)" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_GLOBAL", "logging" ], [ "LOAD_METHOD", "logging.exception" ], [ "LOAD_FAST", "fullname" ], [ "CALL_METHOD", "logging.exception('Loader for %s raised an error', fullname)" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "source" ], [ "CONTAINS_OP", "'birdseye' not in source" ], [ "LOAD_GLOBAL", "should_trace" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "should_trace(source)" ], [ "LOAD_FAST", "trace_stmt" ], [ "LOAD_GLOBAL", "BirdsEyeLoader" ], [ "LOAD_FAST", "spec" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "deep" ], [ "CALL_FUNCTION", "BirdsEyeLoader(spec, source, deep)" ], [ "LOAD_GLOBAL", "spec_from_loader" ], [ "LOAD_FAST", "fullname" ], [ "LOAD_FAST", "loader" ], [ "CALL_FUNCTION", "spec_from_loader(fullname, loader)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.parse" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "ast.parse(source)" ], [ "LOAD_ATTR", "ast.parse(source).body" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Import" ], [ "CALL_FUNCTION", "isinstance(stmt, ast.Import)" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_ATTR", "stmt.names" ], [ "LOAD_FAST", "alias" ], [ "LOAD_ATTR", "alias.name" ], [ "LOAD_METHOD", "alias.name.startswith" ], [ "CALL_METHOD", "alias.name.startswith('birdseye.trace_module')" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_FAST", "alias" ], [ "LOAD_ATTR", "alias.name" ], [ "LOAD_METHOD", "alias.name.endswith" ], [ "CALL_METHOD", "alias.name.endswith('deep')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.ImportFrom" ], [ "CALL_FUNCTION", "isinstance(stmt, ast.ImportFrom)" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_ATTR", "stmt.module" ], [ "COMPARE_OP", "stmt.module == 'birdseye'" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_ATTR", "stmt.names" ], [ "LOAD_FAST", "alias" ], [ "LOAD_ATTR", "alias.name" ], [ "LOAD_METHOD", "alias.name.startswith" ], [ "CALL_METHOD", "alias.name.startswith('trace_module')" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_FAST", "alias" ], [ "LOAD_ATTR", "alias.name" ], [ "LOAD_METHOD", "alias.name.endswith" ], [ "CALL_METHOD", "alias.name.endswith('deep')" ], [ "LOAD_FAST", "deep" ], [ "LOAD_FAST", "trace_stmt" ] ], "ipython.py": [ [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "BytesIO" ], [ "LOAD_NAME", "StringIO" ], [ "LOAD_NAME", "stream_proxy" ], [ "LOAD_NAME", "sys" ], [ "LOAD_ATTR", "sys.stderr" ], [ "CALL_FUNCTION", "stream_proxy(sys.stderr)" ], [ "LOAD_NAME", "sys" ], [ "LOAD_NAME", "stream_proxy" ], [ "LOAD_NAME", "sys" ], [ "LOAD_ATTR", "sys.stdout" ], [ "CALL_FUNCTION", "stream_proxy(sys.stdout)" ], [ "LOAD_NAME", "sys" ], [ "LOAD_NAME", "Environment" ], [ "LOAD_NAME", "PackageLoader" ], [ "CALL_FUNCTION", "PackageLoader('birdseye', 'templates')" ], [ "LOAD_NAME", "select_autoescape" ], [ "CALL_FUNCTION", "select_autoescape(['html', 'xml'])" ], [ "CALL_FUNCTION_KW", "Environment(\n loader=PackageLoader('birdseye', 'templates'),\n autoescape=select_autoescape(['html', 'xml'])\n)" ], [ "LOAD_NAME", "magics_class" ], [ "LOAD_NAME", "Magics" ], [ "CALL_FUNCTION", "magics_class" ], [ "LOAD_GLOBAL", "LocalProxy" ], [ "LOAD_FAST", "p" ], [ "CALL_FUNCTION", "LocalProxy(p)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.currentframe" ], [ "CALL_METHOD", "inspect.currentframe()" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_GLOBAL", "ThreadingMixIn" ], [ "LOAD_ATTR", "ThreadingMixIn.process_request_thread" ], [ "LOAD_ATTR", "ThreadingMixIn.process_request_thread.__code__" ], [ "COMPARE_OP", "frame.f_code == ThreadingMixIn.process_request_thread.__code__" ], [ "LOAD_GLOBAL", "fake_stream" ], [ "CALL_FUNCTION", "fake_stream()" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_FAST", "frame" ], [ "LOAD_GLOBAL", "thread_proxies" ], [ "LOAD_METHOD", "thread_proxies.get" ], [ "LOAD_GLOBAL", "currentThread" ], [ "CALL_FUNCTION", "currentThread()" ], [ "LOAD_ATTR", "currentThread().ident" ], [ "LOAD_DEREF", "original" ], [ "CALL_METHOD", "thread_proxies.get(currentThread().ident,\n original)" ], [ "LOAD_FAST", "show_server_output" ], [ "LOAD_GLOBAL", "fake_stream" ], [ "CALL_FUNCTION", "fake_stream()" ], [ "LOAD_GLOBAL", "thread_proxies" ], [ "LOAD_GLOBAL", "currentThread" ], [ "CALL_FUNCTION", "currentThread()" ], [ "LOAD_ATTR", "currentThread().ident" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_ATTR", "server.app" ], [ "LOAD_ATTR", "server.app.run" ], [ "LOAD_FAST", "port" ], [ "LOAD_FAST", "bind_host" ], [ "CALL_FUNCTION_KW", "server.app.run(\n debug=True,\n port=port,\n host=bind_host,\n use_reloader=False,\n )" ], [ "LOAD_GLOBAL", "socket" ], [ "LOAD_ATTR", "socket.error" ], [ "LOAD_NAME", "Unicode" ], [ "CALL_FUNCTION_KW", "Unicode(\n u'', config=True,\n help='If set, a server will not be automatically started by %%eye. '\n 'The iframe containing birdseye output will use this value as the base '\n 'of its URL.'\n )" ], [ "LOAD_NAME", "Int" ], [ "CALL_FUNCTION_KW", "Int(\n 7777, config=True,\n help='Port number for the server started by %%eye.'\n )" ], [ "LOAD_NAME", "Unicode" ], [ "CALL_FUNCTION_KW", "Unicode(\n '127.0.0.1', config=True,\n help='Host that the server started by %%eye listens on. '\n 'Set to 0.0.0.0 to make it accessible anywhere.'\n )" ], [ "LOAD_NAME", "Bool" ], [ "CALL_FUNCTION_KW", "Bool(\n False, config=True,\n help='Set to True to show stdout and stderr from the server started by %%eye.'\n )" ], [ "LOAD_NAME", "Unicode" ], [ "CALL_FUNCTION_KW", "Unicode(\n u'', config=True,\n help='The database URL that the server started by %%eye reads from. '\n 'Equivalent to the environment variable BIRDSEYE_DB.'\n )" ], [ "LOAD_NAME", "cell_magic" ], [ "CALL_FUNCTION", "cell_magic" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.server_url" ], [ "LOAD_GLOBAL", "Database" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.db_url" ], [ "CALL_FUNCTION", "Database(self.db_url)" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_ATTR", "server.db" ], [ "LOAD_ATTR", "server.db.Function" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_ATTR", "server.db" ], [ "LOAD_ATTR", "server.db.Call" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_ATTR", "server.db" ], [ "LOAD_ATTR", "server.db.Session" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_GLOBAL", "Thread" ], [ "LOAD_GLOBAL", "run_server" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.port" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.bind_host" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.show_server_output" ], [ "CALL_FUNCTION_KW", "Thread(\n target=run_server,\n args=(\n self.port,\n self.bind_host,\n self.show_server_output,\n ),\n )" ], [ "LOAD_METHOD", "Thread(\n target=run_server,\n args=(\n self.port,\n self.bind_host,\n self.show_server_output,\n ),\n ).start" ], [ "CALL_METHOD", "Thread(\n target=run_server,\n args=(\n self.port,\n self.bind_host,\n self.show_server_output,\n ),\n ).start()" ], [ "LOAD_GLOBAL", "Database" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.db_url" ], [ "CALL_FUNCTION", "Database(self.db_url)" ], [ "LOAD_GLOBAL", "eye" ], [ "LOAD_GLOBAL", "eye" ], [ "LOAD_METHOD", "eye.exec_ipython_cell" ], [ "LOAD_FAST", "cell" ], [ "LOAD_FAST", "callback" ], [ "CALL_METHOD", "eye.exec_ipython_cell(cell, callback)" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "call_id" ], [ "IS_OP", "call_id is None" ], [ "LOAD_GLOBAL", "HTML" ], [ "LOAD_GLOBAL", "templates_env" ], [ "LOAD_METHOD", "templates_env.get_template" ], [ "CALL_METHOD", "templates_env.get_template('ipython_iframe.html')" ], [ "LOAD_ATTR", "templates_env.get_template('ipython_iframe.html').render" ], [ "LOAD_FAST", "call_id" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.server_url" ], [ "LOAD_METHOD", "self.server_url.rstrip" ], [ "CALL_METHOD", "self.server_url.rstrip('/')" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.port" ], [ "LOAD_GLOBAL", "uuid4" ], [ "CALL_FUNCTION", "uuid4()" ], [ "LOAD_ATTR", "uuid4().hex" ], [ "CALL_FUNCTION_KW", "templates_env.get_template('ipython_iframe.html').render(\n call_id=call_id,\n url=self.server_url.rstrip('/'),\n port=self.port,\n container_id=uuid4().hex,\n )" ], [ "CALL_FUNCTION", "HTML(templates_env.get_template('ipython_iframe.html').render(\n call_id=call_id,\n url=self.server_url.rstrip('/'),\n port=self.port,\n container_id=uuid4().hex,\n ))" ], [ "LOAD_GLOBAL", "display" ], [ "LOAD_FAST", "html" ], [ "CALL_FUNCTION", "display(html)" ] ], "server.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOAD_METHOD", "standard_library.install_aliases" ], [ "CALL_METHOD", "standard_library.install_aliases()" ], [ "LOAD_NAME", "Flask" ], [ "CALL_FUNCTION", "Flask('birdseye')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.jinja_env" ], [ "LOAD_NAME", "Humanize" ], [ "LOAD_NAME", "app" ], [ "CALL_FUNCTION", "Humanize(app)" ], [ "LOAD_NAME", "PathConverter" ], [ "LOAD_NAME", "FileConverter" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.url_map" ], [ "LOAD_ATTR", "app.url_map.converters" ], [ "LOAD_NAME", "Database" ], [ "CALL_FUNCTION", "Database()" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.Session" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.Function" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.Call" ], [ "LOAD_NAME", "app" ], [ "LOAD_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/file/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/file/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/file//__function__/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/file//__function__/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/api/file//__function__//latest_call/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/api/file//__function__//latest_call/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "LOAD_NAME", "app" ], [ "LOAD_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/call/')" ], [ "CALL_FUNCTION", "app.route('/call/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/ipython_call/')" ], [ "CALL_FUNCTION", "app.route('/ipython_call/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/ipython_iframe/')" ], [ "CALL_FUNCTION", "app.route('/ipython_iframe/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION_KW", "app.route('/kill', methods=['POST'])" ], [ "CALL_FUNCTION", "app.route('/kill', methods=['POST'])" ], [ "LOAD_NAME", "app" ], [ "LOAD_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/api/call/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/api/call/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/api/calls_by_body_hash/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/api/calls_by_body_hash/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION_KW", "app.route('/api/body_hashes_present/', methods=['POST'])" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/api/body_hashes_present/', methods=['POST'])" ], [ "LOAD_NAME", "sys" ], [ "LOAD_ATTR", "sys.argv" ], [ "BINARY_SUBSCR", "sys.argv[1:]" ], [ "LOAD_NAME", "__name__" ], [ "COMPARE_OP", "__name__ == '__main__'" ], [ "LOAD_NAME", "main" ], [ "CALL_FUNCTION", "main()" ], [ "LOAD_GLOBAL", "db" ], [ "LOAD_METHOD", "db.all_file_paths" ], [ "CALL_METHOD", "db.all_file_paths()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_columns" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.basic_columns" ], [ "BINARY_ADD", "Call.basic_columns + Function.basic_columns" ], [ "CALL_FUNCTION_EX", "session.query(*(Call.basic_columns + Function.basic_columns))" ], [ "LOAD_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)" ], [ "LOAD_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .order_by" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.start_time" ], [ "LOAD_METHOD", "Call.start_time.desc" ], [ "CALL_METHOD", "Call.start_time.desc()" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .order_by(Call.start_time.desc())" ], [ "BINARY_SUBSCR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .order_by(Call.start_time.desc())[:100]" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "CALL_FUNCTION", "OrderedDict()" ], [ "LOAD_FAST", "recent_calls" ], [ "LOAD_GLOBAL", "is_ipython_cell" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.file" ], [ "CALL_FUNCTION", "is_ipython_cell(row.file)" ], [ "LOAD_FAST", "files" ], [ "LOAD_METHOD", "files.setdefault" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.file" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "CALL_FUNCTION", "OrderedDict()" ], [ "CALL_METHOD", "files.setdefault(\n row.file, OrderedDict()\n )" ], [ "LOAD_METHOD", "files.setdefault(\n row.file, OrderedDict()\n ).setdefault" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.name" ], [ "LOAD_FAST", "row" ], [ "CALL_METHOD", "files.setdefault(\n row.file, OrderedDict()\n ).setdefault(\n row.name, row\n )" ], [ "LOAD_FAST", "all_paths" ], [ "LOAD_FAST", "files" ], [ "LOAD_METHOD", "files.setdefault" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "CALL_FUNCTION", "OrderedDict()" ], [ "CALL_METHOD", "files.setdefault(\n path, OrderedDict()\n )" ], [ "LOAD_GLOBAL", "partial" ], [ "LOAD_GLOBAL", "short_path" ], [ "LOAD_FAST", "all_paths" ], [ "CALL_FUNCTION_KW", "partial(short_path, all_paths=all_paths)" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "short" ], [ "LOAD_FAST", "files" ], [ "CALL_FUNCTION_KW", "render_template('index.html',\n short=short,\n files=files)" ], [ "LOAD_GLOBAL", "fix_abs_path" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "fix_abs_path(path)" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_columns" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.basic_columns" ], [ "BINARY_ADD", "Call.basic_columns + Function.basic_columns" ], [ "CALL_FUNCTION_EX", "session.query(*(Call.basic_columns + Function.basic_columns))" ], [ "LOAD_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)" ], [ "LOAD_ATTR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION_KW", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path)" ], [ "LOAD_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path)\n .subquery" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path)\n .subquery('filtered_calls')" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.query" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.name" ], [ "LOAD_GLOBAL", "sqlalchemy" ], [ "LOAD_ATTR", "sqlalchemy.func" ], [ "LOAD_METHOD", "sqlalchemy.func.max" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.start_time" ], [ "CALL_METHOD", "sqlalchemy.func.max(filtered_calls.c.start_time)" ], [ "LOAD_METHOD", "sqlalchemy.func.max(filtered_calls.c.start_time).label" ], [ "CALL_METHOD", "sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')" ], [ "CALL_METHOD", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n )" ], [ "LOAD_METHOD", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n ).group_by" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.name" ], [ "CALL_METHOD", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n ).group_by(\n filtered_calls.c.name,\n )" ], [ "LOAD_METHOD", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n ).group_by(\n filtered_calls.c.name,\n ).subquery" ], [ "CALL_METHOD", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n ).group_by(\n filtered_calls.c.name,\n ).subquery('latest_calls')" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.query" ], [ "LOAD_FAST", "filtered_calls" ], [ "CALL_METHOD", "session.query(filtered_calls)" ], [ "LOAD_METHOD", "session.query(filtered_calls).join" ], [ "LOAD_FAST", "latest_calls" ], [ "LOAD_GLOBAL", "sqlalchemy" ], [ "LOAD_METHOD", "sqlalchemy.and_" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.name" ], [ "LOAD_FAST", "latest_calls" ], [ "LOAD_ATTR", "latest_calls.c" ], [ "LOAD_ATTR", "latest_calls.c.name" ], [ "COMPARE_OP", "filtered_calls.c.name == latest_calls.c.name" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.start_time" ], [ "LOAD_FAST", "latest_calls" ], [ "LOAD_ATTR", "latest_calls.c" ], [ "LOAD_ATTR", "latest_calls.c.maxtime" ], [ "COMPARE_OP", "filtered_calls.c.start_time == latest_calls.c.maxtime" ], [ "CALL_METHOD", "sqlalchemy.and_(\n filtered_calls.c.name == latest_calls.c.name,\n filtered_calls.c.start_time == latest_calls.c.maxtime,\n )" ], [ "CALL_METHOD", "session.query(filtered_calls).join(\n latest_calls,\n sqlalchemy.and_(\n filtered_calls.c.name == latest_calls.c.name,\n filtered_calls.c.start_time == latest_calls.c.maxtime,\n )\n )" ], [ "LOAD_METHOD", "session.query(filtered_calls).join(\n latest_calls,\n sqlalchemy.and_(\n filtered_calls.c.name == latest_calls.c.name,\n filtered_calls.c.start_time == latest_calls.c.maxtime,\n )\n ).order_by" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.start_time" ], [ "LOAD_METHOD", "filtered_calls.c.start_time.desc" ], [ "CALL_METHOD", "filtered_calls.c.start_time.desc()" ], [ "CALL_METHOD", "session.query(filtered_calls).join(\n latest_calls,\n sqlalchemy.and_(\n filtered_calls.c.name == latest_calls.c.name,\n filtered_calls.c.start_time == latest_calls.c.maxtime,\n )\n ).order_by(filtered_calls.c.start_time.desc())" ], [ "LOAD_GLOBAL", "group_by_attr" ], [ "LOAD_FAST", "query" ], [ "CALL_FUNCTION", "group_by_attr(query, 'type')" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.query" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.name" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.type" ], [ "CALL_METHOD", "session.query(Function.name, Function.type)" ], [ "LOAD_ATTR", "session.query(Function.name, Function.type)\n .filter_by" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION_KW", "session.query(Function.name, Function.type)\n .filter_by(file=path)" ], [ "LOAD_METHOD", "session.query(Function.name, Function.type)\n .filter_by(file=path)\n .distinct" ], [ "CALL_METHOD", "session.query(Function.name, Function.type)\n .filter_by(file=path)\n .distinct()" ], [ "CALL_FUNCTION", "sorted(session.query(Function.name, Function.type)\n .filter_by(file=path)\n .distinct())" ], [ "LOAD_FAST", "query" ], [ "LOAD_FAST", "all_funcs" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.name" ], [ "LOAD_FAST", "func_names" ], [ "CONTAINS_OP", "func.name not in func_names" ], [ "LOAD_FAST", "funcs" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.type" ], [ "BINARY_SUBSCR", "funcs[func.type]" ], [ "LOAD_METHOD", "funcs[func.type].append" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "funcs[func.type].append(func)" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "funcs" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "COMPARE_OP", "path == IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "basename" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "basename(path)" ], [ "CALL_FUNCTION_KW", "render_template('file.html',\n funcs=funcs,\n is_ipython=path == IPYTHON_FILE_PATH,\n full_path=path,\n short_path=basename(path))" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.name" ], [ "LOAD_GLOBAL", "fix_abs_path" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "fix_abs_path(path)" ], [ "LOAD_GLOBAL", "get_calls" ], [ "LOAD_FAST", "session" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "func_name" ], [ "CALL_FUNCTION", "get_calls(session, path, func_name, 200)" ], [ "LOAD_FAST", "query" ], [ "LOAD_FAST", "query" ], [ "BINARY_SUBSCR", "query[0]" ], [ "LOAD_FAST", "query" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.query" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_METHOD", "session.query(Function)" ], [ "LOAD_ATTR", "session.query(Function).filter_by" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "func_name" ], [ "CALL_FUNCTION_KW", "session.query(Function).filter_by(file=path, name=func_name)" ], [ "BINARY_SUBSCR", "session.query(Function).filter_by(file=path, name=func_name)[0]" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "func" ], [ "LOAD_GLOBAL", "basename" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "basename(path)" ], [ "LOAD_FAST", "calls" ], [ "CALL_FUNCTION_KW", "render_template('function.html',\n func=func,\n short_path=basename(path),\n calls=calls)" ], [ "LOAD_GLOBAL", "withattrs" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_FUNCTION", "Call()" ], [ "LOAD_FAST", "row" ], [ "LOAD_METHOD", "row._asdict" ], [ "CALL_METHOD", "row._asdict()" ], [ "CALL_FUNCTION_EX", "withattrs(Call(), **row._asdict())" ], [ "LOAD_GLOBAL", "fix_abs_path" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "fix_abs_path(path)" ], [ "LOAD_GLOBAL", "get_calls" ], [ "LOAD_FAST", "session" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "func_name" ], [ "CALL_FUNCTION", "get_calls(session, path, func_name, 1)" ], [ "BINARY_SUBSCR", "get_calls(session, path, func_name, 1)[0]" ], [ "LOAD_GLOBAL", "jsonify" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.id" ], [ "LOAD_GLOBAL", "url_for" ], [ "LOAD_GLOBAL", "call_view" ], [ "LOAD_ATTR", "call_view.__name__" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.id" ], [ "CALL_FUNCTION_KW", "url_for(call_view.__name__,\n call_id=call.id)" ], [ "CALL_FUNCTION_KW", "dict(\n id=call.id,\n url=url_for(call_view.__name__,\n call_id=call.id),\n )" ], [ "CALL_FUNCTION", "jsonify(dict(\n id=call.id,\n url=url_for(call_view.__name__,\n call_id=call.id),\n ))" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_columns" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.basic_columns" ], [ "BINARY_ADD", "Call.basic_columns + Function.basic_columns" ], [ "CALL_FUNCTION_EX", "session.query(*(Call.basic_columns + Function.basic_columns))" ], [ "LOAD_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)" ], [ "LOAD_ATTR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "func_name" ], [ "CALL_FUNCTION_KW", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path, name=func_name)" ], [ "LOAD_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path, name=func_name)\n .order_by" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.start_time" ], [ "LOAD_METHOD", "Call.start_time.desc" ], [ "CALL_METHOD", "Call.start_time.desc()" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path, name=func_name)\n .order_by(Call.start_time.desc())" ], [ "LOAD_FAST", "limit" ], [ "BINARY_SUBSCR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path, name=func_name)\n .order_by(Call.start_time.desc())[:limit]" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_METHOD", "session.query(Call)" ], [ "LOAD_ATTR", "session.query(Call).filter_by" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION_KW", "session.query(Call).filter_by(id=call_id)" ], [ "LOAD_METHOD", "session.query(Call).filter_by(id=call_id).one" ], [ "CALL_METHOD", "session.query(Call).filter_by(id=call_id).one()" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.function" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "template" ], [ "LOAD_GLOBAL", "basename" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.file" ], [ "CALL_FUNCTION", "basename(func.file)" ], [ "LOAD_FAST", "call" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION_KW", "render_template(template,\n short_path=basename(func.file),\n call=call,\n func=func)" ], [ "LOAD_GLOBAL", "base_call_view" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION", "base_call_view(call_id, 'call.html')" ], [ "LOAD_GLOBAL", "base_call_view" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION", "base_call_view(call_id, 'ipython_call.html')" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION_KW", "render_template('ipython_iframe.html',\n container_id='1234',\n port=7777,\n call_id=call_id)" ], [ "LOAD_GLOBAL", "request" ], [ "LOAD_ATTR", "request.environ" ], [ "LOAD_METHOD", "request.environ.get" ], [ "CALL_METHOD", "request.environ.get('werkzeug.server.shutdown')" ], [ "LOAD_FAST", "func" ], [ "IS_OP", "func is None" ], [ "LOAD_GLOBAL", "RuntimeError" ], [ "CALL_FUNCTION", "RuntimeError('Not running with the Werkzeug Server')" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "func()" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_METHOD", "session.query(Call)" ], [ "LOAD_ATTR", "session.query(Call).filter_by" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION_KW", "session.query(Call).filter_by(id=call_id)" ], [ "LOAD_METHOD", "session.query(Call).filter_by(id=call_id).one" ], [ "CALL_METHOD", "session.query(Call).filter_by(id=call_id).one()" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.function" ], [ "LOAD_GLOBAL", "DecentJSONEncoder" ], [ "CALL_FUNCTION", "DecentJSONEncoder()" ], [ "LOAD_METHOD", "DecentJSONEncoder().encode" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.parsed_data" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_METHOD", "Call.basic_dict" ], [ "LOAD_FAST", "call" ], [ "CALL_METHOD", "Call.basic_dict(call)" ], [ "CALL_FUNCTION_EX", "dict(data=call.parsed_data, **Call.basic_dict(call))" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.parsed_data" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_METHOD", "Function.basic_dict" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "Function.basic_dict(func)" ], [ "CALL_FUNCTION_EX", "dict(data=func.parsed_data, **Function.basic_dict(func))" ], [ "CALL_FUNCTION_KW", "dict(\n call=dict(data=call.parsed_data, **Call.basic_dict(call)),\n function=dict(data=func.parsed_data, **Function.basic_dict(func)))" ], [ "CALL_METHOD", "DecentJSONEncoder().encode(dict(\n call=dict(data=call.parsed_data, **Call.basic_dict(call)),\n function=dict(data=func.parsed_data, **Function.basic_dict(func))))" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_columns" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.data" ], [ "BINARY_ADD", "Call.basic_columns + (Function.data,)" ], [ "CALL_FUNCTION_EX", "session.query(*Call.basic_columns + (Function.data,))" ], [ "LOAD_METHOD", "session.query(*Call.basic_columns + (Function.data,))\n .join" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_METHOD", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)" ], [ "LOAD_ATTR", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by" ], [ "LOAD_FAST", "body_hash" ], [ "CALL_FUNCTION_KW", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by(body_hash=body_hash)" ], [ "LOAD_METHOD", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by(body_hash=body_hash)\n .order_by" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.start_time" ], [ "LOAD_METHOD", "Call.start_time.desc" ], [ "CALL_METHOD", "Call.start_time.desc()" ], [ "CALL_METHOD", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by(body_hash=body_hash)\n .order_by(Call.start_time.desc())" ], [ "BINARY_SUBSCR", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by(body_hash=body_hash)\n .order_by(Call.start_time.desc())[:200]" ], [ "LOAD_FAST", "query" ], [ "LOAD_FAST", "query" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "function_data_set" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_METHOD", "json.loads" ], [ "LOAD_DEREF", "function_data" ], [ "CALL_METHOD", "json.loads(function_data)" ], [ "LOAD_FAST", "add" ], [ "LOAD_FAST", "ranges" ], [ "CALL_FUNCTION", "add('node_ranges', ranges)" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "add" ], [ "LOAD_FAST", "current_loop_ranges" ], [ "CALL_FUNCTION", "add('loop_ranges', current_loop_ranges)" ], [ "LOAD_FAST", "loop_ranges" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "current_loop_ranges" ], [ "CONTAINS_OP", "loop_ranges in (set(), current_loop_ranges)" ], [ "LOAD_FAST", "current_loop_ranges" ], [ "LOAD_FAST", "ranges" ], [ "LOAD_FAST", "loop_ranges" ], [ "LOAD_GLOBAL", "DecentJSONEncoder" ], [ "CALL_FUNCTION", "DecentJSONEncoder()" ], [ "LOAD_METHOD", "DecentJSONEncoder().encode" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "calls" ], [ "LOAD_FAST", "ranges" ], [ "LOAD_FAST", "loop_ranges" ], [ "CALL_FUNCTION_KW", "dict(\n calls=calls, ranges=ranges, loop_ranges=loop_ranges)" ], [ "CALL_METHOD", "DecentJSONEncoder().encode(dict(\n calls=calls, ranges=ranges, loop_ranges=loop_ranges))" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_METHOD", "Call.basic_dict" ], [ "LOAD_GLOBAL", "withattrs" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_FUNCTION", "Call()" ], [ "LOAD_FAST", "row" ], [ "LOAD_METHOD", "row._asdict" ], [ "CALL_METHOD", "row._asdict()" ], [ "CALL_FUNCTION_EX", "withattrs(Call(), **row._asdict())" ], [ "CALL_METHOD", "Call.basic_dict(withattrs(Call(), **row._asdict()))" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.data" ], [ "LOAD_DEREF", "function_data" ], [ "LOAD_FAST", "key" ], [ "BINARY_SUBSCR", "function_data[key]" ], [ "LOAD_FAST", "ranges_set" ], [ "LOAD_METHOD", "ranges_set.add" ], [ "LOAD_FAST", "node" ], [ "BINARY_SUBSCR", "node['start']" ], [ "LOAD_FAST", "node" ], [ "BINARY_SUBSCR", "node['end']" ], [ "CALL_METHOD", "ranges_set.add((node['start'], node['end']))" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "CALL_FUNCTION_KW", "dict(start=start, end=end)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "CALL_FUNCTION_KW", "dict(start=start, end=end)" ], [ "LOAD_GLOBAL", "request" ], [ "LOAD_METHOD", "request.get_json" ], [ "CALL_METHOD", "request.get_json()" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.query" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.body_hash" ], [ "LOAD_GLOBAL", "sqlalchemy" ], [ "LOAD_ATTR", "sqlalchemy.func" ], [ "LOAD_METHOD", "sqlalchemy.func.count" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.id" ], [ "CALL_METHOD", "sqlalchemy.func.count(Call.id)" ], [ "CALL_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))" ], [ "LOAD_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)" ], [ "LOAD_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)\n .filter" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.body_hash" ], [ "LOAD_METHOD", "Function.body_hash.in_" ], [ "LOAD_FAST", "hashes" ], [ "CALL_METHOD", "Function.body_hash.in_(hashes)" ], [ "CALL_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)\n .filter(Function.body_hash.in_(hashes))" ], [ "LOAD_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)\n .filter(Function.body_hash.in_(hashes))\n .group_by" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.body_hash" ], [ "CALL_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)\n .filter(Function.body_hash.in_(hashes))\n .group_by(Function.body_hash)" ], [ "LOAD_GLOBAL", "DecentJSONEncoder" ], [ "CALL_FUNCTION", "DecentJSONEncoder()" ], [ "LOAD_METHOD", "DecentJSONEncoder().encode" ], [ "LOAD_FAST", "query" ], [ "CALL_METHOD", "DecentJSONEncoder().encode([\n dict(hash=h, count=count)\n for h, count in query\n ])" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "h" ], [ "LOAD_FAST", "count" ], [ "CALL_FUNCTION_KW", "dict(hash=h, count=count)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "argv" ], [ "CALL_FUNCTION", "len(argv)" ], [ "COMPARE_OP", "len(argv) == 1" ], [ "LOAD_FAST", "argv" ], [ "BINARY_SUBSCR", "argv[0]" ], [ "LOAD_METHOD", "argv[0].isdigit" ], [ "CALL_METHOD", "argv[0].isdigit()" ], [ "LOAD_FAST", "argv" ], [ "LOAD_METHOD", "argv.insert" ], [ "CALL_METHOD", "argv.insert(0, '--port')" ], [ "LOAD_GLOBAL", "argparse" ], [ "LOAD_ATTR", "argparse.ArgumentParser" ], [ "CALL_FUNCTION_KW", "argparse.ArgumentParser(description=\"Bird's Eye: A graphical Python debugger\")" ], [ "LOAD_FAST", "parser" ], [ "LOAD_ATTR", "parser.add_argument" ], [ "LOAD_GLOBAL", "int" ], [ "CALL_FUNCTION_KW", "parser.add_argument('-p', '--port', help='HTTP port, default is 7777', default=7777, type=int)" ], [ "LOAD_FAST", "parser" ], [ "LOAD_ATTR", "parser.add_argument" ], [ "CALL_FUNCTION_KW", "parser.add_argument('--host', help=\"HTTP host, default is 'localhost'\", default='localhost')" ], [ "LOAD_FAST", "parser" ], [ "LOAD_METHOD", "parser.parse_args" ], [ "LOAD_FAST", "argv" ], [ "CALL_METHOD", "parser.parse_args(argv)" ], [ "LOAD_GLOBAL", "app" ], [ "LOAD_ATTR", "app.run" ], [ "LOAD_FAST", "args" ], [ "LOAD_ATTR", "args.port" ], [ "LOAD_FAST", "args" ], [ "LOAD_ATTR", "args.host" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.environ" ], [ "LOAD_METHOD", "os.environ.get" ], [ "CALL_METHOD", "os.environ.get('BIRDSEYE_RELOADER')" ], [ "COMPARE_OP", "os.environ.get('BIRDSEYE_RELOADER') == '1'" ], [ "CALL_FUNCTION_KW", "app.run(\n port=args.port,\n host=args.host,\n use_reloader=os.environ.get('BIRDSEYE_RELOADER') == '1',\n )" ] ], "tests.py": [ [ "LOAD_NAME", "unittest" ], [ "LOAD_ATTR", "unittest.TestCase" ], [ "LOAD_NAME", "unittest" ], [ "LOAD_ATTR", "unittest.TestCase" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "TestFile" ], [ "CALL_FUNCTION", "TestFile()" ], [ "LOAD_METHOD", "TestFile().test_file" ], [ "CALL_METHOD", "TestFile().test_file()" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "Tester" ], [ "CALL_FUNCTION", "Tester()" ], [ "LOAD_NAME", "tester" ], [ "CALL_FUNCTION", "tester([1, 2, 3])" ], [ "COMPARE_OP", "tester([1, 2, 3]) == [1, 2, 3]" ], [ "LOAD_NAME", "tester" ], [ "LOAD_ATTR", "tester.asd" ], [ "LOAD_NAME", "tester" ], [ "IS_OP", "tester.asd is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_SUBSCR", "tester[19]" ], [ "LOAD_NAME", "tester" ], [ "IS_OP", "tester[19] is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_POWER", "tester ** 4" ], [ "LOAD_NAME", "tester" ], [ "IS_OP", "tester ** 4 is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_MULTIPLY", "tester * 3" ], [ "LOAD_NAME", "tester" ], [ "IS_OP", "tester * 3 is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_SUBTRACT", "tester - 2" ], [ "LOAD_NAME", "tester" ], [ "IS_OP", "tester - 2 is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_ADD", "tester + 1" ], [ "LOAD_NAME", "tester" ], [ "IS_OP", "tester + 1 is tester" ], [ "LOAD_NAME", "tester" ], [ "UNARY_NEGATIVE", "-tester" ], [ "LOAD_NAME", "tester" ], [ "IS_OP", "-tester is tester" ], [ "LOAD_NAME", "tester" ], [ "UNARY_POSITIVE", "+tester" ], [ "LOAD_NAME", "tester" ], [ "IS_OP", "+tester is tester" ], [ "LOAD_NAME", "tester" ], [ "UNARY_INVERT", "~tester" ], [ "LOAD_NAME", "tester" ], [ "IS_OP", "~tester is tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester < 7" ], [ "LOAD_NAME", "tester" ], [ "IS_OP", "(tester < 7) is tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester >= 78" ], [ "LOAD_NAME", "tester" ], [ "IS_OP", "(tester >= 78) is tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester != 79" ], [ "LOAD_NAME", "tester" ], [ "IS_OP", "(tester != 79) is tester" ], [ "LOAD_NAME", "tester" ], [ "LOAD_METHOD", "tester.foo" ], [ "CALL_METHOD", "tester.foo(45, False)" ], [ "COMPARE_OP", "tester.foo(45, False) == 45" ], [ "LOAD_NAME", "__name__" ], [ "COMPARE_OP", "__name__ == '__main__'" ], [ "LOAD_NAME", "unittest" ], [ "LOAD_METHOD", "unittest.main" ], [ "CALL_METHOD", "unittest.main()" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(1)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(2)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(3)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(9\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n 8)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n 99\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(33)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([4,\n 5, 6, [\n 7]])" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "LOAD_GLOBAL", "decorator_with_args" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('123')" ], [ "LOAD_GLOBAL", "int" ], [ "CALL_FUNCTION", "int()" ], [ "CALL_FUNCTION_KW", "decorator_with_args(tester('123'), x=int())" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "tuple([1, 2])" ], [ "CALL_FUNCTION", "list(tuple([1, 2]))" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "CALL_FUNCTION_KW", "tester(list(tuple([1, 2])), returns=empty_decorator)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "tuple(\n [3, 4])" ], [ "CALL_FUNCTION", "list(\n tuple(\n [3, 4]))" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "CALL_FUNCTION_KW", "tester(\n list(\n tuple(\n [3, 4])),\n returns=empty_decorator)" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "LOAD_GLOBAL", "decorator_with_args" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "str()" ], [ "LOAD_GLOBAL", "int" ], [ "CALL_FUNCTION", "int()" ], [ "CALL_FUNCTION_KW", "decorator_with_args(\n str(),\n x=int())" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "tuple([5, 6])" ], [ "CALL_FUNCTION", "list(tuple([5, 6]))" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "CALL_FUNCTION_KW", "tester(list(tuple([5, 6])), returns=empty_decorator)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "tuple([7, 8])" ], [ "CALL_FUNCTION", "list(tuple([7, 8]))" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "CALL_FUNCTION_KW", "tester(list(tuple([7, 8])), returns=empty_decorator)" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "LOAD_GLOBAL", "decorator_with_args" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('sdf')" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('123234')" ], [ "CALL_FUNCTION_KW", "decorator_with_args(tester('sdf'), x=tester('123234'))" ], [ "CALL_FUNCTION", "decorator_with_args(tester('sdf'), x=tester('123234'))" ], [ "CALL_FUNCTION", "empty_decorator" ], [ "CALL_FUNCTION", "tester(list(tuple([7, 8])), returns=empty_decorator)" ], [ "CALL_FUNCTION", "tester(list(tuple([5, 6])), returns=empty_decorator)" ], [ "CALL_FUNCTION", "decorator_with_args(\n str(),\n x=int())" ], [ "CALL_FUNCTION", "empty_decorator" ], [ "CALL_FUNCTION", "tester(\n list(\n tuple(\n [3, 4])),\n returns=empty_decorator)" ], [ "CALL_FUNCTION", "tester(list(tuple([1, 2])), returns=empty_decorator)" ], [ "CALL_FUNCTION", "decorator_with_args(tester('123'), x=int())" ], [ "CALL_FUNCTION", "empty_decorator" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "str([{tester(x) for x in [1]}, {tester(y) for y in [1]}])" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "str([{tester(x) for x in [1]},\n {tester(x) for x in [1]}])" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "list(tester(x) for x in [1])" ], [ "CALL_FUNCTION", "str([{tester(x) for x in [1]}, list(tester(x) for x in [1])])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "y" ], [ "CALL_FUNCTION", "tester(y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertEqual" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(3)" ], [ "CALL_FUNCTION", "(lambda x: (tester(x), tester(x)))(tester(3))" ], [ "CALL_METHOD", "self.assertEqual(\n (lambda x: (tester(x), tester(x)))(tester(3)),\n (3, 3),\n )" ], [ "CALL_FUNCTION", "(lambda: (lambda: tester(1))())()" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertEqual" ], [ "CALL_FUNCTION", "(lambda: [tester(x) for x in tester([1, 2])])()" ], [ "CALL_METHOD", "self.assertEqual(\n (lambda: [tester(x) for x in tester([1, 2])])(),\n [1, 2],\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "CALL_FUNCTION", "(lambda: tester(1))()" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(1)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x): {tester(b+x): {tester(c+x) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_FAST", "foo" ], [ "CALL_FUNCTION", "foo()" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "CALL_FUNCTION", "tester(a+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "CALL_FUNCTION", "tester(b+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "CALL_FUNCTION", "tester(c+x)" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x): {tester(b+x): {tester(c+x) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+y): {tester(b+y): {tester(c+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x+y): {tester(b+x+y): {tester(c+x+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_FAST", "bar" ], [ "CALL_FUNCTION", "bar()" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "CALL_FUNCTION", "tester(a+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "CALL_FUNCTION", "tester(b+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "CALL_FUNCTION", "tester(c+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+y" ], [ "CALL_FUNCTION", "tester(a+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+y" ], [ "CALL_FUNCTION", "tester(b+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+y" ], [ "CALL_FUNCTION", "tester(c+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+x+y" ], [ "CALL_FUNCTION", "tester(a+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+x+y" ], [ "CALL_FUNCTION", "tester(b+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+x+y" ], [ "CALL_FUNCTION", "tester(c+x+y)" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x): {tester(b+x): {tester(c+x) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+y): {tester(b+y): {tester(c+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x+y): {tester(b+x+y): {tester(c+x+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x+y+z): {tester(b+x+y+z): {tester(c+x+y+z) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "CALL_FUNCTION", "tester(a+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "CALL_FUNCTION", "tester(b+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "CALL_FUNCTION", "tester(c+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+y" ], [ "CALL_FUNCTION", "tester(a+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+y" ], [ "CALL_FUNCTION", "tester(b+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+y" ], [ "CALL_FUNCTION", "tester(c+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+x+y" ], [ "CALL_FUNCTION", "tester(a+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+x+y" ], [ "CALL_FUNCTION", "tester(b+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+x+y" ], [ "CALL_FUNCTION", "tester(c+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+x+y" ], [ "LOAD_DEREF", "z" ], [ "BINARY_ADD", "a+x+y+z" ], [ "CALL_FUNCTION", "tester(a+x+y+z)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+x+y" ], [ "LOAD_DEREF", "z" ], [ "BINARY_ADD", "b+x+y+z" ], [ "CALL_FUNCTION", "tester(b+x+y+z)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+x+y" ], [ "LOAD_DEREF", "z" ], [ "BINARY_ADD", "c+x+y+z" ], [ "CALL_FUNCTION", "tester(c+x+y+z)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION_KW", "dict(x=tester)" ], [ "BINARY_SUBSCR", "dict(x=tester)['x']" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "dict(x=tester)['x'](tester)" ], [ "CALL_FUNCTION_KW", "dict(x=tester)['x'](tester)(3, check_func=False)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertRaises" ], [ "LOAD_GLOBAL", "TypeError" ], [ "CALL_METHOD", "self.assertRaises(TypeError)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2, 3])" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(0)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(0)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(4)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(5)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "tester(ValueError)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(9)" ], [ "LOAD_GLOBAL", "TypeError" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(10)" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "str()" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertRaises" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "Exception" ], [ "CALL_FUNCTION", "tester(Exception)" ], [ "CALL_METHOD", "self.assertRaises(tester(Exception))" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(0)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(0)" ], [ "LOAD_GLOBAL", "tester" ], [ "BINARY_TRUE_DIVIDE", "1 / 0" ], [ "CALL_FUNCTION", "tester(1 / 0)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "gen" ], [ "CALL_FUNCTION", "gen()" ], [ "CALL_FUNCTION", "list(gen())" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "gen2" ], [ "CALL_FUNCTION", "list(gen2)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(4)" ], [ "LOAD_GLOBAL", "time" ], [ "LOAD_METHOD", "time.time" ], [ "CALL_METHOD", "time.time()" ], [ "LOAD_GLOBAL", "range" ], [ "CALL_FUNCTION", "range(10000)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_METHOD", "Source.executing" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.currentframe" ], [ "CALL_METHOD", "inspect.currentframe()" ], [ "CALL_METHOD", "Source.executing(inspect.currentframe())" ], [ "LOAD_ATTR", "Source.executing(inspect.currentframe()).node" ], [ "LOAD_FAST", "node" ], [ "IS_OP", "node is None" ], [ "LOAD_FAST", "new_node" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertIs" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "new_node" ], [ "CALL_METHOD", "self.assertIs(node, new_node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertLess" ], [ "LOAD_GLOBAL", "time" ], [ "LOAD_METHOD", "time.time" ], [ "CALL_METHOD", "time.time()" ], [ "LOAD_FAST", "start" ], [ "BINARY_SUBTRACT", "time.time() - start" ], [ "CALL_METHOD", "self.assertLess(time.time() - start, 1)" ], [ "LOAD_FAST", "check" ], [ "CALL_FUNCTION", "check(u'# coding=utf8\\n\u00e9', 'utf8')" ], [ "LOAD_FAST", "check" ], [ "CALL_FUNCTION", "check(u'# coding=gbk\\n\u00e9', 'gbk')" ], [ "LOAD_FAST", "check" ], [ "LOAD_GLOBAL", "UnicodeDecodeError" ], [ "CALL_FUNCTION_KW", "check(u'# coding=utf8\\n\u00e9', 'gbk', exception=UnicodeDecodeError)" ], [ "LOAD_FAST", "check" ], [ "CALL_FUNCTION_KW", "check(u'# coding=gbk\\n\u00e9', 'utf8', matches=False)" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_FAST", "check" ], [ "CALL_FUNCTION", "check(u'\u00e9', 'utf8')" ], [ "LOAD_FAST", "check" ], [ "LOAD_GLOBAL", "SyntaxError" ], [ "CALL_FUNCTION_KW", "check(u'\u00e9', 'gbk', exception=SyntaxError)" ], [ "LOAD_FAST", "source" ], [ "LOAD_METHOD", "source.encode" ], [ "LOAD_FAST", "encoding" ], [ "CALL_METHOD", "source.encode(encoding)" ], [ "LOAD_FAST", "exception" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self.assertRaises" ], [ "LOAD_FAST", "exception" ], [ "CALL_METHOD", "self.assertRaises(exception)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_METHOD", "Source.decode_source" ], [ "LOAD_FAST", "encoded" ], [ "CALL_METHOD", "Source.decode_source(encoded)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_METHOD", "Source.decode_source" ], [ "LOAD_FAST", "encoded" ], [ "CALL_METHOD", "Source.decode_source(encoded)" ], [ "LOAD_FAST", "matches" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self.assertEqual" ], [ "LOAD_FAST", "decoded" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "self.assertEqual(decoded, source)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self.assertNotEqual" ], [ "LOAD_FAST", "decoded" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "self.assertNotEqual(decoded, source)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('a')" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('''\n ab''')" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('''\n abc\n def\n '''\n )" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n '''\n 123\n 456\n '''\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n '''\n 345\n 456786\n '''\n )" ], [ "CALL_FUNCTION", "str([\n tester(\n '''\n 123\n 456\n '''\n ),\n tester(\n '''\n 345\n 456786\n '''\n ),\n ])" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n [\n '''\n 123\n 456\n '''\n '''\n 345\n 456786\n '''\n ,\n '''\n 123\n 456\n ''',\n '''\n 345\n 456786\n '''\n ]\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(1)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(2)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(3)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_METHOD", "Source.for_filename" ], [ "LOAD_GLOBAL", "__file__" ], [ "CALL_METHOD", "Source.for_filename(__file__)" ], [ "LOAD_METHOD", "Source.for_filename(__file__).code_qualname" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.__code__" ], [ "CALL_METHOD", "Source.for_filename(__file__).code_qualname(func.__code__)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertEqual" ], [ "LOAD_FAST", "qn" ], [ "LOAD_FAST", "qualname" ], [ "CALL_METHOD", "self.assertEqual(qn, qualname)" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_FAST", "check_actual_qualname" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertEqual" ], [ "LOAD_FAST", "qn" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.__qualname__" ], [ "CALL_METHOD", "self.assertEqual(qn, func.__qualname__)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertTrue" ], [ "LOAD_FAST", "qn" ], [ "LOAD_METHOD", "qn.endswith" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.__name__" ], [ "CALL_METHOD", "qn.endswith(func.__name__)" ], [ "CALL_METHOD", "self.assertTrue(qn.endswith(func.__name__))" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assert_qualname" ], [ "LOAD_GLOBAL", "C" ], [ "LOAD_ATTR", "C.f" ], [ "CALL_METHOD", "self.assert_qualname(C.f, 'C.f')" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assert_qualname" ], [ "LOAD_GLOBAL", "C" ], [ "LOAD_ATTR", "C.D" ], [ "LOAD_ATTR", "C.D.g" ], [ "CALL_METHOD", "self.assert_qualname(C.D.g, 'C.D.g')" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assert_qualname" ], [ "LOAD_GLOBAL", "f" ], [ "CALL_METHOD", "self.assert_qualname(f, 'f')" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assert_qualname" ], [ "LOAD_GLOBAL", "f" ], [ "CALL_FUNCTION", "f()" ], [ "CALL_METHOD", "self.assert_qualname(f(), 'f..g')" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assert_qualname" ], [ "LOAD_GLOBAL", "C" ], [ "LOAD_ATTR", "C.D" ], [ "LOAD_METHOD", "C.D.h" ], [ "CALL_METHOD", "C.D.h()" ], [ "CALL_METHOD", "self.assert_qualname(C.D.h(), 'C.D.h..i..j')" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assert_qualname" ], [ "LOAD_GLOBAL", "lamb" ], [ "CALL_METHOD", "self.assert_qualname(lamb, '')" ], [ "LOAD_GLOBAL", "lambda_maker" ], [ "CALL_FUNCTION", "lambda_maker()" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assert_qualname" ], [ "LOAD_FAST", "foo" ], [ "CALL_METHOD", "self.assert_qualname(foo, 'lambda_maker..foo')" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assert_qualname" ], [ "LOAD_FAST", "foo" ], [ "LOAD_ATTR", "foo.x" ], [ "CALL_METHOD", "self.assert_qualname(foo.x, 'lambda_maker..')" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assert_qualname" ], [ "LOAD_FAST", "foo" ], [ "CALL_FUNCTION", "foo()" ], [ "CALL_METHOD", "self.assert_qualname(foo(), 'lambda_maker..foo..')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assert_qualname" ], [ "LOAD_FAST", "foo" ], [ "CALL_FUNCTION", "foo()" ], [ "CALL_FUNCTION", "foo()()" ], [ "CALL_FUNCTION_KW", "self.assert_qualname(foo()(), 'lambda_maker..foo..', check_actual_qualname=False)" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "range" ], [ "CALL_FUNCTION", "range(66000)" ], [ "CALL_FUNCTION", "list(range(66000))" ], [ "BINARY_MODULO", "'tester(6)\\n%s\\ntester(9)' % list(range(66000))" ], [ "LOAD_GLOBAL", "tempfile" ], [ "LOAD_METHOD", "tempfile.mkstemp" ], [ "CALL_METHOD", "tempfile.mkstemp()" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "compile(source, filename, 'exec')" ], [ "LOAD_GLOBAL", "open" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "open(filename, 'w')" ], [ "LOAD_FAST", "outfile" ], [ "LOAD_METHOD", "outfile.write" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "outfile.write(source)" ], [ "LOAD_GLOBAL", "exec" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "exec(code)" ], [ "LOAD_GLOBAL", "range" ], [ "CALL_FUNCTION", "range(5)" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "n" ], [ "CALL_FUNCTION", "range(n)" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "n == 1" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertEqual" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_FAST", "gen" ], [ "CALL_FUNCTION", "only(gen)" ], [ "CALL_METHOD", "self.assertEqual(only(gen), 0)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertRaises" ], [ "LOAD_GLOBAL", "NotOneValueFound" ], [ "CALL_METHOD", "self.assertRaises(NotOneValueFound)" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_FAST", "gen" ], [ "CALL_FUNCTION", "only(gen)" ], [ "LOAD_FAST", "i" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_METHOD", "os.path.join" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_METHOD", "os.path.dirname" ], [ "LOAD_GLOBAL", "__file__" ], [ "CALL_METHOD", "os.path.dirname(__file__)" ], [ "CALL_METHOD", "os.path.join(os.path.dirname(__file__), 'not_code.txt', )" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_METHOD", "Source.for_filename" ], [ "LOAD_FAST", "path" ], [ "CALL_METHOD", "Source.for_filename(path)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertIsNone" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.tree" ], [ "CALL_METHOD", "self.assertIsNone(source.tree)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.currentframe" ], [ "CALL_METHOD", "inspect.currentframe()" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_METHOD", "Source.executing" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "Source.executing(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertEqual" ], [ "LOAD_FAST", "executing" ], [ "LOAD_METHOD", "executing.code_qualname" ], [ "CALL_METHOD", "executing.code_qualname()" ], [ "CALL_METHOD", "self.assertEqual(executing.code_qualname(), 'TestStuff.test_executing_methods')" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.version" ], [ "LOAD_METHOD", "sys.version.lower" ], [ "CALL_METHOD", "sys.version.lower()" ], [ "CONTAINS_OP", "'pypy' not in sys.version.lower()" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertEqual" ], [ "LOAD_FAST", "executing" ], [ "LOAD_METHOD", "executing.text" ], [ "CALL_METHOD", "executing.text()" ], [ "LOAD_FAST", "text" ], [ "CALL_METHOD", "self.assertEqual(executing.text(), text)" ], [ "LOAD_FAST", "executing" ], [ "LOAD_METHOD", "executing.text_range" ], [ "CALL_METHOD", "executing.text_range()" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertEqual" ], [ "LOAD_FAST", "executing" ], [ "LOAD_ATTR", "executing.source" ], [ "LOAD_ATTR", "executing.source.text" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "BINARY_SUBSCR", "executing.source.text[start:end]" ], [ "LOAD_FAST", "text" ], [ "CALL_METHOD", "self.assertEqual(executing.source.text[start:end], text)" ], [ "LOAD_GLOBAL", "C" ], [ "CALL_FUNCTION", "C()" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_FAST", "c" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.x" ], [ "LOAD_ATTR", "c.x.x" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.x" ], [ "LOAD_ATTR", "c.x.y" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.y" ], [ "LOAD_ATTR", "c.y.x" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.y" ], [ "LOAD_ATTR", "c.y.y" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.x" ], [ "LOAD_ATTR", "c.x.asd" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.y" ], [ "LOAD_ATTR", "c.y.qwe" ], [ "CALL_FUNCTION", "str((c.x.x, c.x.y, c.y.x, c.y.y, c.x.asd, c.y.qwe))" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_METHOD", "Source.for_frame" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.currentframe" ], [ "CALL_METHOD", "inspect.currentframe()" ], [ "CALL_METHOD", "Source.for_frame(inspect.currentframe())" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.text" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.filename" ], [ "CALL_FUNCTION", "compile(source.text, source.filename, 'exec')" ], [ "LOAD_GLOBAL", "get_instructions" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "get_instructions(code)" ], [ "LOAD_FAST", "instructions" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.starts_line" ], [ "IS_OP", "inst.starts_line is not None" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.starts_line" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.opname" ], [ "LOAD_METHOD", "inst.opname.startswith" ], [ "CALL_METHOD", "inst.opname.startswith(\n ('BINARY_', 'UNARY_', 'LOAD_ATTR', 'LOAD_METHOD', 'LOOKUP_METHOD', 'COMPARE_OP'))" ], [ "LOAD_GLOBAL", "C" ], [ "CALL_FUNCTION", "C()" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.offset" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "frame" ], [ "LOAD_GLOBAL", "globals" ], [ "CALL_FUNCTION", "globals()" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "lineno" ], [ "LOAD_FAST", "frame" ], [ "LOAD_GLOBAL", "print" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.opname" ], [ "CALL_FUNCTION", "print(inst.opname)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_METHOD", "Source.executing" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "Source.executing(frame)" ], [ "LOAD_ATTR", "Source.executing(frame).node" ], [ "IS_OP", "Source.executing(frame).node is not None" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_FAST", "i" ], [ "CALL_FUNCTION", "i()" ], [ "LOAD_FAST", "j" ], [ "LOAD_FAST", "g" ], [ "LOAD_FAST", "assign" ], [ "CALL_FUNCTION", "assign(lambda: 1)" ], [ "CALL_FUNCTION", "assign(lambda: 1)" ], [ "LOAD_FAST", "foo" ], [ "LOAD_FAST", "decorator" ], [ "LOAD_DEREF", "x" ], [ "LOAD_FAST", "func" ], [ "LOAD_FAST", "func" ], [ "LOAD_NAME", "__add__" ], [ "LOAD_NAME", "__invert__" ], [ "LOAD_NAME", "__lt__" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.currentframe" ], [ "CALL_METHOD", "inspect.currentframe()" ], [ "LOAD_ATTR", "inspect.currentframe().f_back" ], [ "LOAD_ATTR", "inspect.currentframe().f_back.f_back" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_METHOD", "Source.lazycache" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "Source.lazycache(frame)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_METHOD", "Source.executing" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "Source.executing(frame)" ], [ "LOAD_ATTR", "Source.executing(frame).node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "typ" ], [ "CALL_FUNCTION", "isinstance(node, typ)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "typ" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.currentframe" ], [ "CALL_METHOD", "inspect.currentframe()" ], [ "LOAD_ATTR", "inspect.currentframe().f_back" ], [ "LOAD_ATTR", "inspect.currentframe().f_back.f_back" ], [ "LOAD_GLOBAL", "eval" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.Expression" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.Expression(node)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_filename" ], [ "CALL_FUNCTION", "compile(ast.Expression(node), frame.f_code.co_filename, 'eval')" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "CALL_FUNCTION", "eval(\n compile(ast.Expression(node), frame.f_code.co_filename, 'eval'),\n frame.f_globals,\n frame.f_locals,\n )" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "value" ], [ "COMPARE_OP", "result == value" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Call" ], [ "CALL_METHOD", "self.get_node(ast.Call)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.check" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.args" ], [ "BINARY_SUBSCR", "call.args[0]" ], [ "LOAD_FAST", "arg" ], [ "CALL_METHOD", "self.check(call.args[0], arg)" ], [ "LOAD_FAST", "check_func" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.check" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.func" ], [ "LOAD_FAST", "self" ], [ "CALL_METHOD", "self.check(call.func, self)" ], [ "LOAD_FAST", "returns" ], [ "IS_OP", "returns is None" ], [ "LOAD_FAST", "arg" ], [ "LOAD_FAST", "returns" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Attribute" ], [ "CALL_METHOD", "self.get_node(ast.Attribute)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.value" ], [ "LOAD_FAST", "self" ], [ "CALL_METHOD", "self.check(node.value, self)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.attr" ], [ "LOAD_FAST", "item" ], [ "COMPARE_OP", "node.attr == item" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Subscript" ], [ "CALL_METHOD", "self.get_node(ast.Subscript)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.value" ], [ "LOAD_FAST", "self" ], [ "CALL_METHOD", "self.check(node.value, self)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.slice" ], [ "LOAD_ATTR", "node.slice.value" ], [ "LOAD_FAST", "item" ], [ "CALL_METHOD", "self.check(node.slice.value, item)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.BinOp" ], [ "CALL_METHOD", "self.get_node(ast.BinOp)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.left" ], [ "LOAD_FAST", "self" ], [ "CALL_METHOD", "self.check(node.left, self)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.right" ], [ "LOAD_FAST", "other" ], [ "CALL_METHOD", "self.check(node.right, other)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.UnaryOp" ], [ "CALL_METHOD", "self.get_node(ast.UnaryOp)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.operand" ], [ "LOAD_FAST", "self" ], [ "CALL_METHOD", "self.check(node.operand, self)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Compare" ], [ "CALL_METHOD", "self.get_node(ast.Compare)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.left" ], [ "LOAD_FAST", "self" ], [ "CALL_METHOD", "self.check(node.left, self)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.comparators" ], [ "BINARY_SUBSCR", "node.comparators[0]" ], [ "LOAD_FAST", "other" ], [ "CALL_METHOD", "self.check(node.comparators[0], other)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "func" ], [ "LOAD_GLOBAL", "empty_decorator" ] ], "tracer.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOAD_METHOD", "standard_library.install_aliases" ], [ "CALL_METHOD", "standard_library.install_aliases()" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "NamedTuple" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "Union" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "BINARY_SUBSCR", "Union[ast.expr, ast.stmt]" ], [ "BINARY_SUBSCR", "Optional[Union[ast.expr, ast.stmt]]" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.AST" ], [ "LOAD_NAME", "FrameType" ], [ "LOAD_NAME", "FrameType" ], [ "CALL_FUNCTION", "NamedTuple('EnterCallInfo', [\n\n # Node from where the call was made\n ('call_node', Optional[Union[ast.expr, ast.stmt]]),\n\n # Node where the call begins\n ('enter_node', ast.AST),\n\n # Frame from which the call was made\n ('caller_frame', FrameType),\n\n # Frame of the call\n ('current_frame', FrameType)])" ], [ "LOAD_NAME", "NamedTuple" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "Union" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "BINARY_SUBSCR", "Union[ast.expr, ast.stmt]" ], [ "BINARY_SUBSCR", "Optional[Union[ast.expr, ast.stmt]]" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.Return" ], [ "BINARY_SUBSCR", "Optional[ast.Return]" ], [ "LOAD_NAME", "FrameType" ], [ "LOAD_NAME", "FrameType" ], [ "LOAD_NAME", "Any" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "Exception" ], [ "BINARY_SUBSCR", "Optional[Exception]" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "TracebackType" ], [ "BINARY_SUBSCR", "Optional[TracebackType]" ], [ "CALL_FUNCTION", "NamedTuple('ExitCallInfo', [\n\n # Node from where the call was made\n ('call_node', Optional[Union[ast.expr, ast.stmt]]),\n\n # Node where the call explicitly returned\n ('return_node', Optional[ast.Return]),\n\n # Frame from which the call was made\n ('caller_frame', FrameType),\n\n # Frame of the call\n ('current_frame', FrameType),\n\n # Node where the call explicitly returned\n ('return_value', Any),\n\n # Exception raised in the call causing it to end,\n # will propagate to the caller\n ('exc_value', Optional[Exception]),\n\n # Traceback corresponding to exc_value\n ('exc_tb', Optional[TracebackType])])" ], [ "LOAD_NAME", "namedtuple" ], [ "CALL_FUNCTION", "namedtuple('ChangeValue', 'value')" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.NodeTransformer" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "Union" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "BINARY_SUBSCR", "Union[ast.For, ast.While, ast.comprehension]" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.PyCF_ONLY_AST" ], [ "LOAD_FAST", "flags" ], [ "BINARY_OR", "ast.PyCF_ONLY_AST | flags" ], [ "CALL_FUNCTION_KW", "compile(source, filename, 'exec', ast.PyCF_ONLY_AST | flags, dont_inherit=True)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.set_basic_node_attributes" ], [ "CALL_METHOD", "self.set_basic_node_attributes()" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_METHOD", "tracer.parse_extra" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "CALL_METHOD", "tracer.parse_extra(self.root, source, filename)" ], [ "LOAD_FAST", "new_root" ], [ "IS_OP", "new_root is not None" ], [ "LOAD_FAST", "new_root" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.set_basic_node_attributes" ], [ "CALL_METHOD", "self.set_basic_node_attributes()" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.set_enter_call_nodes" ], [ "CALL_METHOD", "self.set_enter_call_nodes()" ], [ "LOAD_GLOBAL", "deepcopy" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "CALL_FUNCTION", "deepcopy(self.root)" ], [ "LOAD_GLOBAL", "_NodeVisitor" ], [ "CALL_FUNCTION", "_NodeVisitor()" ], [ "LOAD_METHOD", "_NodeVisitor().visit" ], [ "LOAD_FAST", "new_root" ], [ "CALL_METHOD", "_NodeVisitor().visit(new_root)" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "new_root" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "flags" ], [ "CALL_FUNCTION_KW", "compile(new_root, filename, \"exec\", dont_inherit=True, flags=flags)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.walk" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "CALL_METHOD", "ast.walk(self.root)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.iter_child_nodes" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.iter_child_nodes(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.nodes" ], [ "CALL_FUNCTION", "len(self.nodes)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.nodes" ], [ "LOAD_METHOD", "self.nodes.append" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self.nodes.append(node)" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "LOAD_ATTR", "self.root.body" ], [ "CALL_FUNCTION", "enumerate(self.root.body)" ], [ "LOAD_GLOBAL", "is_future_import" ], [ "LOAD_FAST", "stmt" ], [ "CALL_FUNCTION", "is_future_import(stmt)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "LOAD_ATTR", "self.root.body" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "self.root.body[:i + 1]" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.walk" ], [ "LOAD_FAST", "s" ], [ "CALL_METHOD", "ast.walk(s)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.nodes" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Module" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(node, (ast.Module, ast.FunctionDef))" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.body" ], [ "LOAD_GLOBAL", "is_future_import" ], [ "LOAD_FAST", "stmt" ], [ "CALL_FUNCTION", "is_future_import(stmt)" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_NAME", "lru_cache" ], [ "CALL_FUNCTION", "lru_cache()" ], [ "CALL_FUNCTION", "lru_cache()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "defaultdict(list)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "TracedFile" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "flags" ], [ "CALL_FUNCTION", "TracedFile(self, source, filename, flags)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._treetrace_hidden_with_stmt" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._treetrace_hidden_before_expr" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._treetrace_hidden_after_expr" ], [ "LOAD_FAST", "f" ], [ "LOAD_ATTR", "f.__name__" ], [ "LOAD_GLOBAL", "partial" ], [ "LOAD_FAST", "f" ], [ "LOAD_DEREF", "traced_file" ], [ "CALL_FUNCTION", "partial(f, traced_file)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_DEREF", "func" ], [ "LOAD_GLOBAL", "FunctionType" ], [ "CALL_FUNCTION", "isinstance(func, FunctionType)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError('You can only trace user-defined functions. '\n 'The birdseye decorator must be applied first, '\n 'at the bottom of the list.')" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.iscoroutinefunction" ], [ "LOAD_DEREF", "func" ], [ "CALL_METHOD", "inspect.iscoroutinefunction(func)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.isasyncgenfunction" ], [ "LOAD_DEREF", "func" ], [ "CALL_METHOD", "inspect.isasyncgenfunction(func)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError('You cannot trace async functions')" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_GLOBAL", "is_lambda" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "is_lambda(func)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError('You cannot trace lambdas')" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.getsourcefile" ], [ "LOAD_DEREF", "func" ], [ "CALL_METHOD", "inspect.getsourcefile(func)" ], [ "LOAD_GLOBAL", "is_ipython_cell" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "is_ipython_cell(filename)" ], [ "LOAD_FAST", "get_ipython" ], [ "CALL_FUNCTION", "get_ipython()" ], [ "LOAD_ATTR", "get_ipython().compile" ], [ "LOAD_ATTR", "get_ipython().compile.flags" ], [ "LOAD_METHOD", "''.join" ], [ "LOAD_FAST", "linecache" ], [ "LOAD_ATTR", "linecache.cache" ], [ "LOAD_FAST", "filename" ], [ "BINARY_SUBSCR", "linecache.cache[filename]" ], [ "BINARY_SUBSCR", "linecache.cache[filename][2]" ], [ "CALL_METHOD", "''.join(linecache.cache[filename][2])" ], [ "LOAD_GLOBAL", "read_source_file" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "read_source_file(filename)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "flags" ], [ "CALL_METHOD", "self.compile(source, filename, flags)" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__dict__" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError('The birdseye decorator must be applied first, '\n 'at the bottom of the list.')" ], [ "LOAD_DEREF", "find_code" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.code" ], [ "CALL_FUNCTION", "find_code(traced_file.code)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_DEREF", "code_options" ], [ "CALL_FUNCTION", "len(code_options)" ], [ "COMPARE_OP", "len(code_options) > 1" ], [ "LOAD_GLOBAL", "is_lambda" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "is_lambda(func)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError(\"Failed to trace lambda. Convert the function to a def.\")" ], [ "LOAD_DEREF", "code_options" ], [ "BINARY_SUBSCR", "code_options[0]" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__globals__" ], [ "LOAD_METHOD", "func.__globals__.update" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._trace_methods_dict" ], [ "LOAD_FAST", "traced_file" ], [ "CALL_METHOD", "self._trace_methods_dict(traced_file)" ], [ "CALL_METHOD", "func.__globals__.update(self._trace_methods_dict(traced_file))" ], [ "LOAD_GLOBAL", "FunctionType" ], [ "LOAD_FAST", "new_func_code" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__globals__" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__name__" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__defaults__" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__closure__" ], [ "CALL_FUNCTION", "FunctionType(new_func_code, func.__globals__, func.__name__, func.__defaults__, func.__closure__)" ], [ "LOAD_GLOBAL", "update_wrapper" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "update_wrapper(new_func, func)" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "getattr(func, '__kwdefaults__', None)" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_FAST", "root_code" ], [ "LOAD_ATTR", "root_code.co_consts" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.iscode" ], [ "LOAD_FAST", "const" ], [ "CALL_METHOD", "inspect.iscode(const)" ], [ "LOAD_FAST", "const" ], [ "LOAD_ATTR", "const.co_firstlineno" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__code__" ], [ "LOAD_ATTR", "func.__code__.co_firstlineno" ], [ "COMPARE_OP", "const.co_firstlineno == func.__code__.co_firstlineno" ], [ "LOAD_FAST", "const" ], [ "LOAD_ATTR", "const.co_name" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__code__" ], [ "LOAD_ATTR", "func.__code__.co_name" ], [ "COMPARE_OP", "const.co_name == func.__code__.co_name" ], [ "LOAD_FAST", "matches" ], [ "LOAD_DEREF", "code_options" ], [ "LOAD_METHOD", "code_options.append" ], [ "LOAD_FAST", "const" ], [ "CALL_METHOD", "code_options.append(const)" ], [ "LOAD_DEREF", "find_code" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "find_code(const)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.isclass" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "inspect.isclass(func)" ], [ "LOAD_GLOBAL", "TypeError" ], [ "CALL_FUNCTION", "TypeError('Decorating classes is no longer supported')" ], [ "LOAD_FAST", "func" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self.trace_function" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "self.trace_function(func)" ], [ "LOAD_FAST", "optional" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.trace_function" ], [ "LOAD_FAST", "decorator" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self.trace_function" ], [ "LOAD_DEREF", "actual_func" ], [ "CALL_METHOD", "self.trace_function(actual_func)" ], [ "LOAD_GLOBAL", "wraps" ], [ "LOAD_DEREF", "actual_func" ], [ "CALL_FUNCTION", "wraps(actual_func)" ], [ "CALL_FUNCTION", "wraps(actual_func)" ], [ "LOAD_FAST", "wrapper" ], [ "LOAD_FAST", "kwargs" ], [ "LOAD_METHOD", "kwargs.pop" ], [ "CALL_METHOD", "kwargs.pop('trace_call', False)" ], [ "LOAD_FAST", "trace_call" ], [ "LOAD_DEREF", "traced" ], [ "LOAD_DEREF", "actual_func" ], [ "LOAD_FAST", "f" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "f(*args, **kwargs)" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_METHOD", "sys._getframe" ], [ "CALL_METHOD", "sys._getframe(2)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.secondary_to_main_frames" ], [ "LOAD_METHOD", "self.secondary_to_main_frames.get" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self.secondary_to_main_frames.get(frame)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "CONTAINS_OP", "frame.f_code.co_name in ('', '', '')" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "CONTAINS_OP", "frame.f_code.co_name in ('', '', '')" ], [ "LOAD_GLOBAL", "ancestors" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ancestors(node)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Lambda" ], [ "CALL_FUNCTION", "isinstance(node, (ast.FunctionDef, ast.Lambda))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.ClassDef" ], [ "CALL_FUNCTION", "isinstance(node, ast.ClassDef)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "CONTAINS_OP", "frame.f_code.co_name in ('', '')" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.secondary_to_main_frames" ], [ "LOAD_FAST", "original_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.main_to_secondary_frames" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.main_to_secondary_frames[frame]" ], [ "LOAD_METHOD", "self.main_to_secondary_frames[frame].append" ], [ "LOAD_FAST", "original_frame" ], [ "CALL_METHOD", "self.main_to_secondary_frames[frame].append(original_frame)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.nodes" ], [ "LOAD_FAST", "_tree_index" ], [ "BINARY_SUBSCR", "traced_file.nodes[_tree_index]" ], [ "LOAD_GLOBAL", "cast" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "cast(ast.stmt, node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._main_frame" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self._main_frame(node)" ], [ "LOAD_GLOBAL", "_StmtContext" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "_StmtContext(self, node, frame)" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.nodes" ], [ "LOAD_FAST", "_tree_index" ], [ "BINARY_SUBSCR", "traced_file.nodes[_tree_index]" ], [ "LOAD_GLOBAL", "cast" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "cast(ast.expr, node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._main_frame" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self._main_frame(node)" ], [ "LOAD_FAST", "frame" ], [ "IS_OP", "frame is None" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_stack" ], [ "LOAD_METHOD", "frame_info.expression_stack.append" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "frame_info.expression_stack.append(node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.before_expr" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self.before_expr(node, frame)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._main_frame" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self._main_frame(node)" ], [ "LOAD_FAST", "frame" ], [ "IS_OP", "frame is None" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._after_expr" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "value" ], [ "CALL_METHOD", "self._after_expr(node, frame, value, None, None)" ], [ "LOAD_FAST", "result" ], [ "IS_OP", "result is not None" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "ChangeValue" ], [ "CALL_FUNCTION", "isinstance(result, ChangeValue)" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.value" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_stack" ], [ "LOAD_METHOD", "frame_info.expression_stack.pop" ], [ "CALL_METHOD", "frame_info.expression_stack.pop()" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_values" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.after_expr" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "exc_value" ], [ "LOAD_FAST", "exc_tb" ], [ "CALL_METHOD", "self.after_expr(node, frame, value, exc_value, exc_tb)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._get_caller_stuff" ], [ "LOAD_FAST", "current_frame" ], [ "CALL_METHOD", "self._get_caller_stuff(current_frame)" ], [ "LOAD_GLOBAL", "FrameInfo" ], [ "CALL_FUNCTION", "FrameInfo()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "current_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.enter_call" ], [ "LOAD_GLOBAL", "EnterCallInfo" ], [ "LOAD_FAST", "call_node" ], [ "LOAD_FAST", "enter_node" ], [ "LOAD_FAST", "caller_frame" ], [ "LOAD_FAST", "current_frame" ], [ "CALL_FUNCTION", "EnterCallInfo(call_node, enter_node, caller_frame, current_frame)" ], [ "CALL_METHOD", "self.enter_call(EnterCallInfo(call_node, enter_node, caller_frame, current_frame))" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.secondary_to_main_frames" ], [ "LOAD_METHOD", "self.secondary_to_main_frames.get" ], [ "LOAD_FAST", "caller_frame" ], [ "CALL_METHOD", "self.secondary_to_main_frames.get(caller_frame)" ], [ "LOAD_FAST", "main_frame" ], [ "LOAD_FAST", "main_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "caller_frame" ], [ "BINARY_SUBSCR", "self.stack[caller_frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_stack" ], [ "LOAD_FAST", "expression_stack" ], [ "LOAD_FAST", "expression_stack" ], [ "BINARY_SUBSCR", "expression_stack[-1]" ], [ "LOAD_FAST", "caller_frame" ], [ "LOAD_FAST", "call_node" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.statement_stack" ], [ "BINARY_SUBSCR", "frame_info.statement_stack[-1]" ], [ "LOAD_FAST", "caller_frame" ], [ "LOAD_FAST", "call_node" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "getattr(node, '_visit_ignore', False)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "CALL_FUNCTION", "isinstance(node, ast.expr)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "hasattr(node, \"ctx\")" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.ctx" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Load" ], [ "CALL_FUNCTION", "isinstance(node.ctx, ast.Load)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "ast" ], [ "CALL_FUNCTION", "getattr(ast, 'Starred', ())" ], [ "CALL_FUNCTION", "isinstance(node, getattr(ast, 'Starred', ()))" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.visit_expr" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self.visit_expr(node)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "CALL_FUNCTION", "isinstance(node, ast.stmt)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.visit_stmt" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self.visit_stmt(node)" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "_NodeVisitor" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self)" ], [ "LOAD_METHOD", "super(_NodeVisitor, self).generic_visit" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "super(_NodeVisitor, self).generic_visit(node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._create_simple_marker_call" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "TreeTracerBase" ], [ "LOAD_ATTR", "TreeTracerBase._treetrace_hidden_before_expr" ], [ "CALL_METHOD", "self._create_simple_marker_call(node, TreeTracerBase._treetrace_hidden_before_expr)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.copy_location" ], [ "LOAD_FAST", "before_marker" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.copy_location(before_marker, node)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Call" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Name" ], [ "LOAD_GLOBAL", "TreeTracerBase" ], [ "LOAD_ATTR", "TreeTracerBase._treetrace_hidden_after_expr" ], [ "LOAD_ATTR", "TreeTracerBase._treetrace_hidden_after_expr.__name__" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.Load" ], [ "CALL_METHOD", "ast.Load()" ], [ "CALL_FUNCTION_KW", "ast.Name(id=TreeTracerBase._treetrace_hidden_after_expr.__name__,\n ctx=ast.Load())" ], [ "LOAD_FAST", "before_marker" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "_NodeVisitor" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self)" ], [ "LOAD_METHOD", "super(_NodeVisitor, self).generic_visit" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "super(_NodeVisitor, self).generic_visit(node)" ], [ "CALL_FUNCTION_KW", "ast.Call(\n func=ast.Name(id=TreeTracerBase._treetrace_hidden_after_expr.__name__,\n ctx=ast.Load()),\n args=[\n before_marker,\n super(_NodeVisitor, self).generic_visit(node),\n ],\n keywords=[],\n )" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.copy_location" ], [ "LOAD_FAST", "after_marker" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.copy_location(after_marker, node)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.fix_missing_locations" ], [ "LOAD_FAST", "after_marker" ], [ "CALL_METHOD", "ast.fix_missing_locations(after_marker)" ], [ "LOAD_FAST", "after_marker" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._create_simple_marker_call" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "_NodeVisitor" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self)" ], [ "LOAD_METHOD", "super(_NodeVisitor, self).generic_visit" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "super(_NodeVisitor, self).generic_visit(node)" ], [ "LOAD_GLOBAL", "TreeTracerBase" ], [ "LOAD_ATTR", "TreeTracerBase._treetrace_hidden_with_stmt" ], [ "CALL_METHOD", "self._create_simple_marker_call(\n super(_NodeVisitor, self).generic_visit(node),\n TreeTracerBase._treetrace_hidden_with_stmt)" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.With" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.withitem" ], [ "LOAD_FAST", "context_expr" ], [ "CALL_FUNCTION_KW", "ast.withitem(context_expr=context_expr)" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION_KW", "ast.With(\n items=[ast.withitem(context_expr=context_expr)],\n body=[node],\n )" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.With" ], [ "LOAD_FAST", "context_expr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION_KW", "ast.With(\n context_expr=context_expr,\n body=[node],\n )" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.copy_location" ], [ "LOAD_FAST", "wrapped" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.copy_location(wrapped, node)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.fix_missing_locations" ], [ "LOAD_FAST", "wrapped" ], [ "CALL_METHOD", "ast.fix_missing_locations(wrapped)" ], [ "LOAD_FAST", "wrapped" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Call" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Name" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.__name__" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.Load" ], [ "CALL_METHOD", "ast.Load()" ], [ "CALL_FUNCTION_KW", "ast.Name(id=func.__name__,\n ctx=ast.Load())" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.Num" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "CALL_METHOD", "ast.Num(node._tree_index)" ], [ "CALL_FUNCTION_KW", "ast.Call(\n func=ast.Name(id=func.__name__,\n ctx=ast.Load()),\n args=[ast.Num(node._tree_index)],\n keywords=[],\n )" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tracer" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "getattr(node, '_enter_call_node', False)" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_METHOD", "tracer._enter_call" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "tracer._enter_call(node, frame)" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "tracer.stack[frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.statement_stack" ], [ "LOAD_METHOD", "frame_info.statement_stack.append" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "frame_info.statement_stack.append(node)" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_METHOD", "tracer.before_stmt" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "tracer.before_stmt(node, frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tracer" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "tracer.stack[frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.statement_stack" ], [ "LOAD_METHOD", "frame_info.statement_stack.pop" ], [ "CALL_METHOD", "frame_info.statement_stack.pop()" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.exc_value" ], [ "IS_OP", "exc_val is not frame_info.exc_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_stack" ], [ "LOAD_FAST", "expression_stack" ], [ "LOAD_FAST", "expression_stack" ], [ "BINARY_SUBSCR", "expression_stack[-1]" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_METHOD", "tracer._after_expr" ], [ "LOAD_FAST", "exc_node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "exc_tb" ], [ "CALL_METHOD", "tracer._after_expr(exc_node, frame, None, exc_val, exc_tb)" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_METHOD", "tracer.after_stmt" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "exc_tb" ], [ "LOAD_FAST", "exc_node" ], [ "CALL_METHOD", "tracer.after_stmt(node, frame, exc_val, exc_tb, exc_node)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Return" ], [ "CALL_FUNCTION", "isinstance(node, ast.Return)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.return_node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Module" ], [ "CALL_FUNCTION", "isinstance(parent, (ast.FunctionDef, ast.Module))" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.body" ], [ "BINARY_SUBSCR", "parent.body[-1]" ], [ "IS_OP", "node is parent.body[-1]" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_FAST", "exiting" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_METHOD", "tracer._get_caller_stuff" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "tracer._get_caller_stuff(frame)" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_ATTR", "return_node.value" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_values" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_ATTR", "return_node.value" ], [ "BINARY_SUBSCR", "frame_info.expression_values[return_node.value]" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_METHOD", "tracer.exit_call" ], [ "LOAD_GLOBAL", "ExitCallInfo" ], [ "LOAD_FAST", "call_node" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_FAST", "caller_frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "return_value" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "exc_tb" ], [ "CALL_FUNCTION", "ExitCallInfo(call_node,\n return_node,\n caller_frame,\n frame,\n return_value,\n exc_val,\n exc_tb\n )" ], [ "CALL_METHOD", "tracer.exit_call(ExitCallInfo(call_node,\n return_node,\n caller_frame,\n frame,\n return_value,\n exc_val,\n exc_tb\n ))" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.stack" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tracer" ], [ "LOAD_ATTR", "self.tracer.main_to_secondary_frames" ], [ "LOAD_METHOD", "self.tracer.main_to_secondary_frames.pop" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self.tracer.main_to_secondary_frames.pop(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tracer" ], [ "LOAD_ATTR", "self.tracer.secondary_to_main_frames" ], [ "LOAD_FAST", "secondary_frame" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(parent, ast.FunctionDef)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "CALL_FUNCTION", "isinstance(parent, ast.For)" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.iter" ], [ "LOAD_DEREF", "node" ], [ "IS_OP", "parent.iter is not node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "CALL_FUNCTION", "isinstance(parent, ast.While)" ], [ "LOAD_DEREF", "node" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.orelse" ], [ "CONTAINS_OP", "node not in parent.orelse" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "CALL_FUNCTION", "isinstance(parent, ast.comprehension)" ], [ "LOAD_DEREF", "node" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.ifs" ], [ "CONTAINS_OP", "node in parent.ifs" ], [ "LOAD_FAST", "is_containing_loop" ], [ "LOAD_FAST", "result" ], [ "LOAD_METHOD", "result.append" ], [ "LOAD_FAST", "parent" ], [ "CALL_METHOD", "result.append(parent)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.ListComp" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.GeneratorExp" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.DictComp" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.SetComp" ], [ "CALL_FUNCTION", "isinstance(parent, (ast.ListComp,\n ast.GeneratorExp,\n ast.DictComp,\n ast.SetComp))" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.generators" ], [ "LOAD_DEREF", "node" ], [ "LOAD_FAST", "generators" ], [ "CONTAINS_OP", "node in generators" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "takewhile" ], [ "LOAD_FAST", "generators" ], [ "CALL_FUNCTION", "takewhile(lambda n: n != node, generators)" ], [ "CALL_FUNCTION", "list(takewhile(lambda n: n != node, generators))" ], [ "LOAD_FAST", "result" ], [ "LOAD_METHOD", "result.extend" ], [ "LOAD_GLOBAL", "reversed" ], [ "LOAD_FAST", "generators" ], [ "CALL_FUNCTION", "reversed(generators)" ], [ "CALL_METHOD", "result.extend(reversed(generators))" ], [ "LOAD_FAST", "parent" ], [ "LOAD_FAST", "result" ], [ "LOAD_METHOD", "result.reverse" ], [ "CALL_METHOD", "result.reverse()" ], [ "LOAD_GLOBAL", "tuple" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "tuple(result)" ], [ "LOAD_FAST", "n" ], [ "LOAD_DEREF", "node" ], [ "COMPARE_OP", "n != node" ] ], "tracer2.py": [ [ "LOAD_NAME", "find_repr_function" ], [ "LOAD_NAME", "six" ], [ "LOAD_ATTR", "six.text_type" ], [ "CALL_FUNCTION", "find_repr_function(six.text_type)" ], [ "LOAD_NAME", "find_repr_function" ], [ "LOAD_NAME", "six" ], [ "LOAD_ATTR", "six.binary_type" ], [ "CALL_FUNCTION", "find_repr_function(six.binary_type)" ], [ "LOAD_NAME", "find_repr_function" ], [ "LOAD_NAME", "object" ], [ "CALL_FUNCTION", "find_repr_function(object)" ], [ "LOAD_NAME", "find_repr_function" ], [ "LOAD_NAME", "int" ], [ "CALL_FUNCTION", "find_repr_function(int)" ], [ "LOAD_NAME", "cheap_repr" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "threading" ], [ "LOAD_METHOD", "threading.local" ], [ "CALL_METHOD", "threading.local()" ], [ "LOAD_NAME", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_METHOD", "os.path.dirname" ], [ "LOAD_ATTR", "(lambda: 0).__code__" ], [ "LOAD_ATTR", "(lambda: 0).__code__.co_filename" ], [ "CALL_METHOD", "os.path.dirname((lambda: 0).__code__.co_filename)" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_METHOD", "os.path.dirname" ], [ "LOAD_NAME", "birdseye" ], [ "LOAD_ATTR", "birdseye.__file__" ], [ "CALL_METHOD", "os.path.dirname(birdseye.__file__)" ], [ "LOAD_NAME", "type" ], [ "LOAD_NAME", "six" ], [ "LOAD_METHOD", "six.add_metaclass" ], [ "LOAD_NAME", "TracerMeta" ], [ "CALL_METHOD", "six.add_metaclass(TracerMeta)" ], [ "LOAD_NAME", "object" ], [ "CALL_FUNCTION", "six.add_metaclass(TracerMeta)" ], [ "LOAD_NAME", "object" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lineno" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "CALL_FUNCTION", "OrderedDict()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_METHOD", "Source.for_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "Source.for_frame(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_flags" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.CO_GENERATOR" ], [ "BINARY_AND", "frame.f_code.co_flags & inspect.CO_GENERATOR" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "is_comprehension_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "is_comprehension_frame(frame)" ], [ "LOAD_GLOBAL", "re" ], [ "LOAD_METHOD", "re.match" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "CALL_METHOD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name)" ], [ "LOAD_METHOD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group" ], [ "CALL_METHOD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group(1)" ], [ "LOAD_METHOD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group(1).title" ], [ "CALL_METHOD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group(1).title()" ], [ "BINARY_ADD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group(1).title()\n + u' comprehension'" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_lineno" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.local_reprs" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.get_local_reprs" ], [ "LOAD_FAST", "watch" ], [ "LOAD_FAST", "watch_extras" ], [ "CALL_METHOD", "self.get_local_reprs(watch, watch_extras)" ], [ "CALL_FUNCTION", "OrderedDict(\n (source, my_cheap_repr(value))\n for source, value in\n self.get_local_reprs(watch, watch_extras)\n )" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.comprehension_type" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.local_reprs" ], [ "LOAD_METHOD", "self.local_reprs.items" ], [ "CALL_METHOD", "self.local_reprs.items()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.comprehension_variables" ], [ "LOAD_METHOD", "self.comprehension_variables.setdefault" ], [ "LOAD_FAST", "name" ], [ "CALL_METHOD", "self.comprehension_variables.setdefault(name, [])" ], [ "LOAD_FAST", "values" ], [ "LOAD_FAST", "values" ], [ "BINARY_SUBSCR", "values[-1]" ], [ "LOAD_FAST", "value_repr" ], [ "COMPARE_OP", "values[-1] != value_repr" ], [ "LOAD_FAST", "values" ], [ "LOAD_METHOD", "values.append" ], [ "LOAD_FAST", "value_repr" ], [ "CALL_METHOD", "values.append(value_repr)" ], [ "LOAD_GLOBAL", "truncate_list" ], [ "LOAD_FAST", "values" ], [ "CALL_FUNCTION", "truncate_list(values, 11)" ], [ "LOAD_FAST", "values" ], [ "LOAD_FAST", "event" ], [ "CONTAINS_OP", "event in ('return', 'exception')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.comprehension_variables" ], [ "LOAD_METHOD", "self.comprehension_variables.items" ], [ "CALL_METHOD", "self.comprehension_variables.items()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.local_reprs" ], [ "LOAD_METHOD", "self.local_reprs.items" ], [ "CALL_METHOD", "self.local_reprs.items()" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "old_local_reprs" ], [ "CONTAINS_OP", "name not in old_local_reprs" ], [ "LOAD_FAST", "old_local_reprs" ], [ "LOAD_FAST", "name" ], [ "BINARY_SUBSCR", "old_local_reprs[name]" ], [ "LOAD_FAST", "value_repr" ], [ "COMPARE_OP", "old_local_reprs[name] != value_repr" ], [ "LOAD_FAST", "variables" ], [ "LOAD_METHOD", "variables.append" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "value_repr" ], [ "CALL_METHOD", "variables.append((name, value_repr))" ], [ "LOAD_FAST", "variables" ], [ "LOAD_FAST", "source" ], [ "LOAD_GLOBAL", "my_cheap_repr" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "my_cheap_repr(value)" ], [ "LOAD_FAST", "name" ], [ "LOAD_METHOD", "', '.join" ], [ "LOAD_FAST", "values" ], [ "CALL_METHOD", "', '.join(values)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_varnames" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_cellvars" ], [ "BINARY_ADD", "code.co_varnames + code.co_cellvars" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_freevars" ], [ "BINARY_ADD", "code.co_varnames + code.co_cellvars + code.co_freevars" ], [ "LOAD_GLOBAL", "tuple" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "LOAD_METHOD", "frame.f_locals.keys" ], [ "CALL_METHOD", "frame.f_locals.keys()" ], [ "CALL_FUNCTION", "tuple(frame.f_locals.keys())" ], [ "BINARY_ADD", "code.co_varnames + code.co_cellvars + code.co_freevars + tuple(frame.f_locals.keys())" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "LOAD_METHOD", "frame.f_locals.items" ], [ "CALL_METHOD", "frame.f_locals.items()" ], [ "CALL_FUNCTION_KW", "sorted(\n frame.f_locals.items(),\n key=lambda key_value: vars_order.index(key_value[0])\n )" ], [ "LOAD_FAST", "watch" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_FAST", "variable" ], [ "LOAD_METHOD", "variable.items" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "variable.items(frame)" ], [ "CALL_FUNCTION", "sorted(variable.items(frame))" ], [ "LOAD_FAST", "result_items" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "watch_extras" ], [ "LOAD_FAST", "extra" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "extra(source, value)" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_FAST", "pair" ], [ "IS_OP", "pair is not None" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "pair" ], [ "CALL_FUNCTION", "len(pair)" ], [ "COMPARE_OP", "len(pair) == 2" ], [ "LOAD_FAST", "pair" ], [ "LOAD_DEREF", "vars_order" ], [ "LOAD_METHOD", "vars_order.index" ], [ "LOAD_FAST", "key_value" ], [ "BINARY_SUBSCR", "key_value[0]" ], [ "CALL_METHOD", "vars_order.index(key_value[0])" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "TracerMeta" ], [ "LOAD_FAST", "mcs" ], [ "CALL_FUNCTION", "super(TracerMeta, mcs)" ], [ "LOAD_ATTR", "super(TracerMeta, mcs).__new__" ], [ "LOAD_FAST", "mcs" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "super(TracerMeta, mcs).__new__(mcs, *args, **kwargs)" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "result()" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "no_args_decorator" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION", "no_args_decorator(args, kwargs)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_METHOD", "cls.default" ], [ "LOAD_FAST", "args" ], [ "BINARY_SUBSCR", "args[0]" ], [ "CALL_METHOD", "cls.default(args[0])" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "TracerMeta" ], [ "LOAD_FAST", "cls" ], [ "CALL_FUNCTION", "super(TracerMeta, cls)" ], [ "LOAD_ATTR", "super(TracerMeta, cls).__call__" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "super(TracerMeta, cls).__call__(*args, **kwargs)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.default" ], [ "LOAD_ATTR", "self.default.__enter__" ], [ "CALL_FUNCTION_KW", "self.default.__enter__(context=1)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.default" ], [ "LOAD_ATTR", "self.default.__exit__" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION_EX", "self.default.__exit__(*args, context=1)" ], [ "LOAD_GLOBAL", "ensure_tuple" ], [ "LOAD_FAST", "watch" ], [ "CALL_FUNCTION", "ensure_tuple(watch)" ], [ "LOAD_GLOBAL", "ensure_tuple" ], [ "LOAD_FAST", "watch_explode" ], [ "CALL_FUNCTION", "ensure_tuple(watch_explode)" ], [ "BINARY_ADD", "[\n v if isinstance(v, BaseVariable) else CommonVariable(v)\n for v in ensure_tuple(watch)\n ] + [\n v if isinstance(v, BaseVariable) else Exploding(v)\n for v in ensure_tuple(watch_explode)\n ]" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "ArgDefaultDict" ], [ "LOAD_GLOBAL", "FrameInfo" ], [ "CALL_FUNCTION", "ArgDefaultDict(FrameInfo)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "depth" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.depth" ], [ "COMPARE_OP", "self.depth >= 1" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "BaseVariable" ], [ "CALL_FUNCTION", "isinstance(v, BaseVariable)" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "CommonVariable" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "CommonVariable(v)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "BaseVariable" ], [ "CALL_FUNCTION", "isinstance(v, BaseVariable)" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "Exploding" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "Exploding(v)" ], [ "LOAD_GLOBAL", "iscoroutinefunction" ], [ "LOAD_DEREF", "function" ], [ "CALL_FUNCTION", "iscoroutinefunction(function)" ], [ "LOAD_GLOBAL", "NotImplementedError" ], [ "CALL_FUNCTION", "NotImplementedError(\"coroutines are not supported, sorry!\")" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.target_codes" ], [ "LOAD_METHOD", "self.target_codes.add" ], [ "LOAD_DEREF", "function" ], [ "LOAD_ATTR", "function.__code__" ], [ "CALL_METHOD", "self.target_codes.add(function.__code__)" ], [ "LOAD_GLOBAL", "functools" ], [ "LOAD_METHOD", "functools.wraps" ], [ "LOAD_DEREF", "function" ], [ "CALL_METHOD", "functools.wraps(function)" ], [ "CALL_FUNCTION", "functools.wraps(function)" ], [ "LOAD_GLOBAL", "functools" ], [ "LOAD_METHOD", "functools.wraps" ], [ "LOAD_DEREF", "function" ], [ "CALL_METHOD", "functools.wraps(function)" ], [ "CALL_FUNCTION", "functools.wraps(function)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.isgeneratorfunction" ], [ "LOAD_DEREF", "function" ], [ "CALL_METHOD", "inspect.isgeneratorfunction(function)" ], [ "LOAD_FAST", "generator_wrapper" ], [ "LOAD_FAST", "simple_wrapper" ], [ "LOAD_DEREF", "self" ], [ "LOAD_DEREF", "function" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "function(*args, **kwargs)" ], [ "LOAD_DEREF", "function" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "function(*args, **kwargs)" ], [ "LOAD_FAST", "gen" ], [ "LOAD_ATTR", "gen.send" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "method" ], [ "LOAD_FAST", "incoming" ], [ "CALL_FUNCTION", "method(incoming)" ], [ "LOAD_GLOBAL", "StopIteration" ], [ "LOAD_FAST", "gen" ], [ "LOAD_ATTR", "gen.send" ], [ "LOAD_FAST", "outgoing" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_FAST", "gen" ], [ "LOAD_ATTR", "gen.throw" ], [ "LOAD_FAST", "e" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.enabled" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_METHOD", "sys._getframe" ], [ "LOAD_FAST", "context" ], [ "BINARY_ADD", "context + 1" ], [ "CALL_METHOD", "sys._getframe(context + 1)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._is_internal_frame" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_METHOD", "self._is_internal_frame(calling_frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.trace" ], [ "LOAD_FAST", "calling_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.target_frames" ], [ "LOAD_METHOD", "self.target_frames.add" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_METHOD", "self.target_frames.add(calling_frame)" ], [ "LOAD_FAST", "calling_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.trace" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_METHOD", "self.trace(calling_frame, 'enter', None)" ], [ "LOAD_GLOBAL", "thread_global" ], [ "LOAD_ATTR", "thread_global.__dict__" ], [ "LOAD_METHOD", "thread_global.__dict__.setdefault" ], [ "CALL_METHOD", "thread_global.__dict__.setdefault('original_trace_functions', [])" ], [ "LOAD_FAST", "stack" ], [ "LOAD_METHOD", "stack.append" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_METHOD", "sys.gettrace" ], [ "CALL_METHOD", "sys.gettrace()" ], [ "CALL_METHOD", "stack.append(sys.gettrace())" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_METHOD", "sys.settrace" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.trace" ], [ "CALL_METHOD", "sys.settrace(self.trace)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.enabled" ], [ "LOAD_GLOBAL", "thread_global" ], [ "LOAD_ATTR", "thread_global.original_trace_functions" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_METHOD", "sys.settrace" ], [ "LOAD_FAST", "stack" ], [ "LOAD_METHOD", "stack.pop" ], [ "CALL_METHOD", "stack.pop()" ], [ "CALL_METHOD", "sys.settrace(stack.pop())" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_METHOD", "sys._getframe" ], [ "LOAD_FAST", "context" ], [ "BINARY_ADD", "context + 1" ], [ "CALL_METHOD", "sys._getframe(context + 1)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.trace" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_METHOD", "self.trace(calling_frame, 'exit', None)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.target_frames" ], [ "LOAD_METHOD", "self.target_frames.discard" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_METHOD", "self.target_frames.discard(calling_frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame_infos" ], [ "LOAD_METHOD", "self.frame_infos.pop" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_METHOD", "self.frame_infos.pop(calling_frame, None)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_filename" ], [ "LOAD_METHOD", "frame.f_code.co_filename.startswith" ], [ "LOAD_GLOBAL", "internal_directories" ], [ "CALL_METHOD", "frame.f_code.co_filename.startswith(internal_directories)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.target_codes" ], [ "CONTAINS_OP", "frame.f_code in self.target_codes" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.target_frames" ], [ "CONTAINS_OP", "frame in self.target_frames" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._is_traced_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self._is_traced_frame(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.depth" ], [ "COMPARE_OP", "self.depth == 1" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._is_internal_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self._is_internal_frame(frame)" ], [ "LOAD_GLOBAL", "is_comprehension_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "is_comprehension_frame(frame)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_GLOBAL", "is_comprehension_frame" ], [ "LOAD_FAST", "candidate" ], [ "CALL_FUNCTION", "is_comprehension_frame(candidate)" ], [ "LOAD_FAST", "candidate" ], [ "LOAD_ATTR", "candidate.f_back" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._is_traced_frame" ], [ "LOAD_FAST", "candidate" ], [ "CALL_METHOD", "self._is_traced_frame(candidate)" ], [ "LOAD_FAST", "candidate" ], [ "LOAD_ATTR", "candidate.f_back" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.depth" ], [ "COMPARE_OP", "i >= self.depth" ], [ "LOAD_FAST", "candidate" ], [ "IS_OP", "candidate is None" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._is_internal_frame" ], [ "LOAD_FAST", "candidate" ], [ "CALL_METHOD", "self._is_internal_frame(candidate)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.thread_local" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_ATTR", "thread_local.__dict__" ], [ "LOAD_METHOD", "thread_local.__dict__.setdefault" ], [ "CALL_METHOD", "thread_local.__dict__.setdefault('depth', -1)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame_infos" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.frame_infos[frame]" ], [ "LOAD_FAST", "event" ], [ "CONTAINS_OP", "event in ('call', 'enter')" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.last_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.last_frame" ], [ "LOAD_FAST", "frame" ], [ "IS_OP", "self.config.last_frame is not frame" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.last_line_no" ], [ "LOAD_GLOBAL", "Event" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "event" ], [ "LOAD_FAST", "arg" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_ATTR", "thread_local.depth" ], [ "LOAD_FAST", "line_no" ], [ "CALL_FUNCTION_KW", "Event(frame_info, event, arg, thread_local.depth, line_no=line_no)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.formatter" ], [ "LOAD_METHOD", "self.config.formatter.format_line_only" ], [ "LOAD_FAST", "trace_event" ], [ "CALL_METHOD", "self.config.formatter.format_line_only(trace_event)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_METHOD", "self.config.write" ], [ "LOAD_FAST", "line" ], [ "CALL_METHOD", "self.config.write(line)" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event == 'exception'" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_GLOBAL", "Event" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "event" ], [ "LOAD_FAST", "arg" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_ATTR", "thread_local.depth" ], [ "CALL_FUNCTION", "Event(frame_info, event, arg, thread_local.depth)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "COMPARE_OP", "frame.f_code.co_name == ''" ], [ "LOAD_FAST", "event" ], [ "CONTAINS_OP", "event not in ('return', 'exception')" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_METHOD", "frame_info.update_variables" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.watch" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.watch_extras" ], [ "LOAD_FAST", "event" ], [ "CALL_METHOD", "frame_info.update_variables(\n self.watch,\n self.config.watch_extras,\n event,\n )" ], [ "LOAD_FAST", "trace_event" ], [ "LOAD_FAST", "event" ], [ "CONTAINS_OP", "event in ('return', 'exit')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame_infos" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.formatter" ], [ "LOAD_METHOD", "self.config.formatter.format" ], [ "LOAD_FAST", "trace_event" ], [ "CALL_METHOD", "self.config.formatter.format(trace_event)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_METHOD", "self.config.write" ], [ "LOAD_FAST", "formatted" ], [ "CALL_METHOD", "self.config.write(formatted)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.trace" ], [ "LOAD_FAST", "config" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "NO_ASTTOKENS" ], [ "LOAD_GLOBAL", "Exception" ], [ "CALL_FUNCTION", "Exception(\"birdseye doesn't support this version of Python\")" ], [ "LOAD_GLOBAL", "ImportError" ], [ "LOAD_GLOBAL", "Exception" ], [ "CALL_FUNCTION", "Exception(\"You must install birdseye separately to use spy: pip install birdseye\")" ], [ "LOAD_GLOBAL", "no_args_decorator" ], [ "LOAD_DEREF", "args" ], [ "LOAD_DEREF", "kwargs" ], [ "CALL_FUNCTION", "no_args_decorator(args, kwargs)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self._trace" ], [ "LOAD_DEREF", "args" ], [ "BINARY_SUBSCR", "args[0]" ], [ "CALL_METHOD", "self._trace(args[0])" ], [ "LOAD_FAST", "decorator" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._trace" ], [ "LOAD_FAST", "func" ], [ "LOAD_DEREF", "args" ], [ "LOAD_DEREF", "kwargs" ], [ "CALL_FUNCTION_EX", "self._trace(func, *args, **kwargs)" ], [ "LOAD_FAST", "eye" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "eye(func)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.snoop" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "self.config.snoop(*args, **kwargs)" ], [ "LOAD_DEREF", "traced" ], [ "CALL_FUNCTION", "self.config.snoop(*args, **kwargs)(traced)" ], [ "LOAD_GLOBAL", "functools" ], [ "LOAD_METHOD", "functools.wraps" ], [ "LOAD_DEREF", "func" ], [ "CALL_METHOD", "functools.wraps(func)" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "LOAD_FAST", "wrapper" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.enabled" ], [ "LOAD_DEREF", "traced" ], [ "LOAD_DEREF", "func" ], [ "LOAD_FAST", "final_func" ], [ "LOAD_FAST", "func_args" ], [ "LOAD_FAST", "func_kwargs" ], [ "CALL_FUNCTION_EX", "final_func(*func_args, **func_kwargs)" ] ], "utils.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOAD_METHOD", "standard_library.install_aliases" ], [ "CALL_METHOD", "standard_library.install_aliases()" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "type" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "version_info" ], [ "LOAD_ATTR", "version_info.major" ], [ "COMPARE_OP", "version_info.major == 2" ], [ "LOAD_NAME", "PY2" ], [ "UNARY_NOT", "not PY2" ], [ "LOAD_NAME", "TypeVar" ], [ "CALL_FUNCTION", "TypeVar('T')" ], [ "LOAD_NAME", "TypeVar" ], [ "CALL_FUNCTION", "TypeVar('RT')" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "unicode" ], [ "LOAD_NAME", "str" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "type" ], [ "LOAD_NAME", "json" ], [ "LOAD_ATTR", "json.JSONEncoder" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_GLOBAL", "ntpath" ], [ "LOAD_METHOD", "ntpath.split" ], [ "LOAD_FAST", "path" ], [ "CALL_METHOD", "ntpath.split(path)" ], [ "LOAD_FAST", "tail" ], [ "LOAD_GLOBAL", "ntpath" ], [ "LOAD_METHOD", "ntpath.basename" ], [ "LOAD_FAST", "head" ], [ "CALL_METHOD", "ntpath.basename(head)" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_METHOD", "os.path.commonprefix" ], [ "LOAD_FAST", "paths" ], [ "CALL_METHOD", "os.path.commonprefix(paths)" ], [ "LOAD_GLOBAL", "ntpath" ], [ "LOAD_METHOD", "ntpath.split" ], [ "LOAD_FAST", "prefix" ], [ "CALL_METHOD", "ntpath.split(prefix)" ], [ "BINARY_SUBSCR", "ntpath.split(prefix)[0]" ], [ "LOAD_FAST", "paths" ], [ "BINARY_SUBSCR", "paths[0]" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "prefix" ], [ "CALL_FUNCTION", "len(prefix)" ], [ "BINARY_SUBSCR", "paths[0][len(prefix)]" ], [ "LOAD_FAST", "first_char_after" ], [ "CONTAINS_OP", "first_char_after in r'\\/'" ], [ "LOAD_FAST", "first_char_after" ], [ "LOAD_FAST", "prefix" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "COMPARE_OP", "path == IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "all_paths" ], [ "LOAD_GLOBAL", "common_ancestor" ], [ "LOAD_FAST", "all_paths" ], [ "CALL_FUNCTION", "common_ancestor(all_paths)" ], [ "LOAD_FAST", "prefix" ], [ "CONTAINS_OP", "prefix in r'\\/'" ], [ "LOAD_GLOBAL", "strip_required_prefix" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "prefix" ], [ "CALL_FUNCTION", "strip_required_prefix(path, prefix)" ], [ "LOAD_GLOBAL", "path_leaf" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "path_leaf(path)" ], [ "LOAD_FAST", "f" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "COMPARE_OP", "f != IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "f" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "COMPARE_OP", "path == IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.sep" ], [ "COMPARE_OP", "os.path.sep == '/'" ], [ "LOAD_FAST", "path" ], [ "LOAD_METHOD", "path.startswith" ], [ "CALL_METHOD", "path.startswith('/')" ], [ "LOAD_FAST", "path" ], [ "BINARY_ADD", "'/' + path" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "type" ], [ "LOAD_FAST", "obj" ], [ "CALL_FUNCTION", "type(obj)" ], [ "LOAD_FAST", "t" ], [ "LOAD_GLOBAL", "types" ], [ "LOAD_ATTR", "types.InstanceType" ], [ "IS_OP", "t is types.InstanceType" ], [ "LOAD_FAST", "obj" ], [ "LOAD_ATTR", "obj.__class__" ], [ "LOAD_FAST", "t" ], [ "LOAD_FAST", "iterable" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_DEREF", "type_or_tuple" ], [ "CALL_FUNCTION", "isinstance(x, type_or_tuple)" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "next" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "next(it)" ], [ "LOAD_GLOBAL", "StopIteration" ], [ "LOAD_GLOBAL", "raise_from" ], [ "LOAD_GLOBAL", "RuntimeError" ], [ "LOAD_FAST", "e" ], [ "CALL_FUNCTION", "raise_from(RuntimeError, e)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "expression" ], [ "CALL_FUNCTION", "hasattr(expression, 'one_or_none')" ], [ "LOAD_FAST", "expression" ], [ "LOAD_METHOD", "expression.one_or_none" ], [ "CALL_METHOD", "expression.one_or_none()" ], [ "LOAD_FAST", "expression" ], [ "LOAD_METHOD", "expression.all" ], [ "CALL_METHOD", "expression.all()" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "len(result)" ], [ "COMPARE_OP", "len(result) == 0" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "len(result)" ], [ "COMPARE_OP", "len(result) == 1" ], [ "LOAD_FAST", "result" ], [ "BINARY_SUBSCR", "result[0]" ], [ "LOAD_GLOBAL", "Exception" ], [ "CALL_FUNCTION", "Exception(\"There is more than one item returned for the supplied filter\")" ], [ "LOAD_FAST", "lst" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "isinstance(x, list)" ], [ "LOAD_FAST", "result" ], [ "LOAD_METHOD", "result.extend" ], [ "LOAD_GLOBAL", "flatten_list" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "flatten_list(x)" ], [ "CALL_METHOD", "result.extend(flatten_list(x))" ], [ "LOAD_FAST", "result" ], [ "LOAD_METHOD", "result.append" ], [ "LOAD_FAST", "x" ], [ "CALL_METHOD", "result.append(x)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "f" ], [ "LOAD_ATTR", "f.__code__" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "LOAD_ATTR", "(lambda: 0).__code__" ], [ "LOAD_ATTR", "(lambda: 0).__code__.co_name" ], [ "COMPARE_OP", "code.co_name == (lambda: 0).__code__.co_name" ], [ "LOAD_FAST", "o" ], [ "LOAD_ATTR", "o.as_json" ], [ "LOAD_FAST", "method" ], [ "CALL_FUNCTION", "method()" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "ProtocolEncoder" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(ProtocolEncoder, self)" ], [ "LOAD_METHOD", "super(ProtocolEncoder, self).default" ], [ "LOAD_FAST", "o" ], [ "CALL_METHOD", "super(ProtocolEncoder, self).default(o)" ], [ "LOAD_GLOBAL", "io" ], [ "LOAD_METHOD", "io.open" ], [ "LOAD_FAST", "filename" ], [ "CALL_METHOD", "io.open(filename, 'rb')" ], [ "LOAD_GLOBAL", "detect_encoding" ], [ "LOAD_FAST", "fp" ], [ "LOAD_ATTR", "fp.readline" ], [ "CALL_FUNCTION", "detect_encoding(fp.readline)" ], [ "LOAD_FAST", "fp" ], [ "LOAD_METHOD", "fp.seek" ], [ "CALL_METHOD", "fp.seek(0)" ], [ "LOAD_GLOBAL", "io" ], [ "LOAD_ATTR", "io.TextIOWrapper" ], [ "LOAD_FAST", "fp" ], [ "LOAD_FAST", "encoding" ], [ "CALL_FUNCTION_KW", "io.TextIOWrapper(fp, encoding, line_buffering=True)" ], [ "LOAD_FAST", "text" ], [ "LOAD_FAST", "text" ], [ "LOAD_FAST", "fp" ], [ "LOAD_METHOD", "fp.close" ], [ "CALL_METHOD", "fp.close()" ], [ "LOAD_FAST", "filename" ], [ "LOAD_METHOD", "filename.endswith" ], [ "CALL_METHOD", "filename.endswith('.pyc')" ], [ "LOAD_FAST", "filename" ], [ "BINARY_SUBSCR", "filename[:-1]" ], [ "LOAD_GLOBAL", "open_with_encoding_check" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "open_with_encoding_check(filename)" ], [ "LOAD_METHOD", "''.join" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "f" ], [ "CALL_FUNCTION", "enumerate(f)" ], [ "CALL_METHOD", "''.join([\n '\\n' if i < 2 and cookie_re.match(line)\n else line\n for i, line in enumerate(f)\n ])" ], [ "LOAD_FAST", "i" ], [ "COMPARE_OP", "i < 2" ], [ "LOAD_DEREF", "cookie_re" ], [ "LOAD_METHOD", "cookie_re.match" ], [ "LOAD_FAST", "line" ], [ "CALL_METHOD", "cookie_re.match(line)" ], [ "LOAD_FAST", "line" ], [ "LOAD_GLOBAL", "safe_next" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_METHOD", "tokens.get_tokens" ], [ "LOAD_FAST", "function_node" ], [ "CALL_METHOD", "tokens.get_tokens(function_node)" ], [ "CALL_FUNCTION", "safe_next(t for t in tokens.get_tokens(function_node)\n if t.string == 'def' and t.type == token.NAME)" ], [ "LOAD_FAST", "def_token" ], [ "LOAD_ATTR", "def_token.startpos" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_ATTR", "tokens.text" ], [ "LOAD_FAST", "startpos" ], [ "LOAD_FAST", "function_node" ], [ "LOAD_ATTR", "function_node.last_token" ], [ "LOAD_ATTR", "function_node.last_token.endpos" ], [ "BINARY_SUBSCR", "tokens.text[startpos:function_node.last_token.endpos]" ], [ "LOAD_METHOD", "tokens.text[startpos:function_node.last_token.endpos].rstrip" ], [ "CALL_METHOD", "tokens.text[startpos:function_node.last_token.endpos].rstrip()" ], [ "LOAD_FAST", "source" ], [ "LOAD_METHOD", "source.startswith" ], [ "CALL_METHOD", "source.startswith('def')" ], [ "LOAD_FAST", "startpos" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "t" ], [ "LOAD_ATTR", "t.string" ], [ "COMPARE_OP", "t.string == 'def'" ], [ "LOAD_FAST", "t" ], [ "LOAD_ATTR", "t.type" ], [ "LOAD_GLOBAL", "token" ], [ "LOAD_ATTR", "token.NAME" ], [ "COMPARE_OP", "t.type == token.NAME" ], [ "LOAD_FAST", "t" ], [ "LOAD_FAST", "args" ], [ "LOAD_GLOBAL", "print" ], [ "LOAD_FAST", "arg" ], [ "CALL_FUNCTION", "print(arg)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION", "len(args)" ], [ "COMPARE_OP", "len(args) == 1" ], [ "LOAD_FAST", "args" ], [ "BINARY_SUBSCR", "args[0]" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "filename" ], [ "LOAD_METHOD", "filename.startswith" ], [ "CALL_METHOD", "filename.startswith(' max_length" ], [ "LOAD_FAST", "max_length" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "middle" ], [ "CALL_FUNCTION", "len(middle)" ], [ "BINARY_SUBTRACT", "max_length - len(middle)" ], [ "BINARY_FLOOR_DIVIDE", "(max_length - len(middle)) // 2" ], [ "LOAD_FAST", "max_length" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "middle" ], [ "CALL_FUNCTION", "len(middle)" ], [ "BINARY_SUBTRACT", "max_length - len(middle)" ], [ "LOAD_FAST", "left" ], [ "BINARY_SUBTRACT", "max_length - len(middle) - left" ], [ "LOAD_FAST", "seq" ], [ "LOAD_FAST", "left" ], [ "BINARY_SUBSCR", "seq[:left]" ], [ "LOAD_FAST", "middle" ], [ "BINARY_ADD", "seq[:left] + middle" ], [ "LOAD_FAST", "seq" ], [ "LOAD_FAST", "right" ], [ "UNARY_NEGATIVE", "-right" ], [ "BINARY_SUBSCR", "seq[-right:]" ], [ "BINARY_ADD", "seq[:left] + middle + seq[-right:]" ], [ "LOAD_FAST", "seq" ], [ "LOAD_GLOBAL", "truncate" ], [ "LOAD_FAST", "string" ], [ "LOAD_FAST", "max_length" ], [ "CALL_FUNCTION", "truncate(string, max_length, '...')" ], [ "LOAD_GLOBAL", "truncate" ], [ "LOAD_FAST", "lst" ], [ "LOAD_FAST", "max_length" ], [ "CALL_FUNCTION", "truncate(lst, max_length, ['...'])" ], [ "LOAD_FAST", "split" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "six" ], [ "LOAD_ATTR", "six.string_types" ], [ "CALL_FUNCTION", "isinstance(x, six.string_types)" ], [ "LOAD_FAST", "x" ], [ "LOAD_METHOD", "x.replace" ], [ "CALL_METHOD", "x.replace(',', ' ')" ], [ "LOAD_METHOD", "x.replace(',', ' ').split" ], [ "CALL_METHOD", "x.replace(',', ' ').split()" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "set" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "isinstance(x, (list, set, tuple))" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "tuple" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tuple(x)" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_METHOD", "os.path.basename" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_filename" ], [ "CALL_METHOD", "os.path.basename(code.co_filename)" ], [ "LOAD_FAST", "result" ], [ "LOAD_METHOD", "result.endswith" ], [ "CALL_METHOD", "result.endswith('.pyc')" ], [ "LOAD_FAST", "result" ], [ "BINARY_SUBSCR", "result[:-1]" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "CONTAINS_OP", "frame.f_code.co_name in ('', '', '')" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "code('{}.x')" ], [ "LOAD_GLOBAL", "SyntaxError" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "code('({})')" ], [ "LOAD_FAST", "without_parens" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "code('({}).x')" ], [ "COMPARE_OP", "without_parens != code('({}).x')" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "s" ], [ "LOAD_METHOD", "s.format" ], [ "LOAD_DEREF", "source" ], [ "CALL_METHOD", "s.format(source)" ], [ "CALL_FUNCTION", "compile(s.format(source), '', 'eval')" ], [ "LOAD_ATTR", "compile(s.format(source), '', 'eval').co_code" ], [ "LOAD_GLOBAL", "needs_parentheses" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "needs_parentheses(source)" ], [ "LOAD_METHOD", "'({})'.format" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "'({})'.format(source)" ], [ "LOAD_FAST", "source" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "REPR_TARGET_LENGTH" ], [ "CALL_FUNCTION_KW", "cheap_repr(x, target_length=REPR_TARGET_LENGTH)" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "ArgDefaultDict" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(ArgDefaultDict, self)" ], [ "LOAD_METHOD", "super(ArgDefaultDict, self).__init__" ], [ "CALL_METHOD", "super(ArgDefaultDict, self).__init__()" ], [ "LOAD_FAST", "factory" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.factory" ], [ "LOAD_FAST", "key" ], [ "CALL_METHOD", "self.factory(key)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "key" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "lst" ], [ "CALL_FUNCTION", "len(lst)" ], [ "COMPARE_OP", "len(lst) == 1" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "CALL_FUNCTION", "str(i + 1)" ], [ "BINARY_ADD", "' ' + str(i + 1)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_GLOBAL", "os" ], [ "CALL_FUNCTION", "hasattr(os, 'PathLike')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.PathLike" ], [ "CALL_FUNCTION", "isinstance(x, os.PathLike)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "hasattr(x, '__fspath__')" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "hasattr(x, 'open')" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.__class__" ], [ "LOAD_ATTR", "x.__class__.__name__" ], [ "LOAD_METHOD", "x.__class__.__name__.lower" ], [ "CALL_METHOD", "x.__class__.__name__.lower()" ], [ "CONTAINS_OP", "'path' in x.__class__.__name__.lower()" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION", "len(args)" ], [ "COMPARE_OP", "len(args) == 1" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.isfunction" ], [ "LOAD_FAST", "args" ], [ "BINARY_SUBSCR", "args[0]" ], [ "CALL_METHOD", "inspect.isfunction(args[0])" ], [ "LOAD_FAST", "kwargs" ], [ "UNARY_NOT", "not kwargs" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_ADD", "max_length + 2" ], [ "COMPARE_OP", "length <= max_length + 2" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "range(length)" ], [ "LOAD_GLOBAL", "chain" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_FLOOR_DIVIDE", "max_length // 2" ], [ "CALL_FUNCTION", "range(max_length // 2)" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_FLOOR_DIVIDE", "max_length // 2" ], [ "BINARY_SUBTRACT", "length - max_length // 2" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "range(length - max_length // 2,\n length)" ], [ "CALL_FUNCTION", "chain(range(max_length // 2),\n range(length - max_length // 2,\n length))" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "len(x)" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "n == 0" ], [ "LOAD_GLOBAL", "repr" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "repr(x)" ], [ "LOAD_FAST", "helper" ], [ "LOAD_ATTR", "helper.level" ], [ "BINARY_SUBTRACT", "helper.level - 1" ], [ "LOAD_GLOBAL", "_repr_series_one_line" ], [ "LOAD_ATTR", "_repr_series_one_line.maxparts" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "n" ], [ "LOAD_FAST", "maxparts" ], [ "CALL_FUNCTION", "_sample_indices(n, maxparts)" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.index" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "x.index[i:i + 1]" ], [ "LOAD_ATTR", "x.index[i:i + 1].format" ], [ "CALL_FUNCTION_KW", "x.index[i:i + 1].format(sparsify=False)" ], [ "BINARY_SUBSCR", "x.index[i:i + 1].format(sparsify=False)[0]" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.iloc" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "x.iloc[i]" ], [ "LOAD_FAST", "pieces" ], [ "LOAD_METHOD", "pieces.append" ], [ "LOAD_FAST", "k" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "v" ], [ "LOAD_FAST", "newlevel" ], [ "CALL_FUNCTION", "cheap_repr(v, newlevel)" ], [ "BINARY_MODULO", "'%s = %s' % (k, cheap_repr(v, newlevel))" ], [ "CALL_METHOD", "pieces.append('%s = %s' % (k, cheap_repr(v, newlevel)))" ], [ "LOAD_FAST", "n" ], [ "LOAD_FAST", "maxparts" ], [ "BINARY_ADD", "maxparts + 2" ], [ "COMPARE_OP", "n > maxparts + 2" ], [ "LOAD_FAST", "pieces" ], [ "LOAD_METHOD", "pieces.insert" ], [ "LOAD_FAST", "maxparts" ], [ "BINARY_FLOOR_DIVIDE", "maxparts // 2" ], [ "CALL_METHOD", "pieces.insert(maxparts // 2, '...')" ], [ "LOAD_METHOD", "'; '.join" ], [ "LOAD_FAST", "pieces" ], [ "CALL_METHOD", "'; '.join(pieces)" ] ] }executing-0.8.0/tests/sample_results/3.4.json000066400000000000000000021436761410133640400211340ustar00rootroot00000000000000{ "bird.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOAD_ATTR", "standard_library.install_aliases" ], [ "CALL_FUNCTION", "standard_library.install_aliases()" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "warn_if_outdated" ], [ "LOAD_NAME", "__version__" ], [ "CALL_FUNCTION", "warn_if_outdated('birdseye', __version__)" ], [ "LOAD_NAME", "namedtuple" ], [ "CALL_FUNCTION", "namedtuple('CodeInfo', 'db_func traced_file arg_names')" ], [ "LOAD_NAME", "TreeTracerBase" ], [ "LOAD_NAME", "BirdsEye" ], [ "CALL_FUNCTION", "BirdsEye()" ], [ "LOAD_NAME", "NamedTuple" ], [ "LOAD_NAME", "int" ], [ "LOAD_NAME", "bool" ], [ "LOAD_NAME", "int" ], [ "LOAD_NAME", "str" ], [ "CALL_FUNCTION", "NamedTuple('HTMLPosition', [\n ('index', int),\n ('is_start', bool),\n ('depth', int),\n ('html', str),\n])" ], [ "LOAD_NAME", "eye" ], [ "LOAD_ATTR", "eye.enter_call" ], [ "LOAD_ATTR", "eye.enter_call.__code__" ], [ "LOAD_NAME", "eye" ], [ "LOAD_ATTR", "eye.exit_call" ], [ "LOAD_ATTR", "eye.exit_call.__code__" ], [ "LOAD_NAME", "eye" ], [ "LOAD_ATTR", "eye.after_expr" ], [ "LOAD_ATTR", "eye.after_expr.__code__" ], [ "LOAD_NAME", "eye" ], [ "LOAD_ATTR", "eye.after_stmt" ], [ "LOAD_ATTR", "eye.after_stmt.__code__" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "Iterable" ], [ "LOAD_NAME", "Iteration" ], [ "BINARY_SUBSCR", "Iterable[Iteration]" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "TypeRegistry" ], [ "CALL_FUNCTION", "TypeRegistry()" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "try_register_repr" ], [ "CALL_FUNCTION", "try_register_repr('pandas', 'Series')" ], [ "CALL_FUNCTION", "try_register_repr('pandas', 'Series')" ], [ "LOAD_NAME", "cached_property" ], [ "CALL_FUNCTION", "cached_property" ], [ "LOAD_NAME", "lru_cache" ], [ "CALL_FUNCTION", "lru_cache()" ], [ "CALL_FUNCTION", "lru_cache()" ], [ "LOAD_NAME", "retry_db" ], [ "CALL_FUNCTION", "retry_db" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "BirdsEye" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(BirdsEye, self)" ], [ "LOAD_ATTR", "super(BirdsEye, self).__init__" ], [ "CALL_FUNCTION", "super(BirdsEye, self).__init__()" ], [ "LOAD_FAST", "db_uri" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "num_samples" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "dict" ], [ "CALL_FUNCTION", "dict(\n attributes=50,\n dict=50,\n list=30,\n set=30,\n pandas_rows=20,\n pandas_cols=100,\n )" ], [ "LOAD_GLOBAL", "dict" ], [ "CALL_FUNCTION", "dict(\n attributes=50,\n dict=10,\n list=6,\n set=6,\n pandas_rows=6,\n pandas_cols=10,\n )" ], [ "CALL_FUNCTION", "dict(\n big=dict(\n attributes=50,\n dict=50,\n list=30,\n set=30,\n pandas_rows=20,\n pandas_cols=100,\n ),\n small=dict(\n attributes=50,\n dict=10,\n list=6,\n set=6,\n pandas_rows=6,\n pandas_cols=10,\n ),\n )" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "Database" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._db_uri" ], [ "CALL_FUNCTION", "Database(self._db_uri)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.walk" ], [ "LOAD_FAST", "root" ], [ "CALL_FUNCTION", "ast.walk(root)" ], [ "LOAD_GLOBAL", "tracer" ], [ "LOAD_ATTR", "tracer.loops" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "tracer.loops(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "CALL_FUNCTION", "isinstance(node, ast.expr)" ], [ "LOAD_GLOBAL", "is_interesting_expression" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "is_interesting_expression(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "BirdsEye" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(BirdsEye, self)" ], [ "LOAD_ATTR", "super(BirdsEye, self).compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "flags" ], [ "CALL_FUNCTION", "super(BirdsEye, self).compile(source, filename, flags)" ], [ "LOAD_GLOBAL", "ASTTokens" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.root" ], [ "CALL_FUNCTION", "ASTTokens(source, tree=traced_file.root)" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.For)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.body" ], [ "BINARY_SUBSCR", "node.parent.body[0]" ], [ "COMPARE_OP", "node is node.parent.body[0]" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._add_iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "self._add_iteration(node._loops, frame)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.While)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.test" ], [ "COMPARE_OP", "node is node.parent.test" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._add_iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "self._add_iteration(node._loops, frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_ATTR", "self.stack[frame].iteration" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "loops" ], [ "CALL_FUNCTION", "enumerate(loops)" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.loops" ], [ "LOAD_FAST", "loop_node" ], [ "LOAD_ATTR", "loop_node._tree_index" ], [ "BINARY_SUBSCR", "iteration.loops[loop_node._tree_index]" ], [ "LOAD_FAST", "i" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "loops" ], [ "CALL_FUNCTION", "len(loops)" ], [ "BINARY_SUBTRACT", "len(loops) - 1" ], [ "COMPARE_OP", "i == len(loops) - 1" ], [ "LOAD_FAST", "loop" ], [ "LOAD_ATTR", "loop.append" ], [ "LOAD_GLOBAL", "Iteration" ], [ "CALL_FUNCTION", "Iteration()" ], [ "CALL_FUNCTION", "loop.append(Iteration())" ], [ "LOAD_FAST", "loop" ], [ "LOAD_ATTR", "loop.last" ], [ "CALL_FUNCTION", "loop.last()" ], [ "LOAD_GLOBAL", "_tracing_recursively" ], [ "LOAD_DEREF", "frame" ], [ "CALL_FUNCTION", "_tracing_recursively(frame)" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._is_interesting_expression" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "BINARY_SUBSCR", "self._code_infos[frame.f_code]" ], [ "LOAD_ATTR", "self._code_infos[frame.f_code].traced_file" ], [ "LOAD_ATTR", "self._code_infos[frame.f_code].traced_file.is_ipython_cell" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Expr" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.Expr)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.parent" ], [ "LOAD_ATTR", "node.parent.parent.body" ], [ "BINARY_SUBSCR", "node.parent.parent.body[-1]" ], [ "COMPARE_OP", "node.parent is node.parent.parent.body[-1]" ], [ "LOAD_DEREF", "value" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "is_obvious_builtin" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_DEREF", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_ATTR", "self.stack[frame].expression_values" ], [ "LOAD_FAST", "node" ], [ "BINARY_SUBSCR", "self.stack[frame].expression_values[node]" ], [ "CALL_FUNCTION", "is_obvious_builtin(node, self.stack[frame].expression_values[node])" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_DEREF", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_FAST", "exc_value" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._exception_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_FAST", "exc_value" ], [ "CALL_FUNCTION", "self._exception_value(node, frame, exc_value)" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOAD_ATTR", "NodeValue.expression" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.num_samples" ], [ "LOAD_DEREF", "value" ], [ "LOAD_GLOBAL", "max" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "CALL_FUNCTION", "len(node._loops)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._is_first_loop_iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "frame" ], [ "CALL_FUNCTION", "self._is_first_loop_iteration(node, frame)" ], [ "UNARY_NOT", "not self._is_first_loop_iteration(node, frame)" ], [ "BINARY_MULTIPLY", "len(node._loops) * (not self._is_first_loop_iteration(node, frame))" ], [ "BINARY_SUBTRACT", "3 - len(node._loops) * (not self._is_first_loop_iteration(node, frame))" ], [ "CALL_FUNCTION", "max(1, 3 - len(node._loops) * (not self._is_first_loop_iteration(node, frame)))" ], [ "CALL_FUNCTION", "NodeValue.expression(\n self.num_samples,\n value,\n level=max(1, 3 - len(node._loops) * (not self._is_first_loop_iteration(node, frame))),\n )" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._set_node_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_FAST", "node_value" ], [ "CALL_FUNCTION", "self._set_node_value(node, frame, node_value)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._check_inner_call" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node_value" ], [ "CALL_FUNCTION", "self._check_inner_call(frame_info, node, node_value)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.comprehension)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.iter" ], [ "COMPARE_OP", "node is node.parent.iter" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.GeneratorExp" ], [ "CALL_FUNCTION", "isinstance(node.parent.parent, ast.GeneratorExp)" ], [ "UNARY_NOT", "not isinstance(node.parent.parent, ast.GeneratorExp)" ], [ "LOAD_FAST", "is_special_comprehension_iter" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._set_node_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOAD_ATTR", "NodeValue.covered" ], [ "CALL_FUNCTION", "NodeValue.covered()" ], [ "CALL_FUNCTION", "self._set_node_value(node.parent, frame, NodeValue.covered())" ], [ "LOAD_FAST", "exc_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "BINARY_ADD", "node._loops + (node.parent,)" ], [ "LOAD_GLOBAL", "ChangeValue" ], [ "LOAD_FAST", "comprehension_iter_proxy" ], [ "CALL_FUNCTION", "comprehension_iter_proxy()" ], [ "CALL_FUNCTION", "ChangeValue(comprehension_iter_proxy())" ], [ "LOAD_DEREF", "value" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._add_iteration" ], [ "LOAD_DEREF", "loops" ], [ "LOAD_DEREF", "frame" ], [ "CALL_FUNCTION", "self._add_iteration(loops, frame)" ], [ "LOAD_FAST", "item" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.inner_calls" ], [ "LOAD_ATTR", "frame_info.inner_calls.pop" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "frame_info.inner_calls.pop(node, None)" ], [ "LOAD_FAST", "inner_calls" ], [ "LOAD_FAST", "node_value" ], [ "LOAD_ATTR", "node_value.set_meta" ], [ "LOAD_FAST", "inner_calls" ], [ "CALL_FUNCTION", "node_value.set_meta('inner_calls', inner_calls)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_ATTR", "self.stack[frame].iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.loops" ], [ "LOAD_FAST", "loop_node" ], [ "LOAD_ATTR", "loop_node._tree_index" ], [ "BINARY_SUBSCR", "iteration.loops[loop_node._tree_index]" ], [ "LOAD_FAST", "loop" ], [ "LOAD_ATTR", "loop.last" ], [ "CALL_FUNCTION", "loop.last()" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.index" ], [ "COMPARE_OP", "iteration.index > 0" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_ATTR", "self.stack[frame].iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.loops" ], [ "LOAD_FAST", "loop_node" ], [ "LOAD_ATTR", "loop_node._tree_index" ], [ "BINARY_SUBSCR", "iteration.loops[loop_node._tree_index]" ], [ "LOAD_FAST", "loop" ], [ "LOAD_ATTR", "loop.recorded_node" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "loop.recorded_node(node)" ], [ "LOAD_FAST", "loop" ], [ "LOAD_ATTR", "loop.last" ], [ "CALL_FUNCTION", "loop.last()" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.vals" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOAD_ATTR", "NodeValue.exception" ], [ "LOAD_FAST", "exc_value" ], [ "CALL_FUNCTION", "NodeValue.exception(exc_value)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._set_node_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "self._set_node_value(node, frame, value)" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_GLOBAL", "_tracing_recursively" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "_tracing_recursively(frame)" ], [ "LOAD_FAST", "exc_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "exc_node" ], [ "COMPARE_OP", "node is exc_node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._exception_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "exc_value" ], [ "CALL_FUNCTION", "self._exception_value(node, frame, exc_value)" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOAD_ATTR", "NodeValue.covered" ], [ "CALL_FUNCTION", "NodeValue.covered()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._set_node_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "self._set_node_value(node, frame, value)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._check_inner_call" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "self._check_inner_call(self.stack[frame], node, value)" ], [ "LOAD_FAST", "enter_info" ], [ "LOAD_ATTR", "enter_info.current_frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_GLOBAL", "_tracing_recursively" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "_tracing_recursively(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_GLOBAL", "get_unfrozen_datetime" ], [ "CALL_FUNCTION", "get_unfrozen_datetime()" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_GLOBAL", "Iteration" ], [ "CALL_FUNCTION", "Iteration()" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "BINARY_SUBSCR", "self._code_infos[frame.f_code]" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "enter_info" ], [ "LOAD_ATTR", "enter_info.enter_node" ], [ "LOAD_ATTR", "enter_info.enter_node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Module" ], [ "CALL_FUNCTION", "isinstance(enter_info.enter_node.parent, ast.Module)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "LOAD_ATTR", "frame.f_locals.copy" ], [ "CALL_FUNCTION", "frame.f_locals.copy()" ], [ "LOAD_FAST", "code_info" ], [ "LOAD_ATTR", "code_info.arg_names" ], [ "LOAD_DEREF", "f_locals" ], [ "LOAD_ATTR", "f_locals.items" ], [ "CALL_FUNCTION", "f_locals.items()" ], [ "BINARY_ADD", "[(name, f_locals.pop(name))\n for name in code_info.arg_names\n if name] + [\n\n # Local variables other than actual arguments. These are variables from\n # the enclosing scope. It's handy to treat them like arguments in the UI\n it for it in f_locals.items()\n if it[0][0] != '.' # Appears when using nested tuple arguments\n ]" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_ATTR", "json.dumps" ], [ "LOAD_FAST", "arguments" ], [ "CALL_FUNCTION", "json.dumps([[k, cheap_repr(v)] for k, v in arguments])" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._call_id" ], [ "CALL_FUNCTION", "self._call_id()" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "defaultdict(list)" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_ATTR", "self.stack.get" ], [ "LOAD_FAST", "enter_info" ], [ "LOAD_ATTR", "enter_info.caller_frame" ], [ "CALL_FUNCTION", "self.stack.get(enter_info.caller_frame)" ], [ "LOAD_FAST", "prev" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "prev" ], [ "CALL_FUNCTION", "getattr(prev, 'inner_calls', None)" ], [ "LOAD_FAST", "inner_calls" ], [ "COMPARE_OP", "inner_calls is not None" ], [ "LOAD_FAST", "inner_calls" ], [ "LOAD_FAST", "enter_info" ], [ "LOAD_ATTR", "enter_info.call_node" ], [ "BINARY_SUBSCR", "inner_calls[enter_info.call_node]" ], [ "LOAD_ATTR", "inner_calls[enter_info.call_node].append" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.call_id" ], [ "CALL_FUNCTION", "inner_calls[enter_info.call_node].append(frame_info.call_id)" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "name" ], [ "LOAD_DEREF", "f_locals" ], [ "LOAD_ATTR", "f_locals.pop" ], [ "LOAD_FAST", "name" ], [ "CALL_FUNCTION", "f_locals.pop(name)" ], [ "LOAD_FAST", "it" ], [ "BINARY_SUBSCR", "it[0]" ], [ "BINARY_SUBSCR", "it[0][0]" ], [ "COMPARE_OP", "it[0][0] != '.'" ], [ "LOAD_FAST", "it" ], [ "LOAD_FAST", "k" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "cheap_repr(v)" ], [ "LOAD_GLOBAL", "uuid4" ], [ "CALL_FUNCTION", "uuid4()" ], [ "LOAD_ATTR", "uuid4().hex" ], [ "LOAD_DEREF", "exit_info" ], [ "LOAD_ATTR", "exit_info.current_frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_GLOBAL", "_tracing_recursively" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "_tracing_recursively(frame)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.iteration" ], [ "LOAD_GLOBAL", "_deep_dict" ], [ "CALL_FUNCTION", "_deep_dict()" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._extract_node_values" ], [ "LOAD_DEREF", "top_iteration" ], [ "LOAD_DEREF", "node_values" ], [ "CALL_FUNCTION", "self._extract_node_values(top_iteration, (), node_values)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "BINARY_SUBSCR", "self._code_infos[frame.f_code]" ], [ "LOAD_ATTR", "self._code_infos[frame.f_code].db_func" ], [ "LOAD_DEREF", "exit_info" ], [ "LOAD_ATTR", "exit_info.exc_value" ], [ "LOAD_FAST", "exc" ], [ "LOAD_ATTR", "''.join" ], [ "LOAD_GLOBAL", "traceback" ], [ "LOAD_ATTR", "traceback.format_exception" ], [ "LOAD_GLOBAL", "type" ], [ "LOAD_FAST", "exc" ], [ "CALL_FUNCTION", "type(exc)" ], [ "LOAD_FAST", "exc" ], [ "LOAD_DEREF", "exit_info" ], [ "LOAD_ATTR", "exit_info.exc_tb" ], [ "CALL_FUNCTION", "traceback.format_exception(type(exc), exc, exit_info.exc_tb)" ], [ "CALL_FUNCTION", "''.join(traceback.format_exception(type(exc), exc, exit_info.exc_tb))" ], [ "LOAD_GLOBAL", "exception_string" ], [ "LOAD_FAST", "exc" ], [ "CALL_FUNCTION", "exception_string(exc)" ], [ "LOAD_GLOBAL", "retry_db" ], [ "CALL_FUNCTION", "retry_db" ], [ "LOAD_FAST", "add_call" ], [ "CALL_FUNCTION", "add_call()" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.call_id" ], [ "LOAD_DEREF", "self" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.db" ], [ "LOAD_ATTR", "self.db.Call" ], [ "LOAD_FAST", "Call" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.call_id" ], [ "LOAD_DEREF", "db_func" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.arguments" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_DEREF", "exit_info" ], [ "LOAD_ATTR", "exit_info.return_value" ], [ "CALL_FUNCTION", "cheap_repr(exit_info.return_value)" ], [ "LOAD_DEREF", "exception" ], [ "LOAD_DEREF", "traceback_str" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_ATTR", "json.dumps" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_DEREF", "node_values" ], [ "LOAD_DEREF", "top_iteration" ], [ "LOAD_ATTR", "top_iteration.extract_iterations" ], [ "CALL_FUNCTION", "top_iteration.extract_iterations()" ], [ "BINARY_SUBSCR", "top_iteration.extract_iterations()['loops']" ], [ "LOAD_GLOBAL", "type_registry" ], [ "LOAD_ATTR", "type_registry.names" ], [ "CALL_FUNCTION", "type_registry.names()" ], [ "LOAD_GLOBAL", "type_registry" ], [ "LOAD_ATTR", "type_registry.num_special_types" ], [ "CALL_FUNCTION", "dict(\n node_values=node_values,\n loop_iterations=top_iteration.extract_iterations()['loops'],\n type_names=type_registry.names(),\n num_special_types=type_registry.num_special_types,\n )" ], [ "LOAD_GLOBAL", "ProtocolEncoder" ], [ "CALL_FUNCTION", "json.dumps(\n dict(\n node_values=node_values,\n loop_iterations=top_iteration.extract_iterations()['loops'],\n type_names=type_registry.names(),\n num_special_types=type_registry.num_special_types,\n ),\n cls=ProtocolEncoder,\n separators=(',', ':')\n )" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.start_time" ], [ "CALL_FUNCTION", "Call(id=frame_info.call_id,\n function_id=db_func,\n arguments=frame_info.arguments,\n return_value=cheap_repr(exit_info.return_value),\n exception=exception,\n traceback=traceback_str,\n data=json.dumps(\n dict(\n node_values=node_values,\n loop_iterations=top_iteration.extract_iterations()['loops'],\n type_names=type_registry.names(),\n num_special_types=type_registry.num_special_types,\n ),\n cls=ProtocolEncoder,\n separators=(',', ':')\n ),\n start_time=frame_info.start_time)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.db" ], [ "LOAD_ATTR", "self.db.session_scope" ], [ "CALL_FUNCTION", "self.db.session_scope()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.add" ], [ "LOAD_FAST", "call" ], [ "CALL_FUNCTION", "session.add(call)" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.vals" ], [ "LOAD_ATTR", "iteration.vals.items" ], [ "CALL_FUNCTION", "iteration.vals.items()" ], [ "LOAD_FAST", "tree_index" ], [ "LOAD_FAST", "path" ], [ "BINARY_ADD", "(tree_index,) + path" ], [ "LOAD_FAST", "node_values" ], [ "LOAD_FAST", "full_path" ], [ "BINARY_SUBSCR", "full_path[:-1]" ], [ "LOAD_FAST", "d" ], [ "LOAD_FAST", "path_k" ], [ "BINARY_SUBSCR", "d[path_k]" ], [ "LOAD_FAST", "node_value" ], [ "LOAD_FAST", "d" ], [ "LOAD_FAST", "full_path" ], [ "BINARY_SUBSCR", "full_path[-1]" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.loops" ], [ "LOAD_ATTR", "iteration.loops.values" ], [ "CALL_FUNCTION", "iteration.loops.values()" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "loop" ], [ "CALL_FUNCTION", "enumerate(loop)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._extract_node_values" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "path + (i,)" ], [ "LOAD_FAST", "node_values" ], [ "CALL_FUNCTION", "self._extract_node_values(iteration, path + (i,), node_values)" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "BirdsEye" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(BirdsEye, self)" ], [ "LOAD_ATTR", "super(BirdsEye, self).trace_function" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "super(BirdsEye, self).trace_function(func)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_ATTR", "self._code_infos.get" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_ATTR", "new_func.__code__" ], [ "CALL_FUNCTION", "self._code_infos.get(new_func.__code__)" ], [ "LOAD_FAST", "code_info" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.getsourcelines" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "inspect.getsourcelines(func)" ], [ "LOAD_FAST", "start_lineno" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "lines" ], [ "CALL_FUNCTION", "len(lines)" ], [ "BINARY_ADD", "start_lineno + len(lines)" ], [ "LOAD_GLOBAL", "safe_qualname" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "safe_qualname(func)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.getsourcefile" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "inspect.getsourcefile(func)" ], [ "LOAD_FAST", "source_file" ], [ "LOAD_ATTR", "source_file.startswith" ], [ "CALL_FUNCTION", "source_file.startswith('= 0" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.getsourcefile" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "inspect.getsourcefile(frame)" ], [ "LOAD_FAST", "filename" ], [ "COMPARE_OP", "filename is not None" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.abspath" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "os.path.abspath(filename)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "LOAD_ATTR", "frame.f_globals.get" ], [ "CALL_FUNCTION", "frame.f_globals.get('__name__')" ], [ "COMPARE_OP", "frame.f_globals.get('__name__') != '__main__'" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._treetrace_hidden_with_stmt" ], [ "LOAD_ATTR", "self._treetrace_hidden_with_stmt.__name__" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "COMPARE_OP", "self._treetrace_hidden_with_stmt.__name__ not in frame.f_globals" ], [ "LOAD_GLOBAL", "RuntimeError" ], [ "CALL_FUNCTION", "RuntimeError(\n 'To trace an imported module, you must import birdseye before '\n 'importing that module.')" ], [ "LOAD_GLOBAL", "read_source_file" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "read_source_file(filename)" ], [ "LOAD_ATTR", "read_source_file(filename).splitlines" ], [ "CALL_FUNCTION", "read_source_file(filename).splitlines()" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lineno" ], [ "BINARY_MULTIPLY", "[''] * frame.f_lineno" ], [ "LOAD_FAST", "lines" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lineno" ], [ "LOAD_ATTR", "'\\n'.join" ], [ "LOAD_FAST", "lines" ], [ "CALL_FUNCTION", "'\\n'.join(lines)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.exec_string" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "LOAD_FAST", "deep" ], [ "CALL_FUNCTION", "self.exec_string(source, filename, frame.f_globals, frame.f_locals, deep)" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.exit" ], [ "CALL_FUNCTION", "sys.exit(0)" ], [ "LOAD_FAST", "globs" ], [ "LOAD_FAST", "locs" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.compile" ], [ "LOAD_DEREF", "source" ], [ "LOAD_DEREF", "filename" ], [ "CALL_FUNCTION", "self.compile(source, filename)" ], [ "LOAD_FAST", "globs" ], [ "LOAD_ATTR", "globs.update" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._trace_methods_dict" ], [ "LOAD_DEREF", "traced_file" ], [ "CALL_FUNCTION", "self._trace_methods_dict(traced_file)" ], [ "CALL_FUNCTION", "globs.update(self._trace_methods_dict(traced_file))" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._trace" ], [ "LOAD_GLOBAL", "FILE_SENTINEL_NAME" ], [ "LOAD_DEREF", "filename" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.code" ], [ "LOAD_DEREF", "source" ], [ "CALL_FUNCTION", "self._trace(FILE_SENTINEL_NAME, filename, traced_file, traced_file.code, 'module', source)" ], [ "LOAD_FAST", "deep" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.nodes" ], [ "LOAD_DEREF", "find_code" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.code" ], [ "CALL_FUNCTION", "find_code(traced_file.code)" ], [ "LOAD_GLOBAL", "exec" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.code" ], [ "LOAD_FAST", "globs" ], [ "LOAD_FAST", "locs" ], [ "CALL_FUNCTION", "exec(traced_file.code, globs, locs)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(node, ast.FunctionDef)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.lineno" ], [ "LOAD_FAST", "root_code" ], [ "LOAD_ATTR", "root_code.co_consts" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.iscode" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "inspect.iscode(code)" ], [ "UNARY_NOT", "not inspect.iscode(code)" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "LOAD_ATTR", "code.co_name.startswith" ], [ "CALL_FUNCTION", "code.co_name.startswith('<')" ], [ "LOAD_DEREF", "find_code" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "find_code(code)" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_firstlineno" ], [ "LOAD_DEREF", "nodes_by_lineno" ], [ "LOAD_ATTR", "nodes_by_lineno.get" ], [ "LOAD_FAST", "lineno" ], [ "CALL_FUNCTION", "nodes_by_lineno.get(lineno)" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._trace" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "LOAD_DEREF", "filename" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_FAST", "code" ], [ "LOAD_DEREF", "source" ], [ "LOAD_FAST", "lineno" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.last_token" ], [ "LOAD_ATTR", "node.last_token.end" ], [ "BINARY_SUBSCR", "node.last_token.end[0]" ], [ "BINARY_ADD", "node.last_token.end[0] + 1" ], [ "CALL_FUNCTION", "self._trace(\n code.co_name, filename, traced_file, code,\n typ='function',\n source=source,\n start_lineno=lineno,\n end_lineno=node.last_token.end[0] + 1,\n )" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_DEREF", "start_lineno" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.splitlines" ], [ "CALL_FUNCTION", "source.splitlines()" ], [ "CALL_FUNCTION", "len(source.splitlines())" ], [ "BINARY_ADD", "start_lineno + len(source.splitlines())" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._nodes_of_interest" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_DEREF", "start_lineno" ], [ "LOAD_FAST", "end_lineno" ], [ "CALL_FUNCTION", "self._nodes_of_interest(traced_file, start_lineno, end_lineno)" ], [ "CALL_FUNCTION", "list(self._nodes_of_interest(traced_file, start_lineno, end_lineno))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._nodes_html" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_DEREF", "start_lineno" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_FAST", "traced_file" ], [ "CALL_FUNCTION", "self._nodes_html(nodes, start_lineno, end_lineno, traced_file)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "nodes" ], [ "CALL_FUNCTION", "dict(\n # This maps each node to the loops enclosing that node\n node_loops={\n node._tree_index: [n._tree_index for n in node._loops]\n for node, _ in nodes\n if node._loops\n },\n )" ], [ "LOAD_FAST", "typ" ], [ "COMPARE_OP", "typ == 'function'" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.tokens" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_FAST", "nodes" ], [ "CALL_FUNCTION", "only(node\n for node, _ in nodes\n if isinstance(node, ast.FunctionDef)\n and node.first_token.start[0] == start_lineno)" ], [ "LOAD_GLOBAL", "source_without_decorators" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_FAST", "func_node" ], [ "CALL_FUNCTION", "source_without_decorators(tokens, func_node)" ], [ "LOAD_FAST", "data_dict" ], [ "LOAD_ATTR", "data_dict.update" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._node_ranges" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_FAST", "func_startpos" ], [ "CALL_FUNCTION", "self._node_ranges(nodes, tokens, func_startpos)" ], [ "CALL_FUNCTION", "list(self._node_ranges(nodes, tokens, func_startpos))" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._loop_ranges" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_FAST", "func_startpos" ], [ "CALL_FUNCTION", "self._loop_ranges(nodes, tokens, func_startpos)" ], [ "CALL_FUNCTION", "list(self._loop_ranges(nodes, tokens, func_startpos))" ], [ "CALL_FUNCTION", "data_dict.update(\n node_ranges=list(self._node_ranges(nodes, tokens, func_startpos)),\n loop_ranges=list(self._loop_ranges(nodes, tokens, func_startpos)),\n )" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_ATTR", "json.dumps" ], [ "LOAD_FAST", "data_dict" ], [ "CALL_FUNCTION", "json.dumps(data_dict, sort_keys=True)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._db_func" ], [ "LOAD_FAST", "data" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "html_body" ], [ "LOAD_FAST", "name" ], [ "LOAD_DEREF", "start_lineno" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "typ" ], [ "CALL_FUNCTION", "self._db_func(data, filename, html_body, name, start_lineno, source, typ)" ], [ "LOAD_GLOBAL", "CodeInfo" ], [ "LOAD_FAST", "db_func" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_FAST", "arg_names" ], [ "CALL_FUNCTION", "CodeInfo(db_func, traced_file, arg_names)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_FAST", "n" ], [ "LOAD_ATTR", "n._tree_index" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(node, ast.FunctionDef)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.first_token" ], [ "LOAD_ATTR", "node.first_token.start" ], [ "BINARY_SUBSCR", "node.first_token.start[0]" ], [ "LOAD_DEREF", "start_lineno" ], [ "COMPARE_OP", "node.first_token.start[0] == start_lineno" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "classes" ], [ "COMPARE_OP", "'loop' not in classes" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.target" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.test" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_ATTR", "tokens.get_text_range" ], [ "LOAD_FAST", "target" ], [ "CALL_FUNCTION", "tokens.get_text_range(target)" ], [ "LOAD_FAST", "func_start" ], [ "LOAD_FAST", "func_start" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "CALL_FUNCTION", "dict(\n tree_index=node._tree_index,\n start=start,\n end=end\n )" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_ATTR", "tokens.get_text_range" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "tokens.get_text_range(node)" ], [ "LOAD_FAST", "func_start" ], [ "LOAD_FAST", "func_start" ], [ "LOAD_FAST", "start" ], [ "COMPARE_OP", "start < 0" ], [ "LOAD_FAST", "end" ], [ "COMPARE_OP", "end < 0" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(node, ast.FunctionDef)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._depth" ], [ "LOAD_FAST", "classes" ], [ "CALL_FUNCTION", "dict(\n tree_index=node._tree_index,\n start=start,\n end=end,\n depth=node._depth,\n classes=classes,\n )" ], [ "LOAD_FAST", "h" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "name" ], [ "BINARY_ADD", "filename + name" ], [ "LOAD_FAST", "html_body" ], [ "BINARY_ADD", "filename + name + html_body" ], [ "LOAD_FAST", "data" ], [ "BINARY_ADD", "filename + name + html_body + data" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "start_lineno" ], [ "CALL_FUNCTION", "str(start_lineno)" ], [ "BINARY_ADD", "filename + name + html_body + data + str(start_lineno)" ], [ "CALL_FUNCTION", "h(filename + name + html_body + data + str(start_lineno))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.db" ], [ "LOAD_ATTR", "self.db.Function" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.db" ], [ "LOAD_ATTR", "self.db.session_scope" ], [ "CALL_FUNCTION", "self.db.session_scope()" ], [ "LOAD_GLOBAL", "one_or_none" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_FAST", "Function" ], [ "CALL_FUNCTION", "session.query(Function)" ], [ "LOAD_ATTR", "session.query(Function).filter_by" ], [ "LOAD_FAST", "function_hash" ], [ "CALL_FUNCTION", "session.query(Function).filter_by(hash=function_hash)" ], [ "CALL_FUNCTION", "one_or_none(session.query(Function).filter_by(hash=function_hash))" ], [ "LOAD_FAST", "db_func" ], [ "LOAD_FAST", "Function" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "typ" ], [ "LOAD_FAST", "html_body" ], [ "LOAD_FAST", "start_lineno" ], [ "LOAD_FAST", "data" ], [ "LOAD_FAST", "h" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "h(source)" ], [ "LOAD_FAST", "function_hash" ], [ "CALL_FUNCTION", "Function(file=filename,\n name=name,\n type=typ,\n html_body=html_body,\n lineno=start_lineno,\n data=data,\n body_hash=h(source),\n hash=function_hash)" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.add" ], [ "LOAD_FAST", "db_func" ], [ "CALL_FUNCTION", "session.add(db_func)" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.commit" ], [ "CALL_FUNCTION", "session.commit()" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "db_func" ], [ "LOAD_ATTR", "db_func.id" ], [ "LOAD_GLOBAL", "int" ], [ "CALL_FUNCTION", "isinstance(db_func.id, int)" ], [ "LOAD_FAST", "db_func" ], [ "LOAD_ATTR", "db_func.id" ], [ "LOAD_GLOBAL", "hashlib" ], [ "LOAD_ATTR", "hashlib.sha256" ], [ "LOAD_FAST", "s" ], [ "LOAD_ATTR", "s.encode" ], [ "CALL_FUNCTION", "s.encode('utf8')" ], [ "CALL_FUNCTION", "hashlib.sha256(s.encode('utf8'))" ], [ "LOAD_ATTR", "hashlib.sha256(s.encode('utf8')).hexdigest" ], [ "CALL_FUNCTION", "hashlib.sha256(s.encode('utf8')).hexdigest()" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.nodes" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "CALL_FUNCTION", "isinstance(node, (ast.While, ast.For, ast.comprehension))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.GeneratorExp" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.GeneratorExp)" ], [ "UNARY_NOT", "not isinstance(node.parent, ast.GeneratorExp)" ], [ "LOAD_FAST", "classes" ], [ "LOAD_ATTR", "classes.append" ], [ "CALL_FUNCTION", "classes.append('loop')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "CALL_FUNCTION", "isinstance(node, ast.stmt)" ], [ "LOAD_FAST", "classes" ], [ "LOAD_ATTR", "classes.append" ], [ "CALL_FUNCTION", "classes.append('stmt')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "CALL_FUNCTION", "isinstance(node, ast.expr)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._is_interesting_expression" ], [ "LOAD_FAST", "classes" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.AST" ], [ "CALL_FUNCTION", "isinstance(node, ast.AST)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "hasattr(node, 'first_token')" ], [ "LOAD_FAST", "start_lineno" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.first_token" ], [ "LOAD_ATTR", "node.first_token.start" ], [ "BINARY_SUBSCR", "node.first_token.start[0]" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.tokens" ], [ "LOAD_ATTR", "traced_file.tokens.get_text_range" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "traced_file.tokens.get_text_range(node)" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "classes" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.root" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.walk" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.root" ], [ "CALL_FUNCTION", "ast.walk(traced_file.root)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.iter_child_nodes" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ast.iter_child_nodes(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._depth" ], [ "BINARY_ADD", "node._depth + 1" ], [ "LOAD_FAST", "child" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "positions" ], [ "LOAD_ATTR", "positions.extend" ], [ "LOAD_GLOBAL", "map" ], [ "LOAD_GLOBAL", "HTMLPosition" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._depth" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._depth" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_ATTR", "' '.join" ], [ "LOAD_FAST", "classes" ], [ "CALL_FUNCTION", "' '.join(classes)" ], [ "BINARY_MODULO", "'' % (node._tree_index, ' '.join(classes))" ], [ "CALL_FUNCTION", "map(\n HTMLPosition,\n [start, end],\n [True, False], # is_start\n [node._depth, node._depth],\n ['' % (node._tree_index, ' '.join(classes)),\n ''])" ], [ "CALL_FUNCTION", "positions.extend(map(\n HTMLPosition,\n [start, end],\n [True, False], # is_start\n [node._depth, node._depth],\n ['' % (node._tree_index, ' '.join(classes)),\n '']))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._separate_comprehensions" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_FAST", "positions" ], [ "LOAD_FAST", "traced_file" ], [ "CALL_FUNCTION", "self._separate_comprehensions(\n [n[0] for n in nodes],\n end_lineno, positions, traced_file)" ], [ "LOAD_FAST", "positions" ], [ "LOAD_ATTR", "positions.append" ], [ "LOAD_GLOBAL", "HTMLPosition" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.source" ], [ "CALL_FUNCTION", "len(traced_file.source)" ], [ "CALL_FUNCTION", "HTMLPosition(len(traced_file.source), False, 0, '')" ], [ "CALL_FUNCTION", "positions.append(HTMLPosition(len(traced_file.source), False, 0, ''))" ], [ "LOAD_FAST", "positions" ], [ "LOAD_ATTR", "positions.sort" ], [ "CALL_FUNCTION", "positions.sort()" ], [ "LOAD_FAST", "positions" ], [ "LOAD_FAST", "html_parts" ], [ "LOAD_ATTR", "html_parts.append" ], [ "LOAD_GLOBAL", "html" ], [ "LOAD_ATTR", "html.escape" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.source" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "position" ], [ "LOAD_ATTR", "position.index" ], [ "BINARY_SUBSCR", "traced_file.source[start:position.index]" ], [ "CALL_FUNCTION", "html.escape(traced_file.source[start:position.index])" ], [ "CALL_FUNCTION", "html_parts.append(html.escape(traced_file.source[start:position.index]))" ], [ "LOAD_FAST", "html_parts" ], [ "LOAD_ATTR", "html_parts.append" ], [ "LOAD_FAST", "position" ], [ "LOAD_ATTR", "position.html" ], [ "CALL_FUNCTION", "html_parts.append(position.html)" ], [ "LOAD_FAST", "position" ], [ "LOAD_ATTR", "position.index" ], [ "LOAD_ATTR", "''.join" ], [ "LOAD_FAST", "html_parts" ], [ "CALL_FUNCTION", "''.join(html_parts)" ], [ "LOAD_ATTR", "'\\n'.join" ], [ "LOAD_FAST", "html_body" ], [ "LOAD_ATTR", "html_body.split" ], [ "CALL_FUNCTION", "html_body.split('\\n')" ], [ "LOAD_FAST", "start_lineno" ], [ "BINARY_SUBTRACT", "start_lineno - 1" ], [ "LOAD_FAST", "end_lineno" ], [ "BINARY_SUBTRACT", "end_lineno - 1" ], [ "BINARY_SUBSCR", "html_body.split('\\n')[start_lineno - 1:end_lineno - 1]" ], [ "CALL_FUNCTION", "'\\n'.join(html_body.split('\\n')[start_lineno - 1:end_lineno - 1])" ], [ "LOAD_FAST", "html_body" ], [ "LOAD_ATTR", "html_body.strip" ], [ "CALL_FUNCTION", "html_body.strip('\\n')" ], [ "LOAD_FAST", "n" ], [ "BINARY_SUBSCR", "n[0]" ], [ "LOAD_GLOBAL", "group_by_key_func" ], [ "LOAD_GLOBAL", "of_type" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "LOAD_FAST", "nodes" ], [ "CALL_FUNCTION", "of_type((ast.comprehension, ast.While, ast.For), nodes)" ], [ "CALL_FUNCTION", "group_by_key_func(of_type((ast.comprehension, ast.While, ast.For), nodes),\n lambda c: c.first_token.start[0]\n )" ], [ "LOAD_FAST", "comprehensions" ], [ "LOAD_ATTR", "comprehensions.values" ], [ "CALL_FUNCTION", "comprehensions.values()" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_FAST", "comp_list" ], [ "CALL_FUNCTION", "sorted(comp_list, key=lambda c: c.first_token.startpos)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "comp" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "CALL_FUNCTION", "isinstance(comp, ast.comprehension)" ], [ "LOAD_FAST", "comp" ], [ "LOAD_FAST", "comp" ], [ "LOAD_ATTR", "comp.parent" ], [ "LOAD_ATTR", "comp.parent.generators" ], [ "BINARY_SUBSCR", "comp.parent.generators[0]" ], [ "COMPARE_OP", "comp is comp.parent.generators[0]" ], [ "LOAD_FAST", "get_start" ], [ "LOAD_FAST", "comp" ], [ "LOAD_ATTR", "comp.parent" ], [ "CALL_FUNCTION", "get_start(comp.parent)" ], [ "LOAD_FAST", "prev_start" ], [ "COMPARE_OP", "prev_start is not None" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "prev_start" ], [ "COMPARE_OP", "start < prev_start" ], [ "LOAD_FAST", "get_start" ], [ "LOAD_FAST", "comp" ], [ "CALL_FUNCTION", "get_start(comp)" ], [ "LOAD_FAST", "get_start" ], [ "LOAD_FAST", "comp" ], [ "CALL_FUNCTION", "get_start(comp)" ], [ "LOAD_FAST", "prev_start" ], [ "COMPARE_OP", "prev_start is not None" ], [ "LOAD_FAST", "positions" ], [ "LOAD_ATTR", "positions.append" ], [ "LOAD_GLOBAL", "HTMLPosition" ], [ "LOAD_FAST", "start" ], [ "CALL_FUNCTION", "HTMLPosition(start, True, 0, '\\n ')" ], [ "CALL_FUNCTION", "positions.append(HTMLPosition(start, True, 0, '\\n '))" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.first_token" ], [ "LOAD_ATTR", "c.first_token.start" ], [ "BINARY_SUBSCR", "c.first_token.start[0]" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.tokens" ], [ "LOAD_ATTR", "traced_file.tokens.get_text_range" ], [ "LOAD_FAST", "n" ], [ "CALL_FUNCTION", "traced_file.tokens.get_text_range(n)" ], [ "BINARY_SUBSCR", "traced_file.tokens.get_text_range(n)[0]" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.first_token" ], [ "LOAD_ATTR", "c.first_token.startpos" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "_deep_dict" ], [ "CALL_FUNCTION", "defaultdict(_deep_dict)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_GLOBAL", "_bad_codes" ], [ "COMPARE_OP", "frame.f_code in _bad_codes" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "IterationList" ], [ "CALL_FUNCTION", "defaultdict(IterationList)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.index" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.loops" ], [ "LOAD_ATTR", "self.loops.items" ], [ "CALL_FUNCTION", "self.loops.items()" ], [ "LOAD_FAST", "iteration_list" ], [ "LOAD_FAST", "tree_index" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.extract_iterations" ], [ "CALL_FUNCTION", "iteration.extract_iterations()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "deque" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.side_len" ], [ "CALL_FUNCTION", "deque(maxlen=self.side_len)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "Counter" ], [ "CALL_FUNCTION", "Counter()" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.length" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.side_len" ], [ "COMPARE_OP", "self.length < self.side_len" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start" ], [ "LOAD_ATTR", "self.start.append" ], [ "LOAD_FAST", "iteration" ], [ "CALL_FUNCTION", "self.start.append(iteration)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "CALL_FUNCTION", "len(self.end)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.side_len" ], [ "COMPARE_OP", "len(self.end) >= self.side_len" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "BINARY_SUBSCR", "self.end[0]" ], [ "LOAD_ATTR", "self.end[0].keep" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start" ], [ "LOAD_ATTR", "self.start.append" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "BINARY_SUBSCR", "self.end[0]" ], [ "CALL_FUNCTION", "self.start.append(self.end[0])" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "LOAD_ATTR", "self.end.append" ], [ "LOAD_FAST", "iteration" ], [ "CALL_FUNCTION", "self.end.append(iteration)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.length" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "chain" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "CALL_FUNCTION", "chain(self.start, self.end)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "BINARY_SUBSCR", "self.end[-1]" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start" ], [ "BINARY_SUBSCR", "self.start[-1]" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.recorded" ], [ "LOAD_FAST", "node" ], [ "BINARY_SUBSCR", "self.recorded[node]" ], [ "COMPARE_OP", "self.recorded[node] >= 2" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.last" ], [ "CALL_FUNCTION", "self.last()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.recorded" ], [ "LOAD_FAST", "node" ], [ "LOAD_NAME", "type" ], [ "CALL_FUNCTION", "type(None)" ], [ "LOAD_NAME", "bool" ], [ "LOAD_NAME", "int" ], [ "LOAD_NAME", "float" ], [ "LOAD_NAME", "complex" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "long" ], [ "LOAD_NAME", "basic_types" ], [ "LOAD_NAME", "list" ], [ "LOAD_NAME", "dict" ], [ "LOAD_NAME", "tuple" ], [ "LOAD_NAME", "set" ], [ "LOAD_NAME", "frozenset" ], [ "LOAD_NAME", "str" ], [ "BINARY_ADD", "basic_types + (list, dict, tuple, set, frozenset, str)" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "unicode" ], [ "LOAD_NAME", "bytes" ], [ "LOAD_NAME", "len" ], [ "LOAD_NAME", "special_types" ], [ "CALL_FUNCTION", "len(special_types)" ], [ "LOAD_GLOBAL", "Lock" ], [ "CALL_FUNCTION", "Lock()" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "CALL_FUNCTION", "defaultdict(lambda: len(self.data))" ], [ "LOAD_DEREF", "self" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.special_types" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.data" ], [ "LOAD_FAST", "t" ], [ "BINARY_SUBSCR", "self.data[t]" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.data" ], [ "CALL_FUNCTION", "len(self.data)" ], [ "LOAD_GLOBAL", "correct_type" ], [ "LOAD_FAST", "item" ], [ "CALL_FUNCTION", "correct_type(item)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.lock" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.data" ], [ "LOAD_FAST", "t" ], [ "BINARY_SUBSCR", "self.data[t]" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.data" ], [ "LOAD_ATTR", "self.data.items" ], [ "CALL_FUNCTION", "self.data.items()" ], [ "CALL_FUNCTION", "dict((v, k) for k, v in self.data.items())" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_DEREF", "rev" ], [ "CALL_FUNCTION", "len(rev)" ], [ "CALL_FUNCTION", "range(len(rev))" ], [ "LOAD_FAST", "v" ], [ "LOAD_FAST", "k" ], [ "LOAD_GLOBAL", "safe_qualname" ], [ "LOAD_DEREF", "rev" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "rev[i]" ], [ "CALL_FUNCTION", "safe_qualname(rev[i])" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_FAST", "val_repr" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "type_index" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.meta" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.meta" ], [ "LOAD_FAST", "key" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.children" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.children" ], [ "LOAD_ATTR", "self.children.append" ], [ "LOAD_FAST", "key" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOAD_ATTR", "NodeValue.expression" ], [ "LOAD_FAST", "samples" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "level" ], [ "CALL_FUNCTION", "NodeValue.expression(samples, value, level)" ], [ "CALL_FUNCTION", "self.children.append((key, NodeValue.expression(samples, value, level)))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.val_repr" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.type_index" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.meta" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.children" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.extend" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.children" ], [ "CALL_FUNCTION", "result.extend(self.children)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "cls" ], [ "CALL_FUNCTION", "cls('', -2)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_GLOBAL", "exception_string" ], [ "LOAD_FAST", "exc_value" ], [ "CALL_FUNCTION", "exception_string(exc_value)" ], [ "CALL_FUNCTION", "cls(exception_string(exc_value), -1)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "cheap_repr(val)" ], [ "LOAD_GLOBAL", "type_registry" ], [ "LOAD_FAST", "val" ], [ "BINARY_SUBSCR", "type_registry[val]" ], [ "CALL_FUNCTION", "cls(cheap_repr(val), type_registry[val])" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "TypeRegistry" ], [ "LOAD_ATTR", "TypeRegistry.basic_types" ], [ "LOAD_GLOBAL", "BirdsEye" ], [ "CALL_FUNCTION", "isinstance(val, (TypeRegistry.basic_types, BirdsEye))" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "QuerySet" ], [ "CALL_FUNCTION", "isinstance(val, QuerySet)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "len(val)" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.set_meta" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "result.set_meta('len', length)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "ModuleType" ], [ "CALL_FUNCTION", "isinstance(val, ModuleType)" ], [ "LOAD_GLOBAL", "min" ], [ "LOAD_FAST", "level" ], [ "CALL_FUNCTION", "min(level, 2)" ], [ "LOAD_GLOBAL", "partial" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.add_child" ], [ "LOAD_FAST", "samples" ], [ "LOAD_FAST", "level" ], [ "BINARY_SUBTRACT", "level - 1" ], [ "CALL_FUNCTION", "partial(result.add_child, samples, level - 1)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Series" ], [ "LOAD_GLOBAL", "ndarray" ], [ "CALL_FUNCTION", "isinstance(val, (Series, ndarray))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "ndarray" ], [ "CALL_FUNCTION", "isinstance(val, ndarray)" ], [ "LOAD_FAST", "attrs" ], [ "LOAD_ATTR", "attrs.append" ], [ "CALL_FUNCTION", "attrs.append('shape')" ], [ "LOAD_FAST", "attrs" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "val" ], [ "LOAD_FAST", "name" ], [ "CALL_FUNCTION", "getattr(val, name)" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "attr" ], [ "CALL_FUNCTION", "add_child(name, attr)" ], [ "LOAD_FAST", "level" ], [ "COMPARE_OP", "level >= 3" ], [ "LOAD_FAST", "level" ], [ "COMPARE_OP", "level >= 2" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Series" ], [ "CALL_FUNCTION", "isinstance(val, Series)" ], [ "LOAD_FAST", "samples" ], [ "LOAD_FAST", "sample_type" ], [ "BINARY_SUBSCR", "samples[sample_type]" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "DataFrame" ], [ "CALL_FUNCTION", "isinstance(val, DataFrame)" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.set_meta" ], [ "LOAD_FAST", "meta" ], [ "CALL_FUNCTION", "result.set_meta('dataframe', meta)" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['pandas_rows']" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['pandas_cols']" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_rows" ], [ "BINARY_ADD", "max_rows + 2" ], [ "COMPARE_OP", "length > max_rows + 2" ], [ "LOAD_FAST", "max_rows" ], [ "BINARY_FLOOR_DIVIDE", "max_rows // 2" ], [ "LOAD_FAST", "meta" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.columns" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "columns" ], [ "CALL_FUNCTION", "len(columns)" ], [ "LOAD_FAST", "num_cols" ], [ "LOAD_FAST", "max_cols" ], [ "BINARY_ADD", "max_cols + 2" ], [ "COMPARE_OP", "num_cols > max_cols + 2" ], [ "LOAD_FAST", "max_cols" ], [ "BINARY_FLOOR_DIVIDE", "max_cols // 2" ], [ "LOAD_FAST", "meta" ], [ "LOAD_GLOBAL", "set" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "num_cols" ], [ "LOAD_FAST", "max_cols" ], [ "CALL_FUNCTION", "_sample_indices(num_cols, max_cols)" ], [ "CALL_FUNCTION", "set(_sample_indices(num_cols, max_cols))" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_GLOBAL", "zip" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.columns" ], [ "LOAD_ATTR", "val.columns.format" ], [ "CALL_FUNCTION", "val.columns.format(sparsify=False)" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.columns" ], [ "CALL_FUNCTION", "zip(val.columns.format(sparsify=False),\n val.columns)" ], [ "CALL_FUNCTION", "enumerate(zip(val.columns.format(sparsify=False),\n val.columns))" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "indices" ], [ "COMPARE_OP", "i in indices" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_FAST", "formatted_name" ], [ "LOAD_FAST", "val" ], [ "LOAD_FAST", "label" ], [ "BINARY_SUBSCR", "val[label]" ], [ "CALL_FUNCTION", "add_child(formatted_name, val[label])" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Series" ], [ "CALL_FUNCTION", "isinstance(val, Series)" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['pandas_rows']" ], [ "CALL_FUNCTION", "_sample_indices(length, samples['pandas_rows'])" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.index" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "val.index[i:i + 1]" ], [ "LOAD_ATTR", "val.index[i:i + 1].format" ], [ "CALL_FUNCTION", "val.index[i:i + 1].format(sparsify=False)" ], [ "BINARY_SUBSCR", "val.index[i:i + 1].format(sparsify=False)[0]" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.iloc" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "val.iloc[i]" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_FAST", "k" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child(k, v)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "level" ], [ "COMPARE_OP", "level <= 0" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "bytes" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "unicode" ], [ "LOAD_GLOBAL", "xrange" ], [ "CALL_FUNCTION", "isinstance(val,\n (str, bytes, range)\n if PY3 else\n (str, unicode, xrange))" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Sequence" ], [ "LOAD_GLOBAL", "ndarray" ], [ "CALL_FUNCTION", "isinstance(val, (Sequence, ndarray))" ], [ "LOAD_FAST", "length" ], [ "COMPARE_OP", "length is not None" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['list']" ], [ "CALL_FUNCTION", "_sample_indices(length, samples['list'])" ], [ "LOAD_FAST", "val" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "val[i]" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "i" ], [ "CALL_FUNCTION", "str(i)" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child(str(i), v)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Mapping" ], [ "CALL_FUNCTION", "isinstance(val, Mapping)" ], [ "LOAD_GLOBAL", "islice" ], [ "LOAD_GLOBAL", "_safe_iter" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "iteritems" ], [ "CALL_FUNCTION", "_safe_iter(val, iteritems)" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['dict']" ], [ "CALL_FUNCTION", "islice(_safe_iter(val, iteritems), samples['dict'])" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "k" ], [ "CALL_FUNCTION", "cheap_repr(k)" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child(cheap_repr(k), v)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Set" ], [ "CALL_FUNCTION", "isinstance(val, Set)" ], [ "LOAD_GLOBAL", "_safe_iter" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "_safe_iter(val)" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['set']" ], [ "LOAD_FAST", "length" ], [ "COMPARE_OP", "length is None" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "num_items" ], [ "BINARY_ADD", "num_items + 2" ], [ "COMPARE_OP", "length > num_items + 2" ], [ "LOAD_GLOBAL", "islice" ], [ "LOAD_FAST", "vals" ], [ "LOAD_FAST", "num_items" ], [ "CALL_FUNCTION", "islice(vals, num_items)" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "vals" ], [ "CALL_FUNCTION", "enumerate(vals)" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_FAST", "i" ], [ "BINARY_MODULO", "'<%s>' % i" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child('<%s>' % i, v)" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "getattr(val, '__dict__', None)" ], [ "LOAD_FAST", "d" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_GLOBAL", "islice" ], [ "LOAD_GLOBAL", "_safe_iter" ], [ "LOAD_FAST", "d" ], [ "CALL_FUNCTION", "_safe_iter(d)" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['attributes']" ], [ "CALL_FUNCTION", "islice(_safe_iter(d),\n samples['attributes'])" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "sorted(islice(_safe_iter(d),\n samples['attributes']),\n key=str)" ], [ "LOAD_FAST", "d" ], [ "LOAD_FAST", "k" ], [ "BINARY_SUBSCR", "d[k]" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "TracedFile" ], [ "CALL_FUNCTION", "isinstance(v, TracedFile)" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "k" ], [ "CALL_FUNCTION", "str(k)" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child(str(k), v)" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "type" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "type(val)" ], [ "CALL_FUNCTION", "getattr(type(val), '__slots__', None)" ], [ "CALL_FUNCTION", "sorted(getattr(type(val), '__slots__', None) or ())" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "val" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "getattr(val, s)" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "str(s)" ], [ "LOAD_FAST", "attr" ], [ "CALL_FUNCTION", "add_child(str(s), attr)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "x" ], [ "LOAD_FAST", "f" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "f(val)" ], [ "LOAD_FAST", "x" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_ADD", "max_length + 2" ], [ "COMPARE_OP", "length <= max_length + 2" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "range(length)" ], [ "LOAD_GLOBAL", "chain" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_FLOOR_DIVIDE", "max_length // 2" ], [ "CALL_FUNCTION", "range(max_length // 2)" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_FLOOR_DIVIDE", "max_length // 2" ], [ "BINARY_SUBTRACT", "length - max_length // 2" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "range(length - max_length // 2,\n length)" ], [ "CALL_FUNCTION", "chain(range(max_length // 2),\n range(length - max_length // 2,\n length))" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "len(x)" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "n == 0" ], [ "LOAD_GLOBAL", "repr" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "repr(x)" ], [ "LOAD_FAST", "helper" ], [ "LOAD_ATTR", "helper.level" ], [ "BINARY_SUBTRACT", "helper.level - 1" ], [ "LOAD_GLOBAL", "_repr_series_one_line" ], [ "LOAD_ATTR", "_repr_series_one_line.maxparts" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "n" ], [ "LOAD_FAST", "maxparts" ], [ "CALL_FUNCTION", "_sample_indices(n, maxparts)" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.index" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "x.index[i:i + 1]" ], [ "LOAD_ATTR", "x.index[i:i + 1].format" ], [ "CALL_FUNCTION", "x.index[i:i + 1].format(sparsify=False)" ], [ "BINARY_SUBSCR", "x.index[i:i + 1].format(sparsify=False)[0]" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.iloc" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "x.iloc[i]" ], [ "LOAD_FAST", "pieces" ], [ "LOAD_ATTR", "pieces.append" ], [ "LOAD_FAST", "k" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "v" ], [ "LOAD_FAST", "newlevel" ], [ "CALL_FUNCTION", "cheap_repr(v, newlevel)" ], [ "BINARY_MODULO", "'%s = %s' % (k, cheap_repr(v, newlevel))" ], [ "CALL_FUNCTION", "pieces.append('%s = %s' % (k, cheap_repr(v, newlevel)))" ], [ "LOAD_FAST", "n" ], [ "LOAD_FAST", "maxparts" ], [ "BINARY_ADD", "maxparts + 2" ], [ "COMPARE_OP", "n > maxparts + 2" ], [ "LOAD_FAST", "pieces" ], [ "LOAD_ATTR", "pieces.insert" ], [ "LOAD_FAST", "maxparts" ], [ "BINARY_FLOOR_DIVIDE", "maxparts // 2" ], [ "CALL_FUNCTION", "pieces.insert(maxparts // 2, '...')" ], [ "LOAD_ATTR", "'; '.join" ], [ "LOAD_FAST", "pieces" ], [ "CALL_FUNCTION", "'; '.join(pieces)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "CALL_FUNCTION", "isinstance(node, ast.expr)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Num" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Str" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "ast" ], [ "CALL_FUNCTION", "getattr(ast, 'NameConstant', ())" ], [ "CALL_FUNCTION", "isinstance(node, (ast.Num, ast.Str, getattr(ast, 'NameConstant', ())))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "getattr(node, 'ctx', None)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Store" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Del" ], [ "CALL_FUNCTION", "isinstance(getattr(node, 'ctx', None),\n (ast.Store, ast.Del))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.UnaryOp" ], [ "CALL_FUNCTION", "isinstance(node, ast.UnaryOp)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.op" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.UAdd" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.USub" ], [ "CALL_FUNCTION", "isinstance(node.op, (ast.UAdd, ast.USub))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.operand" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Num" ], [ "CALL_FUNCTION", "isinstance(node.operand, ast.Num)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.List" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Tuple" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Dict" ], [ "CALL_FUNCTION", "isinstance(node, (ast.List, ast.Tuple, ast.Dict))" ], [ "LOAD_GLOBAL", "any" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.iter_child_nodes" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ast.iter_child_nodes(node)" ], [ "CALL_FUNCTION", "any(is_interesting_expression(n) for n in ast.iter_child_nodes(node))" ], [ "UNARY_NOT", "not any(is_interesting_expression(n) for n in ast.iter_child_nodes(node))" ], [ "UNARY_NOT", "not (isinstance(node, (ast.Num, ast.Str, getattr(ast, 'NameConstant', ()))) or\n isinstance(getattr(node, 'ctx', None),\n (ast.Store, ast.Del)) or\n (isinstance(node, ast.UnaryOp) and\n isinstance(node.op, (ast.UAdd, ast.USub)) and\n isinstance(node.operand, ast.Num)) or\n (isinstance(node, (ast.List, ast.Tuple, ast.Dict)) and\n not any(is_interesting_expression(n) for n in ast.iter_child_nodes(node))))" ], [ "LOAD_GLOBAL", "is_interesting_expression" ], [ "LOAD_FAST", "n" ], [ "CALL_FUNCTION", "is_interesting_expression(n)" ], [ "LOAD_GLOBAL", "cast" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "__builtins__" ], [ "CALL_FUNCTION", "cast(dict, __builtins__)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Name" ], [ "CALL_FUNCTION", "isinstance(node, ast.Name)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.id" ], [ "LOAD_FAST", "builtins" ], [ "COMPARE_OP", "node.id in builtins" ], [ "LOAD_FAST", "builtins" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.id" ], [ "BINARY_SUBSCR", "builtins[node.id]" ], [ "LOAD_FAST", "value" ], [ "COMPARE_OP", "builtins[node.id] is value" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "ast" ], [ "CALL_FUNCTION", "getattr(ast, 'NameConstant', ())" ], [ "CALL_FUNCTION", "isinstance(node, getattr(ast, 'NameConstant', ()))" ] ], "configuration.py": [ [ "LOAD_NAME", "ctypes" ], [ "LOAD_ATTR", "ctypes.windll" ], [ "LOAD_ATTR", "ctypes.windll.kernel32" ], [ "LOAD_NAME", "kernel32" ], [ "LOAD_ATTR", "kernel32.SetConsoleMode" ], [ "LOAD_NAME", "kernel32" ], [ "LOAD_ATTR", "kernel32.GetStdHandle" ], [ "CALL_FUNCTION", "kernel32.GetStdHandle(-11)" ], [ "CALL_FUNCTION", "kernel32.SetConsoleMode(kernel32.GetStdHandle(-11), 7)" ], [ "LOAD_NAME", "Exception" ], [ "LOAD_NAME", "os" ], [ "LOAD_ATTR", "os.name" ], [ "COMPARE_OP", "os.name != 'nt'" ], [ "LOAD_NAME", "DefaultFormatter" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "object" ], [ "LOAD_FAST", "builtins" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_GLOBAL", "builtins_module" ], [ "LOAD_FAST", "snoop" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.snoop" ], [ "CALL_FUNCTION", "setattr(builtins_module, snoop, package.snoop)" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_GLOBAL", "builtins_module" ], [ "LOAD_FAST", "pp" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.pp" ], [ "CALL_FUNCTION", "setattr(builtins_module, pp, package.pp)" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_GLOBAL", "builtins_module" ], [ "LOAD_FAST", "spy" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.spy" ], [ "CALL_FUNCTION", "setattr(builtins_module, spy, package.spy)" ], [ "LOAD_GLOBAL", "Config" ], [ "LOAD_FAST", "out" ], [ "LOAD_FAST", "prefix" ], [ "LOAD_FAST", "columns" ], [ "LOAD_FAST", "overwrite" ], [ "LOAD_FAST", "color" ], [ "LOAD_FAST", "enabled" ], [ "LOAD_FAST", "watch_extras" ], [ "LOAD_FAST", "replace_watch_extras" ], [ "LOAD_FAST", "formatter_class" ], [ "CALL_FUNCTION", "Config(\n out=out,\n prefix=prefix,\n columns=columns,\n overwrite=overwrite,\n color=color,\n enabled=enabled,\n watch_extras=watch_extras,\n replace_watch_extras=replace_watch_extras,\n formatter_class=formatter_class,\n )" ], [ "LOAD_FAST", "config" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.snoop" ], [ "LOAD_FAST", "config" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.pp" ], [ "LOAD_FAST", "config" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.spy" ], [ "LOAD_NAME", "DefaultFormatter" ], [ "LOAD_GLOBAL", "can_color" ], [ "LOAD_FAST", "color" ], [ "COMPARE_OP", "color is None" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "out" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.stderr" ], [ "CALL_FUNCTION", "getattr(out or sys.stderr, 'isatty', lambda: False)" ], [ "LOAD_GLOBAL", "bool" ], [ "LOAD_FAST", "isatty" ], [ "CALL_FUNCTION", "isatty()" ], [ "CALL_FUNCTION", "bool(isatty())" ], [ "LOAD_GLOBAL", "get_write_function" ], [ "LOAD_FAST", "out" ], [ "LOAD_FAST", "overwrite" ], [ "CALL_FUNCTION", "get_write_function(out, overwrite)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "formatter_class" ], [ "LOAD_FAST", "prefix" ], [ "LOAD_FAST", "columns" ], [ "LOAD_FAST", "color" ], [ "CALL_FUNCTION", "formatter_class(prefix, columns, color)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "enabled" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "PP" ], [ "LOAD_DEREF", "self" ], [ "CALL_FUNCTION", "PP(self)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "Tracer" ], [ "LOAD_FAST", "ConfiguredTracer" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "Spy" ], [ "LOAD_DEREF", "self" ], [ "CALL_FUNCTION", "Spy(self)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "threading" ], [ "LOAD_ATTR", "threading.local" ], [ "CALL_FUNCTION", "threading.local()" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "replace_watch_extras" ], [ "COMPARE_OP", "replace_watch_extras is not None" ], [ "LOAD_GLOBAL", "ensure_tuple" ], [ "LOAD_FAST", "replace_watch_extras" ], [ "CALL_FUNCTION", "ensure_tuple(replace_watch_extras)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "len_shape_watch" ], [ "LOAD_GLOBAL", "dtype_watch" ], [ "LOAD_GLOBAL", "ensure_tuple" ], [ "LOAD_FAST", "watch_extras" ], [ "CALL_FUNCTION", "ensure_tuple(watch_extras)" ], [ "BINARY_ADD", "(len_shape_watch, dtype_watch) + ensure_tuple(watch_extras)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_CLASSDEREF", "self" ], [ "LOAD_FAST", "value" ], [ "LOAD_ATTR", "value.shape" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.ismethod" ], [ "LOAD_FAST", "shape" ], [ "CALL_FUNCTION", "inspect.ismethod(shape)" ], [ "LOAD_ATTR", "'{}.shape'.format" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "'{}.shape'.format(source)" ], [ "LOAD_FAST", "shape" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "value" ], [ "LOAD_GLOBAL", "QuerySet" ], [ "CALL_FUNCTION", "isinstance(value, QuerySet)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "len(value)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "value" ], [ "LOAD_GLOBAL", "six" ], [ "LOAD_ATTR", "six.string_types" ], [ "CALL_FUNCTION", "isinstance(value, six.string_types)" ], [ "LOAD_FAST", "length" ], [ "COMPARE_OP", "length < 50" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "value" ], [ "LOAD_GLOBAL", "Mapping" ], [ "LOAD_GLOBAL", "Set" ], [ "LOAD_GLOBAL", "Sequence" ], [ "CALL_FUNCTION", "isinstance(value, (Mapping, Set, Sequence))" ], [ "LOAD_FAST", "length" ], [ "COMPARE_OP", "length == 0" ], [ "LOAD_ATTR", "'len({})'.format" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "'len({})'.format(source)" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "value" ], [ "LOAD_ATTR", "value.dtype" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.ismethod" ], [ "LOAD_FAST", "dtype" ], [ "CALL_FUNCTION", "inspect.ismethod(dtype)" ], [ "LOAD_ATTR", "'{}.dtype'.format" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "'{}.dtype'.format(source)" ], [ "LOAD_FAST", "dtype" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_DEREF", "output" ], [ "LOAD_GLOBAL", "six" ], [ "LOAD_ATTR", "six.string_types" ], [ "CALL_FUNCTION", "isinstance(output, six.string_types)" ], [ "LOAD_GLOBAL", "is_pathlike" ], [ "LOAD_DEREF", "output" ], [ "CALL_FUNCTION", "is_pathlike(output)" ], [ "LOAD_FAST", "is_path" ], [ "LOAD_GLOBAL", "FileWriter" ], [ "LOAD_DEREF", "output" ], [ "LOAD_FAST", "overwrite" ], [ "CALL_FUNCTION", "FileWriter(output, overwrite)" ], [ "LOAD_ATTR", "FileWriter(output, overwrite).write" ], [ "LOAD_GLOBAL", "callable" ], [ "LOAD_DEREF", "output" ], [ "CALL_FUNCTION", "callable(output)" ], [ "LOAD_DEREF", "output" ], [ "LOAD_FAST", "write" ], [ "LOAD_DEREF", "output" ], [ "LOAD_FAST", "stream" ], [ "COMPARE_OP", "stream is None" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.stderr" ], [ "LOAD_FAST", "stream" ], [ "LOAD_ATTR", "stream.write" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "stream.write(s)" ], [ "LOAD_GLOBAL", "UnicodeEncodeError" ], [ "LOAD_FAST", "stream" ], [ "LOAD_ATTR", "stream.write" ], [ "LOAD_GLOBAL", "shitcode" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "shitcode(s)" ], [ "CALL_FUNCTION", "stream.write(shitcode(s))" ], [ "LOAD_GLOBAL", "six" ], [ "LOAD_ATTR", "six.text_type" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "six.text_type(path)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "overwrite" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "open" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.path" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.overwrite" ], [ "CALL_FUNCTION", "open(self.path, 'w' if self.overwrite else 'a', encoding='utf-8')" ], [ "LOAD_FAST", "f" ], [ "LOAD_ATTR", "f.write" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "f.write(s)" ], [ "LOAD_FAST", "self" ] ], "db.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOAD_ATTR", "standard_library.install_aliases" ], [ "CALL_FUNCTION", "standard_library.install_aliases()" ], [ "LOAD_NAME", "RESERVED_WORDS" ], [ "LOAD_ATTR", "RESERVED_WORDS.add" ], [ "CALL_FUNCTION", "RESERVED_WORDS.add('function')" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "retry" ], [ "LOAD_NAME", "InterfaceError" ], [ "LOAD_NAME", "OperationalError" ], [ "LOAD_NAME", "InternalError" ], [ "LOAD_NAME", "ProgrammingError" ], [ "CALL_FUNCTION", "retry(3, (InterfaceError, OperationalError, InternalError, ProgrammingError))" ], [ "LOAD_NAME", "contextmanager" ], [ "CALL_FUNCTION", "contextmanager" ], [ "LOAD_FAST", "db_uri" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.environ" ], [ "LOAD_ATTR", "os.environ.get" ], [ "CALL_FUNCTION", "os.environ.get('BIRDSEYE_DB')" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.join" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.expanduser" ], [ "CALL_FUNCTION", "os.path.expanduser('~')" ], [ "CALL_FUNCTION", "os.path.join(os.path.expanduser('~'),\n '.birdseye.db')" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "dict" ], [ "CALL_FUNCTION", "dict(\n pool_recycle=280,\n echo=False, # for convenience when debugging\n )" ], [ "LOAD_GLOBAL", "create_engine" ], [ "LOAD_FAST", "db_uri" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_KW", "create_engine(db_uri, **kwargs)" ], [ "LOAD_GLOBAL", "ArgumentError" ], [ "LOAD_FAST", "db_uri" ], [ "BINARY_ADD", "'sqlite:///' + db_uri" ], [ "LOAD_GLOBAL", "create_engine" ], [ "LOAD_FAST", "db_uri" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_KW", "create_engine(db_uri, **kwargs)" ], [ "LOAD_FAST", "engine" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "sessionmaker" ], [ "LOAD_FAST", "engine" ], [ "CALL_FUNCTION", "sessionmaker(bind=engine)" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "object" ], [ "LOAD_GLOBAL", "declarative_base" ], [ "LOAD_FAST", "Base" ], [ "CALL_FUNCTION", "declarative_base(cls=Base)" ], [ "LOAD_FAST", "Base" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "object" ], [ "LOAD_FAST", "engine" ], [ "LOAD_ATTR", "engine.name" ], [ "COMPARE_OP", "engine.name == 'mysql'" ], [ "LOAD_GLOBAL", "LONGTEXT" ], [ "LOAD_GLOBAL", "Text" ], [ "LOAD_FAST", "Base" ], [ "LOAD_FAST", "Base" ], [ "LOAD_FAST", "Call" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "Function" ], [ "LOAD_FAST", "self" ], [ "LOAD_DEREF", "KeyValue" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "KeyValueStore" ], [ "CALL_FUNCTION", "KeyValueStore()" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "_skip_version_check" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.table_exists" ], [ "LOAD_FAST", "Function" ], [ "CALL_FUNCTION", "self.table_exists(Function)" ], [ "LOAD_FAST", "Base" ], [ "LOAD_ATTR", "Base.metadata" ], [ "LOAD_ATTR", "Base.metadata.create_all" ], [ "LOAD_FAST", "engine" ], [ "CALL_FUNCTION", "Base.metadata.create_all(engine)" ], [ "LOAD_GLOBAL", "DB_VERSION" ], [ "LOAD_FAST", "kv" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.table_exists" ], [ "LOAD_DEREF", "KeyValue" ], [ "CALL_FUNCTION", "self.table_exists(KeyValue)" ], [ "UNARY_NOT", "not self.table_exists(KeyValue)" ], [ "LOAD_GLOBAL", "int" ], [ "LOAD_FAST", "kv" ], [ "LOAD_ATTR", "kv.version" ], [ "CALL_FUNCTION", "int(kv.version)" ], [ "LOAD_GLOBAL", "DB_VERSION" ], [ "COMPARE_OP", "int(kv.version) < DB_VERSION" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.exit" ], [ "CALL_FUNCTION", "sys.exit('The birdseye database schema is out of date. '\n 'Run \"python -m birdseye.clear_db\" to delete the existing tables.')" ], [ "LOAD_NAME", "declared_attr" ], [ "CALL_FUNCTION", "declared_attr" ], [ "LOAD_FAST", "cls" ], [ "LOAD_ATTR", "cls.__name__" ], [ "LOAD_ATTR", "cls.__name__.lower" ], [ "CALL_FUNCTION", "cls.__name__.lower()" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "String" ], [ "CALL_FUNCTION", "String(50)" ], [ "CALL_FUNCTION", "Column(String(50), primary_key=True)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "__getitem__" ], [ "LOAD_NAME", "__setitem__" ], [ "LOAD_DEREF", "db_self" ], [ "LOAD_ATTR", "db_self.session_scope" ], [ "CALL_FUNCTION", "db_self.session_scope()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session\n .query" ], [ "LOAD_DEREF", "KeyValue" ], [ "LOAD_ATTR", "KeyValue.value" ], [ "CALL_FUNCTION", "session\n .query(KeyValue.value)" ], [ "LOAD_ATTR", "session\n .query(KeyValue.value)\n .filter_by" ], [ "LOAD_FAST", "item" ], [ "CALL_FUNCTION", "session\n .query(KeyValue.value)\n .filter_by(key=item)" ], [ "LOAD_ATTR", "session\n .query(KeyValue.value)\n .filter_by(key=item)\n .scalar" ], [ "CALL_FUNCTION", "session\n .query(KeyValue.value)\n .filter_by(key=item)\n .scalar()" ], [ "LOAD_DEREF", "db_self" ], [ "LOAD_ATTR", "db_self.session_scope" ], [ "CALL_FUNCTION", "db_self.session_scope()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_DEREF", "KeyValue" ], [ "CALL_FUNCTION", "session.query(KeyValue)" ], [ "LOAD_ATTR", "session.query(KeyValue).filter_by" ], [ "LOAD_FAST", "key" ], [ "CALL_FUNCTION", "session.query(KeyValue).filter_by(key=key)" ], [ "LOAD_ATTR", "session.query(KeyValue).filter_by(key=key).delete" ], [ "CALL_FUNCTION", "session.query(KeyValue).filter_by(key=key).delete()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.add" ], [ "LOAD_DEREF", "KeyValue" ], [ "LOAD_FAST", "key" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "str(value)" ], [ "CALL_FUNCTION", "KeyValue(key=key, value=str(value))" ], [ "CALL_FUNCTION", "session.add(KeyValue(key=key, value=str(value)))" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "String" ], [ "CALL_FUNCTION", "String(length=32)" ], [ "CALL_FUNCTION", "Column(String(length=32), primary_key=True)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Integer" ], [ "LOAD_NAME", "ForeignKey" ], [ "CALL_FUNCTION", "ForeignKey('function.id')" ], [ "CALL_FUNCTION", "Column(Integer, ForeignKey('function.id'), index=True)" ], [ "LOAD_NAME", "relationship" ], [ "LOAD_NAME", "backref" ], [ "CALL_FUNCTION", "backref('calls', lazy='dynamic')" ], [ "CALL_FUNCTION", "relationship('Function', backref=backref('calls', lazy='dynamic'))" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_CLASSDEREF", "LongText" ], [ "CALL_FUNCTION", "Column(LongText)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "DateTime" ], [ "CALL_FUNCTION", "Column(DateTime, index=True)" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "id" ], [ "LOAD_NAME", "function_id" ], [ "LOAD_NAME", "return_value" ], [ "LOAD_NAME", "traceback" ], [ "LOAD_NAME", "exception" ], [ "LOAD_NAME", "start_time" ], [ "LOAD_NAME", "arguments" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._pretty_time" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start_time" ], [ "CALL_FUNCTION", "self._pretty_time(self.start_time)" ], [ "LOAD_FAST", "dt" ], [ "LOAD_GLOBAL", "Markup" ], [ "LOAD_FAST", "dt" ], [ "LOAD_ATTR", "dt.strftime" ], [ "CALL_FUNCTION", "dt.strftime('%Y-%m-%d %H:%M:%S')" ], [ "LOAD_GLOBAL", "naturaltime" ], [ "LOAD_FAST", "dt" ], [ "CALL_FUNCTION", "naturaltime(dt)" ], [ "BINARY_MODULO", "'%s (%s)' % (\n dt.strftime('%Y-%m-%d %H:%M:%S'),\n naturaltime(dt))" ], [ "CALL_FUNCTION", "Markup('%s (%s)' % (\n dt.strftime('%Y-%m-%d %H:%M:%S'),\n naturaltime(dt)))" ], [ "LOAD_GLOBAL", "Markup" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.success" ], [ "BINARY_MODULO", "'' % (\n ('ok', 'green') if self.success else\n ('remove', 'red'))" ], [ "CALL_FUNCTION", "Markup('' % (\n ('ok', 'green') if self.success else\n ('remove', 'red')))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.exception" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.traceback" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.return_value" ], [ "COMPARE_OP", "self.return_value == 'None'" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.traceback" ], [ "UNARY_NOT", "not self.traceback" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.success" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.return_value" ], [ "CALL_FUNCTION", "str(self.return_value)" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.exception" ], [ "CALL_FUNCTION", "str(self.exception)" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_ATTR", "json.loads" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.arguments" ], [ "CALL_FUNCTION", "json.loads(self.arguments)" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_ATTR", "json.loads" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.data" ], [ "CALL_FUNCTION", "json.loads(self.data)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.arguments_list" ], [ "LOAD_GLOBAL", "select_attrs" ], [ "LOAD_FAST", "call" ], [ "CALL_FUNCTION", "select_attrs(call, 'id function_id return_value traceback '\n 'exception start_time')" ], [ "CALL_FUNCTION_KW", "dict(arguments=call.arguments_list,\n **select_attrs(call, 'id function_id return_value traceback '\n 'exception start_time'))" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Integer" ], [ "LOAD_NAME", "Sequence" ], [ "CALL_FUNCTION", "Sequence('function_id_seq')" ], [ "CALL_FUNCTION", "Column(Integer, Sequence('function_id_seq'), primary_key=True)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_CLASSDEREF", "LongText" ], [ "CALL_FUNCTION", "Column(LongText)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Integer" ], [ "CALL_FUNCTION", "Column(Integer)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_CLASSDEREF", "LongText" ], [ "CALL_FUNCTION", "Column(LongText)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "String" ], [ "CALL_FUNCTION", "String(length=64)" ], [ "CALL_FUNCTION", "Column(String(length=64), index=True)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "String" ], [ "CALL_FUNCTION", "String(length=64)" ], [ "CALL_FUNCTION", "Column(String(length=64), index=True)" ], [ "LOAD_NAME", "UniqueConstraint" ], [ "CALL_FUNCTION", "UniqueConstraint('hash',\n name='everything_unique')" ], [ "LOAD_NAME", "Index" ], [ "CALL_FUNCTION", "Index('idx_file', 'file', mysql_length=256)" ], [ "LOAD_NAME", "Index" ], [ "CALL_FUNCTION", "Index('idx_name', 'name', mysql_length=32)" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "file" ], [ "LOAD_NAME", "name" ], [ "LOAD_NAME", "lineno" ], [ "LOAD_NAME", "hash" ], [ "LOAD_NAME", "body_hash" ], [ "LOAD_NAME", "type" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_ATTR", "json.loads" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.data" ], [ "CALL_FUNCTION", "json.loads(self.data)" ], [ "LOAD_GLOBAL", "select_attrs" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "select_attrs(func, 'file name lineno hash body_hash type')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.engine" ], [ "LOAD_ATTR", "self.engine.dialect" ], [ "LOAD_ATTR", "self.engine.dialect.has_table" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.engine" ], [ "LOAD_FAST", "table" ], [ "LOAD_ATTR", "table.__name__" ], [ "CALL_FUNCTION", "self.engine.dialect.has_table(self.engine, table.__name__)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.session_scope" ], [ "CALL_FUNCTION", "self.session_scope()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.Function" ], [ "LOAD_ATTR", "self.Function.file" ], [ "CALL_FUNCTION", "session.query(self.Function.file)" ], [ "LOAD_ATTR", "session.query(self.Function.file).distinct" ], [ "CALL_FUNCTION", "session.query(self.Function.file).distinct()" ], [ "LOAD_FAST", "paths" ], [ "LOAD_ATTR", "paths.sort" ], [ "CALL_FUNCTION", "paths.sort()" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "paths" ], [ "COMPARE_OP", "IPYTHON_FILE_PATH in paths" ], [ "LOAD_FAST", "paths" ], [ "LOAD_ATTR", "paths.remove" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "CALL_FUNCTION", "paths.remove(IPYTHON_FILE_PATH)" ], [ "LOAD_FAST", "paths" ], [ "LOAD_ATTR", "paths.insert" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "CALL_FUNCTION", "paths.insert(0, IPYTHON_FILE_PATH)" ], [ "LOAD_FAST", "paths" ], [ "LOAD_GLOBAL", "is_ipython_cell" ], [ "LOAD_FAST", "f" ], [ "BINARY_SUBSCR", "f[0]" ], [ "CALL_FUNCTION", "is_ipython_cell(f[0])" ], [ "LOAD_FAST", "f" ], [ "BINARY_SUBSCR", "f[0]" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.Call" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.Function" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._KeyValue" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.table_exists" ], [ "LOAD_FAST", "model" ], [ "CALL_FUNCTION", "self.table_exists(model)" ], [ "LOAD_FAST", "model" ], [ "LOAD_ATTR", "model.__table__" ], [ "LOAD_ATTR", "model.__table__.drop" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.engine" ], [ "CALL_FUNCTION", "model.__table__.drop(self.engine)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.Session" ], [ "CALL_FUNCTION", "self.Session()" ], [ "LOAD_FAST", "session" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.commit" ], [ "CALL_FUNCTION", "session.commit()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.rollback" ], [ "CALL_FUNCTION", "session.rollback()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.close" ], [ "CALL_FUNCTION", "session.close()" ], [ "LOAD_GLOBAL", "functools" ], [ "LOAD_ATTR", "functools.wraps" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "LOAD_GLOBAL", "retry_db" ], [ "LOAD_FAST", "wrapper" ], [ "CALL_FUNCTION", "retry_db(wrapper)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.session_scope" ], [ "CALL_FUNCTION", "self.session_scope()" ], [ "LOAD_DEREF", "func" ], [ "LOAD_FAST", "session" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "func(session, *args, **kwargs)" ] ], "executing.py": [ [ "LOAD_NAME", "sys" ], [ "LOAD_ATTR", "sys.version_info" ], [ "BINARY_SUBSCR", "sys.version_info[0]" ], [ "COMPARE_OP", "sys.version_info[0] == 3" ], [ "LOAD_NAME", "PY3" ], [ "LOAD_NAME", "lru_cache" ], [ "CALL_FUNCTION", "lru_cache(maxsize=None)" ], [ "LOAD_NAME", "str" ], [ "LOAD_NAME", "unicode" ], [ "LOAD_NAME", "dis" ], [ "LOAD_ATTR", "dis.get_instructions" ], [ "LOAD_NAME", "AttributeError" ], [ "LOAD_NAME", "namedtuple" ], [ "CALL_FUNCTION", "namedtuple('Instruction', 'offset argval opname')" ], [ "LOAD_NAME", "Exception" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.NodeVisitor" ], [ "LOAD_NAME", "sum" ], [ "LOAD_NAME", "__future__" ], [ "LOAD_ATTR", "__future__.all_feature_names" ], [ "CALL_FUNCTION", "sum(\n getattr(__future__, fname).compiler_flag\n for fname in __future__.all_feature_names\n)" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "RLock" ], [ "CALL_FUNCTION", "RLock()" ], [ "LOAD_NAME", "cache" ], [ "CALL_FUNCTION", "cache" ], [ "LOAD_GLOBAL", "functools" ], [ "LOAD_ATTR", "functools.wraps" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "LOAD_FAST", "wrapper" ], [ "LOAD_FAST", "args" ], [ "LOAD_DEREF", "d" ], [ "COMPARE_OP", "args in d" ], [ "LOAD_DEREF", "d" ], [ "LOAD_FAST", "args" ], [ "BINARY_SUBSCR", "d[args]" ], [ "LOAD_DEREF", "func" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION_VAR", "func(*args)" ], [ "LOAD_DEREF", "d" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "co" ], [ "LOAD_ATTR", "co.co_code" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "len(code)" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "i < n" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "code[i]" ], [ "LOAD_GLOBAL", "ord" ], [ "LOAD_FAST", "c" ], [ "CALL_FUNCTION", "ord(c)" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "LOAD_FAST", "op" ], [ "LOAD_GLOBAL", "HAVE_ARGUMENT" ], [ "COMPARE_OP", "op >= HAVE_ARGUMENT" ], [ "LOAD_GLOBAL", "ord" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "code[i]" ], [ "CALL_FUNCTION", "ord(code[i])" ], [ "LOAD_GLOBAL", "ord" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "code[i + 1]" ], [ "CALL_FUNCTION", "ord(code[i + 1])" ], [ "BINARY_MULTIPLY", "ord(code[i + 1]) * 256" ], [ "BINARY_ADD", "ord(code[i]) + ord(code[i + 1]) * 256" ], [ "LOAD_FAST", "extended_arg" ], [ "BINARY_ADD", "ord(code[i]) + ord(code[i + 1]) * 256 + extended_arg" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 2" ], [ "LOAD_FAST", "op" ], [ "LOAD_GLOBAL", "EXTENDED_ARG" ], [ "COMPARE_OP", "op == EXTENDED_ARG" ], [ "LOAD_FAST", "oparg" ], [ "BINARY_MULTIPLY", "oparg * 65536" ], [ "LOAD_FAST", "op" ], [ "LOAD_GLOBAL", "hasconst" ], [ "COMPARE_OP", "op in hasconst" ], [ "LOAD_FAST", "co" ], [ "LOAD_ATTR", "co.co_consts" ], [ "LOAD_FAST", "oparg" ], [ "BINARY_SUBSCR", "co.co_consts[oparg]" ], [ "LOAD_GLOBAL", "Instruction" ], [ "LOAD_FAST", "offset" ], [ "LOAD_FAST", "argval" ], [ "LOAD_GLOBAL", "opname" ], [ "LOAD_FAST", "op" ], [ "BINARY_SUBSCR", "opname[op]" ], [ "CALL_FUNCTION", "Instruction(offset, argval, opname[op])" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "it" ], [ "LOAD_GLOBAL", "Sized" ], [ "CALL_FUNCTION", "isinstance(it, Sized)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "len(it)" ], [ "COMPARE_OP", "len(it) != 1" ], [ "LOAD_GLOBAL", "NotOneValueFound" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "len(it)" ], [ "BINARY_MODULO", "'Expected one value, found %s' % len(it)" ], [ "CALL_FUNCTION", "NotOneValueFound('Expected one value, found %s' % len(it))" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "list(it)" ], [ "BINARY_SUBSCR", "list(it)[0]" ], [ "LOAD_GLOBAL", "tuple" ], [ "LOAD_GLOBAL", "islice" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "islice(it, 2)" ], [ "CALL_FUNCTION", "tuple(islice(it, 2))" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "lst" ], [ "CALL_FUNCTION", "len(lst)" ], [ "COMPARE_OP", "len(lst) == 0" ], [ "LOAD_GLOBAL", "NotOneValueFound" ], [ "CALL_FUNCTION", "NotOneValueFound('Expected one value, found 0')" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "lst" ], [ "CALL_FUNCTION", "len(lst)" ], [ "COMPARE_OP", "len(lst) > 1" ], [ "LOAD_GLOBAL", "NotOneValueFound" ], [ "CALL_FUNCTION", "NotOneValueFound('Expected one value, found several')" ], [ "LOAD_FAST", "lst" ], [ "BINARY_SUBSCR", "lst[0]" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "cache" ], [ "CALL_FUNCTION", "cache" ], [ "LOAD_NAME", "cache" ], [ "CALL_FUNCTION", "cache" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "text" ], [ "LOAD_GLOBAL", "text_type" ], [ "CALL_FUNCTION", "isinstance(text, text_type)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.decode_source" ], [ "LOAD_FAST", "text" ], [ "CALL_FUNCTION", "self.decode_source(text)" ], [ "LOAD_FAST", "text" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_FAST", "text" ], [ "LOAD_ATTR", "''.join" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "text" ], [ "LOAD_ATTR", "text.splitlines" ], [ "CALL_FUNCTION", "text.splitlines(True)" ], [ "CALL_FUNCTION", "enumerate(text.splitlines(True))" ], [ "CALL_FUNCTION", "''.join([\n '\\n' if i < 2 and encoding_pattern.match(line)\n else line\n for i, line in enumerate(text.splitlines(True))\n ])" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "defaultdict(list)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "text" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.parse" ], [ "LOAD_FAST", "ast_text" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "ast.parse(ast_text, filename=filename)" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "SyntaxError" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.walk" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tree" ], [ "CALL_FUNCTION", "ast.walk(self.tree)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.iter_child_nodes" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ast.iter_child_nodes(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "hasattr(node, 'lineno')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._nodes_by_line" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.lineno" ], [ "BINARY_SUBSCR", "self._nodes_by_line[node.lineno]" ], [ "LOAD_ATTR", "self._nodes_by_line[node.lineno].append" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "self._nodes_by_line[node.lineno].append(node)" ], [ "LOAD_GLOBAL", "QualnameVisitor" ], [ "CALL_FUNCTION", "QualnameVisitor()" ], [ "LOAD_FAST", "visitor" ], [ "LOAD_ATTR", "visitor.visit" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tree" ], [ "CALL_FUNCTION", "visitor.visit(self.tree)" ], [ "LOAD_FAST", "visitor" ], [ "LOAD_ATTR", "visitor.qualnames" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "i" ], [ "COMPARE_OP", "i < 2" ], [ "LOAD_GLOBAL", "encoding_pattern" ], [ "LOAD_ATTR", "encoding_pattern.match" ], [ "LOAD_FAST", "line" ], [ "CALL_FUNCTION", "encoding_pattern.match(line)" ], [ "LOAD_FAST", "line" ], [ "LOAD_FAST", "cls" ], [ "LOAD_ATTR", "cls.for_filename" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_filename" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "CALL_FUNCTION", "cls.for_filename(frame.f_code.co_filename, frame.f_globals or {})" ], [ "LOAD_FAST", "cls" ], [ "LOAD_ATTR", "cls._class_local" ], [ "CALL_FUNCTION", "cls._class_local('__source_cache', {})" ], [ "LOAD_FAST", "source_cache" ], [ "LOAD_FAST", "filename" ], [ "BINARY_SUBSCR", "source_cache[filename]" ], [ "LOAD_GLOBAL", "KeyError" ], [ "LOAD_GLOBAL", "linecache" ], [ "LOAD_ATTR", "linecache.getlines" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "module_globals" ], [ "CALL_FUNCTION", "linecache.getlines(filename, module_globals)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_FAST", "filename" ], [ "LOAD_ATTR", "''.join" ], [ "LOAD_FAST", "lines" ], [ "CALL_FUNCTION", "''.join(lines)" ], [ "CALL_FUNCTION", "cls(filename, ''.join(lines))" ], [ "LOAD_FAST", "source_cache" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_GLOBAL", "linecache" ], [ "CALL_FUNCTION", "hasattr(linecache, 'lazycache')" ], [ "LOAD_GLOBAL", "linecache" ], [ "LOAD_ATTR", "linecache.lazycache" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_filename" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "CALL_FUNCTION", "linecache.lazycache(frame.f_code.co_filename, frame.f_globals)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lasti" ], [ "LOAD_FAST", "cls" ], [ "LOAD_ATTR", "cls._class_local" ], [ "CALL_FUNCTION", "cls._class_local('__executing_cache', {})" ], [ "LOAD_FAST", "executing_cache" ], [ "LOAD_FAST", "key" ], [ "BINARY_SUBSCR", "executing_cache[key]" ], [ "LOAD_GLOBAL", "KeyError" ], [ "LOAD_FAST", "cls" ], [ "LOAD_ATTR", "cls.for_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "cls.for_frame(frame)" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.tree" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.statements_at_line" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lineno" ], [ "CALL_FUNCTION", "source.statements_at_line(frame.f_lineno)" ], [ "LOAD_GLOBAL", "NodeFinder" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "stmts" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.tree" ], [ "CALL_FUNCTION", "NodeFinder(frame, stmts, source.tree)" ], [ "LOAD_ATTR", "NodeFinder(frame, stmts, source.tree).result" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_GLOBAL", "statement_containing_node" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "statement_containing_node(node)" ], [ "LOAD_FAST", "new_stmts" ], [ "LOAD_FAST", "stmts" ], [ "COMPARE_OP", "new_stmts <= stmts" ], [ "LOAD_FAST", "new_stmts" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "stmts" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "executing_cache" ], [ "LOAD_FAST", "key" ], [ "LOAD_GLOBAL", "Executing" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION_VAR", "Executing(frame, *args)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_ATTR", "cls.__dict__" ], [ "LOAD_ATTR", "cls.__dict__.get" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "default" ], [ "CALL_FUNCTION", "cls.__dict__.get(name, default)" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_FAST", "cls" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "setattr(cls, name, result)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._nodes_by_line" ], [ "LOAD_FAST", "lineno" ], [ "BINARY_SUBSCR", "self._nodes_by_line[lineno]" ], [ "LOAD_GLOBAL", "statement_containing_node" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "statement_containing_node(node)" ], [ "LOAD_FAST", "ASTTokens" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.text" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tree" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.filename" ], [ "CALL_FUNCTION", "ASTTokens(\n self.text,\n tree=self.tree,\n filename=self.filename,\n )" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "source" ], [ "LOAD_GLOBAL", "bytes" ], [ "CALL_FUNCTION", "isinstance(source, bytes)" ], [ "LOAD_GLOBAL", "detect_encoding" ], [ "LOAD_GLOBAL", "io" ], [ "LOAD_ATTR", "io.BytesIO" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "io.BytesIO(source)" ], [ "LOAD_ATTR", "io.BytesIO(source).readline" ], [ "CALL_FUNCTION", "detect_encoding(io.BytesIO(source).readline)" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.decode" ], [ "LOAD_FAST", "encoding" ], [ "CALL_FUNCTION", "source.decode(encoding)" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_filename" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.filename" ], [ "COMPARE_OP", "code.co_filename == self.filename" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._qualnames" ], [ "LOAD_ATTR", "self._qualnames.get" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_firstlineno" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "CALL_FUNCTION", "self._qualnames.get((code.co_name, code.co_firstlineno), code.co_name)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "stmts" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.source" ], [ "LOAD_ATTR", "self.source.code_qualname" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_code" ], [ "CALL_FUNCTION", "self.source.code_qualname(self.frame.f_code)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.source" ], [ "LOAD_ATTR", "self.source.asttokens" ], [ "CALL_FUNCTION", "self.source.asttokens()" ], [ "LOAD_ATTR", "self.source.asttokens().get_text" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.node" ], [ "CALL_FUNCTION", "self.source.asttokens().get_text(self.node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.source" ], [ "LOAD_ATTR", "self.source.asttokens" ], [ "CALL_FUNCTION", "self.source.asttokens()" ], [ "LOAD_ATTR", "self.source.asttokens().get_text_range" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.node" ], [ "CALL_FUNCTION", "self.source.asttokens().get_text_range(self.node)" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "QualnameVisitor" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(QualnameVisitor, self)" ], [ "LOAD_ATTR", "super(QualnameVisitor, self).__init__" ], [ "CALL_FUNCTION", "super(QualnameVisitor, self).__init__()" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.name" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_ATTR", "self.stack.append" ], [ "LOAD_FAST", "name" ], [ "CALL_FUNCTION", "self.stack.append(name)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.qualnames" ], [ "LOAD_ATTR", "self.qualnames.setdefault" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.lineno" ], [ "LOAD_ATTR", "\".\".join" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "CALL_FUNCTION", "\".\".join(self.stack)" ], [ "CALL_FUNCTION", "self.qualnames.setdefault((name, node.lineno), \".\".join(self.stack))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_ATTR", "self.stack.append" ], [ "CALL_FUNCTION", "self.stack.append('')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Lambda" ], [ "CALL_FUNCTION", "isinstance(node, ast.Lambda)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.body" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.body" ], [ "LOAD_FAST", "children" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.visit" ], [ "LOAD_FAST", "child" ], [ "CALL_FUNCTION", "self.visit(child)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_ATTR", "self.stack.pop" ], [ "CALL_FUNCTION", "self.stack.pop()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_ATTR", "self.stack.pop" ], [ "CALL_FUNCTION", "self.stack.pop()" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.iter_fields" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ast.iter_fields(node)" ], [ "LOAD_FAST", "field" ], [ "COMPARE_OP", "field == 'body'" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.AST" ], [ "CALL_FUNCTION", "isinstance(child, ast.AST)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.visit" ], [ "LOAD_FAST", "child" ], [ "CALL_FUNCTION", "self.visit(child)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "isinstance(child, list)" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "grandchild" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.AST" ], [ "CALL_FUNCTION", "isinstance(grandchild, ast.AST)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.visit" ], [ "LOAD_FAST", "grandchild" ], [ "CALL_FUNCTION", "self.visit(grandchild)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.visit_FunctionDef" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "self.visit_FunctionDef(node, '')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_ATTR", "self.stack.append" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.name" ], [ "CALL_FUNCTION", "self.stack.append(node.name)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.generic_visit" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "self.generic_visit(node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_ATTR", "self.stack.pop" ], [ "CALL_FUNCTION", "self.stack.pop()" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "__future__" ], [ "LOAD_FAST", "fname" ], [ "CALL_FUNCTION", "getattr(__future__, fname)" ], [ "LOAD_ATTR", "getattr(__future__, fname).compiler_flag" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "matching_code" ], [ "LOAD_ATTR", "matching_code.co_filename" ], [ "LOAD_GLOBAL", "future_flags" ], [ "LOAD_FAST", "matching_code" ], [ "LOAD_ATTR", "matching_code.co_flags" ], [ "BINARY_AND", "future_flags & matching_code.co_flags" ], [ "CALL_FUNCTION", "compile(\n source,\n matching_code.co_filename,\n 'exec',\n flags=future_flags & matching_code.co_flags,\n dont_inherit=True,\n )" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "tree" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_code" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lasti" ], [ "BINARY_SUBSCR", "frame.f_code.co_code[frame.f_lasti]" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_GLOBAL", "ord" ], [ "LOAD_FAST", "b" ], [ "CALL_FUNCTION", "ord(b)" ], [ "LOAD_GLOBAL", "dis" ], [ "LOAD_ATTR", "dis.opname" ], [ "LOAD_FAST", "b" ], [ "BINARY_SUBSCR", "dis.opname[b]" ], [ "LOAD_FAST", "op_name" ], [ "LOAD_ATTR", "op_name.startswith" ], [ "CALL_FUNCTION", "op_name.startswith('CALL_')" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Call" ], [ "LOAD_FAST", "op_name" ], [ "COMPARE_OP", "op_name == 'BINARY_SUBSCR'" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Subscript" ], [ "LOAD_FAST", "op_name" ], [ "LOAD_ATTR", "op_name.startswith" ], [ "CALL_FUNCTION", "op_name.startswith('BINARY_')" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.BinOp" ], [ "LOAD_FAST", "op_name" ], [ "LOAD_ATTR", "op_name.startswith" ], [ "CALL_FUNCTION", "op_name.startswith('UNARY_')" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.UnaryOp" ], [ "LOAD_FAST", "op_name" ], [ "COMPARE_OP", "op_name in ('LOAD_ATTR', 'LOAD_METHOD', 'LOOKUP_METHOD')" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Attribute" ], [ "LOAD_FAST", "op_name" ], [ "COMPARE_OP", "op_name == 'COMPARE_OP'" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Compare" ], [ "LOAD_GLOBAL", "RuntimeError" ], [ "LOAD_FAST", "op_name" ], [ "CALL_FUNCTION", "RuntimeError(op_name)" ], [ "LOAD_GLOBAL", "lock" ], [ "LOAD_FAST", "stmts" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.matching_nodes" ], [ "LOAD_FAST", "exprs" ], [ "CALL_FUNCTION", "self.matching_nodes(exprs)" ], [ "CALL_FUNCTION", "list(self.matching_nodes(exprs))" ], [ "CALL_FUNCTION", "only(list(self.matching_nodes(exprs)))" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.walk" ], [ "LOAD_FAST", "stmt" ], [ "CALL_FUNCTION", "ast.walk(stmt)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "typ" ], [ "CALL_FUNCTION", "isinstance(node, typ)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "hasattr(node, \"ctx\")" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.ctx" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Load" ], [ "CALL_FUNCTION", "isinstance(node.ctx, ast.Load)" ], [ "UNARY_NOT", "not isinstance(node.ctx, ast.Load)" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "exprs" ], [ "CALL_FUNCTION", "enumerate(exprs)" ], [ "LOAD_GLOBAL", "get_setter" ], [ "LOAD_FAST", "expr" ], [ "CALL_FUNCTION", "get_setter(expr)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.BinOp" ], [ "LOAD_FAST", "expr" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Pow" ], [ "CALL_FUNCTION", "ast.Pow()" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Str" ], [ "LOAD_GLOBAL", "sentinel" ], [ "CALL_FUNCTION", "ast.Str(s=sentinel)" ], [ "CALL_FUNCTION", "ast.BinOp(\n left=expr,\n op=ast.Pow(),\n right=ast.Str(s=sentinel),\n )" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.fix_missing_locations" ], [ "LOAD_FAST", "replacement" ], [ "CALL_FUNCTION", "ast.fix_missing_locations(replacement)" ], [ "LOAD_FAST", "setter" ], [ "LOAD_FAST", "replacement" ], [ "CALL_FUNCTION", "setter(replacement)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.compile_instructions" ], [ "CALL_FUNCTION", "self.compile_instructions()" ], [ "LOAD_GLOBAL", "SyntaxError" ], [ "LOAD_FAST", "setter" ], [ "LOAD_FAST", "expr" ], [ "CALL_FUNCTION", "setter(expr)" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "instructions" ], [ "CALL_FUNCTION", "enumerate(instructions)" ], [ "LOAD_FAST", "indices" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_FAST", "indices" ], [ "CALL_FUNCTION", "only(indices)" ], [ "BINARY_SUBTRACT", "only(indices) - 1" ], [ "LOAD_FAST", "instructions" ], [ "LOAD_FAST", "arg_index" ], [ "BINARY_SUBSCR", "instructions[arg_index]" ], [ "LOAD_ATTR", "instructions[arg_index].opname" ], [ "COMPARE_OP", "instructions[arg_index].opname == 'EXTENDED_ARG'" ], [ "LOAD_FAST", "instructions" ], [ "LOAD_FAST", "arg_index" ], [ "BINARY_SUBSCR", "instructions[arg_index]" ], [ "LOAD_ATTR", "instructions[arg_index].offset" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_lasti" ], [ "COMPARE_OP", "instructions[arg_index].offset == self.frame.f_lasti" ], [ "LOAD_FAST", "expr" ], [ "LOAD_FAST", "instruction" ], [ "LOAD_ATTR", "instruction.argval" ], [ "LOAD_GLOBAL", "sentinel" ], [ "COMPARE_OP", "instruction.argval == sentinel" ], [ "LOAD_FAST", "i" ], [ "LOAD_GLOBAL", "compile_similar_to" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tree" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_code" ], [ "CALL_FUNCTION", "compile_similar_to(self.tree, self.frame.f_code)" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_GLOBAL", "find_codes" ], [ "LOAD_FAST", "module_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_code" ], [ "CALL_FUNCTION", "find_codes(module_code, self.frame.f_code)" ], [ "CALL_FUNCTION", "only(find_codes(module_code, self.frame.f_code))" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "get_instructions" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "get_instructions(code)" ], [ "CALL_FUNCTION", "list(get_instructions(code))" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.iter_fields" ], [ "LOAD_DEREF", "parent" ], [ "CALL_FUNCTION", "ast.iter_fields(parent)" ], [ "LOAD_DEREF", "field" ], [ "LOAD_FAST", "node" ], [ "COMPARE_OP", "field is node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_DEREF", "field" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "isinstance(field, list)" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_DEREF", "field" ], [ "CALL_FUNCTION", "enumerate(field)" ], [ "LOAD_FAST", "item" ], [ "LOAD_FAST", "node" ], [ "COMPARE_OP", "item is node" ], [ "LOAD_FAST", "setter" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_DEREF", "parent" ], [ "LOAD_DEREF", "name" ], [ "LOAD_FAST", "new_node" ], [ "CALL_FUNCTION", "setattr(parent, name, new_node)" ], [ "LOAD_FAST", "new_node" ], [ "LOAD_DEREF", "field" ], [ "LOAD_DEREF", "i" ], [ "LOAD_DEREF", "matches" ], [ "LOAD_FAST", "root_code" ], [ "CALL_FUNCTION", "matches(root_code)" ], [ "LOAD_DEREF", "code_options" ], [ "LOAD_ATTR", "code_options.append" ], [ "LOAD_FAST", "root_code" ], [ "CALL_FUNCTION", "code_options.append(root_code)" ], [ "LOAD_DEREF", "finder" ], [ "LOAD_FAST", "root_code" ], [ "CALL_FUNCTION", "finder(root_code)" ], [ "LOAD_DEREF", "code_options" ], [ "LOAD_GLOBAL", "all" ], [ "LOAD_GLOBAL", "attrgetter" ], [ "CALL_FUNCTION", "attrgetter('co_firstlineno')" ], [ "LOAD_GLOBAL", "attrgetter" ], [ "CALL_FUNCTION", "attrgetter('co_name')" ], [ "LOAD_GLOBAL", "code_names" ], [ "CALL_FUNCTION", "all(\n f(c) == f(matching)\n for f in [\n attrgetter('co_firstlineno'),\n attrgetter('co_name'),\n code_names,\n ]\n )" ], [ "LOAD_FAST", "f" ], [ "LOAD_DEREF", "c" ], [ "CALL_FUNCTION", "f(c)" ], [ "LOAD_FAST", "f" ], [ "LOAD_DEREF", "matching" ], [ "CALL_FUNCTION", "f(matching)" ], [ "COMPARE_OP", "f(c) == f(matching)" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_consts" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.iscode" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "inspect.iscode(const)" ], [ "LOAD_DEREF", "matches" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "matches(const)" ], [ "LOAD_DEREF", "code_options" ], [ "LOAD_ATTR", "code_options.append" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "code_options.append(const)" ], [ "LOAD_DEREF", "finder" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "finder(const)" ], [ "LOAD_GLOBAL", "frozenset" ], [ "CALL_FUNCTION", "frozenset()" ], [ "LOAD_ATTR", "frozenset().union" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_names" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_varnames" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_freevars" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_cellvars" ], [ "CALL_FUNCTION", "frozenset().union(\n code.co_names,\n code.co_varnames,\n code.co_freevars,\n code.co_cellvars,\n )" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "CALL_FUNCTION", "isinstance(node, ast.stmt)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_FAST", "node" ] ], "import_hook.py": [ [ "LOAD_NAME", "object" ], [ "LOAD_FAST", "spec" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "deep" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "eye" ], [ "LOAD_ATTR", "eye.exec_string" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.source" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._spec" ], [ "LOAD_ATTR", "self._spec.origin" ], [ "LOAD_FAST", "module" ], [ "LOAD_ATTR", "module.__dict__" ], [ "LOAD_FAST", "module" ], [ "LOAD_ATTR", "module.__dict__" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.deep" ], [ "CALL_FUNCTION", "eye.exec_string(\n source=self.source,\n filename=self._spec.origin,\n globs=module.__dict__,\n locs=module.__dict__,\n deep=self.deep,\n )" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._spec" ], [ "LOAD_ATTR", "self._spec.loader" ], [ "LOAD_ATTR", "self._spec.loader.get_filename" ], [ "LOAD_FAST", "fullname" ], [ "CALL_FUNCTION", "self._spec.loader.get_filename(fullname)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._spec" ], [ "LOAD_ATTR", "self._spec.loader" ], [ "LOAD_ATTR", "self._spec.loader.is_package" ], [ "LOAD_FAST", "fullname" ], [ "CALL_FUNCTION", "self._spec.loader.is_package(fullname)" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.meta_path" ], [ "LOAD_FAST", "finder" ], [ "LOAD_FAST", "self" ], [ "COMPARE_OP", "finder is self" ], [ "LOAD_FAST", "finder" ], [ "LOAD_ATTR", "finder.__module__" ], [ "COMPARE_OP", "'pytest' in finder.__module__" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "finder" ], [ "CALL_FUNCTION", "hasattr(finder, 'find_spec')" ], [ "LOAD_FAST", "finder" ], [ "LOAD_ATTR", "finder.find_spec" ], [ "LOAD_FAST", "fullname" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "target" ], [ "CALL_FUNCTION", "finder.find_spec(fullname, path, target=target)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "finder" ], [ "CALL_FUNCTION", "hasattr(finder, 'load_module')" ], [ "LOAD_GLOBAL", "spec_from_loader" ], [ "LOAD_FAST", "fullname" ], [ "LOAD_FAST", "finder" ], [ "CALL_FUNCTION", "spec_from_loader(fullname, finder)" ], [ "LOAD_FAST", "spec" ], [ "COMPARE_OP", "spec is not None" ], [ "LOAD_FAST", "spec" ], [ "LOAD_ATTR", "spec.origin" ], [ "COMPARE_OP", "spec.origin != 'builtin'" ], [ "LOAD_FAST", "spec" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._find_plain_spec" ], [ "LOAD_FAST", "fullname" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "target" ], [ "CALL_FUNCTION", "self._find_plain_spec(fullname, path, target)" ], [ "LOAD_FAST", "spec" ], [ "COMPARE_OP", "spec is None" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "spec" ], [ "LOAD_ATTR", "spec.loader" ], [ "CALL_FUNCTION", "hasattr(spec.loader, 'get_source')" ], [ "LOAD_GLOBAL", "callable" ], [ "LOAD_FAST", "spec" ], [ "LOAD_ATTR", "spec.loader" ], [ "LOAD_ATTR", "spec.loader.get_source" ], [ "CALL_FUNCTION", "callable(spec.loader.get_source)" ], [ "UNARY_NOT", "not (hasattr(spec.loader, 'get_source') and\n callable(spec.loader.get_source))" ], [ "LOAD_FAST", "fullname" ], [ "COMPARE_OP", "fullname != 'org'" ], [ "LOAD_GLOBAL", "logging" ], [ "LOAD_ATTR", "logging.debug" ], [ "LOAD_FAST", "fullname" ], [ "CALL_FUNCTION", "logging.debug('Failed finding spec for %s', fullname)" ], [ "LOAD_FAST", "spec" ], [ "LOAD_ATTR", "spec.loader" ], [ "LOAD_ATTR", "spec.loader.get_source" ], [ "LOAD_FAST", "fullname" ], [ "CALL_FUNCTION", "spec.loader.get_source(fullname)" ], [ "LOAD_GLOBAL", "ImportError" ], [ "LOAD_GLOBAL", "logging" ], [ "LOAD_ATTR", "logging.debug" ], [ "LOAD_FAST", "fullname" ], [ "CALL_FUNCTION", "logging.debug('Loader for %s was unable to find the sources',\n fullname)" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_GLOBAL", "logging" ], [ "LOAD_ATTR", "logging.exception" ], [ "LOAD_FAST", "fullname" ], [ "CALL_FUNCTION", "logging.exception('Loader for %s raised an error', fullname)" ], [ "LOAD_FAST", "source" ], [ "UNARY_NOT", "not source" ], [ "LOAD_FAST", "source" ], [ "COMPARE_OP", "'birdseye' not in source" ], [ "LOAD_GLOBAL", "should_trace" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "should_trace(source)" ], [ "LOAD_FAST", "trace_stmt" ], [ "LOAD_GLOBAL", "BirdsEyeLoader" ], [ "LOAD_FAST", "spec" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "deep" ], [ "CALL_FUNCTION", "BirdsEyeLoader(spec, source, deep)" ], [ "LOAD_GLOBAL", "spec_from_loader" ], [ "LOAD_FAST", "fullname" ], [ "LOAD_FAST", "loader" ], [ "CALL_FUNCTION", "spec_from_loader(fullname, loader)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.parse" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "ast.parse(source)" ], [ "LOAD_ATTR", "ast.parse(source).body" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Import" ], [ "CALL_FUNCTION", "isinstance(stmt, ast.Import)" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_ATTR", "stmt.names" ], [ "LOAD_FAST", "alias" ], [ "LOAD_ATTR", "alias.name" ], [ "LOAD_ATTR", "alias.name.startswith" ], [ "CALL_FUNCTION", "alias.name.startswith('birdseye.trace_module')" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_FAST", "alias" ], [ "LOAD_ATTR", "alias.name" ], [ "LOAD_ATTR", "alias.name.endswith" ], [ "CALL_FUNCTION", "alias.name.endswith('deep')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.ImportFrom" ], [ "CALL_FUNCTION", "isinstance(stmt, ast.ImportFrom)" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_ATTR", "stmt.module" ], [ "COMPARE_OP", "stmt.module == 'birdseye'" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_ATTR", "stmt.names" ], [ "LOAD_FAST", "alias" ], [ "LOAD_ATTR", "alias.name" ], [ "LOAD_ATTR", "alias.name.startswith" ], [ "CALL_FUNCTION", "alias.name.startswith('trace_module')" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_FAST", "alias" ], [ "LOAD_ATTR", "alias.name" ], [ "LOAD_ATTR", "alias.name.endswith" ], [ "CALL_FUNCTION", "alias.name.endswith('deep')" ], [ "LOAD_FAST", "deep" ], [ "LOAD_FAST", "trace_stmt" ] ], "ipython.py": [ [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "BytesIO" ], [ "LOAD_NAME", "StringIO" ], [ "LOAD_NAME", "stream_proxy" ], [ "LOAD_NAME", "sys" ], [ "LOAD_ATTR", "sys.stderr" ], [ "CALL_FUNCTION", "stream_proxy(sys.stderr)" ], [ "LOAD_NAME", "sys" ], [ "LOAD_NAME", "stream_proxy" ], [ "LOAD_NAME", "sys" ], [ "LOAD_ATTR", "sys.stdout" ], [ "CALL_FUNCTION", "stream_proxy(sys.stdout)" ], [ "LOAD_NAME", "sys" ], [ "LOAD_NAME", "Environment" ], [ "LOAD_NAME", "PackageLoader" ], [ "CALL_FUNCTION", "PackageLoader('birdseye', 'templates')" ], [ "LOAD_NAME", "select_autoescape" ], [ "CALL_FUNCTION", "select_autoescape(['html', 'xml'])" ], [ "CALL_FUNCTION", "Environment(\n loader=PackageLoader('birdseye', 'templates'),\n autoescape=select_autoescape(['html', 'xml'])\n)" ], [ "LOAD_NAME", "magics_class" ], [ "LOAD_NAME", "Magics" ], [ "CALL_FUNCTION", "magics_class" ], [ "LOAD_GLOBAL", "LocalProxy" ], [ "LOAD_FAST", "p" ], [ "CALL_FUNCTION", "LocalProxy(p)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.currentframe" ], [ "CALL_FUNCTION", "inspect.currentframe()" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_GLOBAL", "ThreadingMixIn" ], [ "LOAD_ATTR", "ThreadingMixIn.process_request_thread" ], [ "LOAD_ATTR", "ThreadingMixIn.process_request_thread.__code__" ], [ "COMPARE_OP", "frame.f_code == ThreadingMixIn.process_request_thread.__code__" ], [ "LOAD_GLOBAL", "fake_stream" ], [ "CALL_FUNCTION", "fake_stream()" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_GLOBAL", "thread_proxies" ], [ "LOAD_ATTR", "thread_proxies.get" ], [ "LOAD_GLOBAL", "currentThread" ], [ "CALL_FUNCTION", "currentThread()" ], [ "LOAD_ATTR", "currentThread().ident" ], [ "LOAD_DEREF", "original" ], [ "CALL_FUNCTION", "thread_proxies.get(currentThread().ident,\n original)" ], [ "LOAD_FAST", "show_server_output" ], [ "LOAD_GLOBAL", "fake_stream" ], [ "CALL_FUNCTION", "fake_stream()" ], [ "LOAD_GLOBAL", "thread_proxies" ], [ "LOAD_GLOBAL", "currentThread" ], [ "CALL_FUNCTION", "currentThread()" ], [ "LOAD_ATTR", "currentThread().ident" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_ATTR", "server.app" ], [ "LOAD_ATTR", "server.app.run" ], [ "LOAD_FAST", "port" ], [ "LOAD_FAST", "bind_host" ], [ "CALL_FUNCTION", "server.app.run(\n debug=True,\n port=port,\n host=bind_host,\n use_reloader=False,\n )" ], [ "LOAD_GLOBAL", "socket" ], [ "LOAD_ATTR", "socket.error" ], [ "LOAD_NAME", "Unicode" ], [ "CALL_FUNCTION", "Unicode(\n u'', config=True,\n help='If set, a server will not be automatically started by %%eye. '\n 'The iframe containing birdseye output will use this value as the base '\n 'of its URL.'\n )" ], [ "LOAD_NAME", "Int" ], [ "CALL_FUNCTION", "Int(\n 7777, config=True,\n help='Port number for the server started by %%eye.'\n )" ], [ "LOAD_NAME", "Unicode" ], [ "CALL_FUNCTION", "Unicode(\n '127.0.0.1', config=True,\n help='Host that the server started by %%eye listens on. '\n 'Set to 0.0.0.0 to make it accessible anywhere.'\n )" ], [ "LOAD_NAME", "Bool" ], [ "CALL_FUNCTION", "Bool(\n False, config=True,\n help='Set to True to show stdout and stderr from the server started by %%eye.'\n )" ], [ "LOAD_NAME", "Unicode" ], [ "CALL_FUNCTION", "Unicode(\n u'', config=True,\n help='The database URL that the server started by %%eye reads from. '\n 'Equivalent to the environment variable BIRDSEYE_DB.'\n )" ], [ "LOAD_NAME", "cell_magic" ], [ "CALL_FUNCTION", "cell_magic" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.server_url" ], [ "LOAD_GLOBAL", "Database" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.db_url" ], [ "CALL_FUNCTION", "Database(self.db_url)" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_ATTR", "server.db" ], [ "LOAD_ATTR", "server.db.Function" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_ATTR", "server.db" ], [ "LOAD_ATTR", "server.db.Call" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_ATTR", "server.db" ], [ "LOAD_ATTR", "server.db.Session" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_GLOBAL", "Thread" ], [ "LOAD_GLOBAL", "run_server" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.port" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.bind_host" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.show_server_output" ], [ "CALL_FUNCTION", "Thread(\n target=run_server,\n args=(\n self.port,\n self.bind_host,\n self.show_server_output,\n ),\n )" ], [ "LOAD_ATTR", "Thread(\n target=run_server,\n args=(\n self.port,\n self.bind_host,\n self.show_server_output,\n ),\n ).start" ], [ "CALL_FUNCTION", "Thread(\n target=run_server,\n args=(\n self.port,\n self.bind_host,\n self.show_server_output,\n ),\n ).start()" ], [ "LOAD_GLOBAL", "Database" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.db_url" ], [ "CALL_FUNCTION", "Database(self.db_url)" ], [ "LOAD_GLOBAL", "eye" ], [ "LOAD_GLOBAL", "eye" ], [ "LOAD_ATTR", "eye.exec_ipython_cell" ], [ "LOAD_FAST", "cell" ], [ "LOAD_FAST", "callback" ], [ "CALL_FUNCTION", "eye.exec_ipython_cell(cell, callback)" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "call_id" ], [ "COMPARE_OP", "call_id is None" ], [ "LOAD_GLOBAL", "HTML" ], [ "LOAD_GLOBAL", "templates_env" ], [ "LOAD_ATTR", "templates_env.get_template" ], [ "CALL_FUNCTION", "templates_env.get_template('ipython_iframe.html')" ], [ "LOAD_ATTR", "templates_env.get_template('ipython_iframe.html').render" ], [ "LOAD_FAST", "call_id" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.server_url" ], [ "LOAD_ATTR", "self.server_url.rstrip" ], [ "CALL_FUNCTION", "self.server_url.rstrip('/')" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.port" ], [ "LOAD_GLOBAL", "uuid4" ], [ "CALL_FUNCTION", "uuid4()" ], [ "LOAD_ATTR", "uuid4().hex" ], [ "CALL_FUNCTION", "templates_env.get_template('ipython_iframe.html').render(\n call_id=call_id,\n url=self.server_url.rstrip('/'),\n port=self.port,\n container_id=uuid4().hex,\n )" ], [ "CALL_FUNCTION", "HTML(templates_env.get_template('ipython_iframe.html').render(\n call_id=call_id,\n url=self.server_url.rstrip('/'),\n port=self.port,\n container_id=uuid4().hex,\n ))" ], [ "LOAD_GLOBAL", "display" ], [ "LOAD_FAST", "html" ], [ "CALL_FUNCTION", "display(html)" ] ], "server.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOAD_ATTR", "standard_library.install_aliases" ], [ "CALL_FUNCTION", "standard_library.install_aliases()" ], [ "LOAD_NAME", "Flask" ], [ "CALL_FUNCTION", "Flask('birdseye')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.jinja_env" ], [ "LOAD_NAME", "Humanize" ], [ "LOAD_NAME", "app" ], [ "CALL_FUNCTION", "Humanize(app)" ], [ "LOAD_NAME", "PathConverter" ], [ "LOAD_NAME", "FileConverter" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.url_map" ], [ "LOAD_ATTR", "app.url_map.converters" ], [ "LOAD_NAME", "Database" ], [ "CALL_FUNCTION", "Database()" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.Session" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.Function" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.Call" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION", "app.route('/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION", "app.route('/file/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/file/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION", "app.route('/file//__function__/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/file//__function__/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION", "app.route('/api/file//__function__//latest_call/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/api/file//__function__//latest_call/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION", "app.route('/call/')" ], [ "CALL_FUNCTION", "app.route('/call/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION", "app.route('/ipython_call/')" ], [ "CALL_FUNCTION", "app.route('/ipython_call/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION", "app.route('/ipython_iframe/')" ], [ "CALL_FUNCTION", "app.route('/ipython_iframe/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION", "app.route('/kill', methods=['POST'])" ], [ "CALL_FUNCTION", "app.route('/kill', methods=['POST'])" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION", "app.route('/api/call/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/api/call/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION", "app.route('/api/calls_by_body_hash/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/api/calls_by_body_hash/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION", "app.route('/api/body_hashes_present/', methods=['POST'])" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/api/body_hashes_present/', methods=['POST'])" ], [ "LOAD_NAME", "sys" ], [ "LOAD_ATTR", "sys.argv" ], [ "BINARY_SUBSCR", "sys.argv[1:]" ], [ "LOAD_NAME", "__name__" ], [ "COMPARE_OP", "__name__ == '__main__'" ], [ "LOAD_NAME", "main" ], [ "CALL_FUNCTION", "main()" ], [ "LOAD_GLOBAL", "db" ], [ "LOAD_ATTR", "db.all_file_paths" ], [ "CALL_FUNCTION", "db.all_file_paths()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_columns" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.basic_columns" ], [ "BINARY_ADD", "Call.basic_columns + Function.basic_columns" ], [ "CALL_FUNCTION_VAR", "session.query(*(Call.basic_columns + Function.basic_columns))" ], [ "LOAD_ATTR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_FUNCTION", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)" ], [ "LOAD_ATTR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .order_by" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.start_time" ], [ "LOAD_ATTR", "Call.start_time.desc" ], [ "CALL_FUNCTION", "Call.start_time.desc()" ], [ "CALL_FUNCTION", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .order_by(Call.start_time.desc())" ], [ "BINARY_SUBSCR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .order_by(Call.start_time.desc())[:100]" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "CALL_FUNCTION", "OrderedDict()" ], [ "LOAD_FAST", "recent_calls" ], [ "LOAD_GLOBAL", "is_ipython_cell" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.file" ], [ "CALL_FUNCTION", "is_ipython_cell(row.file)" ], [ "LOAD_FAST", "files" ], [ "LOAD_ATTR", "files.setdefault" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.file" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "CALL_FUNCTION", "OrderedDict()" ], [ "CALL_FUNCTION", "files.setdefault(\n row.file, OrderedDict()\n )" ], [ "LOAD_ATTR", "files.setdefault(\n row.file, OrderedDict()\n ).setdefault" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.name" ], [ "LOAD_FAST", "row" ], [ "CALL_FUNCTION", "files.setdefault(\n row.file, OrderedDict()\n ).setdefault(\n row.name, row\n )" ], [ "LOAD_FAST", "all_paths" ], [ "LOAD_FAST", "files" ], [ "LOAD_ATTR", "files.setdefault" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "CALL_FUNCTION", "OrderedDict()" ], [ "CALL_FUNCTION", "files.setdefault(\n path, OrderedDict()\n )" ], [ "LOAD_GLOBAL", "partial" ], [ "LOAD_GLOBAL", "short_path" ], [ "LOAD_FAST", "all_paths" ], [ "CALL_FUNCTION", "partial(short_path, all_paths=all_paths)" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "short" ], [ "LOAD_FAST", "files" ], [ "CALL_FUNCTION", "render_template('index.html',\n short=short,\n files=files)" ], [ "LOAD_GLOBAL", "fix_abs_path" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "fix_abs_path(path)" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_columns" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.basic_columns" ], [ "BINARY_ADD", "Call.basic_columns + Function.basic_columns" ], [ "CALL_FUNCTION_VAR", "session.query(*(Call.basic_columns + Function.basic_columns))" ], [ "LOAD_ATTR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_FUNCTION", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)" ], [ "LOAD_ATTR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path)" ], [ "LOAD_ATTR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path)\n .subquery" ], [ "CALL_FUNCTION", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path)\n .subquery('filtered_calls')" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.name" ], [ "LOAD_GLOBAL", "sqlalchemy" ], [ "LOAD_ATTR", "sqlalchemy.func" ], [ "LOAD_ATTR", "sqlalchemy.func.max" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.start_time" ], [ "CALL_FUNCTION", "sqlalchemy.func.max(filtered_calls.c.start_time)" ], [ "LOAD_ATTR", "sqlalchemy.func.max(filtered_calls.c.start_time).label" ], [ "CALL_FUNCTION", "sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')" ], [ "CALL_FUNCTION", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n )" ], [ "LOAD_ATTR", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n ).group_by" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.name" ], [ "CALL_FUNCTION", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n ).group_by(\n filtered_calls.c.name,\n )" ], [ "LOAD_ATTR", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n ).group_by(\n filtered_calls.c.name,\n ).subquery" ], [ "CALL_FUNCTION", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n ).group_by(\n filtered_calls.c.name,\n ).subquery('latest_calls')" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_FAST", "filtered_calls" ], [ "CALL_FUNCTION", "session.query(filtered_calls)" ], [ "LOAD_ATTR", "session.query(filtered_calls).join" ], [ "LOAD_FAST", "latest_calls" ], [ "LOAD_GLOBAL", "sqlalchemy" ], [ "LOAD_ATTR", "sqlalchemy.and_" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.name" ], [ "LOAD_FAST", "latest_calls" ], [ "LOAD_ATTR", "latest_calls.c" ], [ "LOAD_ATTR", "latest_calls.c.name" ], [ "COMPARE_OP", "filtered_calls.c.name == latest_calls.c.name" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.start_time" ], [ "LOAD_FAST", "latest_calls" ], [ "LOAD_ATTR", "latest_calls.c" ], [ "LOAD_ATTR", "latest_calls.c.maxtime" ], [ "COMPARE_OP", "filtered_calls.c.start_time == latest_calls.c.maxtime" ], [ "CALL_FUNCTION", "sqlalchemy.and_(\n filtered_calls.c.name == latest_calls.c.name,\n filtered_calls.c.start_time == latest_calls.c.maxtime,\n )" ], [ "CALL_FUNCTION", "session.query(filtered_calls).join(\n latest_calls,\n sqlalchemy.and_(\n filtered_calls.c.name == latest_calls.c.name,\n filtered_calls.c.start_time == latest_calls.c.maxtime,\n )\n )" ], [ "LOAD_ATTR", "session.query(filtered_calls).join(\n latest_calls,\n sqlalchemy.and_(\n filtered_calls.c.name == latest_calls.c.name,\n filtered_calls.c.start_time == latest_calls.c.maxtime,\n )\n ).order_by" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.start_time" ], [ "LOAD_ATTR", "filtered_calls.c.start_time.desc" ], [ "CALL_FUNCTION", "filtered_calls.c.start_time.desc()" ], [ "CALL_FUNCTION", "session.query(filtered_calls).join(\n latest_calls,\n sqlalchemy.and_(\n filtered_calls.c.name == latest_calls.c.name,\n filtered_calls.c.start_time == latest_calls.c.maxtime,\n )\n ).order_by(filtered_calls.c.start_time.desc())" ], [ "LOAD_GLOBAL", "group_by_attr" ], [ "LOAD_FAST", "query" ], [ "CALL_FUNCTION", "group_by_attr(query, 'type')" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.name" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.type" ], [ "CALL_FUNCTION", "session.query(Function.name, Function.type)" ], [ "LOAD_ATTR", "session.query(Function.name, Function.type)\n .filter_by" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "session.query(Function.name, Function.type)\n .filter_by(file=path)" ], [ "LOAD_ATTR", "session.query(Function.name, Function.type)\n .filter_by(file=path)\n .distinct" ], [ "CALL_FUNCTION", "session.query(Function.name, Function.type)\n .filter_by(file=path)\n .distinct()" ], [ "CALL_FUNCTION", "sorted(session.query(Function.name, Function.type)\n .filter_by(file=path)\n .distinct())" ], [ "LOAD_FAST", "query" ], [ "LOAD_FAST", "all_funcs" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.name" ], [ "LOAD_FAST", "func_names" ], [ "COMPARE_OP", "func.name not in func_names" ], [ "LOAD_FAST", "funcs" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.type" ], [ "BINARY_SUBSCR", "funcs[func.type]" ], [ "LOAD_ATTR", "funcs[func.type].append" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "funcs[func.type].append(func)" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "funcs" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "COMPARE_OP", "path == IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "basename" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "basename(path)" ], [ "CALL_FUNCTION", "render_template('file.html',\n funcs=funcs,\n is_ipython=path == IPYTHON_FILE_PATH,\n full_path=path,\n short_path=basename(path))" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.name" ], [ "LOAD_GLOBAL", "fix_abs_path" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "fix_abs_path(path)" ], [ "LOAD_GLOBAL", "get_calls" ], [ "LOAD_FAST", "session" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "func_name" ], [ "CALL_FUNCTION", "get_calls(session, path, func_name, 200)" ], [ "LOAD_FAST", "query" ], [ "LOAD_FAST", "query" ], [ "BINARY_SUBSCR", "query[0]" ], [ "LOAD_FAST", "query" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_FUNCTION", "session.query(Function)" ], [ "LOAD_ATTR", "session.query(Function).filter_by" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "func_name" ], [ "CALL_FUNCTION", "session.query(Function).filter_by(file=path, name=func_name)" ], [ "BINARY_SUBSCR", "session.query(Function).filter_by(file=path, name=func_name)[0]" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "func" ], [ "LOAD_GLOBAL", "basename" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "basename(path)" ], [ "LOAD_FAST", "calls" ], [ "CALL_FUNCTION", "render_template('function.html',\n func=func,\n short_path=basename(path),\n calls=calls)" ], [ "LOAD_GLOBAL", "withattrs" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_FUNCTION", "Call()" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row._asdict" ], [ "CALL_FUNCTION", "row._asdict()" ], [ "CALL_FUNCTION_KW", "withattrs(Call(), **row._asdict())" ], [ "LOAD_GLOBAL", "fix_abs_path" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "fix_abs_path(path)" ], [ "LOAD_GLOBAL", "get_calls" ], [ "LOAD_FAST", "session" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "func_name" ], [ "CALL_FUNCTION", "get_calls(session, path, func_name, 1)" ], [ "BINARY_SUBSCR", "get_calls(session, path, func_name, 1)[0]" ], [ "LOAD_GLOBAL", "jsonify" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.id" ], [ "LOAD_GLOBAL", "url_for" ], [ "LOAD_GLOBAL", "call_view" ], [ "LOAD_ATTR", "call_view.__name__" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.id" ], [ "CALL_FUNCTION", "url_for(call_view.__name__,\n call_id=call.id)" ], [ "CALL_FUNCTION", "dict(\n id=call.id,\n url=url_for(call_view.__name__,\n call_id=call.id),\n )" ], [ "CALL_FUNCTION", "jsonify(dict(\n id=call.id,\n url=url_for(call_view.__name__,\n call_id=call.id),\n ))" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_columns" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.basic_columns" ], [ "BINARY_ADD", "Call.basic_columns + Function.basic_columns" ], [ "CALL_FUNCTION_VAR", "session.query(*(Call.basic_columns + Function.basic_columns))" ], [ "LOAD_ATTR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_FUNCTION", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)" ], [ "LOAD_ATTR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "func_name" ], [ "CALL_FUNCTION", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path, name=func_name)" ], [ "LOAD_ATTR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path, name=func_name)\n .order_by" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.start_time" ], [ "LOAD_ATTR", "Call.start_time.desc" ], [ "CALL_FUNCTION", "Call.start_time.desc()" ], [ "CALL_FUNCTION", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path, name=func_name)\n .order_by(Call.start_time.desc())" ], [ "LOAD_FAST", "limit" ], [ "BINARY_SUBSCR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path, name=func_name)\n .order_by(Call.start_time.desc())[:limit]" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_FUNCTION", "session.query(Call)" ], [ "LOAD_ATTR", "session.query(Call).filter_by" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION", "session.query(Call).filter_by(id=call_id)" ], [ "LOAD_ATTR", "session.query(Call).filter_by(id=call_id).one" ], [ "CALL_FUNCTION", "session.query(Call).filter_by(id=call_id).one()" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.function" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "template" ], [ "LOAD_GLOBAL", "basename" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.file" ], [ "CALL_FUNCTION", "basename(func.file)" ], [ "LOAD_FAST", "call" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "render_template(template,\n short_path=basename(func.file),\n call=call,\n func=func)" ], [ "LOAD_GLOBAL", "base_call_view" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION", "base_call_view(call_id, 'call.html')" ], [ "LOAD_GLOBAL", "base_call_view" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION", "base_call_view(call_id, 'ipython_call.html')" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION", "render_template('ipython_iframe.html',\n container_id='1234',\n port=7777,\n call_id=call_id)" ], [ "LOAD_GLOBAL", "request" ], [ "LOAD_ATTR", "request.environ" ], [ "LOAD_ATTR", "request.environ.get" ], [ "CALL_FUNCTION", "request.environ.get('werkzeug.server.shutdown')" ], [ "LOAD_FAST", "func" ], [ "COMPARE_OP", "func is None" ], [ "LOAD_GLOBAL", "RuntimeError" ], [ "CALL_FUNCTION", "RuntimeError('Not running with the Werkzeug Server')" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "func()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_FUNCTION", "session.query(Call)" ], [ "LOAD_ATTR", "session.query(Call).filter_by" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION", "session.query(Call).filter_by(id=call_id)" ], [ "LOAD_ATTR", "session.query(Call).filter_by(id=call_id).one" ], [ "CALL_FUNCTION", "session.query(Call).filter_by(id=call_id).one()" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.function" ], [ "LOAD_GLOBAL", "DecentJSONEncoder" ], [ "CALL_FUNCTION", "DecentJSONEncoder()" ], [ "LOAD_ATTR", "DecentJSONEncoder().encode" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.parsed_data" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_dict" ], [ "LOAD_FAST", "call" ], [ "CALL_FUNCTION", "Call.basic_dict(call)" ], [ "CALL_FUNCTION_KW", "dict(data=call.parsed_data, **Call.basic_dict(call))" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.parsed_data" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.basic_dict" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "Function.basic_dict(func)" ], [ "CALL_FUNCTION_KW", "dict(data=func.parsed_data, **Function.basic_dict(func))" ], [ "CALL_FUNCTION", "dict(\n call=dict(data=call.parsed_data, **Call.basic_dict(call)),\n function=dict(data=func.parsed_data, **Function.basic_dict(func)))" ], [ "CALL_FUNCTION", "DecentJSONEncoder().encode(dict(\n call=dict(data=call.parsed_data, **Call.basic_dict(call)),\n function=dict(data=func.parsed_data, **Function.basic_dict(func))))" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_columns" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.data" ], [ "BINARY_ADD", "Call.basic_columns + (Function.data,)" ], [ "CALL_FUNCTION_VAR", "session.query(*Call.basic_columns + (Function.data,))" ], [ "LOAD_ATTR", "session.query(*Call.basic_columns + (Function.data,))\n .join" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_FUNCTION", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)" ], [ "LOAD_ATTR", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by" ], [ "LOAD_FAST", "body_hash" ], [ "CALL_FUNCTION", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by(body_hash=body_hash)" ], [ "LOAD_ATTR", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by(body_hash=body_hash)\n .order_by" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.start_time" ], [ "LOAD_ATTR", "Call.start_time.desc" ], [ "CALL_FUNCTION", "Call.start_time.desc()" ], [ "CALL_FUNCTION", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by(body_hash=body_hash)\n .order_by(Call.start_time.desc())" ], [ "BINARY_SUBSCR", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by(body_hash=body_hash)\n .order_by(Call.start_time.desc())[:200]" ], [ "LOAD_FAST", "query" ], [ "LOAD_FAST", "query" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "function_data_set" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_ATTR", "json.loads" ], [ "LOAD_DEREF", "function_data" ], [ "CALL_FUNCTION", "json.loads(function_data)" ], [ "LOAD_FAST", "add" ], [ "LOAD_FAST", "ranges" ], [ "CALL_FUNCTION", "add('node_ranges', ranges)" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "add" ], [ "LOAD_FAST", "current_loop_ranges" ], [ "CALL_FUNCTION", "add('loop_ranges', current_loop_ranges)" ], [ "LOAD_FAST", "loop_ranges" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "current_loop_ranges" ], [ "COMPARE_OP", "loop_ranges in (set(), current_loop_ranges)" ], [ "LOAD_FAST", "current_loop_ranges" ], [ "LOAD_FAST", "ranges" ], [ "LOAD_FAST", "loop_ranges" ], [ "LOAD_GLOBAL", "DecentJSONEncoder" ], [ "CALL_FUNCTION", "DecentJSONEncoder()" ], [ "LOAD_ATTR", "DecentJSONEncoder().encode" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "calls" ], [ "LOAD_FAST", "ranges" ], [ "LOAD_FAST", "loop_ranges" ], [ "CALL_FUNCTION", "dict(\n calls=calls, ranges=ranges, loop_ranges=loop_ranges)" ], [ "CALL_FUNCTION", "DecentJSONEncoder().encode(dict(\n calls=calls, ranges=ranges, loop_ranges=loop_ranges))" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_dict" ], [ "LOAD_GLOBAL", "withattrs" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_FUNCTION", "Call()" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row._asdict" ], [ "CALL_FUNCTION", "row._asdict()" ], [ "CALL_FUNCTION_KW", "withattrs(Call(), **row._asdict())" ], [ "CALL_FUNCTION", "Call.basic_dict(withattrs(Call(), **row._asdict()))" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.data" ], [ "LOAD_DEREF", "function_data" ], [ "LOAD_FAST", "key" ], [ "BINARY_SUBSCR", "function_data[key]" ], [ "LOAD_FAST", "ranges_set" ], [ "LOAD_ATTR", "ranges_set.add" ], [ "LOAD_FAST", "node" ], [ "BINARY_SUBSCR", "node['start']" ], [ "LOAD_FAST", "node" ], [ "BINARY_SUBSCR", "node['end']" ], [ "CALL_FUNCTION", "ranges_set.add((node['start'], node['end']))" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "CALL_FUNCTION", "dict(start=start, end=end)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "CALL_FUNCTION", "dict(start=start, end=end)" ], [ "LOAD_GLOBAL", "request" ], [ "LOAD_ATTR", "request.get_json" ], [ "CALL_FUNCTION", "request.get_json()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.body_hash" ], [ "LOAD_GLOBAL", "sqlalchemy" ], [ "LOAD_ATTR", "sqlalchemy.func" ], [ "LOAD_ATTR", "sqlalchemy.func.count" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.id" ], [ "CALL_FUNCTION", "sqlalchemy.func.count(Call.id)" ], [ "CALL_FUNCTION", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))" ], [ "LOAD_ATTR", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_FUNCTION", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)" ], [ "LOAD_ATTR", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)\n .filter" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.body_hash" ], [ "LOAD_ATTR", "Function.body_hash.in_" ], [ "LOAD_FAST", "hashes" ], [ "CALL_FUNCTION", "Function.body_hash.in_(hashes)" ], [ "CALL_FUNCTION", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)\n .filter(Function.body_hash.in_(hashes))" ], [ "LOAD_ATTR", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)\n .filter(Function.body_hash.in_(hashes))\n .group_by" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.body_hash" ], [ "CALL_FUNCTION", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)\n .filter(Function.body_hash.in_(hashes))\n .group_by(Function.body_hash)" ], [ "LOAD_GLOBAL", "DecentJSONEncoder" ], [ "CALL_FUNCTION", "DecentJSONEncoder()" ], [ "LOAD_ATTR", "DecentJSONEncoder().encode" ], [ "LOAD_FAST", "query" ], [ "CALL_FUNCTION", "DecentJSONEncoder().encode([\n dict(hash=h, count=count)\n for h, count in query\n ])" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "h" ], [ "LOAD_FAST", "count" ], [ "CALL_FUNCTION", "dict(hash=h, count=count)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "argv" ], [ "CALL_FUNCTION", "len(argv)" ], [ "COMPARE_OP", "len(argv) == 1" ], [ "LOAD_FAST", "argv" ], [ "BINARY_SUBSCR", "argv[0]" ], [ "LOAD_ATTR", "argv[0].isdigit" ], [ "CALL_FUNCTION", "argv[0].isdigit()" ], [ "LOAD_FAST", "argv" ], [ "LOAD_ATTR", "argv.insert" ], [ "CALL_FUNCTION", "argv.insert(0, '--port')" ], [ "LOAD_GLOBAL", "argparse" ], [ "LOAD_ATTR", "argparse.ArgumentParser" ], [ "CALL_FUNCTION", "argparse.ArgumentParser(description=\"Bird's Eye: A graphical Python debugger\")" ], [ "LOAD_FAST", "parser" ], [ "LOAD_ATTR", "parser.add_argument" ], [ "LOAD_GLOBAL", "int" ], [ "CALL_FUNCTION", "parser.add_argument('-p', '--port', help='HTTP port, default is 7777', default=7777, type=int)" ], [ "LOAD_FAST", "parser" ], [ "LOAD_ATTR", "parser.add_argument" ], [ "CALL_FUNCTION", "parser.add_argument('--host', help=\"HTTP host, default is 'localhost'\", default='localhost')" ], [ "LOAD_FAST", "parser" ], [ "LOAD_ATTR", "parser.parse_args" ], [ "LOAD_FAST", "argv" ], [ "CALL_FUNCTION", "parser.parse_args(argv)" ], [ "LOAD_GLOBAL", "app" ], [ "LOAD_ATTR", "app.run" ], [ "LOAD_FAST", "args" ], [ "LOAD_ATTR", "args.port" ], [ "LOAD_FAST", "args" ], [ "LOAD_ATTR", "args.host" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.environ" ], [ "LOAD_ATTR", "os.environ.get" ], [ "CALL_FUNCTION", "os.environ.get('BIRDSEYE_RELOADER')" ], [ "COMPARE_OP", "os.environ.get('BIRDSEYE_RELOADER') == '1'" ], [ "CALL_FUNCTION", "app.run(\n port=args.port,\n host=args.host,\n use_reloader=os.environ.get('BIRDSEYE_RELOADER') == '1',\n )" ] ], "tests.py": [ [ "LOAD_NAME", "unittest" ], [ "LOAD_ATTR", "unittest.TestCase" ], [ "LOAD_NAME", "unittest" ], [ "LOAD_ATTR", "unittest.TestCase" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "TestFile" ], [ "CALL_FUNCTION", "TestFile()" ], [ "LOAD_ATTR", "TestFile().test_file" ], [ "CALL_FUNCTION", "TestFile().test_file()" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "Tester" ], [ "CALL_FUNCTION", "Tester()" ], [ "LOAD_NAME", "tester" ], [ "CALL_FUNCTION", "tester([1, 2, 3])" ], [ "COMPARE_OP", "tester([1, 2, 3]) == [1, 2, 3]" ], [ "LOAD_NAME", "tester" ], [ "LOAD_ATTR", "tester.asd" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester.asd is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_SUBSCR", "tester[19]" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester[19] is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_POWER", "tester ** 4" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester ** 4 is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_MULTIPLY", "tester * 3" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester * 3 is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_SUBTRACT", "tester - 2" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester - 2 is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_ADD", "tester + 1" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester + 1 is tester" ], [ "LOAD_NAME", "tester" ], [ "UNARY_NEGATIVE", "-tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "-tester is tester" ], [ "LOAD_NAME", "tester" ], [ "UNARY_POSITIVE", "+tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "+tester is tester" ], [ "LOAD_NAME", "tester" ], [ "UNARY_INVERT", "~tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "~tester is tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester < 7" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "(tester < 7) is tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester >= 78" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "(tester >= 78) is tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester != 79" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "(tester != 79) is tester" ], [ "LOAD_NAME", "tester" ], [ "LOAD_ATTR", "tester.foo" ], [ "CALL_FUNCTION", "tester.foo(45, False)" ], [ "COMPARE_OP", "tester.foo(45, False) == 45" ], [ "LOAD_NAME", "__name__" ], [ "COMPARE_OP", "__name__ == '__main__'" ], [ "LOAD_NAME", "unittest" ], [ "LOAD_ATTR", "unittest.main" ], [ "CALL_FUNCTION", "unittest.main()" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(1)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(2)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(3)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(9\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n 8)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n 99\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(33)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([4,\n 5, 6, [\n 7]])" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "LOAD_GLOBAL", "decorator_with_args" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('123')" ], [ "LOAD_GLOBAL", "int" ], [ "CALL_FUNCTION", "int()" ], [ "CALL_FUNCTION", "decorator_with_args(tester('123'), x=int())" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "tuple([1, 2])" ], [ "CALL_FUNCTION", "list(tuple([1, 2]))" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "CALL_FUNCTION", "tester(list(tuple([1, 2])), returns=empty_decorator)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "tuple(\n [3, 4])" ], [ "CALL_FUNCTION", "list(\n tuple(\n [3, 4]))" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "CALL_FUNCTION", "tester(\n list(\n tuple(\n [3, 4])),\n returns=empty_decorator)" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "LOAD_GLOBAL", "decorator_with_args" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "str()" ], [ "LOAD_GLOBAL", "int" ], [ "CALL_FUNCTION", "int()" ], [ "CALL_FUNCTION", "decorator_with_args(\n str(),\n x=int())" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "tuple([5, 6])" ], [ "CALL_FUNCTION", "list(tuple([5, 6]))" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "CALL_FUNCTION", "tester(list(tuple([5, 6])), returns=empty_decorator)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "tuple([7, 8])" ], [ "CALL_FUNCTION", "list(tuple([7, 8]))" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "CALL_FUNCTION", "tester(list(tuple([7, 8])), returns=empty_decorator)" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "LOAD_GLOBAL", "decorator_with_args" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('sdf')" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('123234')" ], [ "CALL_FUNCTION", "decorator_with_args(tester('sdf'), x=tester('123234'))" ], [ "CALL_FUNCTION", "decorator_with_args(tester('sdf'), x=tester('123234'))" ], [ "CALL_FUNCTION", "empty_decorator" ], [ "CALL_FUNCTION", "tester(list(tuple([7, 8])), returns=empty_decorator)" ], [ "CALL_FUNCTION", "tester(list(tuple([5, 6])), returns=empty_decorator)" ], [ "CALL_FUNCTION", "decorator_with_args(\n str(),\n x=int())" ], [ "CALL_FUNCTION", "empty_decorator" ], [ "CALL_FUNCTION", "tester(\n list(\n tuple(\n [3, 4])),\n returns=empty_decorator)" ], [ "CALL_FUNCTION", "tester(list(tuple([1, 2])), returns=empty_decorator)" ], [ "CALL_FUNCTION", "decorator_with_args(tester('123'), x=int())" ], [ "CALL_FUNCTION", "empty_decorator" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "str([{tester(x) for x in [1]}, {tester(y) for y in [1]}])" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "str([{tester(x) for x in [1]},\n {tester(x) for x in [1]}])" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "list(tester(x) for x in [1])" ], [ "CALL_FUNCTION", "str([{tester(x) for x in [1]}, list(tester(x) for x in [1])])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "y" ], [ "CALL_FUNCTION", "tester(y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertEqual" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(3)" ], [ "CALL_FUNCTION", "(lambda x: (tester(x), tester(x)))(tester(3))" ], [ "CALL_FUNCTION", "self.assertEqual(\n (lambda x: (tester(x), tester(x)))(tester(3)),\n (3, 3),\n )" ], [ "CALL_FUNCTION", "(lambda: (lambda: tester(1))())()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertEqual" ], [ "CALL_FUNCTION", "(lambda: [tester(x) for x in tester([1, 2])])()" ], [ "CALL_FUNCTION", "self.assertEqual(\n (lambda: [tester(x) for x in tester([1, 2])])(),\n [1, 2],\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "CALL_FUNCTION", "(lambda: tester(1))()" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(1)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x): {tester(b+x): {tester(c+x) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_FAST", "foo" ], [ "CALL_FUNCTION", "foo()" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "CALL_FUNCTION", "tester(a+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "CALL_FUNCTION", "tester(b+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "CALL_FUNCTION", "tester(c+x)" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x): {tester(b+x): {tester(c+x) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+y): {tester(b+y): {tester(c+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x+y): {tester(b+x+y): {tester(c+x+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_FAST", "bar" ], [ "CALL_FUNCTION", "bar()" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "CALL_FUNCTION", "tester(a+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "CALL_FUNCTION", "tester(b+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "CALL_FUNCTION", "tester(c+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+y" ], [ "CALL_FUNCTION", "tester(a+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+y" ], [ "CALL_FUNCTION", "tester(b+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+y" ], [ "CALL_FUNCTION", "tester(c+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+x+y" ], [ "CALL_FUNCTION", "tester(a+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+x+y" ], [ "CALL_FUNCTION", "tester(b+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+x+y" ], [ "CALL_FUNCTION", "tester(c+x+y)" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x): {tester(b+x): {tester(c+x) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+y): {tester(b+y): {tester(c+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x+y): {tester(b+x+y): {tester(c+x+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x+y+z): {tester(b+x+y+z): {tester(c+x+y+z) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "CALL_FUNCTION", "tester(a+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "CALL_FUNCTION", "tester(b+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "CALL_FUNCTION", "tester(c+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+y" ], [ "CALL_FUNCTION", "tester(a+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+y" ], [ "CALL_FUNCTION", "tester(b+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+y" ], [ "CALL_FUNCTION", "tester(c+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+x+y" ], [ "CALL_FUNCTION", "tester(a+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+x+y" ], [ "CALL_FUNCTION", "tester(b+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+x+y" ], [ "CALL_FUNCTION", "tester(c+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+x+y" ], [ "LOAD_DEREF", "z" ], [ "BINARY_ADD", "a+x+y+z" ], [ "CALL_FUNCTION", "tester(a+x+y+z)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+x+y" ], [ "LOAD_DEREF", "z" ], [ "BINARY_ADD", "b+x+y+z" ], [ "CALL_FUNCTION", "tester(b+x+y+z)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+x+y" ], [ "LOAD_DEREF", "z" ], [ "BINARY_ADD", "c+x+y+z" ], [ "CALL_FUNCTION", "tester(c+x+y+z)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "dict(x=tester)" ], [ "BINARY_SUBSCR", "dict(x=tester)['x']" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "dict(x=tester)['x'](tester)" ], [ "CALL_FUNCTION", "dict(x=tester)['x'](tester)(3, check_func=False)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertRaises" ], [ "LOAD_GLOBAL", "TypeError" ], [ "CALL_FUNCTION", "self.assertRaises(TypeError)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2, 3])" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(0)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(4)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(5)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "tester(ValueError)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(9)" ], [ "LOAD_GLOBAL", "TypeError" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(10)" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "str()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertRaises" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "Exception" ], [ "CALL_FUNCTION", "tester(Exception)" ], [ "CALL_FUNCTION", "self.assertRaises(tester(Exception))" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(0)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(0)" ], [ "LOAD_GLOBAL", "tester" ], [ "BINARY_TRUE_DIVIDE", "1 / 0" ], [ "CALL_FUNCTION", "tester(1 / 0)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "gen" ], [ "CALL_FUNCTION", "gen()" ], [ "CALL_FUNCTION", "list(gen())" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "gen2" ], [ "CALL_FUNCTION", "list(gen2)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(4)" ], [ "LOAD_GLOBAL", "time" ], [ "LOAD_ATTR", "time.time" ], [ "CALL_FUNCTION", "time.time()" ], [ "LOAD_GLOBAL", "range" ], [ "CALL_FUNCTION", "range(10000)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_ATTR", "Source.executing" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.currentframe" ], [ "CALL_FUNCTION", "inspect.currentframe()" ], [ "CALL_FUNCTION", "Source.executing(inspect.currentframe())" ], [ "LOAD_ATTR", "Source.executing(inspect.currentframe()).node" ], [ "LOAD_FAST", "node" ], [ "COMPARE_OP", "node is None" ], [ "LOAD_FAST", "new_node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertIs" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "new_node" ], [ "CALL_FUNCTION", "self.assertIs(node, new_node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertLess" ], [ "LOAD_GLOBAL", "time" ], [ "LOAD_ATTR", "time.time" ], [ "CALL_FUNCTION", "time.time()" ], [ "LOAD_FAST", "start" ], [ "BINARY_SUBTRACT", "time.time() - start" ], [ "CALL_FUNCTION", "self.assertLess(time.time() - start, 1)" ], [ "LOAD_FAST", "check" ], [ "CALL_FUNCTION", "check(u'# coding=utf8\\n\u00e9', 'utf8')" ], [ "LOAD_FAST", "check" ], [ "CALL_FUNCTION", "check(u'# coding=gbk\\n\u00e9', 'gbk')" ], [ "LOAD_FAST", "check" ], [ "LOAD_GLOBAL", "UnicodeDecodeError" ], [ "CALL_FUNCTION", "check(u'# coding=utf8\\n\u00e9', 'gbk', exception=UnicodeDecodeError)" ], [ "LOAD_FAST", "check" ], [ "CALL_FUNCTION", "check(u'# coding=gbk\\n\u00e9', 'utf8', matches=False)" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_FAST", "check" ], [ "CALL_FUNCTION", "check(u'\u00e9', 'utf8')" ], [ "LOAD_FAST", "check" ], [ "LOAD_GLOBAL", "SyntaxError" ], [ "CALL_FUNCTION", "check(u'\u00e9', 'gbk', exception=SyntaxError)" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.encode" ], [ "LOAD_FAST", "encoding" ], [ "CALL_FUNCTION", "source.encode(encoding)" ], [ "LOAD_FAST", "exception" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.assertRaises" ], [ "LOAD_FAST", "exception" ], [ "CALL_FUNCTION", "self.assertRaises(exception)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_ATTR", "Source.decode_source" ], [ "LOAD_FAST", "encoded" ], [ "CALL_FUNCTION", "Source.decode_source(encoded)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_ATTR", "Source.decode_source" ], [ "LOAD_FAST", "encoded" ], [ "CALL_FUNCTION", "Source.decode_source(encoded)" ], [ "LOAD_FAST", "matches" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.assertEqual" ], [ "LOAD_FAST", "decoded" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "self.assertEqual(decoded, source)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.assertNotEqual" ], [ "LOAD_FAST", "decoded" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "self.assertNotEqual(decoded, source)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('a')" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('''\n ab''')" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('''\n abc\n def\n '''\n )" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n '''\n 123\n 456\n '''\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n '''\n 345\n 456786\n '''\n )" ], [ "CALL_FUNCTION", "str([\n tester(\n '''\n 123\n 456\n '''\n ),\n tester(\n '''\n 345\n 456786\n '''\n ),\n ])" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n [\n '''\n 123\n 456\n '''\n '''\n 345\n 456786\n '''\n ,\n '''\n 123\n 456\n ''',\n '''\n 345\n 456786\n '''\n ]\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(1)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(2)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(3)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_ATTR", "Source.for_filename" ], [ "LOAD_GLOBAL", "__file__" ], [ "CALL_FUNCTION", "Source.for_filename(__file__)" ], [ "LOAD_ATTR", "Source.for_filename(__file__).code_qualname" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.__code__" ], [ "CALL_FUNCTION", "Source.for_filename(__file__).code_qualname(func.__code__)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertEqual" ], [ "LOAD_FAST", "qn" ], [ "LOAD_FAST", "qualname" ], [ "CALL_FUNCTION", "self.assertEqual(qn, qualname)" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_FAST", "check_actual_qualname" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertEqual" ], [ "LOAD_FAST", "qn" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.__qualname__" ], [ "CALL_FUNCTION", "self.assertEqual(qn, func.__qualname__)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertTrue" ], [ "LOAD_FAST", "qn" ], [ "LOAD_ATTR", "qn.endswith" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.__name__" ], [ "CALL_FUNCTION", "qn.endswith(func.__name__)" ], [ "CALL_FUNCTION", "self.assertTrue(qn.endswith(func.__name__))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assert_qualname" ], [ "LOAD_GLOBAL", "C" ], [ "LOAD_ATTR", "C.f" ], [ "CALL_FUNCTION", "self.assert_qualname(C.f, 'C.f')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assert_qualname" ], [ "LOAD_GLOBAL", "C" ], [ "LOAD_ATTR", "C.D" ], [ "LOAD_ATTR", "C.D.g" ], [ "CALL_FUNCTION", "self.assert_qualname(C.D.g, 'C.D.g')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assert_qualname" ], [ "LOAD_GLOBAL", "f" ], [ "CALL_FUNCTION", "self.assert_qualname(f, 'f')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assert_qualname" ], [ "LOAD_GLOBAL", "f" ], [ "CALL_FUNCTION", "f()" ], [ "CALL_FUNCTION", "self.assert_qualname(f(), 'f..g')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assert_qualname" ], [ "LOAD_GLOBAL", "C" ], [ "LOAD_ATTR", "C.D" ], [ "LOAD_ATTR", "C.D.h" ], [ "CALL_FUNCTION", "C.D.h()" ], [ "CALL_FUNCTION", "self.assert_qualname(C.D.h(), 'C.D.h..i..j')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assert_qualname" ], [ "LOAD_GLOBAL", "lamb" ], [ "CALL_FUNCTION", "self.assert_qualname(lamb, '')" ], [ "LOAD_GLOBAL", "lambda_maker" ], [ "CALL_FUNCTION", "lambda_maker()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assert_qualname" ], [ "LOAD_FAST", "foo" ], [ "CALL_FUNCTION", "self.assert_qualname(foo, 'lambda_maker..foo')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assert_qualname" ], [ "LOAD_FAST", "foo" ], [ "LOAD_ATTR", "foo.x" ], [ "CALL_FUNCTION", "self.assert_qualname(foo.x, 'lambda_maker..')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assert_qualname" ], [ "LOAD_FAST", "foo" ], [ "CALL_FUNCTION", "foo()" ], [ "CALL_FUNCTION", "self.assert_qualname(foo(), 'lambda_maker..foo..')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assert_qualname" ], [ "LOAD_FAST", "foo" ], [ "CALL_FUNCTION", "foo()" ], [ "CALL_FUNCTION", "foo()()" ], [ "CALL_FUNCTION", "self.assert_qualname(foo()(), 'lambda_maker..foo..', check_actual_qualname=False)" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "range" ], [ "CALL_FUNCTION", "range(66000)" ], [ "CALL_FUNCTION", "list(range(66000))" ], [ "BINARY_MODULO", "'tester(6)\\n%s\\ntester(9)' % list(range(66000))" ], [ "LOAD_GLOBAL", "tempfile" ], [ "LOAD_ATTR", "tempfile.mkstemp" ], [ "CALL_FUNCTION", "tempfile.mkstemp()" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "compile(source, filename, 'exec')" ], [ "LOAD_GLOBAL", "open" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "open(filename, 'w')" ], [ "LOAD_FAST", "outfile" ], [ "LOAD_ATTR", "outfile.write" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "outfile.write(source)" ], [ "LOAD_GLOBAL", "exec" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "exec(code)" ], [ "LOAD_GLOBAL", "range" ], [ "CALL_FUNCTION", "range(5)" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "n" ], [ "CALL_FUNCTION", "range(n)" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "n == 1" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertEqual" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_FAST", "gen" ], [ "CALL_FUNCTION", "only(gen)" ], [ "CALL_FUNCTION", "self.assertEqual(only(gen), 0)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertRaises" ], [ "LOAD_GLOBAL", "NotOneValueFound" ], [ "CALL_FUNCTION", "self.assertRaises(NotOneValueFound)" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_FAST", "gen" ], [ "CALL_FUNCTION", "only(gen)" ], [ "LOAD_FAST", "i" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.join" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.dirname" ], [ "LOAD_GLOBAL", "__file__" ], [ "CALL_FUNCTION", "os.path.dirname(__file__)" ], [ "CALL_FUNCTION", "os.path.join(os.path.dirname(__file__), 'not_code.txt', )" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_ATTR", "Source.for_filename" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "Source.for_filename(path)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertIsNone" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.tree" ], [ "CALL_FUNCTION", "self.assertIsNone(source.tree)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.currentframe" ], [ "CALL_FUNCTION", "inspect.currentframe()" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_ATTR", "Source.executing" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "Source.executing(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertEqual" ], [ "LOAD_FAST", "executing" ], [ "LOAD_ATTR", "executing.code_qualname" ], [ "CALL_FUNCTION", "executing.code_qualname()" ], [ "CALL_FUNCTION", "self.assertEqual(executing.code_qualname(), 'TestStuff.test_executing_methods')" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.version" ], [ "LOAD_ATTR", "sys.version.lower" ], [ "CALL_FUNCTION", "sys.version.lower()" ], [ "COMPARE_OP", "'pypy' not in sys.version.lower()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertEqual" ], [ "LOAD_FAST", "executing" ], [ "LOAD_ATTR", "executing.text" ], [ "CALL_FUNCTION", "executing.text()" ], [ "LOAD_FAST", "text" ], [ "CALL_FUNCTION", "self.assertEqual(executing.text(), text)" ], [ "LOAD_FAST", "executing" ], [ "LOAD_ATTR", "executing.text_range" ], [ "CALL_FUNCTION", "executing.text_range()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertEqual" ], [ "LOAD_FAST", "executing" ], [ "LOAD_ATTR", "executing.source" ], [ "LOAD_ATTR", "executing.source.text" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "BINARY_SUBSCR", "executing.source.text[start:end]" ], [ "LOAD_FAST", "text" ], [ "CALL_FUNCTION", "self.assertEqual(executing.source.text[start:end], text)" ], [ "LOAD_GLOBAL", "C" ], [ "CALL_FUNCTION", "C()" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_FAST", "c" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.x" ], [ "LOAD_ATTR", "c.x.x" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.x" ], [ "LOAD_ATTR", "c.x.y" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.y" ], [ "LOAD_ATTR", "c.y.x" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.y" ], [ "LOAD_ATTR", "c.y.y" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.x" ], [ "LOAD_ATTR", "c.x.asd" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.y" ], [ "LOAD_ATTR", "c.y.qwe" ], [ "CALL_FUNCTION", "str((c.x.x, c.x.y, c.y.x, c.y.y, c.x.asd, c.y.qwe))" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_ATTR", "Source.for_frame" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.currentframe" ], [ "CALL_FUNCTION", "inspect.currentframe()" ], [ "CALL_FUNCTION", "Source.for_frame(inspect.currentframe())" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.text" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.filename" ], [ "CALL_FUNCTION", "compile(source.text, source.filename, 'exec')" ], [ "LOAD_GLOBAL", "get_instructions" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "get_instructions(code)" ], [ "LOAD_FAST", "instructions" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.starts_line" ], [ "COMPARE_OP", "inst.starts_line is not None" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.starts_line" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.opname" ], [ "LOAD_ATTR", "inst.opname.startswith" ], [ "CALL_FUNCTION", "inst.opname.startswith(\n ('BINARY_', 'UNARY_', 'LOAD_ATTR', 'LOAD_METHOD', 'LOOKUP_METHOD', 'COMPARE_OP'))" ], [ "LOAD_GLOBAL", "C" ], [ "CALL_FUNCTION", "C()" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.offset" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "frame" ], [ "LOAD_GLOBAL", "globals" ], [ "CALL_FUNCTION", "globals()" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "lineno" ], [ "LOAD_FAST", "frame" ], [ "LOAD_GLOBAL", "print" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.opname" ], [ "CALL_FUNCTION", "print(inst.opname)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_ATTR", "Source.executing" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "Source.executing(frame)" ], [ "LOAD_ATTR", "Source.executing(frame).node" ], [ "COMPARE_OP", "Source.executing(frame).node is not None" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_FAST", "i" ], [ "CALL_FUNCTION", "i()" ], [ "LOAD_FAST", "j" ], [ "LOAD_FAST", "g" ], [ "LOAD_FAST", "assign" ], [ "CALL_FUNCTION", "assign(lambda: 1)" ], [ "CALL_FUNCTION", "assign(lambda: 1)" ], [ "LOAD_FAST", "foo" ], [ "LOAD_FAST", "decorator" ], [ "LOAD_DEREF", "x" ], [ "LOAD_FAST", "func" ], [ "LOAD_FAST", "func" ], [ "LOAD_NAME", "__add__" ], [ "LOAD_NAME", "__invert__" ], [ "LOAD_NAME", "__lt__" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.currentframe" ], [ "CALL_FUNCTION", "inspect.currentframe()" ], [ "LOAD_ATTR", "inspect.currentframe().f_back" ], [ "LOAD_ATTR", "inspect.currentframe().f_back.f_back" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_ATTR", "Source.lazycache" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "Source.lazycache(frame)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_ATTR", "Source.executing" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "Source.executing(frame)" ], [ "LOAD_ATTR", "Source.executing(frame).node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "typ" ], [ "CALL_FUNCTION", "isinstance(node, typ)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "typ" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.currentframe" ], [ "CALL_FUNCTION", "inspect.currentframe()" ], [ "LOAD_ATTR", "inspect.currentframe().f_back" ], [ "LOAD_ATTR", "inspect.currentframe().f_back.f_back" ], [ "LOAD_GLOBAL", "eval" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Expression" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ast.Expression(node)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_filename" ], [ "CALL_FUNCTION", "compile(ast.Expression(node), frame.f_code.co_filename, 'eval')" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "CALL_FUNCTION", "eval(\n compile(ast.Expression(node), frame.f_code.co_filename, 'eval'),\n frame.f_globals,\n frame.f_locals,\n )" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "value" ], [ "COMPARE_OP", "result == value" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Call" ], [ "CALL_FUNCTION", "self.get_node(ast.Call)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.check" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.args" ], [ "BINARY_SUBSCR", "call.args[0]" ], [ "LOAD_FAST", "arg" ], [ "CALL_FUNCTION", "self.check(call.args[0], arg)" ], [ "LOAD_FAST", "check_func" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.check" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.func" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "self.check(call.func, self)" ], [ "LOAD_FAST", "returns" ], [ "COMPARE_OP", "returns is None" ], [ "LOAD_FAST", "arg" ], [ "LOAD_FAST", "returns" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Attribute" ], [ "CALL_FUNCTION", "self.get_node(ast.Attribute)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.value" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "self.check(node.value, self)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.attr" ], [ "LOAD_FAST", "item" ], [ "COMPARE_OP", "node.attr == item" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Subscript" ], [ "CALL_FUNCTION", "self.get_node(ast.Subscript)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.value" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "self.check(node.value, self)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.slice" ], [ "LOAD_ATTR", "node.slice.value" ], [ "LOAD_FAST", "item" ], [ "CALL_FUNCTION", "self.check(node.slice.value, item)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.BinOp" ], [ "CALL_FUNCTION", "self.get_node(ast.BinOp)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.left" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "self.check(node.left, self)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.right" ], [ "LOAD_FAST", "other" ], [ "CALL_FUNCTION", "self.check(node.right, other)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.UnaryOp" ], [ "CALL_FUNCTION", "self.get_node(ast.UnaryOp)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.operand" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "self.check(node.operand, self)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Compare" ], [ "CALL_FUNCTION", "self.get_node(ast.Compare)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.left" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "self.check(node.left, self)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.comparators" ], [ "BINARY_SUBSCR", "node.comparators[0]" ], [ "LOAD_FAST", "other" ], [ "CALL_FUNCTION", "self.check(node.comparators[0], other)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "func" ], [ "LOAD_GLOBAL", "empty_decorator" ] ], "tracer.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOAD_ATTR", "standard_library.install_aliases" ], [ "CALL_FUNCTION", "standard_library.install_aliases()" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "NamedTuple" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "Union" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "BINARY_SUBSCR", "Union[ast.expr, ast.stmt]" ], [ "BINARY_SUBSCR", "Optional[Union[ast.expr, ast.stmt]]" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.AST" ], [ "LOAD_NAME", "FrameType" ], [ "LOAD_NAME", "FrameType" ], [ "CALL_FUNCTION", "NamedTuple('EnterCallInfo', [\n\n # Node from where the call was made\n ('call_node', Optional[Union[ast.expr, ast.stmt]]),\n\n # Node where the call begins\n ('enter_node', ast.AST),\n\n # Frame from which the call was made\n ('caller_frame', FrameType),\n\n # Frame of the call\n ('current_frame', FrameType)])" ], [ "LOAD_NAME", "NamedTuple" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "Union" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "BINARY_SUBSCR", "Union[ast.expr, ast.stmt]" ], [ "BINARY_SUBSCR", "Optional[Union[ast.expr, ast.stmt]]" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.Return" ], [ "BINARY_SUBSCR", "Optional[ast.Return]" ], [ "LOAD_NAME", "FrameType" ], [ "LOAD_NAME", "FrameType" ], [ "LOAD_NAME", "Any" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "Exception" ], [ "BINARY_SUBSCR", "Optional[Exception]" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "TracebackType" ], [ "BINARY_SUBSCR", "Optional[TracebackType]" ], [ "CALL_FUNCTION", "NamedTuple('ExitCallInfo', [\n\n # Node from where the call was made\n ('call_node', Optional[Union[ast.expr, ast.stmt]]),\n\n # Node where the call explicitly returned\n ('return_node', Optional[ast.Return]),\n\n # Frame from which the call was made\n ('caller_frame', FrameType),\n\n # Frame of the call\n ('current_frame', FrameType),\n\n # Node where the call explicitly returned\n ('return_value', Any),\n\n # Exception raised in the call causing it to end,\n # will propagate to the caller\n ('exc_value', Optional[Exception]),\n\n # Traceback corresponding to exc_value\n ('exc_tb', Optional[TracebackType])])" ], [ "LOAD_NAME", "namedtuple" ], [ "CALL_FUNCTION", "namedtuple('ChangeValue', 'value')" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.NodeTransformer" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "Union" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "BINARY_SUBSCR", "Union[ast.For, ast.While, ast.comprehension]" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.PyCF_ONLY_AST" ], [ "LOAD_FAST", "flags" ], [ "BINARY_OR", "ast.PyCF_ONLY_AST | flags" ], [ "CALL_FUNCTION", "compile(source, filename, 'exec', ast.PyCF_ONLY_AST | flags, dont_inherit=True)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.set_basic_node_attributes" ], [ "CALL_FUNCTION", "self.set_basic_node_attributes()" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.parse_extra" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "tracer.parse_extra(self.root, source, filename)" ], [ "LOAD_FAST", "new_root" ], [ "COMPARE_OP", "new_root is not None" ], [ "LOAD_FAST", "new_root" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.set_basic_node_attributes" ], [ "CALL_FUNCTION", "self.set_basic_node_attributes()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.set_enter_call_nodes" ], [ "CALL_FUNCTION", "self.set_enter_call_nodes()" ], [ "LOAD_GLOBAL", "deepcopy" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "CALL_FUNCTION", "deepcopy(self.root)" ], [ "LOAD_GLOBAL", "_NodeVisitor" ], [ "CALL_FUNCTION", "_NodeVisitor()" ], [ "LOAD_ATTR", "_NodeVisitor().visit" ], [ "LOAD_FAST", "new_root" ], [ "CALL_FUNCTION", "_NodeVisitor().visit(new_root)" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "new_root" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "flags" ], [ "CALL_FUNCTION", "compile(new_root, filename, \"exec\", dont_inherit=True, flags=flags)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.walk" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "CALL_FUNCTION", "ast.walk(self.root)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.iter_child_nodes" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ast.iter_child_nodes(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.nodes" ], [ "CALL_FUNCTION", "len(self.nodes)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.nodes" ], [ "LOAD_ATTR", "self.nodes.append" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "self.nodes.append(node)" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "LOAD_ATTR", "self.root.body" ], [ "CALL_FUNCTION", "enumerate(self.root.body)" ], [ "LOAD_GLOBAL", "is_future_import" ], [ "LOAD_FAST", "stmt" ], [ "CALL_FUNCTION", "is_future_import(stmt)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "LOAD_ATTR", "self.root.body" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "self.root.body[:i + 1]" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.walk" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "ast.walk(s)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.nodes" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Module" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(node, (ast.Module, ast.FunctionDef))" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.body" ], [ "LOAD_GLOBAL", "is_future_import" ], [ "LOAD_FAST", "stmt" ], [ "CALL_FUNCTION", "is_future_import(stmt)" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_NAME", "lru_cache" ], [ "CALL_FUNCTION", "lru_cache()" ], [ "CALL_FUNCTION", "lru_cache()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "defaultdict(list)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "TracedFile" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "flags" ], [ "CALL_FUNCTION", "TracedFile(self, source, filename, flags)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._treetrace_hidden_with_stmt" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._treetrace_hidden_before_expr" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._treetrace_hidden_after_expr" ], [ "LOAD_GLOBAL", "partial" ], [ "LOAD_FAST", "f" ], [ "LOAD_DEREF", "traced_file" ], [ "CALL_FUNCTION", "partial(f, traced_file)" ], [ "LOAD_FAST", "f" ], [ "LOAD_ATTR", "f.__name__" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_DEREF", "func" ], [ "LOAD_GLOBAL", "FunctionType" ], [ "CALL_FUNCTION", "isinstance(func, FunctionType)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError('You can only trace user-defined functions. '\n 'The birdseye decorator must be applied first, '\n 'at the bottom of the list.')" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.iscoroutinefunction" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "inspect.iscoroutinefunction(func)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.isasyncgenfunction" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "inspect.isasyncgenfunction(func)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError('You cannot trace async functions')" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_GLOBAL", "is_lambda" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "is_lambda(func)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError('You cannot trace lambdas')" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.getsourcefile" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "inspect.getsourcefile(func)" ], [ "LOAD_GLOBAL", "is_ipython_cell" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "is_ipython_cell(filename)" ], [ "LOAD_FAST", "get_ipython" ], [ "CALL_FUNCTION", "get_ipython()" ], [ "LOAD_ATTR", "get_ipython().compile" ], [ "LOAD_ATTR", "get_ipython().compile.flags" ], [ "LOAD_ATTR", "''.join" ], [ "LOAD_FAST", "linecache" ], [ "LOAD_ATTR", "linecache.cache" ], [ "LOAD_FAST", "filename" ], [ "BINARY_SUBSCR", "linecache.cache[filename]" ], [ "BINARY_SUBSCR", "linecache.cache[filename][2]" ], [ "CALL_FUNCTION", "''.join(linecache.cache[filename][2])" ], [ "LOAD_GLOBAL", "read_source_file" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "read_source_file(filename)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "flags" ], [ "CALL_FUNCTION", "self.compile(source, filename, flags)" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__dict__" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError('The birdseye decorator must be applied first, '\n 'at the bottom of the list.')" ], [ "LOAD_DEREF", "find_code" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.code" ], [ "CALL_FUNCTION", "find_code(traced_file.code)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_DEREF", "code_options" ], [ "CALL_FUNCTION", "len(code_options)" ], [ "COMPARE_OP", "len(code_options) > 1" ], [ "LOAD_GLOBAL", "is_lambda" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "is_lambda(func)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError(\"Failed to trace lambda. Convert the function to a def.\")" ], [ "LOAD_DEREF", "code_options" ], [ "BINARY_SUBSCR", "code_options[0]" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__globals__" ], [ "LOAD_ATTR", "func.__globals__.update" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._trace_methods_dict" ], [ "LOAD_FAST", "traced_file" ], [ "CALL_FUNCTION", "self._trace_methods_dict(traced_file)" ], [ "CALL_FUNCTION", "func.__globals__.update(self._trace_methods_dict(traced_file))" ], [ "LOAD_GLOBAL", "FunctionType" ], [ "LOAD_FAST", "new_func_code" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__globals__" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__name__" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__defaults__" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__closure__" ], [ "CALL_FUNCTION", "FunctionType(new_func_code, func.__globals__, func.__name__, func.__defaults__, func.__closure__)" ], [ "LOAD_GLOBAL", "update_wrapper" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "update_wrapper(new_func, func)" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "getattr(func, '__kwdefaults__', None)" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_FAST", "root_code" ], [ "LOAD_ATTR", "root_code.co_consts" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.iscode" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "inspect.iscode(const)" ], [ "LOAD_FAST", "const" ], [ "LOAD_ATTR", "const.co_firstlineno" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__code__" ], [ "LOAD_ATTR", "func.__code__.co_firstlineno" ], [ "COMPARE_OP", "const.co_firstlineno == func.__code__.co_firstlineno" ], [ "LOAD_FAST", "const" ], [ "LOAD_ATTR", "const.co_name" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__code__" ], [ "LOAD_ATTR", "func.__code__.co_name" ], [ "COMPARE_OP", "const.co_name == func.__code__.co_name" ], [ "LOAD_FAST", "matches" ], [ "LOAD_DEREF", "code_options" ], [ "LOAD_ATTR", "code_options.append" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "code_options.append(const)" ], [ "LOAD_DEREF", "find_code" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "find_code(const)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.isclass" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "inspect.isclass(func)" ], [ "LOAD_GLOBAL", "TypeError" ], [ "CALL_FUNCTION", "TypeError('Decorating classes is no longer supported')" ], [ "LOAD_FAST", "func" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.trace_function" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "self.trace_function(func)" ], [ "LOAD_FAST", "optional" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.trace_function" ], [ "LOAD_FAST", "decorator" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.trace_function" ], [ "LOAD_DEREF", "actual_func" ], [ "CALL_FUNCTION", "self.trace_function(actual_func)" ], [ "LOAD_GLOBAL", "wraps" ], [ "LOAD_DEREF", "actual_func" ], [ "CALL_FUNCTION", "wraps(actual_func)" ], [ "CALL_FUNCTION", "wraps(actual_func)" ], [ "LOAD_FAST", "wrapper" ], [ "LOAD_FAST", "kwargs" ], [ "LOAD_ATTR", "kwargs.pop" ], [ "CALL_FUNCTION", "kwargs.pop('trace_call', False)" ], [ "LOAD_FAST", "trace_call" ], [ "LOAD_DEREF", "traced" ], [ "LOAD_DEREF", "actual_func" ], [ "LOAD_FAST", "f" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "f(*args, **kwargs)" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys._getframe" ], [ "CALL_FUNCTION", "sys._getframe(2)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.secondary_to_main_frames" ], [ "LOAD_ATTR", "self.secondary_to_main_frames.get" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "self.secondary_to_main_frames.get(frame)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "COMPARE_OP", "frame.f_code.co_name in ('', '', '')" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_GLOBAL", "ancestors" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ancestors(node)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Lambda" ], [ "CALL_FUNCTION", "isinstance(node, (ast.FunctionDef, ast.Lambda))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.ClassDef" ], [ "CALL_FUNCTION", "isinstance(node, ast.ClassDef)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "COMPARE_OP", "frame.f_code.co_name in ('', '')" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.secondary_to_main_frames" ], [ "LOAD_FAST", "original_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.main_to_secondary_frames" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.main_to_secondary_frames[frame]" ], [ "LOAD_ATTR", "self.main_to_secondary_frames[frame].append" ], [ "LOAD_FAST", "original_frame" ], [ "CALL_FUNCTION", "self.main_to_secondary_frames[frame].append(original_frame)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.nodes" ], [ "LOAD_FAST", "_tree_index" ], [ "BINARY_SUBSCR", "traced_file.nodes[_tree_index]" ], [ "LOAD_GLOBAL", "cast" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "cast(ast.stmt, node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._main_frame" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "self._main_frame(node)" ], [ "LOAD_GLOBAL", "_StmtContext" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "_StmtContext(self, node, frame)" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.nodes" ], [ "LOAD_FAST", "_tree_index" ], [ "BINARY_SUBSCR", "traced_file.nodes[_tree_index]" ], [ "LOAD_GLOBAL", "cast" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "cast(ast.expr, node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._main_frame" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "self._main_frame(node)" ], [ "LOAD_FAST", "frame" ], [ "COMPARE_OP", "frame is None" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_stack" ], [ "LOAD_ATTR", "frame_info.expression_stack.append" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "frame_info.expression_stack.append(node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.before_expr" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "self.before_expr(node, frame)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._main_frame" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "self._main_frame(node)" ], [ "LOAD_FAST", "frame" ], [ "COMPARE_OP", "frame is None" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._after_expr" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "self._after_expr(node, frame, value, None, None)" ], [ "LOAD_FAST", "result" ], [ "COMPARE_OP", "result is not None" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "ChangeValue" ], [ "CALL_FUNCTION", "isinstance(result, ChangeValue)" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.value" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_stack" ], [ "LOAD_ATTR", "frame_info.expression_stack.pop" ], [ "CALL_FUNCTION", "frame_info.expression_stack.pop()" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_values" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.after_expr" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "exc_value" ], [ "LOAD_FAST", "exc_tb" ], [ "CALL_FUNCTION", "self.after_expr(node, frame, value, exc_value, exc_tb)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._get_caller_stuff" ], [ "LOAD_FAST", "current_frame" ], [ "CALL_FUNCTION", "self._get_caller_stuff(current_frame)" ], [ "LOAD_GLOBAL", "FrameInfo" ], [ "CALL_FUNCTION", "FrameInfo()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "current_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.enter_call" ], [ "LOAD_GLOBAL", "EnterCallInfo" ], [ "LOAD_FAST", "call_node" ], [ "LOAD_FAST", "enter_node" ], [ "LOAD_FAST", "caller_frame" ], [ "LOAD_FAST", "current_frame" ], [ "CALL_FUNCTION", "EnterCallInfo(call_node, enter_node, caller_frame, current_frame)" ], [ "CALL_FUNCTION", "self.enter_call(EnterCallInfo(call_node, enter_node, caller_frame, current_frame))" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.secondary_to_main_frames" ], [ "LOAD_ATTR", "self.secondary_to_main_frames.get" ], [ "LOAD_FAST", "caller_frame" ], [ "CALL_FUNCTION", "self.secondary_to_main_frames.get(caller_frame)" ], [ "LOAD_FAST", "main_frame" ], [ "LOAD_FAST", "main_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "caller_frame" ], [ "BINARY_SUBSCR", "self.stack[caller_frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_stack" ], [ "LOAD_FAST", "expression_stack" ], [ "LOAD_FAST", "expression_stack" ], [ "BINARY_SUBSCR", "expression_stack[-1]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.statement_stack" ], [ "BINARY_SUBSCR", "frame_info.statement_stack[-1]" ], [ "LOAD_FAST", "caller_frame" ], [ "LOAD_FAST", "call_node" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "getattr(node, '_visit_ignore', False)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "CALL_FUNCTION", "isinstance(node, ast.expr)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "hasattr(node, \"ctx\")" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.ctx" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Load" ], [ "CALL_FUNCTION", "isinstance(node.ctx, ast.Load)" ], [ "UNARY_NOT", "not isinstance(node.ctx, ast.Load)" ], [ "UNARY_NOT", "not (hasattr(node, \"ctx\") and not isinstance(node.ctx, ast.Load))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "ast" ], [ "CALL_FUNCTION", "getattr(ast, 'Starred', ())" ], [ "CALL_FUNCTION", "isinstance(node, getattr(ast, 'Starred', ()))" ], [ "UNARY_NOT", "not isinstance(node, getattr(ast, 'Starred', ()))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.visit_expr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "self.visit_expr(node)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "CALL_FUNCTION", "isinstance(node, ast.stmt)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.visit_stmt" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "self.visit_stmt(node)" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "_NodeVisitor" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self)" ], [ "LOAD_ATTR", "super(_NodeVisitor, self).generic_visit" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self).generic_visit(node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._create_simple_marker_call" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "TreeTracerBase" ], [ "LOAD_ATTR", "TreeTracerBase._treetrace_hidden_before_expr" ], [ "CALL_FUNCTION", "self._create_simple_marker_call(node, TreeTracerBase._treetrace_hidden_before_expr)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.copy_location" ], [ "LOAD_FAST", "before_marker" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ast.copy_location(before_marker, node)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Call" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Name" ], [ "LOAD_GLOBAL", "TreeTracerBase" ], [ "LOAD_ATTR", "TreeTracerBase._treetrace_hidden_after_expr" ], [ "LOAD_ATTR", "TreeTracerBase._treetrace_hidden_after_expr.__name__" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Load" ], [ "CALL_FUNCTION", "ast.Load()" ], [ "CALL_FUNCTION", "ast.Name(id=TreeTracerBase._treetrace_hidden_after_expr.__name__,\n ctx=ast.Load())" ], [ "LOAD_FAST", "before_marker" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "_NodeVisitor" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self)" ], [ "LOAD_ATTR", "super(_NodeVisitor, self).generic_visit" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self).generic_visit(node)" ], [ "CALL_FUNCTION", "ast.Call(\n func=ast.Name(id=TreeTracerBase._treetrace_hidden_after_expr.__name__,\n ctx=ast.Load()),\n args=[\n before_marker,\n super(_NodeVisitor, self).generic_visit(node),\n ],\n keywords=[],\n )" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.copy_location" ], [ "LOAD_FAST", "after_marker" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ast.copy_location(after_marker, node)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.fix_missing_locations" ], [ "LOAD_FAST", "after_marker" ], [ "CALL_FUNCTION", "ast.fix_missing_locations(after_marker)" ], [ "LOAD_FAST", "after_marker" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._create_simple_marker_call" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "_NodeVisitor" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self)" ], [ "LOAD_ATTR", "super(_NodeVisitor, self).generic_visit" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self).generic_visit(node)" ], [ "LOAD_GLOBAL", "TreeTracerBase" ], [ "LOAD_ATTR", "TreeTracerBase._treetrace_hidden_with_stmt" ], [ "CALL_FUNCTION", "self._create_simple_marker_call(\n super(_NodeVisitor, self).generic_visit(node),\n TreeTracerBase._treetrace_hidden_with_stmt)" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.With" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.withitem" ], [ "LOAD_FAST", "context_expr" ], [ "CALL_FUNCTION", "ast.withitem(context_expr=context_expr)" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ast.With(\n items=[ast.withitem(context_expr=context_expr)],\n body=[node],\n )" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.With" ], [ "LOAD_FAST", "context_expr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ast.With(\n context_expr=context_expr,\n body=[node],\n )" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.copy_location" ], [ "LOAD_FAST", "wrapped" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ast.copy_location(wrapped, node)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.fix_missing_locations" ], [ "LOAD_FAST", "wrapped" ], [ "CALL_FUNCTION", "ast.fix_missing_locations(wrapped)" ], [ "LOAD_FAST", "wrapped" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Call" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Name" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.__name__" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Load" ], [ "CALL_FUNCTION", "ast.Load()" ], [ "CALL_FUNCTION", "ast.Name(id=func.__name__,\n ctx=ast.Load())" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Num" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "CALL_FUNCTION", "ast.Num(node._tree_index)" ], [ "CALL_FUNCTION", "ast.Call(\n func=ast.Name(id=func.__name__,\n ctx=ast.Load()),\n args=[ast.Num(node._tree_index)],\n keywords=[],\n )" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tracer" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "getattr(node, '_enter_call_node', False)" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer._enter_call" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "tracer._enter_call(node, frame)" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "tracer.stack[frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.statement_stack" ], [ "LOAD_ATTR", "frame_info.statement_stack.append" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "frame_info.statement_stack.append(node)" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.before_stmt" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "tracer.before_stmt(node, frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tracer" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "tracer.stack[frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.statement_stack" ], [ "LOAD_ATTR", "frame_info.statement_stack.pop" ], [ "CALL_FUNCTION", "frame_info.statement_stack.pop()" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.exc_value" ], [ "COMPARE_OP", "exc_val is not frame_info.exc_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_stack" ], [ "LOAD_FAST", "expression_stack" ], [ "LOAD_FAST", "expression_stack" ], [ "BINARY_SUBSCR", "expression_stack[-1]" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer._after_expr" ], [ "LOAD_FAST", "exc_node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "exc_tb" ], [ "CALL_FUNCTION", "tracer._after_expr(exc_node, frame, None, exc_val, exc_tb)" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.after_stmt" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "exc_tb" ], [ "LOAD_FAST", "exc_node" ], [ "CALL_FUNCTION", "tracer.after_stmt(node, frame, exc_val, exc_tb, exc_node)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Return" ], [ "CALL_FUNCTION", "isinstance(node, ast.Return)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.return_node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Module" ], [ "CALL_FUNCTION", "isinstance(parent, (ast.FunctionDef, ast.Module))" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.body" ], [ "BINARY_SUBSCR", "parent.body[-1]" ], [ "COMPARE_OP", "node is parent.body[-1]" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_FAST", "exiting" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer._get_caller_stuff" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "tracer._get_caller_stuff(frame)" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_ATTR", "return_node.value" ], [ "LOAD_FAST", "exc_val" ], [ "UNARY_NOT", "not exc_val" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_values" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_ATTR", "return_node.value" ], [ "BINARY_SUBSCR", "frame_info.expression_values[return_node.value]" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.exit_call" ], [ "LOAD_GLOBAL", "ExitCallInfo" ], [ "LOAD_FAST", "call_node" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_FAST", "caller_frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "return_value" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "exc_tb" ], [ "CALL_FUNCTION", "ExitCallInfo(call_node,\n return_node,\n caller_frame,\n frame,\n return_value,\n exc_val,\n exc_tb\n )" ], [ "CALL_FUNCTION", "tracer.exit_call(ExitCallInfo(call_node,\n return_node,\n caller_frame,\n frame,\n return_value,\n exc_val,\n exc_tb\n ))" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.stack" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tracer" ], [ "LOAD_ATTR", "self.tracer.main_to_secondary_frames" ], [ "LOAD_ATTR", "self.tracer.main_to_secondary_frames.pop" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "self.tracer.main_to_secondary_frames.pop(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tracer" ], [ "LOAD_ATTR", "self.tracer.secondary_to_main_frames" ], [ "LOAD_FAST", "secondary_frame" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(parent, ast.FunctionDef)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "CALL_FUNCTION", "isinstance(parent, ast.For)" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.iter" ], [ "LOAD_DEREF", "node" ], [ "COMPARE_OP", "parent.iter is not node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "CALL_FUNCTION", "isinstance(parent, ast.While)" ], [ "LOAD_DEREF", "node" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.orelse" ], [ "COMPARE_OP", "node not in parent.orelse" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "CALL_FUNCTION", "isinstance(parent, ast.comprehension)" ], [ "LOAD_DEREF", "node" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.ifs" ], [ "COMPARE_OP", "node in parent.ifs" ], [ "LOAD_FAST", "is_containing_loop" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.append" ], [ "LOAD_FAST", "parent" ], [ "CALL_FUNCTION", "result.append(parent)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.ListComp" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.GeneratorExp" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.DictComp" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.SetComp" ], [ "CALL_FUNCTION", "isinstance(parent, (ast.ListComp,\n ast.GeneratorExp,\n ast.DictComp,\n ast.SetComp))" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.generators" ], [ "LOAD_DEREF", "node" ], [ "LOAD_FAST", "generators" ], [ "COMPARE_OP", "node in generators" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "takewhile" ], [ "LOAD_FAST", "generators" ], [ "CALL_FUNCTION", "takewhile(lambda n: n != node, generators)" ], [ "CALL_FUNCTION", "list(takewhile(lambda n: n != node, generators))" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.extend" ], [ "LOAD_GLOBAL", "reversed" ], [ "LOAD_FAST", "generators" ], [ "CALL_FUNCTION", "reversed(generators)" ], [ "CALL_FUNCTION", "result.extend(reversed(generators))" ], [ "LOAD_FAST", "parent" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.reverse" ], [ "CALL_FUNCTION", "result.reverse()" ], [ "LOAD_GLOBAL", "tuple" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "tuple(result)" ], [ "LOAD_FAST", "n" ], [ "LOAD_DEREF", "node" ], [ "COMPARE_OP", "n != node" ] ], "tracer2.py": [ [ "LOAD_NAME", "find_repr_function" ], [ "LOAD_NAME", "six" ], [ "LOAD_ATTR", "six.text_type" ], [ "CALL_FUNCTION", "find_repr_function(six.text_type)" ], [ "LOAD_NAME", "find_repr_function" ], [ "LOAD_NAME", "six" ], [ "LOAD_ATTR", "six.binary_type" ], [ "CALL_FUNCTION", "find_repr_function(six.binary_type)" ], [ "LOAD_NAME", "find_repr_function" ], [ "LOAD_NAME", "object" ], [ "CALL_FUNCTION", "find_repr_function(object)" ], [ "LOAD_NAME", "find_repr_function" ], [ "LOAD_NAME", "int" ], [ "CALL_FUNCTION", "find_repr_function(int)" ], [ "LOAD_NAME", "cheap_repr" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "threading" ], [ "LOAD_ATTR", "threading.local" ], [ "CALL_FUNCTION", "threading.local()" ], [ "LOAD_NAME", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.dirname" ], [ "LOAD_ATTR", "(lambda: 0).__code__" ], [ "LOAD_ATTR", "(lambda: 0).__code__.co_filename" ], [ "CALL_FUNCTION", "os.path.dirname((lambda: 0).__code__.co_filename)" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.dirname" ], [ "LOAD_NAME", "birdseye" ], [ "LOAD_ATTR", "birdseye.__file__" ], [ "CALL_FUNCTION", "os.path.dirname(birdseye.__file__)" ], [ "LOAD_NAME", "type" ], [ "LOAD_NAME", "six" ], [ "LOAD_ATTR", "six.add_metaclass" ], [ "LOAD_NAME", "TracerMeta" ], [ "CALL_FUNCTION", "six.add_metaclass(TracerMeta)" ], [ "LOAD_NAME", "object" ], [ "CALL_FUNCTION", "six.add_metaclass(TracerMeta)" ], [ "LOAD_NAME", "object" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lineno" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "CALL_FUNCTION", "OrderedDict()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_ATTR", "Source.for_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "Source.for_frame(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_flags" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.CO_GENERATOR" ], [ "BINARY_AND", "frame.f_code.co_flags & inspect.CO_GENERATOR" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "is_comprehension_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "is_comprehension_frame(frame)" ], [ "LOAD_GLOBAL", "re" ], [ "LOAD_ATTR", "re.match" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "CALL_FUNCTION", "re.match(r'<(\\w+)comp>', frame.f_code.co_name)" ], [ "LOAD_ATTR", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group" ], [ "CALL_FUNCTION", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group(1)" ], [ "LOAD_ATTR", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group(1).title" ], [ "CALL_FUNCTION", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group(1).title()" ], [ "BINARY_ADD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group(1).title()\n + u' comprehension'" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_lineno" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.local_reprs" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.get_local_reprs" ], [ "LOAD_FAST", "watch" ], [ "LOAD_FAST", "watch_extras" ], [ "CALL_FUNCTION", "self.get_local_reprs(watch, watch_extras)" ], [ "CALL_FUNCTION", "OrderedDict(\n (source, my_cheap_repr(value))\n for source, value in\n self.get_local_reprs(watch, watch_extras)\n )" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.comprehension_type" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.local_reprs" ], [ "LOAD_ATTR", "self.local_reprs.items" ], [ "CALL_FUNCTION", "self.local_reprs.items()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.comprehension_variables" ], [ "LOAD_ATTR", "self.comprehension_variables.setdefault" ], [ "LOAD_FAST", "name" ], [ "CALL_FUNCTION", "self.comprehension_variables.setdefault(name, [])" ], [ "LOAD_FAST", "values" ], [ "UNARY_NOT", "not values" ], [ "LOAD_FAST", "values" ], [ "BINARY_SUBSCR", "values[-1]" ], [ "LOAD_FAST", "value_repr" ], [ "COMPARE_OP", "values[-1] != value_repr" ], [ "LOAD_FAST", "values" ], [ "LOAD_ATTR", "values.append" ], [ "LOAD_FAST", "value_repr" ], [ "CALL_FUNCTION", "values.append(value_repr)" ], [ "LOAD_GLOBAL", "truncate_list" ], [ "LOAD_FAST", "values" ], [ "CALL_FUNCTION", "truncate_list(values, 11)" ], [ "LOAD_FAST", "values" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event in ('return', 'exception')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.comprehension_variables" ], [ "LOAD_ATTR", "self.comprehension_variables.items" ], [ "CALL_FUNCTION", "self.comprehension_variables.items()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.local_reprs" ], [ "LOAD_ATTR", "self.local_reprs.items" ], [ "CALL_FUNCTION", "self.local_reprs.items()" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "old_local_reprs" ], [ "COMPARE_OP", "name not in old_local_reprs" ], [ "LOAD_FAST", "old_local_reprs" ], [ "LOAD_FAST", "name" ], [ "BINARY_SUBSCR", "old_local_reprs[name]" ], [ "LOAD_FAST", "value_repr" ], [ "COMPARE_OP", "old_local_reprs[name] != value_repr" ], [ "LOAD_FAST", "variables" ], [ "LOAD_ATTR", "variables.append" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "value_repr" ], [ "CALL_FUNCTION", "variables.append((name, value_repr))" ], [ "LOAD_FAST", "variables" ], [ "LOAD_FAST", "source" ], [ "LOAD_GLOBAL", "my_cheap_repr" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "my_cheap_repr(value)" ], [ "LOAD_FAST", "name" ], [ "LOAD_ATTR", "', '.join" ], [ "LOAD_FAST", "values" ], [ "CALL_FUNCTION", "', '.join(values)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_varnames" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_cellvars" ], [ "BINARY_ADD", "code.co_varnames + code.co_cellvars" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_freevars" ], [ "BINARY_ADD", "code.co_varnames + code.co_cellvars + code.co_freevars" ], [ "LOAD_GLOBAL", "tuple" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "LOAD_ATTR", "frame.f_locals.keys" ], [ "CALL_FUNCTION", "frame.f_locals.keys()" ], [ "CALL_FUNCTION", "tuple(frame.f_locals.keys())" ], [ "BINARY_ADD", "code.co_varnames + code.co_cellvars + code.co_freevars + tuple(frame.f_locals.keys())" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "LOAD_ATTR", "frame.f_locals.items" ], [ "CALL_FUNCTION", "frame.f_locals.items()" ], [ "CALL_FUNCTION", "sorted(\n frame.f_locals.items(),\n key=lambda key_value: vars_order.index(key_value[0])\n )" ], [ "LOAD_FAST", "watch" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_FAST", "variable" ], [ "LOAD_ATTR", "variable.items" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "variable.items(frame)" ], [ "CALL_FUNCTION", "sorted(variable.items(frame))" ], [ "LOAD_FAST", "result_items" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "watch_extras" ], [ "LOAD_FAST", "extra" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "extra(source, value)" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_FAST", "pair" ], [ "COMPARE_OP", "pair is not None" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "pair" ], [ "CALL_FUNCTION", "len(pair)" ], [ "COMPARE_OP", "len(pair) == 2" ], [ "LOAD_FAST", "pair" ], [ "LOAD_DEREF", "vars_order" ], [ "LOAD_ATTR", "vars_order.index" ], [ "LOAD_FAST", "key_value" ], [ "BINARY_SUBSCR", "key_value[0]" ], [ "CALL_FUNCTION", "vars_order.index(key_value[0])" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "TracerMeta" ], [ "LOAD_FAST", "mcs" ], [ "CALL_FUNCTION", "super(TracerMeta, mcs)" ], [ "LOAD_ATTR", "super(TracerMeta, mcs).__new__" ], [ "LOAD_FAST", "mcs" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "super(TracerMeta, mcs).__new__(mcs, *args, **kwargs)" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "result()" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "no_args_decorator" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION", "no_args_decorator(args, kwargs)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_ATTR", "cls.default" ], [ "LOAD_FAST", "args" ], [ "BINARY_SUBSCR", "args[0]" ], [ "CALL_FUNCTION", "cls.default(args[0])" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "TracerMeta" ], [ "LOAD_FAST", "cls" ], [ "CALL_FUNCTION", "super(TracerMeta, cls)" ], [ "LOAD_ATTR", "super(TracerMeta, cls).__call__" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "super(TracerMeta, cls).__call__(*args, **kwargs)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.default" ], [ "LOAD_ATTR", "self.default.__enter__" ], [ "CALL_FUNCTION", "self.default.__enter__(context=1)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.default" ], [ "LOAD_ATTR", "self.default.__exit__" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION_VAR", "self.default.__exit__(*args, context=1)" ], [ "LOAD_GLOBAL", "ensure_tuple" ], [ "LOAD_FAST", "watch" ], [ "CALL_FUNCTION", "ensure_tuple(watch)" ], [ "LOAD_GLOBAL", "ensure_tuple" ], [ "LOAD_FAST", "watch_explode" ], [ "CALL_FUNCTION", "ensure_tuple(watch_explode)" ], [ "BINARY_ADD", "[\n v if isinstance(v, BaseVariable) else CommonVariable(v)\n for v in ensure_tuple(watch)\n ] + [\n v if isinstance(v, BaseVariable) else Exploding(v)\n for v in ensure_tuple(watch_explode)\n ]" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "ArgDefaultDict" ], [ "LOAD_GLOBAL", "FrameInfo" ], [ "CALL_FUNCTION", "ArgDefaultDict(FrameInfo)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "depth" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.depth" ], [ "COMPARE_OP", "self.depth >= 1" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "BaseVariable" ], [ "CALL_FUNCTION", "isinstance(v, BaseVariable)" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "CommonVariable" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "CommonVariable(v)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "BaseVariable" ], [ "CALL_FUNCTION", "isinstance(v, BaseVariable)" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "Exploding" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "Exploding(v)" ], [ "LOAD_GLOBAL", "iscoroutinefunction" ], [ "LOAD_DEREF", "function" ], [ "CALL_FUNCTION", "iscoroutinefunction(function)" ], [ "LOAD_GLOBAL", "NotImplementedError" ], [ "CALL_FUNCTION", "NotImplementedError(\"coroutines are not supported, sorry!\")" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.target_codes" ], [ "LOAD_ATTR", "self.target_codes.add" ], [ "LOAD_DEREF", "function" ], [ "LOAD_ATTR", "function.__code__" ], [ "CALL_FUNCTION", "self.target_codes.add(function.__code__)" ], [ "LOAD_GLOBAL", "functools" ], [ "LOAD_ATTR", "functools.wraps" ], [ "LOAD_DEREF", "function" ], [ "CALL_FUNCTION", "functools.wraps(function)" ], [ "CALL_FUNCTION", "functools.wraps(function)" ], [ "LOAD_GLOBAL", "functools" ], [ "LOAD_ATTR", "functools.wraps" ], [ "LOAD_DEREF", "function" ], [ "CALL_FUNCTION", "functools.wraps(function)" ], [ "CALL_FUNCTION", "functools.wraps(function)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.isgeneratorfunction" ], [ "LOAD_DEREF", "function" ], [ "CALL_FUNCTION", "inspect.isgeneratorfunction(function)" ], [ "LOAD_FAST", "generator_wrapper" ], [ "LOAD_FAST", "simple_wrapper" ], [ "LOAD_DEREF", "self" ], [ "LOAD_DEREF", "function" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "function(*args, **kwargs)" ], [ "LOAD_DEREF", "function" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "function(*args, **kwargs)" ], [ "LOAD_FAST", "gen" ], [ "LOAD_ATTR", "gen.send" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "method" ], [ "LOAD_FAST", "incoming" ], [ "CALL_FUNCTION", "method(incoming)" ], [ "LOAD_GLOBAL", "StopIteration" ], [ "LOAD_FAST", "gen" ], [ "LOAD_ATTR", "gen.send" ], [ "LOAD_FAST", "outgoing" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_FAST", "gen" ], [ "LOAD_ATTR", "gen.throw" ], [ "LOAD_FAST", "e" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.enabled" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys._getframe" ], [ "LOAD_FAST", "context" ], [ "BINARY_ADD", "context + 1" ], [ "CALL_FUNCTION", "sys._getframe(context + 1)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._is_internal_frame" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_FUNCTION", "self._is_internal_frame(calling_frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.trace" ], [ "LOAD_FAST", "calling_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.target_frames" ], [ "LOAD_ATTR", "self.target_frames.add" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_FUNCTION", "self.target_frames.add(calling_frame)" ], [ "LOAD_FAST", "calling_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.trace" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_FUNCTION", "self.trace(calling_frame, 'enter', None)" ], [ "LOAD_GLOBAL", "thread_global" ], [ "LOAD_ATTR", "thread_global.__dict__" ], [ "LOAD_ATTR", "thread_global.__dict__.setdefault" ], [ "CALL_FUNCTION", "thread_global.__dict__.setdefault('original_trace_functions', [])" ], [ "LOAD_FAST", "stack" ], [ "LOAD_ATTR", "stack.append" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.gettrace" ], [ "CALL_FUNCTION", "sys.gettrace()" ], [ "CALL_FUNCTION", "stack.append(sys.gettrace())" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.settrace" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.trace" ], [ "CALL_FUNCTION", "sys.settrace(self.trace)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.enabled" ], [ "LOAD_GLOBAL", "thread_global" ], [ "LOAD_ATTR", "thread_global.original_trace_functions" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.settrace" ], [ "LOAD_FAST", "stack" ], [ "LOAD_ATTR", "stack.pop" ], [ "CALL_FUNCTION", "stack.pop()" ], [ "CALL_FUNCTION", "sys.settrace(stack.pop())" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys._getframe" ], [ "LOAD_FAST", "context" ], [ "BINARY_ADD", "context + 1" ], [ "CALL_FUNCTION", "sys._getframe(context + 1)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.trace" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_FUNCTION", "self.trace(calling_frame, 'exit', None)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.target_frames" ], [ "LOAD_ATTR", "self.target_frames.discard" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_FUNCTION", "self.target_frames.discard(calling_frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame_infos" ], [ "LOAD_ATTR", "self.frame_infos.pop" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_FUNCTION", "self.frame_infos.pop(calling_frame, None)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_filename" ], [ "LOAD_ATTR", "frame.f_code.co_filename.startswith" ], [ "LOAD_GLOBAL", "internal_directories" ], [ "CALL_FUNCTION", "frame.f_code.co_filename.startswith(internal_directories)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.target_codes" ], [ "COMPARE_OP", "frame.f_code in self.target_codes" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.target_frames" ], [ "COMPARE_OP", "frame in self.target_frames" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._is_traced_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "self._is_traced_frame(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.depth" ], [ "COMPARE_OP", "self.depth == 1" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._is_internal_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "self._is_internal_frame(frame)" ], [ "LOAD_GLOBAL", "is_comprehension_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "is_comprehension_frame(frame)" ], [ "UNARY_NOT", "not is_comprehension_frame(frame)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_GLOBAL", "is_comprehension_frame" ], [ "LOAD_FAST", "candidate" ], [ "CALL_FUNCTION", "is_comprehension_frame(candidate)" ], [ "LOAD_FAST", "candidate" ], [ "LOAD_ATTR", "candidate.f_back" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._is_traced_frame" ], [ "LOAD_FAST", "candidate" ], [ "CALL_FUNCTION", "self._is_traced_frame(candidate)" ], [ "LOAD_FAST", "candidate" ], [ "LOAD_ATTR", "candidate.f_back" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.depth" ], [ "COMPARE_OP", "i >= self.depth" ], [ "LOAD_FAST", "candidate" ], [ "COMPARE_OP", "candidate is None" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._is_internal_frame" ], [ "LOAD_FAST", "candidate" ], [ "CALL_FUNCTION", "self._is_internal_frame(candidate)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.thread_local" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_ATTR", "thread_local.__dict__" ], [ "LOAD_ATTR", "thread_local.__dict__.setdefault" ], [ "CALL_FUNCTION", "thread_local.__dict__.setdefault('depth', -1)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame_infos" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.frame_infos[frame]" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event in ('call', 'enter')" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.last_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.last_frame" ], [ "LOAD_FAST", "frame" ], [ "COMPARE_OP", "self.config.last_frame is not frame" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.last_line_no" ], [ "LOAD_GLOBAL", "Event" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "event" ], [ "LOAD_FAST", "arg" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_ATTR", "thread_local.depth" ], [ "LOAD_FAST", "line_no" ], [ "CALL_FUNCTION", "Event(frame_info, event, arg, thread_local.depth, line_no=line_no)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.formatter" ], [ "LOAD_ATTR", "self.config.formatter.format_line_only" ], [ "LOAD_FAST", "trace_event" ], [ "CALL_FUNCTION", "self.config.formatter.format_line_only(trace_event)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.write" ], [ "LOAD_FAST", "line" ], [ "CALL_FUNCTION", "self.config.write(line)" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event == 'exception'" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_GLOBAL", "Event" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "event" ], [ "LOAD_FAST", "arg" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_ATTR", "thread_local.depth" ], [ "CALL_FUNCTION", "Event(frame_info, event, arg, thread_local.depth)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "COMPARE_OP", "frame.f_code.co_name == ''" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event not in ('return', 'exception')" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.update_variables" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.watch" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.watch_extras" ], [ "LOAD_FAST", "event" ], [ "CALL_FUNCTION", "frame_info.update_variables(\n self.watch,\n self.config.watch_extras,\n event,\n )" ], [ "LOAD_FAST", "trace_event" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event in ('return', 'exit')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame_infos" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.formatter" ], [ "LOAD_ATTR", "self.config.formatter.format" ], [ "LOAD_FAST", "trace_event" ], [ "CALL_FUNCTION", "self.config.formatter.format(trace_event)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.write" ], [ "LOAD_FAST", "formatted" ], [ "CALL_FUNCTION", "self.config.write(formatted)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.trace" ], [ "LOAD_FAST", "config" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "NO_ASTTOKENS" ], [ "LOAD_GLOBAL", "Exception" ], [ "CALL_FUNCTION", "Exception(\"birdseye doesn't support this version of Python\")" ], [ "LOAD_GLOBAL", "ImportError" ], [ "LOAD_GLOBAL", "Exception" ], [ "CALL_FUNCTION", "Exception(\"You must install birdseye separately to use spy: pip install birdseye\")" ], [ "LOAD_GLOBAL", "no_args_decorator" ], [ "LOAD_DEREF", "args" ], [ "LOAD_DEREF", "kwargs" ], [ "CALL_FUNCTION", "no_args_decorator(args, kwargs)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._trace" ], [ "LOAD_DEREF", "args" ], [ "BINARY_SUBSCR", "args[0]" ], [ "CALL_FUNCTION", "self._trace(args[0])" ], [ "LOAD_FAST", "decorator" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._trace" ], [ "LOAD_FAST", "func" ], [ "LOAD_DEREF", "args" ], [ "LOAD_DEREF", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "self._trace(func, *args, **kwargs)" ], [ "LOAD_FAST", "eye" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "eye(func)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.snoop" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "self.config.snoop(*args, **kwargs)" ], [ "LOAD_DEREF", "traced" ], [ "CALL_FUNCTION", "self.config.snoop(*args, **kwargs)(traced)" ], [ "LOAD_GLOBAL", "functools" ], [ "LOAD_ATTR", "functools.wraps" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "LOAD_FAST", "wrapper" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.enabled" ], [ "LOAD_DEREF", "traced" ], [ "LOAD_DEREF", "func" ], [ "LOAD_FAST", "final_func" ], [ "LOAD_FAST", "func_args" ], [ "LOAD_FAST", "func_kwargs" ], [ "CALL_FUNCTION_VAR_KW", "final_func(*func_args, **func_kwargs)" ] ], "utils.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOAD_ATTR", "standard_library.install_aliases" ], [ "CALL_FUNCTION", "standard_library.install_aliases()" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "type" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "version_info" ], [ "LOAD_ATTR", "version_info.major" ], [ "COMPARE_OP", "version_info.major == 2" ], [ "LOAD_NAME", "PY2" ], [ "UNARY_NOT", "not PY2" ], [ "LOAD_NAME", "TypeVar" ], [ "CALL_FUNCTION", "TypeVar('T')" ], [ "LOAD_NAME", "TypeVar" ], [ "CALL_FUNCTION", "TypeVar('RT')" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "unicode" ], [ "LOAD_NAME", "str" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "type" ], [ "LOAD_NAME", "json" ], [ "LOAD_ATTR", "json.JSONEncoder" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_GLOBAL", "ntpath" ], [ "LOAD_ATTR", "ntpath.split" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "ntpath.split(path)" ], [ "LOAD_FAST", "tail" ], [ "LOAD_GLOBAL", "ntpath" ], [ "LOAD_ATTR", "ntpath.basename" ], [ "LOAD_FAST", "head" ], [ "CALL_FUNCTION", "ntpath.basename(head)" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.commonprefix" ], [ "LOAD_FAST", "paths" ], [ "CALL_FUNCTION", "os.path.commonprefix(paths)" ], [ "LOAD_GLOBAL", "ntpath" ], [ "LOAD_ATTR", "ntpath.split" ], [ "LOAD_FAST", "prefix" ], [ "CALL_FUNCTION", "ntpath.split(prefix)" ], [ "BINARY_SUBSCR", "ntpath.split(prefix)[0]" ], [ "LOAD_FAST", "paths" ], [ "BINARY_SUBSCR", "paths[0]" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "prefix" ], [ "CALL_FUNCTION", "len(prefix)" ], [ "BINARY_SUBSCR", "paths[0][len(prefix)]" ], [ "LOAD_FAST", "first_char_after" ], [ "COMPARE_OP", "first_char_after in r'\\/'" ], [ "LOAD_FAST", "first_char_after" ], [ "LOAD_FAST", "prefix" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "COMPARE_OP", "path == IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "all_paths" ], [ "LOAD_GLOBAL", "common_ancestor" ], [ "LOAD_FAST", "all_paths" ], [ "CALL_FUNCTION", "common_ancestor(all_paths)" ], [ "LOAD_FAST", "prefix" ], [ "COMPARE_OP", "prefix in r'\\/'" ], [ "LOAD_GLOBAL", "strip_required_prefix" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "prefix" ], [ "CALL_FUNCTION", "strip_required_prefix(path, prefix)" ], [ "LOAD_GLOBAL", "path_leaf" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "path_leaf(path)" ], [ "LOAD_FAST", "f" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "COMPARE_OP", "f != IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "f" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "COMPARE_OP", "path == IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.sep" ], [ "COMPARE_OP", "os.path.sep == '/'" ], [ "LOAD_FAST", "path" ], [ "LOAD_ATTR", "path.startswith" ], [ "CALL_FUNCTION", "path.startswith('/')" ], [ "UNARY_NOT", "not path.startswith('/')" ], [ "LOAD_FAST", "path" ], [ "BINARY_ADD", "'/' + path" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "type" ], [ "LOAD_FAST", "obj" ], [ "CALL_FUNCTION", "type(obj)" ], [ "LOAD_FAST", "t" ], [ "LOAD_GLOBAL", "types" ], [ "LOAD_ATTR", "types.InstanceType" ], [ "COMPARE_OP", "t is types.InstanceType" ], [ "LOAD_FAST", "obj" ], [ "LOAD_ATTR", "obj.__class__" ], [ "LOAD_FAST", "t" ], [ "LOAD_FAST", "iterable" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_DEREF", "type_or_tuple" ], [ "CALL_FUNCTION", "isinstance(x, type_or_tuple)" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "next" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "next(it)" ], [ "LOAD_GLOBAL", "StopIteration" ], [ "LOAD_GLOBAL", "raise_from" ], [ "LOAD_GLOBAL", "RuntimeError" ], [ "LOAD_FAST", "e" ], [ "CALL_FUNCTION", "raise_from(RuntimeError, e)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "expression" ], [ "CALL_FUNCTION", "hasattr(expression, 'one_or_none')" ], [ "LOAD_FAST", "expression" ], [ "LOAD_ATTR", "expression.one_or_none" ], [ "CALL_FUNCTION", "expression.one_or_none()" ], [ "LOAD_FAST", "expression" ], [ "LOAD_ATTR", "expression.all" ], [ "CALL_FUNCTION", "expression.all()" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "len(result)" ], [ "COMPARE_OP", "len(result) == 0" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "len(result)" ], [ "COMPARE_OP", "len(result) == 1" ], [ "LOAD_FAST", "result" ], [ "BINARY_SUBSCR", "result[0]" ], [ "LOAD_GLOBAL", "Exception" ], [ "CALL_FUNCTION", "Exception(\"There is more than one item returned for the supplied filter\")" ], [ "LOAD_FAST", "lst" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "isinstance(x, list)" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.extend" ], [ "LOAD_GLOBAL", "flatten_list" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "flatten_list(x)" ], [ "CALL_FUNCTION", "result.extend(flatten_list(x))" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.append" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "result.append(x)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "f" ], [ "LOAD_ATTR", "f.__code__" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "LOAD_ATTR", "(lambda: 0).__code__" ], [ "LOAD_ATTR", "(lambda: 0).__code__.co_name" ], [ "COMPARE_OP", "code.co_name == (lambda: 0).__code__.co_name" ], [ "LOAD_FAST", "o" ], [ "LOAD_ATTR", "o.as_json" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "ProtocolEncoder" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(ProtocolEncoder, self)" ], [ "LOAD_ATTR", "super(ProtocolEncoder, self).default" ], [ "LOAD_FAST", "o" ], [ "CALL_FUNCTION", "super(ProtocolEncoder, self).default(o)" ], [ "LOAD_FAST", "method" ], [ "CALL_FUNCTION", "method()" ], [ "LOAD_GLOBAL", "io" ], [ "LOAD_ATTR", "io.open" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "io.open(filename, 'rb')" ], [ "LOAD_GLOBAL", "detect_encoding" ], [ "LOAD_FAST", "fp" ], [ "LOAD_ATTR", "fp.readline" ], [ "CALL_FUNCTION", "detect_encoding(fp.readline)" ], [ "LOAD_FAST", "fp" ], [ "LOAD_ATTR", "fp.seek" ], [ "CALL_FUNCTION", "fp.seek(0)" ], [ "LOAD_GLOBAL", "io" ], [ "LOAD_ATTR", "io.TextIOWrapper" ], [ "LOAD_FAST", "fp" ], [ "LOAD_FAST", "encoding" ], [ "CALL_FUNCTION", "io.TextIOWrapper(fp, encoding, line_buffering=True)" ], [ "LOAD_FAST", "text" ], [ "LOAD_FAST", "text" ], [ "LOAD_FAST", "fp" ], [ "LOAD_ATTR", "fp.close" ], [ "CALL_FUNCTION", "fp.close()" ], [ "LOAD_FAST", "filename" ], [ "LOAD_ATTR", "filename.endswith" ], [ "CALL_FUNCTION", "filename.endswith('.pyc')" ], [ "LOAD_FAST", "filename" ], [ "BINARY_SUBSCR", "filename[:-1]" ], [ "LOAD_GLOBAL", "open_with_encoding_check" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "open_with_encoding_check(filename)" ], [ "LOAD_ATTR", "''.join" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "f" ], [ "CALL_FUNCTION", "enumerate(f)" ], [ "CALL_FUNCTION", "''.join([\n '\\n' if i < 2 and cookie_re.match(line)\n else line\n for i, line in enumerate(f)\n ])" ], [ "LOAD_FAST", "i" ], [ "COMPARE_OP", "i < 2" ], [ "LOAD_DEREF", "cookie_re" ], [ "LOAD_ATTR", "cookie_re.match" ], [ "LOAD_FAST", "line" ], [ "CALL_FUNCTION", "cookie_re.match(line)" ], [ "LOAD_FAST", "line" ], [ "LOAD_GLOBAL", "safe_next" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_ATTR", "tokens.get_tokens" ], [ "LOAD_FAST", "function_node" ], [ "CALL_FUNCTION", "tokens.get_tokens(function_node)" ], [ "CALL_FUNCTION", "safe_next(t for t in tokens.get_tokens(function_node)\n if t.string == 'def' and t.type == token.NAME)" ], [ "LOAD_FAST", "def_token" ], [ "LOAD_ATTR", "def_token.startpos" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_ATTR", "tokens.text" ], [ "LOAD_FAST", "startpos" ], [ "LOAD_FAST", "function_node" ], [ "LOAD_ATTR", "function_node.last_token" ], [ "LOAD_ATTR", "function_node.last_token.endpos" ], [ "BINARY_SUBSCR", "tokens.text[startpos:function_node.last_token.endpos]" ], [ "LOAD_ATTR", "tokens.text[startpos:function_node.last_token.endpos].rstrip" ], [ "CALL_FUNCTION", "tokens.text[startpos:function_node.last_token.endpos].rstrip()" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.startswith" ], [ "CALL_FUNCTION", "source.startswith('def')" ], [ "LOAD_FAST", "startpos" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "t" ], [ "LOAD_ATTR", "t.string" ], [ "COMPARE_OP", "t.string == 'def'" ], [ "LOAD_FAST", "t" ], [ "LOAD_ATTR", "t.type" ], [ "LOAD_GLOBAL", "token" ], [ "LOAD_ATTR", "token.NAME" ], [ "COMPARE_OP", "t.type == token.NAME" ], [ "LOAD_FAST", "t" ], [ "LOAD_FAST", "args" ], [ "LOAD_GLOBAL", "print" ], [ "LOAD_FAST", "arg" ], [ "CALL_FUNCTION", "print(arg)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION", "len(args)" ], [ "COMPARE_OP", "len(args) == 1" ], [ "LOAD_FAST", "args" ], [ "BINARY_SUBSCR", "args[0]" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "filename" ], [ "LOAD_ATTR", "filename.startswith" ], [ "CALL_FUNCTION", "filename.startswith(' max_length" ], [ "LOAD_FAST", "max_length" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "middle" ], [ "CALL_FUNCTION", "len(middle)" ], [ "BINARY_SUBTRACT", "max_length - len(middle)" ], [ "BINARY_FLOOR_DIVIDE", "(max_length - len(middle)) // 2" ], [ "LOAD_FAST", "max_length" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "middle" ], [ "CALL_FUNCTION", "len(middle)" ], [ "BINARY_SUBTRACT", "max_length - len(middle)" ], [ "LOAD_FAST", "left" ], [ "BINARY_SUBTRACT", "max_length - len(middle) - left" ], [ "LOAD_FAST", "seq" ], [ "LOAD_FAST", "left" ], [ "BINARY_SUBSCR", "seq[:left]" ], [ "LOAD_FAST", "middle" ], [ "BINARY_ADD", "seq[:left] + middle" ], [ "LOAD_FAST", "seq" ], [ "LOAD_FAST", "right" ], [ "UNARY_NEGATIVE", "-right" ], [ "BINARY_SUBSCR", "seq[-right:]" ], [ "BINARY_ADD", "seq[:left] + middle + seq[-right:]" ], [ "LOAD_FAST", "seq" ], [ "LOAD_GLOBAL", "truncate" ], [ "LOAD_FAST", "string" ], [ "LOAD_FAST", "max_length" ], [ "CALL_FUNCTION", "truncate(string, max_length, '...')" ], [ "LOAD_GLOBAL", "truncate" ], [ "LOAD_FAST", "lst" ], [ "LOAD_FAST", "max_length" ], [ "CALL_FUNCTION", "truncate(lst, max_length, ['...'])" ], [ "LOAD_FAST", "split" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "six" ], [ "LOAD_ATTR", "six.string_types" ], [ "CALL_FUNCTION", "isinstance(x, six.string_types)" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.replace" ], [ "CALL_FUNCTION", "x.replace(',', ' ')" ], [ "LOAD_ATTR", "x.replace(',', ' ').split" ], [ "CALL_FUNCTION", "x.replace(',', ' ').split()" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "set" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "isinstance(x, (list, set, tuple))" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "tuple" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tuple(x)" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.basename" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_filename" ], [ "CALL_FUNCTION", "os.path.basename(code.co_filename)" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.endswith" ], [ "CALL_FUNCTION", "result.endswith('.pyc')" ], [ "LOAD_FAST", "result" ], [ "BINARY_SUBSCR", "result[:-1]" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "COMPARE_OP", "frame.f_code.co_name in ('', '', '')" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "code('{}.x')" ], [ "LOAD_GLOBAL", "SyntaxError" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "code('({})')" ], [ "LOAD_FAST", "without_parens" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "code('({}).x')" ], [ "COMPARE_OP", "without_parens != code('({}).x')" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "s" ], [ "LOAD_ATTR", "s.format" ], [ "LOAD_DEREF", "source" ], [ "CALL_FUNCTION", "s.format(source)" ], [ "CALL_FUNCTION", "compile(s.format(source), '', 'eval')" ], [ "LOAD_ATTR", "compile(s.format(source), '', 'eval').co_code" ], [ "LOAD_GLOBAL", "needs_parentheses" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "needs_parentheses(source)" ], [ "LOAD_ATTR", "'({})'.format" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "'({})'.format(source)" ], [ "LOAD_FAST", "source" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "REPR_TARGET_LENGTH" ], [ "CALL_FUNCTION", "cheap_repr(x, target_length=REPR_TARGET_LENGTH)" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "ArgDefaultDict" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(ArgDefaultDict, self)" ], [ "LOAD_ATTR", "super(ArgDefaultDict, self).__init__" ], [ "CALL_FUNCTION", "super(ArgDefaultDict, self).__init__()" ], [ "LOAD_FAST", "factory" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.factory" ], [ "LOAD_FAST", "key" ], [ "CALL_FUNCTION", "self.factory(key)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "key" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "lst" ], [ "CALL_FUNCTION", "len(lst)" ], [ "COMPARE_OP", "len(lst) == 1" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "CALL_FUNCTION", "str(i + 1)" ], [ "BINARY_ADD", "' ' + str(i + 1)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_GLOBAL", "os" ], [ "CALL_FUNCTION", "hasattr(os, 'PathLike')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.PathLike" ], [ "CALL_FUNCTION", "isinstance(x, os.PathLike)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "hasattr(x, '__fspath__')" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "hasattr(x, 'open')" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.__class__" ], [ "LOAD_ATTR", "x.__class__.__name__" ], [ "LOAD_ATTR", "x.__class__.__name__.lower" ], [ "CALL_FUNCTION", "x.__class__.__name__.lower()" ], [ "COMPARE_OP", "'path' in x.__class__.__name__.lower()" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION", "len(args)" ], [ "COMPARE_OP", "len(args) == 1" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.isfunction" ], [ "LOAD_FAST", "args" ], [ "BINARY_SUBSCR", "args[0]" ], [ "CALL_FUNCTION", "inspect.isfunction(args[0])" ], [ "LOAD_FAST", "kwargs" ], [ "UNARY_NOT", "not kwargs" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_ADD", "max_length + 2" ], [ "COMPARE_OP", "length <= max_length + 2" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "range(length)" ], [ "LOAD_GLOBAL", "chain" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_FLOOR_DIVIDE", "max_length // 2" ], [ "CALL_FUNCTION", "range(max_length // 2)" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_FLOOR_DIVIDE", "max_length // 2" ], [ "BINARY_SUBTRACT", "length - max_length // 2" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "range(length - max_length // 2,\n length)" ], [ "CALL_FUNCTION", "chain(range(max_length // 2),\n range(length - max_length // 2,\n length))" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "len(x)" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "n == 0" ], [ "LOAD_GLOBAL", "repr" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "repr(x)" ], [ "LOAD_FAST", "helper" ], [ "LOAD_ATTR", "helper.level" ], [ "BINARY_SUBTRACT", "helper.level - 1" ], [ "LOAD_GLOBAL", "_repr_series_one_line" ], [ "LOAD_ATTR", "_repr_series_one_line.maxparts" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "n" ], [ "LOAD_FAST", "maxparts" ], [ "CALL_FUNCTION", "_sample_indices(n, maxparts)" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.index" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "x.index[i:i + 1]" ], [ "LOAD_ATTR", "x.index[i:i + 1].format" ], [ "CALL_FUNCTION", "x.index[i:i + 1].format(sparsify=False)" ], [ "BINARY_SUBSCR", "x.index[i:i + 1].format(sparsify=False)[0]" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.iloc" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "x.iloc[i]" ], [ "LOAD_FAST", "pieces" ], [ "LOAD_ATTR", "pieces.append" ], [ "LOAD_FAST", "k" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "v" ], [ "LOAD_FAST", "newlevel" ], [ "CALL_FUNCTION", "cheap_repr(v, newlevel)" ], [ "BINARY_MODULO", "'%s = %s' % (k, cheap_repr(v, newlevel))" ], [ "CALL_FUNCTION", "pieces.append('%s = %s' % (k, cheap_repr(v, newlevel)))" ], [ "LOAD_FAST", "n" ], [ "LOAD_FAST", "maxparts" ], [ "BINARY_ADD", "maxparts + 2" ], [ "COMPARE_OP", "n > maxparts + 2" ], [ "LOAD_FAST", "pieces" ], [ "LOAD_ATTR", "pieces.insert" ], [ "LOAD_FAST", "maxparts" ], [ "BINARY_FLOOR_DIVIDE", "maxparts // 2" ], [ "CALL_FUNCTION", "pieces.insert(maxparts // 2, '...')" ], [ "LOAD_ATTR", "'; '.join" ], [ "LOAD_FAST", "pieces" ], [ "CALL_FUNCTION", "'; '.join(pieces)" ] ] }executing-0.8.0/tests/sample_results/3.5.json000066400000000000000000021436761410133640400211350ustar00rootroot00000000000000{ "bird.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOAD_ATTR", "standard_library.install_aliases" ], [ "CALL_FUNCTION", "standard_library.install_aliases()" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "warn_if_outdated" ], [ "LOAD_NAME", "__version__" ], [ "CALL_FUNCTION", "warn_if_outdated('birdseye', __version__)" ], [ "LOAD_NAME", "namedtuple" ], [ "CALL_FUNCTION", "namedtuple('CodeInfo', 'db_func traced_file arg_names')" ], [ "LOAD_NAME", "TreeTracerBase" ], [ "LOAD_NAME", "BirdsEye" ], [ "CALL_FUNCTION", "BirdsEye()" ], [ "LOAD_NAME", "NamedTuple" ], [ "LOAD_NAME", "int" ], [ "LOAD_NAME", "bool" ], [ "LOAD_NAME", "int" ], [ "LOAD_NAME", "str" ], [ "CALL_FUNCTION", "NamedTuple('HTMLPosition', [\n ('index', int),\n ('is_start', bool),\n ('depth', int),\n ('html', str),\n])" ], [ "LOAD_NAME", "eye" ], [ "LOAD_ATTR", "eye.enter_call" ], [ "LOAD_ATTR", "eye.enter_call.__code__" ], [ "LOAD_NAME", "eye" ], [ "LOAD_ATTR", "eye.exit_call" ], [ "LOAD_ATTR", "eye.exit_call.__code__" ], [ "LOAD_NAME", "eye" ], [ "LOAD_ATTR", "eye.after_expr" ], [ "LOAD_ATTR", "eye.after_expr.__code__" ], [ "LOAD_NAME", "eye" ], [ "LOAD_ATTR", "eye.after_stmt" ], [ "LOAD_ATTR", "eye.after_stmt.__code__" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "Iterable" ], [ "LOAD_NAME", "Iteration" ], [ "BINARY_SUBSCR", "Iterable[Iteration]" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "TypeRegistry" ], [ "CALL_FUNCTION", "TypeRegistry()" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "try_register_repr" ], [ "CALL_FUNCTION", "try_register_repr('pandas', 'Series')" ], [ "CALL_FUNCTION", "try_register_repr('pandas', 'Series')" ], [ "LOAD_NAME", "cached_property" ], [ "CALL_FUNCTION", "cached_property" ], [ "LOAD_NAME", "lru_cache" ], [ "CALL_FUNCTION", "lru_cache()" ], [ "CALL_FUNCTION", "lru_cache()" ], [ "LOAD_NAME", "retry_db" ], [ "CALL_FUNCTION", "retry_db" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "BirdsEye" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(BirdsEye, self)" ], [ "LOAD_ATTR", "super(BirdsEye, self).__init__" ], [ "CALL_FUNCTION", "super(BirdsEye, self).__init__()" ], [ "LOAD_FAST", "db_uri" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "num_samples" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "dict" ], [ "CALL_FUNCTION", "dict(\n attributes=50,\n dict=50,\n list=30,\n set=30,\n pandas_rows=20,\n pandas_cols=100,\n )" ], [ "LOAD_GLOBAL", "dict" ], [ "CALL_FUNCTION", "dict(\n attributes=50,\n dict=10,\n list=6,\n set=6,\n pandas_rows=6,\n pandas_cols=10,\n )" ], [ "CALL_FUNCTION", "dict(\n big=dict(\n attributes=50,\n dict=50,\n list=30,\n set=30,\n pandas_rows=20,\n pandas_cols=100,\n ),\n small=dict(\n attributes=50,\n dict=10,\n list=6,\n set=6,\n pandas_rows=6,\n pandas_cols=10,\n ),\n )" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "Database" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._db_uri" ], [ "CALL_FUNCTION", "Database(self._db_uri)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.walk" ], [ "LOAD_FAST", "root" ], [ "CALL_FUNCTION", "ast.walk(root)" ], [ "LOAD_GLOBAL", "tracer" ], [ "LOAD_ATTR", "tracer.loops" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "tracer.loops(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "CALL_FUNCTION", "isinstance(node, ast.expr)" ], [ "LOAD_GLOBAL", "is_interesting_expression" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "is_interesting_expression(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "BirdsEye" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(BirdsEye, self)" ], [ "LOAD_ATTR", "super(BirdsEye, self).compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "flags" ], [ "CALL_FUNCTION", "super(BirdsEye, self).compile(source, filename, flags)" ], [ "LOAD_GLOBAL", "ASTTokens" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.root" ], [ "CALL_FUNCTION", "ASTTokens(source, tree=traced_file.root)" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.For)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.body" ], [ "BINARY_SUBSCR", "node.parent.body[0]" ], [ "COMPARE_OP", "node is node.parent.body[0]" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._add_iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "self._add_iteration(node._loops, frame)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.While)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.test" ], [ "COMPARE_OP", "node is node.parent.test" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._add_iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "self._add_iteration(node._loops, frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_ATTR", "self.stack[frame].iteration" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "loops" ], [ "CALL_FUNCTION", "enumerate(loops)" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.loops" ], [ "LOAD_FAST", "loop_node" ], [ "LOAD_ATTR", "loop_node._tree_index" ], [ "BINARY_SUBSCR", "iteration.loops[loop_node._tree_index]" ], [ "LOAD_FAST", "i" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "loops" ], [ "CALL_FUNCTION", "len(loops)" ], [ "BINARY_SUBTRACT", "len(loops) - 1" ], [ "COMPARE_OP", "i == len(loops) - 1" ], [ "LOAD_FAST", "loop" ], [ "LOAD_ATTR", "loop.append" ], [ "LOAD_GLOBAL", "Iteration" ], [ "CALL_FUNCTION", "Iteration()" ], [ "CALL_FUNCTION", "loop.append(Iteration())" ], [ "LOAD_FAST", "loop" ], [ "LOAD_ATTR", "loop.last" ], [ "CALL_FUNCTION", "loop.last()" ], [ "LOAD_GLOBAL", "_tracing_recursively" ], [ "LOAD_DEREF", "frame" ], [ "CALL_FUNCTION", "_tracing_recursively(frame)" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._is_interesting_expression" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "BINARY_SUBSCR", "self._code_infos[frame.f_code]" ], [ "LOAD_ATTR", "self._code_infos[frame.f_code].traced_file" ], [ "LOAD_ATTR", "self._code_infos[frame.f_code].traced_file.is_ipython_cell" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Expr" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.Expr)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.parent" ], [ "LOAD_ATTR", "node.parent.parent.body" ], [ "BINARY_SUBSCR", "node.parent.parent.body[-1]" ], [ "COMPARE_OP", "node.parent is node.parent.parent.body[-1]" ], [ "LOAD_DEREF", "value" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "is_obvious_builtin" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_DEREF", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_ATTR", "self.stack[frame].expression_values" ], [ "LOAD_FAST", "node" ], [ "BINARY_SUBSCR", "self.stack[frame].expression_values[node]" ], [ "CALL_FUNCTION", "is_obvious_builtin(node, self.stack[frame].expression_values[node])" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_DEREF", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_FAST", "exc_value" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._exception_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_FAST", "exc_value" ], [ "CALL_FUNCTION", "self._exception_value(node, frame, exc_value)" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOAD_ATTR", "NodeValue.expression" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.num_samples" ], [ "LOAD_DEREF", "value" ], [ "LOAD_GLOBAL", "max" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "CALL_FUNCTION", "len(node._loops)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._is_first_loop_iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "frame" ], [ "CALL_FUNCTION", "self._is_first_loop_iteration(node, frame)" ], [ "UNARY_NOT", "not self._is_first_loop_iteration(node, frame)" ], [ "BINARY_MULTIPLY", "len(node._loops) * (not self._is_first_loop_iteration(node, frame))" ], [ "BINARY_SUBTRACT", "3 - len(node._loops) * (not self._is_first_loop_iteration(node, frame))" ], [ "CALL_FUNCTION", "max(1, 3 - len(node._loops) * (not self._is_first_loop_iteration(node, frame)))" ], [ "CALL_FUNCTION", "NodeValue.expression(\n self.num_samples,\n value,\n level=max(1, 3 - len(node._loops) * (not self._is_first_loop_iteration(node, frame))),\n )" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._set_node_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_FAST", "node_value" ], [ "CALL_FUNCTION", "self._set_node_value(node, frame, node_value)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._check_inner_call" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node_value" ], [ "CALL_FUNCTION", "self._check_inner_call(frame_info, node, node_value)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.comprehension)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.iter" ], [ "COMPARE_OP", "node is node.parent.iter" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.GeneratorExp" ], [ "CALL_FUNCTION", "isinstance(node.parent.parent, ast.GeneratorExp)" ], [ "UNARY_NOT", "not isinstance(node.parent.parent, ast.GeneratorExp)" ], [ "LOAD_FAST", "is_special_comprehension_iter" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._set_node_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOAD_ATTR", "NodeValue.covered" ], [ "CALL_FUNCTION", "NodeValue.covered()" ], [ "CALL_FUNCTION", "self._set_node_value(node.parent, frame, NodeValue.covered())" ], [ "LOAD_FAST", "exc_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "BINARY_ADD", "node._loops + (node.parent,)" ], [ "LOAD_GLOBAL", "ChangeValue" ], [ "LOAD_FAST", "comprehension_iter_proxy" ], [ "CALL_FUNCTION", "comprehension_iter_proxy()" ], [ "CALL_FUNCTION", "ChangeValue(comprehension_iter_proxy())" ], [ "LOAD_DEREF", "value" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._add_iteration" ], [ "LOAD_DEREF", "loops" ], [ "LOAD_DEREF", "frame" ], [ "CALL_FUNCTION", "self._add_iteration(loops, frame)" ], [ "LOAD_FAST", "item" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.inner_calls" ], [ "LOAD_ATTR", "frame_info.inner_calls.pop" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "frame_info.inner_calls.pop(node, None)" ], [ "LOAD_FAST", "inner_calls" ], [ "LOAD_FAST", "node_value" ], [ "LOAD_ATTR", "node_value.set_meta" ], [ "LOAD_FAST", "inner_calls" ], [ "CALL_FUNCTION", "node_value.set_meta('inner_calls', inner_calls)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_ATTR", "self.stack[frame].iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.loops" ], [ "LOAD_FAST", "loop_node" ], [ "LOAD_ATTR", "loop_node._tree_index" ], [ "BINARY_SUBSCR", "iteration.loops[loop_node._tree_index]" ], [ "LOAD_FAST", "loop" ], [ "LOAD_ATTR", "loop.last" ], [ "CALL_FUNCTION", "loop.last()" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.index" ], [ "COMPARE_OP", "iteration.index > 0" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_ATTR", "self.stack[frame].iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.loops" ], [ "LOAD_FAST", "loop_node" ], [ "LOAD_ATTR", "loop_node._tree_index" ], [ "BINARY_SUBSCR", "iteration.loops[loop_node._tree_index]" ], [ "LOAD_FAST", "loop" ], [ "LOAD_ATTR", "loop.recorded_node" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "loop.recorded_node(node)" ], [ "LOAD_FAST", "loop" ], [ "LOAD_ATTR", "loop.last" ], [ "CALL_FUNCTION", "loop.last()" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.vals" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOAD_ATTR", "NodeValue.exception" ], [ "LOAD_FAST", "exc_value" ], [ "CALL_FUNCTION", "NodeValue.exception(exc_value)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._set_node_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "self._set_node_value(node, frame, value)" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_GLOBAL", "_tracing_recursively" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "_tracing_recursively(frame)" ], [ "LOAD_FAST", "exc_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "exc_node" ], [ "COMPARE_OP", "node is exc_node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._exception_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "exc_value" ], [ "CALL_FUNCTION", "self._exception_value(node, frame, exc_value)" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOAD_ATTR", "NodeValue.covered" ], [ "CALL_FUNCTION", "NodeValue.covered()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._set_node_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "self._set_node_value(node, frame, value)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._check_inner_call" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "self._check_inner_call(self.stack[frame], node, value)" ], [ "LOAD_FAST", "enter_info" ], [ "LOAD_ATTR", "enter_info.current_frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_GLOBAL", "_tracing_recursively" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "_tracing_recursively(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_GLOBAL", "get_unfrozen_datetime" ], [ "CALL_FUNCTION", "get_unfrozen_datetime()" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_GLOBAL", "Iteration" ], [ "CALL_FUNCTION", "Iteration()" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "BINARY_SUBSCR", "self._code_infos[frame.f_code]" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "enter_info" ], [ "LOAD_ATTR", "enter_info.enter_node" ], [ "LOAD_ATTR", "enter_info.enter_node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Module" ], [ "CALL_FUNCTION", "isinstance(enter_info.enter_node.parent, ast.Module)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "LOAD_ATTR", "frame.f_locals.copy" ], [ "CALL_FUNCTION", "frame.f_locals.copy()" ], [ "LOAD_FAST", "code_info" ], [ "LOAD_ATTR", "code_info.arg_names" ], [ "LOAD_DEREF", "f_locals" ], [ "LOAD_ATTR", "f_locals.items" ], [ "CALL_FUNCTION", "f_locals.items()" ], [ "BINARY_ADD", "[(name, f_locals.pop(name))\n for name in code_info.arg_names\n if name] + [\n\n # Local variables other than actual arguments. These are variables from\n # the enclosing scope. It's handy to treat them like arguments in the UI\n it for it in f_locals.items()\n if it[0][0] != '.' # Appears when using nested tuple arguments\n ]" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_ATTR", "json.dumps" ], [ "LOAD_FAST", "arguments" ], [ "CALL_FUNCTION", "json.dumps([[k, cheap_repr(v)] for k, v in arguments])" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._call_id" ], [ "CALL_FUNCTION", "self._call_id()" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "defaultdict(list)" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_ATTR", "self.stack.get" ], [ "LOAD_FAST", "enter_info" ], [ "LOAD_ATTR", "enter_info.caller_frame" ], [ "CALL_FUNCTION", "self.stack.get(enter_info.caller_frame)" ], [ "LOAD_FAST", "prev" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "prev" ], [ "CALL_FUNCTION", "getattr(prev, 'inner_calls', None)" ], [ "LOAD_FAST", "inner_calls" ], [ "COMPARE_OP", "inner_calls is not None" ], [ "LOAD_FAST", "inner_calls" ], [ "LOAD_FAST", "enter_info" ], [ "LOAD_ATTR", "enter_info.call_node" ], [ "BINARY_SUBSCR", "inner_calls[enter_info.call_node]" ], [ "LOAD_ATTR", "inner_calls[enter_info.call_node].append" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.call_id" ], [ "CALL_FUNCTION", "inner_calls[enter_info.call_node].append(frame_info.call_id)" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "name" ], [ "LOAD_DEREF", "f_locals" ], [ "LOAD_ATTR", "f_locals.pop" ], [ "LOAD_FAST", "name" ], [ "CALL_FUNCTION", "f_locals.pop(name)" ], [ "LOAD_FAST", "it" ], [ "BINARY_SUBSCR", "it[0]" ], [ "BINARY_SUBSCR", "it[0][0]" ], [ "COMPARE_OP", "it[0][0] != '.'" ], [ "LOAD_FAST", "it" ], [ "LOAD_FAST", "k" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "cheap_repr(v)" ], [ "LOAD_GLOBAL", "uuid4" ], [ "CALL_FUNCTION", "uuid4()" ], [ "LOAD_ATTR", "uuid4().hex" ], [ "LOAD_DEREF", "exit_info" ], [ "LOAD_ATTR", "exit_info.current_frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_GLOBAL", "_tracing_recursively" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "_tracing_recursively(frame)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.iteration" ], [ "LOAD_GLOBAL", "_deep_dict" ], [ "CALL_FUNCTION", "_deep_dict()" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._extract_node_values" ], [ "LOAD_DEREF", "top_iteration" ], [ "LOAD_DEREF", "node_values" ], [ "CALL_FUNCTION", "self._extract_node_values(top_iteration, (), node_values)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "BINARY_SUBSCR", "self._code_infos[frame.f_code]" ], [ "LOAD_ATTR", "self._code_infos[frame.f_code].db_func" ], [ "LOAD_DEREF", "exit_info" ], [ "LOAD_ATTR", "exit_info.exc_value" ], [ "LOAD_FAST", "exc" ], [ "LOAD_ATTR", "''.join" ], [ "LOAD_GLOBAL", "traceback" ], [ "LOAD_ATTR", "traceback.format_exception" ], [ "LOAD_GLOBAL", "type" ], [ "LOAD_FAST", "exc" ], [ "CALL_FUNCTION", "type(exc)" ], [ "LOAD_FAST", "exc" ], [ "LOAD_DEREF", "exit_info" ], [ "LOAD_ATTR", "exit_info.exc_tb" ], [ "CALL_FUNCTION", "traceback.format_exception(type(exc), exc, exit_info.exc_tb)" ], [ "CALL_FUNCTION", "''.join(traceback.format_exception(type(exc), exc, exit_info.exc_tb))" ], [ "LOAD_GLOBAL", "exception_string" ], [ "LOAD_FAST", "exc" ], [ "CALL_FUNCTION", "exception_string(exc)" ], [ "LOAD_GLOBAL", "retry_db" ], [ "CALL_FUNCTION", "retry_db" ], [ "LOAD_FAST", "add_call" ], [ "CALL_FUNCTION", "add_call()" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.call_id" ], [ "LOAD_DEREF", "self" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.db" ], [ "LOAD_ATTR", "self.db.Call" ], [ "LOAD_FAST", "Call" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.call_id" ], [ "LOAD_DEREF", "db_func" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.arguments" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_DEREF", "exit_info" ], [ "LOAD_ATTR", "exit_info.return_value" ], [ "CALL_FUNCTION", "cheap_repr(exit_info.return_value)" ], [ "LOAD_DEREF", "exception" ], [ "LOAD_DEREF", "traceback_str" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_ATTR", "json.dumps" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_DEREF", "node_values" ], [ "LOAD_DEREF", "top_iteration" ], [ "LOAD_ATTR", "top_iteration.extract_iterations" ], [ "CALL_FUNCTION", "top_iteration.extract_iterations()" ], [ "BINARY_SUBSCR", "top_iteration.extract_iterations()['loops']" ], [ "LOAD_GLOBAL", "type_registry" ], [ "LOAD_ATTR", "type_registry.names" ], [ "CALL_FUNCTION", "type_registry.names()" ], [ "LOAD_GLOBAL", "type_registry" ], [ "LOAD_ATTR", "type_registry.num_special_types" ], [ "CALL_FUNCTION", "dict(\n node_values=node_values,\n loop_iterations=top_iteration.extract_iterations()['loops'],\n type_names=type_registry.names(),\n num_special_types=type_registry.num_special_types,\n )" ], [ "LOAD_GLOBAL", "ProtocolEncoder" ], [ "CALL_FUNCTION", "json.dumps(\n dict(\n node_values=node_values,\n loop_iterations=top_iteration.extract_iterations()['loops'],\n type_names=type_registry.names(),\n num_special_types=type_registry.num_special_types,\n ),\n cls=ProtocolEncoder,\n separators=(',', ':')\n )" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.start_time" ], [ "CALL_FUNCTION", "Call(id=frame_info.call_id,\n function_id=db_func,\n arguments=frame_info.arguments,\n return_value=cheap_repr(exit_info.return_value),\n exception=exception,\n traceback=traceback_str,\n data=json.dumps(\n dict(\n node_values=node_values,\n loop_iterations=top_iteration.extract_iterations()['loops'],\n type_names=type_registry.names(),\n num_special_types=type_registry.num_special_types,\n ),\n cls=ProtocolEncoder,\n separators=(',', ':')\n ),\n start_time=frame_info.start_time)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.db" ], [ "LOAD_ATTR", "self.db.session_scope" ], [ "CALL_FUNCTION", "self.db.session_scope()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.add" ], [ "LOAD_FAST", "call" ], [ "CALL_FUNCTION", "session.add(call)" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.vals" ], [ "LOAD_ATTR", "iteration.vals.items" ], [ "CALL_FUNCTION", "iteration.vals.items()" ], [ "LOAD_FAST", "tree_index" ], [ "LOAD_FAST", "path" ], [ "BINARY_ADD", "(tree_index,) + path" ], [ "LOAD_FAST", "node_values" ], [ "LOAD_FAST", "full_path" ], [ "BINARY_SUBSCR", "full_path[:-1]" ], [ "LOAD_FAST", "d" ], [ "LOAD_FAST", "path_k" ], [ "BINARY_SUBSCR", "d[path_k]" ], [ "LOAD_FAST", "node_value" ], [ "LOAD_FAST", "d" ], [ "LOAD_FAST", "full_path" ], [ "BINARY_SUBSCR", "full_path[-1]" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.loops" ], [ "LOAD_ATTR", "iteration.loops.values" ], [ "CALL_FUNCTION", "iteration.loops.values()" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "loop" ], [ "CALL_FUNCTION", "enumerate(loop)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._extract_node_values" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "path + (i,)" ], [ "LOAD_FAST", "node_values" ], [ "CALL_FUNCTION", "self._extract_node_values(iteration, path + (i,), node_values)" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "BirdsEye" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(BirdsEye, self)" ], [ "LOAD_ATTR", "super(BirdsEye, self).trace_function" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "super(BirdsEye, self).trace_function(func)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_ATTR", "self._code_infos.get" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_ATTR", "new_func.__code__" ], [ "CALL_FUNCTION", "self._code_infos.get(new_func.__code__)" ], [ "LOAD_FAST", "code_info" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.getsourcelines" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "inspect.getsourcelines(func)" ], [ "LOAD_FAST", "start_lineno" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "lines" ], [ "CALL_FUNCTION", "len(lines)" ], [ "BINARY_ADD", "start_lineno + len(lines)" ], [ "LOAD_GLOBAL", "safe_qualname" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "safe_qualname(func)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.getsourcefile" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "inspect.getsourcefile(func)" ], [ "LOAD_FAST", "source_file" ], [ "LOAD_ATTR", "source_file.startswith" ], [ "CALL_FUNCTION", "source_file.startswith('= 0" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.getsourcefile" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "inspect.getsourcefile(frame)" ], [ "LOAD_FAST", "filename" ], [ "COMPARE_OP", "filename is not None" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.abspath" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "os.path.abspath(filename)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "LOAD_ATTR", "frame.f_globals.get" ], [ "CALL_FUNCTION", "frame.f_globals.get('__name__')" ], [ "COMPARE_OP", "frame.f_globals.get('__name__') != '__main__'" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._treetrace_hidden_with_stmt" ], [ "LOAD_ATTR", "self._treetrace_hidden_with_stmt.__name__" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "COMPARE_OP", "self._treetrace_hidden_with_stmt.__name__ not in frame.f_globals" ], [ "LOAD_GLOBAL", "RuntimeError" ], [ "CALL_FUNCTION", "RuntimeError(\n 'To trace an imported module, you must import birdseye before '\n 'importing that module.')" ], [ "LOAD_GLOBAL", "read_source_file" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "read_source_file(filename)" ], [ "LOAD_ATTR", "read_source_file(filename).splitlines" ], [ "CALL_FUNCTION", "read_source_file(filename).splitlines()" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lineno" ], [ "BINARY_MULTIPLY", "[''] * frame.f_lineno" ], [ "LOAD_FAST", "lines" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lineno" ], [ "LOAD_ATTR", "'\\n'.join" ], [ "LOAD_FAST", "lines" ], [ "CALL_FUNCTION", "'\\n'.join(lines)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.exec_string" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "LOAD_FAST", "deep" ], [ "CALL_FUNCTION", "self.exec_string(source, filename, frame.f_globals, frame.f_locals, deep)" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.exit" ], [ "CALL_FUNCTION", "sys.exit(0)" ], [ "LOAD_FAST", "globs" ], [ "LOAD_FAST", "locs" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.compile" ], [ "LOAD_DEREF", "source" ], [ "LOAD_DEREF", "filename" ], [ "CALL_FUNCTION", "self.compile(source, filename)" ], [ "LOAD_FAST", "globs" ], [ "LOAD_ATTR", "globs.update" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._trace_methods_dict" ], [ "LOAD_DEREF", "traced_file" ], [ "CALL_FUNCTION", "self._trace_methods_dict(traced_file)" ], [ "CALL_FUNCTION", "globs.update(self._trace_methods_dict(traced_file))" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._trace" ], [ "LOAD_GLOBAL", "FILE_SENTINEL_NAME" ], [ "LOAD_DEREF", "filename" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.code" ], [ "LOAD_DEREF", "source" ], [ "CALL_FUNCTION", "self._trace(FILE_SENTINEL_NAME, filename, traced_file, traced_file.code, 'module', source)" ], [ "LOAD_FAST", "deep" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.nodes" ], [ "LOAD_DEREF", "find_code" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.code" ], [ "CALL_FUNCTION", "find_code(traced_file.code)" ], [ "LOAD_GLOBAL", "exec" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.code" ], [ "LOAD_FAST", "globs" ], [ "LOAD_FAST", "locs" ], [ "CALL_FUNCTION", "exec(traced_file.code, globs, locs)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(node, ast.FunctionDef)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.lineno" ], [ "LOAD_FAST", "root_code" ], [ "LOAD_ATTR", "root_code.co_consts" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.iscode" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "inspect.iscode(code)" ], [ "UNARY_NOT", "not inspect.iscode(code)" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "LOAD_ATTR", "code.co_name.startswith" ], [ "CALL_FUNCTION", "code.co_name.startswith('<')" ], [ "LOAD_DEREF", "find_code" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "find_code(code)" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_firstlineno" ], [ "LOAD_DEREF", "nodes_by_lineno" ], [ "LOAD_ATTR", "nodes_by_lineno.get" ], [ "LOAD_FAST", "lineno" ], [ "CALL_FUNCTION", "nodes_by_lineno.get(lineno)" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._trace" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "LOAD_DEREF", "filename" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_FAST", "code" ], [ "LOAD_DEREF", "source" ], [ "LOAD_FAST", "lineno" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.last_token" ], [ "LOAD_ATTR", "node.last_token.end" ], [ "BINARY_SUBSCR", "node.last_token.end[0]" ], [ "BINARY_ADD", "node.last_token.end[0] + 1" ], [ "CALL_FUNCTION", "self._trace(\n code.co_name, filename, traced_file, code,\n typ='function',\n source=source,\n start_lineno=lineno,\n end_lineno=node.last_token.end[0] + 1,\n )" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_DEREF", "start_lineno" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.splitlines" ], [ "CALL_FUNCTION", "source.splitlines()" ], [ "CALL_FUNCTION", "len(source.splitlines())" ], [ "BINARY_ADD", "start_lineno + len(source.splitlines())" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._nodes_of_interest" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_DEREF", "start_lineno" ], [ "LOAD_FAST", "end_lineno" ], [ "CALL_FUNCTION", "self._nodes_of_interest(traced_file, start_lineno, end_lineno)" ], [ "CALL_FUNCTION", "list(self._nodes_of_interest(traced_file, start_lineno, end_lineno))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._nodes_html" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_DEREF", "start_lineno" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_FAST", "traced_file" ], [ "CALL_FUNCTION", "self._nodes_html(nodes, start_lineno, end_lineno, traced_file)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "nodes" ], [ "CALL_FUNCTION", "dict(\n # This maps each node to the loops enclosing that node\n node_loops={\n node._tree_index: [n._tree_index for n in node._loops]\n for node, _ in nodes\n if node._loops\n },\n )" ], [ "LOAD_FAST", "typ" ], [ "COMPARE_OP", "typ == 'function'" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.tokens" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_FAST", "nodes" ], [ "CALL_FUNCTION", "only(node\n for node, _ in nodes\n if isinstance(node, ast.FunctionDef)\n and node.first_token.start[0] == start_lineno)" ], [ "LOAD_GLOBAL", "source_without_decorators" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_FAST", "func_node" ], [ "CALL_FUNCTION", "source_without_decorators(tokens, func_node)" ], [ "LOAD_FAST", "data_dict" ], [ "LOAD_ATTR", "data_dict.update" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._node_ranges" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_FAST", "func_startpos" ], [ "CALL_FUNCTION", "self._node_ranges(nodes, tokens, func_startpos)" ], [ "CALL_FUNCTION", "list(self._node_ranges(nodes, tokens, func_startpos))" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._loop_ranges" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_FAST", "func_startpos" ], [ "CALL_FUNCTION", "self._loop_ranges(nodes, tokens, func_startpos)" ], [ "CALL_FUNCTION", "list(self._loop_ranges(nodes, tokens, func_startpos))" ], [ "CALL_FUNCTION", "data_dict.update(\n node_ranges=list(self._node_ranges(nodes, tokens, func_startpos)),\n loop_ranges=list(self._loop_ranges(nodes, tokens, func_startpos)),\n )" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_ATTR", "json.dumps" ], [ "LOAD_FAST", "data_dict" ], [ "CALL_FUNCTION", "json.dumps(data_dict, sort_keys=True)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._db_func" ], [ "LOAD_FAST", "data" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "html_body" ], [ "LOAD_FAST", "name" ], [ "LOAD_DEREF", "start_lineno" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "typ" ], [ "CALL_FUNCTION", "self._db_func(data, filename, html_body, name, start_lineno, source, typ)" ], [ "LOAD_GLOBAL", "CodeInfo" ], [ "LOAD_FAST", "db_func" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_FAST", "arg_names" ], [ "CALL_FUNCTION", "CodeInfo(db_func, traced_file, arg_names)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_FAST", "n" ], [ "LOAD_ATTR", "n._tree_index" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(node, ast.FunctionDef)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.first_token" ], [ "LOAD_ATTR", "node.first_token.start" ], [ "BINARY_SUBSCR", "node.first_token.start[0]" ], [ "LOAD_DEREF", "start_lineno" ], [ "COMPARE_OP", "node.first_token.start[0] == start_lineno" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "classes" ], [ "COMPARE_OP", "'loop' not in classes" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.target" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.test" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_ATTR", "tokens.get_text_range" ], [ "LOAD_FAST", "target" ], [ "CALL_FUNCTION", "tokens.get_text_range(target)" ], [ "LOAD_FAST", "func_start" ], [ "LOAD_FAST", "func_start" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "CALL_FUNCTION", "dict(\n tree_index=node._tree_index,\n start=start,\n end=end\n )" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_ATTR", "tokens.get_text_range" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "tokens.get_text_range(node)" ], [ "LOAD_FAST", "func_start" ], [ "LOAD_FAST", "func_start" ], [ "LOAD_FAST", "start" ], [ "COMPARE_OP", "start < 0" ], [ "LOAD_FAST", "end" ], [ "COMPARE_OP", "end < 0" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(node, ast.FunctionDef)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._depth" ], [ "LOAD_FAST", "classes" ], [ "CALL_FUNCTION", "dict(\n tree_index=node._tree_index,\n start=start,\n end=end,\n depth=node._depth,\n classes=classes,\n )" ], [ "LOAD_FAST", "h" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "name" ], [ "BINARY_ADD", "filename + name" ], [ "LOAD_FAST", "html_body" ], [ "BINARY_ADD", "filename + name + html_body" ], [ "LOAD_FAST", "data" ], [ "BINARY_ADD", "filename + name + html_body + data" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "start_lineno" ], [ "CALL_FUNCTION", "str(start_lineno)" ], [ "BINARY_ADD", "filename + name + html_body + data + str(start_lineno)" ], [ "CALL_FUNCTION", "h(filename + name + html_body + data + str(start_lineno))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.db" ], [ "LOAD_ATTR", "self.db.Function" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.db" ], [ "LOAD_ATTR", "self.db.session_scope" ], [ "CALL_FUNCTION", "self.db.session_scope()" ], [ "LOAD_GLOBAL", "one_or_none" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_FAST", "Function" ], [ "CALL_FUNCTION", "session.query(Function)" ], [ "LOAD_ATTR", "session.query(Function).filter_by" ], [ "LOAD_FAST", "function_hash" ], [ "CALL_FUNCTION", "session.query(Function).filter_by(hash=function_hash)" ], [ "CALL_FUNCTION", "one_or_none(session.query(Function).filter_by(hash=function_hash))" ], [ "LOAD_FAST", "db_func" ], [ "LOAD_FAST", "Function" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "typ" ], [ "LOAD_FAST", "html_body" ], [ "LOAD_FAST", "start_lineno" ], [ "LOAD_FAST", "data" ], [ "LOAD_FAST", "h" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "h(source)" ], [ "LOAD_FAST", "function_hash" ], [ "CALL_FUNCTION", "Function(file=filename,\n name=name,\n type=typ,\n html_body=html_body,\n lineno=start_lineno,\n data=data,\n body_hash=h(source),\n hash=function_hash)" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.add" ], [ "LOAD_FAST", "db_func" ], [ "CALL_FUNCTION", "session.add(db_func)" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.commit" ], [ "CALL_FUNCTION", "session.commit()" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "db_func" ], [ "LOAD_ATTR", "db_func.id" ], [ "LOAD_GLOBAL", "int" ], [ "CALL_FUNCTION", "isinstance(db_func.id, int)" ], [ "LOAD_FAST", "db_func" ], [ "LOAD_ATTR", "db_func.id" ], [ "LOAD_GLOBAL", "hashlib" ], [ "LOAD_ATTR", "hashlib.sha256" ], [ "LOAD_FAST", "s" ], [ "LOAD_ATTR", "s.encode" ], [ "CALL_FUNCTION", "s.encode('utf8')" ], [ "CALL_FUNCTION", "hashlib.sha256(s.encode('utf8'))" ], [ "LOAD_ATTR", "hashlib.sha256(s.encode('utf8')).hexdigest" ], [ "CALL_FUNCTION", "hashlib.sha256(s.encode('utf8')).hexdigest()" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.nodes" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "CALL_FUNCTION", "isinstance(node, (ast.While, ast.For, ast.comprehension))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.GeneratorExp" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.GeneratorExp)" ], [ "UNARY_NOT", "not isinstance(node.parent, ast.GeneratorExp)" ], [ "LOAD_FAST", "classes" ], [ "LOAD_ATTR", "classes.append" ], [ "CALL_FUNCTION", "classes.append('loop')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "CALL_FUNCTION", "isinstance(node, ast.stmt)" ], [ "LOAD_FAST", "classes" ], [ "LOAD_ATTR", "classes.append" ], [ "CALL_FUNCTION", "classes.append('stmt')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "CALL_FUNCTION", "isinstance(node, ast.expr)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._is_interesting_expression" ], [ "LOAD_FAST", "classes" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.AST" ], [ "CALL_FUNCTION", "isinstance(node, ast.AST)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "hasattr(node, 'first_token')" ], [ "LOAD_FAST", "start_lineno" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.first_token" ], [ "LOAD_ATTR", "node.first_token.start" ], [ "BINARY_SUBSCR", "node.first_token.start[0]" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.tokens" ], [ "LOAD_ATTR", "traced_file.tokens.get_text_range" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "traced_file.tokens.get_text_range(node)" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "classes" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.root" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.walk" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.root" ], [ "CALL_FUNCTION", "ast.walk(traced_file.root)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.iter_child_nodes" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ast.iter_child_nodes(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._depth" ], [ "BINARY_ADD", "node._depth + 1" ], [ "LOAD_FAST", "child" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "positions" ], [ "LOAD_ATTR", "positions.extend" ], [ "LOAD_GLOBAL", "map" ], [ "LOAD_GLOBAL", "HTMLPosition" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._depth" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._depth" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_ATTR", "' '.join" ], [ "LOAD_FAST", "classes" ], [ "CALL_FUNCTION", "' '.join(classes)" ], [ "BINARY_MODULO", "'' % (node._tree_index, ' '.join(classes))" ], [ "CALL_FUNCTION", "map(\n HTMLPosition,\n [start, end],\n [True, False], # is_start\n [node._depth, node._depth],\n ['' % (node._tree_index, ' '.join(classes)),\n ''])" ], [ "CALL_FUNCTION", "positions.extend(map(\n HTMLPosition,\n [start, end],\n [True, False], # is_start\n [node._depth, node._depth],\n ['' % (node._tree_index, ' '.join(classes)),\n '']))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._separate_comprehensions" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_FAST", "positions" ], [ "LOAD_FAST", "traced_file" ], [ "CALL_FUNCTION", "self._separate_comprehensions(\n [n[0] for n in nodes],\n end_lineno, positions, traced_file)" ], [ "LOAD_FAST", "positions" ], [ "LOAD_ATTR", "positions.append" ], [ "LOAD_GLOBAL", "HTMLPosition" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.source" ], [ "CALL_FUNCTION", "len(traced_file.source)" ], [ "CALL_FUNCTION", "HTMLPosition(len(traced_file.source), False, 0, '')" ], [ "CALL_FUNCTION", "positions.append(HTMLPosition(len(traced_file.source), False, 0, ''))" ], [ "LOAD_FAST", "positions" ], [ "LOAD_ATTR", "positions.sort" ], [ "CALL_FUNCTION", "positions.sort()" ], [ "LOAD_FAST", "positions" ], [ "LOAD_FAST", "html_parts" ], [ "LOAD_ATTR", "html_parts.append" ], [ "LOAD_GLOBAL", "html" ], [ "LOAD_ATTR", "html.escape" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.source" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "position" ], [ "LOAD_ATTR", "position.index" ], [ "BINARY_SUBSCR", "traced_file.source[start:position.index]" ], [ "CALL_FUNCTION", "html.escape(traced_file.source[start:position.index])" ], [ "CALL_FUNCTION", "html_parts.append(html.escape(traced_file.source[start:position.index]))" ], [ "LOAD_FAST", "html_parts" ], [ "LOAD_ATTR", "html_parts.append" ], [ "LOAD_FAST", "position" ], [ "LOAD_ATTR", "position.html" ], [ "CALL_FUNCTION", "html_parts.append(position.html)" ], [ "LOAD_FAST", "position" ], [ "LOAD_ATTR", "position.index" ], [ "LOAD_ATTR", "''.join" ], [ "LOAD_FAST", "html_parts" ], [ "CALL_FUNCTION", "''.join(html_parts)" ], [ "LOAD_ATTR", "'\\n'.join" ], [ "LOAD_FAST", "html_body" ], [ "LOAD_ATTR", "html_body.split" ], [ "CALL_FUNCTION", "html_body.split('\\n')" ], [ "LOAD_FAST", "start_lineno" ], [ "BINARY_SUBTRACT", "start_lineno - 1" ], [ "LOAD_FAST", "end_lineno" ], [ "BINARY_SUBTRACT", "end_lineno - 1" ], [ "BINARY_SUBSCR", "html_body.split('\\n')[start_lineno - 1:end_lineno - 1]" ], [ "CALL_FUNCTION", "'\\n'.join(html_body.split('\\n')[start_lineno - 1:end_lineno - 1])" ], [ "LOAD_FAST", "html_body" ], [ "LOAD_ATTR", "html_body.strip" ], [ "CALL_FUNCTION", "html_body.strip('\\n')" ], [ "LOAD_FAST", "n" ], [ "BINARY_SUBSCR", "n[0]" ], [ "LOAD_GLOBAL", "group_by_key_func" ], [ "LOAD_GLOBAL", "of_type" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "LOAD_FAST", "nodes" ], [ "CALL_FUNCTION", "of_type((ast.comprehension, ast.While, ast.For), nodes)" ], [ "CALL_FUNCTION", "group_by_key_func(of_type((ast.comprehension, ast.While, ast.For), nodes),\n lambda c: c.first_token.start[0]\n )" ], [ "LOAD_FAST", "comprehensions" ], [ "LOAD_ATTR", "comprehensions.values" ], [ "CALL_FUNCTION", "comprehensions.values()" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_FAST", "comp_list" ], [ "CALL_FUNCTION", "sorted(comp_list, key=lambda c: c.first_token.startpos)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "comp" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "CALL_FUNCTION", "isinstance(comp, ast.comprehension)" ], [ "LOAD_FAST", "comp" ], [ "LOAD_FAST", "comp" ], [ "LOAD_ATTR", "comp.parent" ], [ "LOAD_ATTR", "comp.parent.generators" ], [ "BINARY_SUBSCR", "comp.parent.generators[0]" ], [ "COMPARE_OP", "comp is comp.parent.generators[0]" ], [ "LOAD_FAST", "get_start" ], [ "LOAD_FAST", "comp" ], [ "LOAD_ATTR", "comp.parent" ], [ "CALL_FUNCTION", "get_start(comp.parent)" ], [ "LOAD_FAST", "prev_start" ], [ "COMPARE_OP", "prev_start is not None" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "prev_start" ], [ "COMPARE_OP", "start < prev_start" ], [ "LOAD_FAST", "get_start" ], [ "LOAD_FAST", "comp" ], [ "CALL_FUNCTION", "get_start(comp)" ], [ "LOAD_FAST", "get_start" ], [ "LOAD_FAST", "comp" ], [ "CALL_FUNCTION", "get_start(comp)" ], [ "LOAD_FAST", "prev_start" ], [ "COMPARE_OP", "prev_start is not None" ], [ "LOAD_FAST", "positions" ], [ "LOAD_ATTR", "positions.append" ], [ "LOAD_GLOBAL", "HTMLPosition" ], [ "LOAD_FAST", "start" ], [ "CALL_FUNCTION", "HTMLPosition(start, True, 0, '\\n ')" ], [ "CALL_FUNCTION", "positions.append(HTMLPosition(start, True, 0, '\\n '))" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.first_token" ], [ "LOAD_ATTR", "c.first_token.start" ], [ "BINARY_SUBSCR", "c.first_token.start[0]" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.tokens" ], [ "LOAD_ATTR", "traced_file.tokens.get_text_range" ], [ "LOAD_FAST", "n" ], [ "CALL_FUNCTION", "traced_file.tokens.get_text_range(n)" ], [ "BINARY_SUBSCR", "traced_file.tokens.get_text_range(n)[0]" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.first_token" ], [ "LOAD_ATTR", "c.first_token.startpos" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "_deep_dict" ], [ "CALL_FUNCTION", "defaultdict(_deep_dict)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_GLOBAL", "_bad_codes" ], [ "COMPARE_OP", "frame.f_code in _bad_codes" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "IterationList" ], [ "CALL_FUNCTION", "defaultdict(IterationList)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.index" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.loops" ], [ "LOAD_ATTR", "self.loops.items" ], [ "CALL_FUNCTION", "self.loops.items()" ], [ "LOAD_FAST", "iteration_list" ], [ "LOAD_FAST", "tree_index" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.extract_iterations" ], [ "CALL_FUNCTION", "iteration.extract_iterations()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "deque" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.side_len" ], [ "CALL_FUNCTION", "deque(maxlen=self.side_len)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "Counter" ], [ "CALL_FUNCTION", "Counter()" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.length" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.side_len" ], [ "COMPARE_OP", "self.length < self.side_len" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start" ], [ "LOAD_ATTR", "self.start.append" ], [ "LOAD_FAST", "iteration" ], [ "CALL_FUNCTION", "self.start.append(iteration)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "CALL_FUNCTION", "len(self.end)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.side_len" ], [ "COMPARE_OP", "len(self.end) >= self.side_len" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "BINARY_SUBSCR", "self.end[0]" ], [ "LOAD_ATTR", "self.end[0].keep" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start" ], [ "LOAD_ATTR", "self.start.append" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "BINARY_SUBSCR", "self.end[0]" ], [ "CALL_FUNCTION", "self.start.append(self.end[0])" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "LOAD_ATTR", "self.end.append" ], [ "LOAD_FAST", "iteration" ], [ "CALL_FUNCTION", "self.end.append(iteration)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.length" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "chain" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "CALL_FUNCTION", "chain(self.start, self.end)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "BINARY_SUBSCR", "self.end[-1]" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start" ], [ "BINARY_SUBSCR", "self.start[-1]" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.recorded" ], [ "LOAD_FAST", "node" ], [ "BINARY_SUBSCR", "self.recorded[node]" ], [ "COMPARE_OP", "self.recorded[node] >= 2" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.last" ], [ "CALL_FUNCTION", "self.last()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.recorded" ], [ "LOAD_FAST", "node" ], [ "LOAD_NAME", "type" ], [ "CALL_FUNCTION", "type(None)" ], [ "LOAD_NAME", "bool" ], [ "LOAD_NAME", "int" ], [ "LOAD_NAME", "float" ], [ "LOAD_NAME", "complex" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "long" ], [ "LOAD_NAME", "basic_types" ], [ "LOAD_NAME", "list" ], [ "LOAD_NAME", "dict" ], [ "LOAD_NAME", "tuple" ], [ "LOAD_NAME", "set" ], [ "LOAD_NAME", "frozenset" ], [ "LOAD_NAME", "str" ], [ "BINARY_ADD", "basic_types + (list, dict, tuple, set, frozenset, str)" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "unicode" ], [ "LOAD_NAME", "bytes" ], [ "LOAD_NAME", "len" ], [ "LOAD_NAME", "special_types" ], [ "CALL_FUNCTION", "len(special_types)" ], [ "LOAD_GLOBAL", "Lock" ], [ "CALL_FUNCTION", "Lock()" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "CALL_FUNCTION", "defaultdict(lambda: len(self.data))" ], [ "LOAD_DEREF", "self" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.special_types" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.data" ], [ "LOAD_FAST", "t" ], [ "BINARY_SUBSCR", "self.data[t]" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.data" ], [ "CALL_FUNCTION", "len(self.data)" ], [ "LOAD_GLOBAL", "correct_type" ], [ "LOAD_FAST", "item" ], [ "CALL_FUNCTION", "correct_type(item)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.lock" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.data" ], [ "LOAD_FAST", "t" ], [ "BINARY_SUBSCR", "self.data[t]" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.data" ], [ "LOAD_ATTR", "self.data.items" ], [ "CALL_FUNCTION", "self.data.items()" ], [ "CALL_FUNCTION", "dict((v, k) for k, v in self.data.items())" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_DEREF", "rev" ], [ "CALL_FUNCTION", "len(rev)" ], [ "CALL_FUNCTION", "range(len(rev))" ], [ "LOAD_FAST", "v" ], [ "LOAD_FAST", "k" ], [ "LOAD_GLOBAL", "safe_qualname" ], [ "LOAD_DEREF", "rev" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "rev[i]" ], [ "CALL_FUNCTION", "safe_qualname(rev[i])" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_FAST", "val_repr" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "type_index" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.meta" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.meta" ], [ "LOAD_FAST", "key" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.children" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.children" ], [ "LOAD_ATTR", "self.children.append" ], [ "LOAD_FAST", "key" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOAD_ATTR", "NodeValue.expression" ], [ "LOAD_FAST", "samples" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "level" ], [ "CALL_FUNCTION", "NodeValue.expression(samples, value, level)" ], [ "CALL_FUNCTION", "self.children.append((key, NodeValue.expression(samples, value, level)))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.val_repr" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.type_index" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.meta" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.children" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.extend" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.children" ], [ "CALL_FUNCTION", "result.extend(self.children)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "cls" ], [ "CALL_FUNCTION", "cls('', -2)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_GLOBAL", "exception_string" ], [ "LOAD_FAST", "exc_value" ], [ "CALL_FUNCTION", "exception_string(exc_value)" ], [ "CALL_FUNCTION", "cls(exception_string(exc_value), -1)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "cheap_repr(val)" ], [ "LOAD_GLOBAL", "type_registry" ], [ "LOAD_FAST", "val" ], [ "BINARY_SUBSCR", "type_registry[val]" ], [ "CALL_FUNCTION", "cls(cheap_repr(val), type_registry[val])" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "TypeRegistry" ], [ "LOAD_ATTR", "TypeRegistry.basic_types" ], [ "LOAD_GLOBAL", "BirdsEye" ], [ "CALL_FUNCTION", "isinstance(val, (TypeRegistry.basic_types, BirdsEye))" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "QuerySet" ], [ "CALL_FUNCTION", "isinstance(val, QuerySet)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "len(val)" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.set_meta" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "result.set_meta('len', length)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "ModuleType" ], [ "CALL_FUNCTION", "isinstance(val, ModuleType)" ], [ "LOAD_GLOBAL", "min" ], [ "LOAD_FAST", "level" ], [ "CALL_FUNCTION", "min(level, 2)" ], [ "LOAD_GLOBAL", "partial" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.add_child" ], [ "LOAD_FAST", "samples" ], [ "LOAD_FAST", "level" ], [ "BINARY_SUBTRACT", "level - 1" ], [ "CALL_FUNCTION", "partial(result.add_child, samples, level - 1)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Series" ], [ "LOAD_GLOBAL", "ndarray" ], [ "CALL_FUNCTION", "isinstance(val, (Series, ndarray))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "ndarray" ], [ "CALL_FUNCTION", "isinstance(val, ndarray)" ], [ "LOAD_FAST", "attrs" ], [ "LOAD_ATTR", "attrs.append" ], [ "CALL_FUNCTION", "attrs.append('shape')" ], [ "LOAD_FAST", "attrs" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "val" ], [ "LOAD_FAST", "name" ], [ "CALL_FUNCTION", "getattr(val, name)" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "attr" ], [ "CALL_FUNCTION", "add_child(name, attr)" ], [ "LOAD_FAST", "level" ], [ "COMPARE_OP", "level >= 3" ], [ "LOAD_FAST", "level" ], [ "COMPARE_OP", "level >= 2" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Series" ], [ "CALL_FUNCTION", "isinstance(val, Series)" ], [ "LOAD_FAST", "samples" ], [ "LOAD_FAST", "sample_type" ], [ "BINARY_SUBSCR", "samples[sample_type]" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "DataFrame" ], [ "CALL_FUNCTION", "isinstance(val, DataFrame)" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.set_meta" ], [ "LOAD_FAST", "meta" ], [ "CALL_FUNCTION", "result.set_meta('dataframe', meta)" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['pandas_rows']" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['pandas_cols']" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_rows" ], [ "BINARY_ADD", "max_rows + 2" ], [ "COMPARE_OP", "length > max_rows + 2" ], [ "LOAD_FAST", "max_rows" ], [ "BINARY_FLOOR_DIVIDE", "max_rows // 2" ], [ "LOAD_FAST", "meta" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.columns" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "columns" ], [ "CALL_FUNCTION", "len(columns)" ], [ "LOAD_FAST", "num_cols" ], [ "LOAD_FAST", "max_cols" ], [ "BINARY_ADD", "max_cols + 2" ], [ "COMPARE_OP", "num_cols > max_cols + 2" ], [ "LOAD_FAST", "max_cols" ], [ "BINARY_FLOOR_DIVIDE", "max_cols // 2" ], [ "LOAD_FAST", "meta" ], [ "LOAD_GLOBAL", "set" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "num_cols" ], [ "LOAD_FAST", "max_cols" ], [ "CALL_FUNCTION", "_sample_indices(num_cols, max_cols)" ], [ "CALL_FUNCTION", "set(_sample_indices(num_cols, max_cols))" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_GLOBAL", "zip" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.columns" ], [ "LOAD_ATTR", "val.columns.format" ], [ "CALL_FUNCTION", "val.columns.format(sparsify=False)" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.columns" ], [ "CALL_FUNCTION", "zip(val.columns.format(sparsify=False),\n val.columns)" ], [ "CALL_FUNCTION", "enumerate(zip(val.columns.format(sparsify=False),\n val.columns))" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "indices" ], [ "COMPARE_OP", "i in indices" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_FAST", "formatted_name" ], [ "LOAD_FAST", "val" ], [ "LOAD_FAST", "label" ], [ "BINARY_SUBSCR", "val[label]" ], [ "CALL_FUNCTION", "add_child(formatted_name, val[label])" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Series" ], [ "CALL_FUNCTION", "isinstance(val, Series)" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['pandas_rows']" ], [ "CALL_FUNCTION", "_sample_indices(length, samples['pandas_rows'])" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.index" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "val.index[i:i + 1]" ], [ "LOAD_ATTR", "val.index[i:i + 1].format" ], [ "CALL_FUNCTION", "val.index[i:i + 1].format(sparsify=False)" ], [ "BINARY_SUBSCR", "val.index[i:i + 1].format(sparsify=False)[0]" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.iloc" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "val.iloc[i]" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_FAST", "k" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child(k, v)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "level" ], [ "COMPARE_OP", "level <= 0" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "bytes" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "unicode" ], [ "LOAD_GLOBAL", "xrange" ], [ "CALL_FUNCTION", "isinstance(val,\n (str, bytes, range)\n if PY3 else\n (str, unicode, xrange))" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Sequence" ], [ "LOAD_GLOBAL", "ndarray" ], [ "CALL_FUNCTION", "isinstance(val, (Sequence, ndarray))" ], [ "LOAD_FAST", "length" ], [ "COMPARE_OP", "length is not None" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['list']" ], [ "CALL_FUNCTION", "_sample_indices(length, samples['list'])" ], [ "LOAD_FAST", "val" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "val[i]" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "i" ], [ "CALL_FUNCTION", "str(i)" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child(str(i), v)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Mapping" ], [ "CALL_FUNCTION", "isinstance(val, Mapping)" ], [ "LOAD_GLOBAL", "islice" ], [ "LOAD_GLOBAL", "_safe_iter" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "iteritems" ], [ "CALL_FUNCTION", "_safe_iter(val, iteritems)" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['dict']" ], [ "CALL_FUNCTION", "islice(_safe_iter(val, iteritems), samples['dict'])" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "k" ], [ "CALL_FUNCTION", "cheap_repr(k)" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child(cheap_repr(k), v)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Set" ], [ "CALL_FUNCTION", "isinstance(val, Set)" ], [ "LOAD_GLOBAL", "_safe_iter" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "_safe_iter(val)" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['set']" ], [ "LOAD_FAST", "length" ], [ "COMPARE_OP", "length is None" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "num_items" ], [ "BINARY_ADD", "num_items + 2" ], [ "COMPARE_OP", "length > num_items + 2" ], [ "LOAD_GLOBAL", "islice" ], [ "LOAD_FAST", "vals" ], [ "LOAD_FAST", "num_items" ], [ "CALL_FUNCTION", "islice(vals, num_items)" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "vals" ], [ "CALL_FUNCTION", "enumerate(vals)" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_FAST", "i" ], [ "BINARY_MODULO", "'<%s>' % i" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child('<%s>' % i, v)" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "getattr(val, '__dict__', None)" ], [ "LOAD_FAST", "d" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_GLOBAL", "islice" ], [ "LOAD_GLOBAL", "_safe_iter" ], [ "LOAD_FAST", "d" ], [ "CALL_FUNCTION", "_safe_iter(d)" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['attributes']" ], [ "CALL_FUNCTION", "islice(_safe_iter(d),\n samples['attributes'])" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "sorted(islice(_safe_iter(d),\n samples['attributes']),\n key=str)" ], [ "LOAD_FAST", "d" ], [ "LOAD_FAST", "k" ], [ "BINARY_SUBSCR", "d[k]" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "TracedFile" ], [ "CALL_FUNCTION", "isinstance(v, TracedFile)" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "k" ], [ "CALL_FUNCTION", "str(k)" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child(str(k), v)" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "type" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "type(val)" ], [ "CALL_FUNCTION", "getattr(type(val), '__slots__', None)" ], [ "CALL_FUNCTION", "sorted(getattr(type(val), '__slots__', None) or ())" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "val" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "getattr(val, s)" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "str(s)" ], [ "LOAD_FAST", "attr" ], [ "CALL_FUNCTION", "add_child(str(s), attr)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "x" ], [ "LOAD_FAST", "f" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "f(val)" ], [ "LOAD_FAST", "x" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_ADD", "max_length + 2" ], [ "COMPARE_OP", "length <= max_length + 2" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "range(length)" ], [ "LOAD_GLOBAL", "chain" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_FLOOR_DIVIDE", "max_length // 2" ], [ "CALL_FUNCTION", "range(max_length // 2)" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_FLOOR_DIVIDE", "max_length // 2" ], [ "BINARY_SUBTRACT", "length - max_length // 2" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "range(length - max_length // 2,\n length)" ], [ "CALL_FUNCTION", "chain(range(max_length // 2),\n range(length - max_length // 2,\n length))" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "len(x)" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "n == 0" ], [ "LOAD_GLOBAL", "repr" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "repr(x)" ], [ "LOAD_FAST", "helper" ], [ "LOAD_ATTR", "helper.level" ], [ "BINARY_SUBTRACT", "helper.level - 1" ], [ "LOAD_GLOBAL", "_repr_series_one_line" ], [ "LOAD_ATTR", "_repr_series_one_line.maxparts" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "n" ], [ "LOAD_FAST", "maxparts" ], [ "CALL_FUNCTION", "_sample_indices(n, maxparts)" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.index" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "x.index[i:i + 1]" ], [ "LOAD_ATTR", "x.index[i:i + 1].format" ], [ "CALL_FUNCTION", "x.index[i:i + 1].format(sparsify=False)" ], [ "BINARY_SUBSCR", "x.index[i:i + 1].format(sparsify=False)[0]" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.iloc" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "x.iloc[i]" ], [ "LOAD_FAST", "pieces" ], [ "LOAD_ATTR", "pieces.append" ], [ "LOAD_FAST", "k" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "v" ], [ "LOAD_FAST", "newlevel" ], [ "CALL_FUNCTION", "cheap_repr(v, newlevel)" ], [ "BINARY_MODULO", "'%s = %s' % (k, cheap_repr(v, newlevel))" ], [ "CALL_FUNCTION", "pieces.append('%s = %s' % (k, cheap_repr(v, newlevel)))" ], [ "LOAD_FAST", "n" ], [ "LOAD_FAST", "maxparts" ], [ "BINARY_ADD", "maxparts + 2" ], [ "COMPARE_OP", "n > maxparts + 2" ], [ "LOAD_FAST", "pieces" ], [ "LOAD_ATTR", "pieces.insert" ], [ "LOAD_FAST", "maxparts" ], [ "BINARY_FLOOR_DIVIDE", "maxparts // 2" ], [ "CALL_FUNCTION", "pieces.insert(maxparts // 2, '...')" ], [ "LOAD_ATTR", "'; '.join" ], [ "LOAD_FAST", "pieces" ], [ "CALL_FUNCTION", "'; '.join(pieces)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "CALL_FUNCTION", "isinstance(node, ast.expr)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Num" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Str" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "ast" ], [ "CALL_FUNCTION", "getattr(ast, 'NameConstant', ())" ], [ "CALL_FUNCTION", "isinstance(node, (ast.Num, ast.Str, getattr(ast, 'NameConstant', ())))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "getattr(node, 'ctx', None)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Store" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Del" ], [ "CALL_FUNCTION", "isinstance(getattr(node, 'ctx', None),\n (ast.Store, ast.Del))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.UnaryOp" ], [ "CALL_FUNCTION", "isinstance(node, ast.UnaryOp)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.op" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.UAdd" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.USub" ], [ "CALL_FUNCTION", "isinstance(node.op, (ast.UAdd, ast.USub))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.operand" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Num" ], [ "CALL_FUNCTION", "isinstance(node.operand, ast.Num)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.List" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Tuple" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Dict" ], [ "CALL_FUNCTION", "isinstance(node, (ast.List, ast.Tuple, ast.Dict))" ], [ "LOAD_GLOBAL", "any" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.iter_child_nodes" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ast.iter_child_nodes(node)" ], [ "CALL_FUNCTION", "any(is_interesting_expression(n) for n in ast.iter_child_nodes(node))" ], [ "UNARY_NOT", "not any(is_interesting_expression(n) for n in ast.iter_child_nodes(node))" ], [ "UNARY_NOT", "not (isinstance(node, (ast.Num, ast.Str, getattr(ast, 'NameConstant', ()))) or\n isinstance(getattr(node, 'ctx', None),\n (ast.Store, ast.Del)) or\n (isinstance(node, ast.UnaryOp) and\n isinstance(node.op, (ast.UAdd, ast.USub)) and\n isinstance(node.operand, ast.Num)) or\n (isinstance(node, (ast.List, ast.Tuple, ast.Dict)) and\n not any(is_interesting_expression(n) for n in ast.iter_child_nodes(node))))" ], [ "LOAD_GLOBAL", "is_interesting_expression" ], [ "LOAD_FAST", "n" ], [ "CALL_FUNCTION", "is_interesting_expression(n)" ], [ "LOAD_GLOBAL", "cast" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "__builtins__" ], [ "CALL_FUNCTION", "cast(dict, __builtins__)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Name" ], [ "CALL_FUNCTION", "isinstance(node, ast.Name)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.id" ], [ "LOAD_FAST", "builtins" ], [ "COMPARE_OP", "node.id in builtins" ], [ "LOAD_FAST", "builtins" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.id" ], [ "BINARY_SUBSCR", "builtins[node.id]" ], [ "LOAD_FAST", "value" ], [ "COMPARE_OP", "builtins[node.id] is value" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "ast" ], [ "CALL_FUNCTION", "getattr(ast, 'NameConstant', ())" ], [ "CALL_FUNCTION", "isinstance(node, getattr(ast, 'NameConstant', ()))" ] ], "configuration.py": [ [ "LOAD_NAME", "ctypes" ], [ "LOAD_ATTR", "ctypes.windll" ], [ "LOAD_ATTR", "ctypes.windll.kernel32" ], [ "LOAD_NAME", "kernel32" ], [ "LOAD_ATTR", "kernel32.SetConsoleMode" ], [ "LOAD_NAME", "kernel32" ], [ "LOAD_ATTR", "kernel32.GetStdHandle" ], [ "CALL_FUNCTION", "kernel32.GetStdHandle(-11)" ], [ "CALL_FUNCTION", "kernel32.SetConsoleMode(kernel32.GetStdHandle(-11), 7)" ], [ "LOAD_NAME", "Exception" ], [ "LOAD_NAME", "os" ], [ "LOAD_ATTR", "os.name" ], [ "COMPARE_OP", "os.name != 'nt'" ], [ "LOAD_NAME", "DefaultFormatter" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "object" ], [ "LOAD_FAST", "builtins" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_GLOBAL", "builtins_module" ], [ "LOAD_FAST", "snoop" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.snoop" ], [ "CALL_FUNCTION", "setattr(builtins_module, snoop, package.snoop)" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_GLOBAL", "builtins_module" ], [ "LOAD_FAST", "pp" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.pp" ], [ "CALL_FUNCTION", "setattr(builtins_module, pp, package.pp)" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_GLOBAL", "builtins_module" ], [ "LOAD_FAST", "spy" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.spy" ], [ "CALL_FUNCTION", "setattr(builtins_module, spy, package.spy)" ], [ "LOAD_GLOBAL", "Config" ], [ "LOAD_FAST", "out" ], [ "LOAD_FAST", "prefix" ], [ "LOAD_FAST", "columns" ], [ "LOAD_FAST", "overwrite" ], [ "LOAD_FAST", "color" ], [ "LOAD_FAST", "enabled" ], [ "LOAD_FAST", "watch_extras" ], [ "LOAD_FAST", "replace_watch_extras" ], [ "LOAD_FAST", "formatter_class" ], [ "CALL_FUNCTION", "Config(\n out=out,\n prefix=prefix,\n columns=columns,\n overwrite=overwrite,\n color=color,\n enabled=enabled,\n watch_extras=watch_extras,\n replace_watch_extras=replace_watch_extras,\n formatter_class=formatter_class,\n )" ], [ "LOAD_FAST", "config" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.snoop" ], [ "LOAD_FAST", "config" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.pp" ], [ "LOAD_FAST", "config" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.spy" ], [ "LOAD_NAME", "DefaultFormatter" ], [ "LOAD_GLOBAL", "can_color" ], [ "LOAD_FAST", "color" ], [ "COMPARE_OP", "color is None" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "out" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.stderr" ], [ "CALL_FUNCTION", "getattr(out or sys.stderr, 'isatty', lambda: False)" ], [ "LOAD_GLOBAL", "bool" ], [ "LOAD_FAST", "isatty" ], [ "CALL_FUNCTION", "isatty()" ], [ "CALL_FUNCTION", "bool(isatty())" ], [ "LOAD_GLOBAL", "get_write_function" ], [ "LOAD_FAST", "out" ], [ "LOAD_FAST", "overwrite" ], [ "CALL_FUNCTION", "get_write_function(out, overwrite)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "formatter_class" ], [ "LOAD_FAST", "prefix" ], [ "LOAD_FAST", "columns" ], [ "LOAD_FAST", "color" ], [ "CALL_FUNCTION", "formatter_class(prefix, columns, color)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "enabled" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "PP" ], [ "LOAD_DEREF", "self" ], [ "CALL_FUNCTION", "PP(self)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "Tracer" ], [ "LOAD_FAST", "ConfiguredTracer" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "Spy" ], [ "LOAD_DEREF", "self" ], [ "CALL_FUNCTION", "Spy(self)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "threading" ], [ "LOAD_ATTR", "threading.local" ], [ "CALL_FUNCTION", "threading.local()" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "replace_watch_extras" ], [ "COMPARE_OP", "replace_watch_extras is not None" ], [ "LOAD_GLOBAL", "ensure_tuple" ], [ "LOAD_FAST", "replace_watch_extras" ], [ "CALL_FUNCTION", "ensure_tuple(replace_watch_extras)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "len_shape_watch" ], [ "LOAD_GLOBAL", "dtype_watch" ], [ "LOAD_GLOBAL", "ensure_tuple" ], [ "LOAD_FAST", "watch_extras" ], [ "CALL_FUNCTION", "ensure_tuple(watch_extras)" ], [ "BINARY_ADD", "(len_shape_watch, dtype_watch) + ensure_tuple(watch_extras)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_CLASSDEREF", "self" ], [ "LOAD_FAST", "value" ], [ "LOAD_ATTR", "value.shape" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.ismethod" ], [ "LOAD_FAST", "shape" ], [ "CALL_FUNCTION", "inspect.ismethod(shape)" ], [ "LOAD_ATTR", "'{}.shape'.format" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "'{}.shape'.format(source)" ], [ "LOAD_FAST", "shape" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "value" ], [ "LOAD_GLOBAL", "QuerySet" ], [ "CALL_FUNCTION", "isinstance(value, QuerySet)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "len(value)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "value" ], [ "LOAD_GLOBAL", "six" ], [ "LOAD_ATTR", "six.string_types" ], [ "CALL_FUNCTION", "isinstance(value, six.string_types)" ], [ "LOAD_FAST", "length" ], [ "COMPARE_OP", "length < 50" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "value" ], [ "LOAD_GLOBAL", "Mapping" ], [ "LOAD_GLOBAL", "Set" ], [ "LOAD_GLOBAL", "Sequence" ], [ "CALL_FUNCTION", "isinstance(value, (Mapping, Set, Sequence))" ], [ "LOAD_FAST", "length" ], [ "COMPARE_OP", "length == 0" ], [ "LOAD_ATTR", "'len({})'.format" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "'len({})'.format(source)" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "value" ], [ "LOAD_ATTR", "value.dtype" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.ismethod" ], [ "LOAD_FAST", "dtype" ], [ "CALL_FUNCTION", "inspect.ismethod(dtype)" ], [ "LOAD_ATTR", "'{}.dtype'.format" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "'{}.dtype'.format(source)" ], [ "LOAD_FAST", "dtype" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_DEREF", "output" ], [ "LOAD_GLOBAL", "six" ], [ "LOAD_ATTR", "six.string_types" ], [ "CALL_FUNCTION", "isinstance(output, six.string_types)" ], [ "LOAD_GLOBAL", "is_pathlike" ], [ "LOAD_DEREF", "output" ], [ "CALL_FUNCTION", "is_pathlike(output)" ], [ "LOAD_FAST", "is_path" ], [ "LOAD_GLOBAL", "FileWriter" ], [ "LOAD_DEREF", "output" ], [ "LOAD_FAST", "overwrite" ], [ "CALL_FUNCTION", "FileWriter(output, overwrite)" ], [ "LOAD_ATTR", "FileWriter(output, overwrite).write" ], [ "LOAD_GLOBAL", "callable" ], [ "LOAD_DEREF", "output" ], [ "CALL_FUNCTION", "callable(output)" ], [ "LOAD_DEREF", "output" ], [ "LOAD_FAST", "write" ], [ "LOAD_DEREF", "output" ], [ "LOAD_FAST", "stream" ], [ "COMPARE_OP", "stream is None" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.stderr" ], [ "LOAD_FAST", "stream" ], [ "LOAD_ATTR", "stream.write" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "stream.write(s)" ], [ "LOAD_GLOBAL", "UnicodeEncodeError" ], [ "LOAD_FAST", "stream" ], [ "LOAD_ATTR", "stream.write" ], [ "LOAD_GLOBAL", "shitcode" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "shitcode(s)" ], [ "CALL_FUNCTION", "stream.write(shitcode(s))" ], [ "LOAD_GLOBAL", "six" ], [ "LOAD_ATTR", "six.text_type" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "six.text_type(path)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "overwrite" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "open" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.path" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.overwrite" ], [ "CALL_FUNCTION", "open(self.path, 'w' if self.overwrite else 'a', encoding='utf-8')" ], [ "LOAD_FAST", "f" ], [ "LOAD_ATTR", "f.write" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "f.write(s)" ], [ "LOAD_FAST", "self" ] ], "db.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOAD_ATTR", "standard_library.install_aliases" ], [ "CALL_FUNCTION", "standard_library.install_aliases()" ], [ "LOAD_NAME", "RESERVED_WORDS" ], [ "LOAD_ATTR", "RESERVED_WORDS.add" ], [ "CALL_FUNCTION", "RESERVED_WORDS.add('function')" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "retry" ], [ "LOAD_NAME", "InterfaceError" ], [ "LOAD_NAME", "OperationalError" ], [ "LOAD_NAME", "InternalError" ], [ "LOAD_NAME", "ProgrammingError" ], [ "CALL_FUNCTION", "retry(3, (InterfaceError, OperationalError, InternalError, ProgrammingError))" ], [ "LOAD_NAME", "contextmanager" ], [ "CALL_FUNCTION", "contextmanager" ], [ "LOAD_FAST", "db_uri" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.environ" ], [ "LOAD_ATTR", "os.environ.get" ], [ "CALL_FUNCTION", "os.environ.get('BIRDSEYE_DB')" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.join" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.expanduser" ], [ "CALL_FUNCTION", "os.path.expanduser('~')" ], [ "CALL_FUNCTION", "os.path.join(os.path.expanduser('~'),\n '.birdseye.db')" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "dict" ], [ "CALL_FUNCTION", "dict(\n pool_recycle=280,\n echo=False, # for convenience when debugging\n )" ], [ "LOAD_GLOBAL", "create_engine" ], [ "LOAD_FAST", "db_uri" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_KW", "create_engine(db_uri, **kwargs)" ], [ "LOAD_GLOBAL", "ArgumentError" ], [ "LOAD_FAST", "db_uri" ], [ "BINARY_ADD", "'sqlite:///' + db_uri" ], [ "LOAD_GLOBAL", "create_engine" ], [ "LOAD_FAST", "db_uri" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_KW", "create_engine(db_uri, **kwargs)" ], [ "LOAD_FAST", "engine" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "sessionmaker" ], [ "LOAD_FAST", "engine" ], [ "CALL_FUNCTION", "sessionmaker(bind=engine)" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "object" ], [ "LOAD_GLOBAL", "declarative_base" ], [ "LOAD_FAST", "Base" ], [ "CALL_FUNCTION", "declarative_base(cls=Base)" ], [ "LOAD_FAST", "Base" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "object" ], [ "LOAD_FAST", "engine" ], [ "LOAD_ATTR", "engine.name" ], [ "COMPARE_OP", "engine.name == 'mysql'" ], [ "LOAD_GLOBAL", "LONGTEXT" ], [ "LOAD_GLOBAL", "Text" ], [ "LOAD_FAST", "Base" ], [ "LOAD_FAST", "Base" ], [ "LOAD_FAST", "Call" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "Function" ], [ "LOAD_FAST", "self" ], [ "LOAD_DEREF", "KeyValue" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "KeyValueStore" ], [ "CALL_FUNCTION", "KeyValueStore()" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "_skip_version_check" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.table_exists" ], [ "LOAD_FAST", "Function" ], [ "CALL_FUNCTION", "self.table_exists(Function)" ], [ "LOAD_FAST", "Base" ], [ "LOAD_ATTR", "Base.metadata" ], [ "LOAD_ATTR", "Base.metadata.create_all" ], [ "LOAD_FAST", "engine" ], [ "CALL_FUNCTION", "Base.metadata.create_all(engine)" ], [ "LOAD_GLOBAL", "DB_VERSION" ], [ "LOAD_FAST", "kv" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.table_exists" ], [ "LOAD_DEREF", "KeyValue" ], [ "CALL_FUNCTION", "self.table_exists(KeyValue)" ], [ "UNARY_NOT", "not self.table_exists(KeyValue)" ], [ "LOAD_GLOBAL", "int" ], [ "LOAD_FAST", "kv" ], [ "LOAD_ATTR", "kv.version" ], [ "CALL_FUNCTION", "int(kv.version)" ], [ "LOAD_GLOBAL", "DB_VERSION" ], [ "COMPARE_OP", "int(kv.version) < DB_VERSION" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.exit" ], [ "CALL_FUNCTION", "sys.exit('The birdseye database schema is out of date. '\n 'Run \"python -m birdseye.clear_db\" to delete the existing tables.')" ], [ "LOAD_NAME", "declared_attr" ], [ "CALL_FUNCTION", "declared_attr" ], [ "LOAD_FAST", "cls" ], [ "LOAD_ATTR", "cls.__name__" ], [ "LOAD_ATTR", "cls.__name__.lower" ], [ "CALL_FUNCTION", "cls.__name__.lower()" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "String" ], [ "CALL_FUNCTION", "String(50)" ], [ "CALL_FUNCTION", "Column(String(50), primary_key=True)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "__getitem__" ], [ "LOAD_NAME", "__setitem__" ], [ "LOAD_DEREF", "db_self" ], [ "LOAD_ATTR", "db_self.session_scope" ], [ "CALL_FUNCTION", "db_self.session_scope()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session\n .query" ], [ "LOAD_DEREF", "KeyValue" ], [ "LOAD_ATTR", "KeyValue.value" ], [ "CALL_FUNCTION", "session\n .query(KeyValue.value)" ], [ "LOAD_ATTR", "session\n .query(KeyValue.value)\n .filter_by" ], [ "LOAD_FAST", "item" ], [ "CALL_FUNCTION", "session\n .query(KeyValue.value)\n .filter_by(key=item)" ], [ "LOAD_ATTR", "session\n .query(KeyValue.value)\n .filter_by(key=item)\n .scalar" ], [ "CALL_FUNCTION", "session\n .query(KeyValue.value)\n .filter_by(key=item)\n .scalar()" ], [ "LOAD_DEREF", "db_self" ], [ "LOAD_ATTR", "db_self.session_scope" ], [ "CALL_FUNCTION", "db_self.session_scope()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_DEREF", "KeyValue" ], [ "CALL_FUNCTION", "session.query(KeyValue)" ], [ "LOAD_ATTR", "session.query(KeyValue).filter_by" ], [ "LOAD_FAST", "key" ], [ "CALL_FUNCTION", "session.query(KeyValue).filter_by(key=key)" ], [ "LOAD_ATTR", "session.query(KeyValue).filter_by(key=key).delete" ], [ "CALL_FUNCTION", "session.query(KeyValue).filter_by(key=key).delete()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.add" ], [ "LOAD_DEREF", "KeyValue" ], [ "LOAD_FAST", "key" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "str(value)" ], [ "CALL_FUNCTION", "KeyValue(key=key, value=str(value))" ], [ "CALL_FUNCTION", "session.add(KeyValue(key=key, value=str(value)))" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "String" ], [ "CALL_FUNCTION", "String(length=32)" ], [ "CALL_FUNCTION", "Column(String(length=32), primary_key=True)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Integer" ], [ "LOAD_NAME", "ForeignKey" ], [ "CALL_FUNCTION", "ForeignKey('function.id')" ], [ "CALL_FUNCTION", "Column(Integer, ForeignKey('function.id'), index=True)" ], [ "LOAD_NAME", "relationship" ], [ "LOAD_NAME", "backref" ], [ "CALL_FUNCTION", "backref('calls', lazy='dynamic')" ], [ "CALL_FUNCTION", "relationship('Function', backref=backref('calls', lazy='dynamic'))" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_CLASSDEREF", "LongText" ], [ "CALL_FUNCTION", "Column(LongText)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "DateTime" ], [ "CALL_FUNCTION", "Column(DateTime, index=True)" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "id" ], [ "LOAD_NAME", "function_id" ], [ "LOAD_NAME", "return_value" ], [ "LOAD_NAME", "traceback" ], [ "LOAD_NAME", "exception" ], [ "LOAD_NAME", "start_time" ], [ "LOAD_NAME", "arguments" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._pretty_time" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start_time" ], [ "CALL_FUNCTION", "self._pretty_time(self.start_time)" ], [ "LOAD_FAST", "dt" ], [ "LOAD_GLOBAL", "Markup" ], [ "LOAD_FAST", "dt" ], [ "LOAD_ATTR", "dt.strftime" ], [ "CALL_FUNCTION", "dt.strftime('%Y-%m-%d %H:%M:%S')" ], [ "LOAD_GLOBAL", "naturaltime" ], [ "LOAD_FAST", "dt" ], [ "CALL_FUNCTION", "naturaltime(dt)" ], [ "BINARY_MODULO", "'%s (%s)' % (\n dt.strftime('%Y-%m-%d %H:%M:%S'),\n naturaltime(dt))" ], [ "CALL_FUNCTION", "Markup('%s (%s)' % (\n dt.strftime('%Y-%m-%d %H:%M:%S'),\n naturaltime(dt)))" ], [ "LOAD_GLOBAL", "Markup" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.success" ], [ "BINARY_MODULO", "'' % (\n ('ok', 'green') if self.success else\n ('remove', 'red'))" ], [ "CALL_FUNCTION", "Markup('' % (\n ('ok', 'green') if self.success else\n ('remove', 'red')))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.exception" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.traceback" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.return_value" ], [ "COMPARE_OP", "self.return_value == 'None'" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.traceback" ], [ "UNARY_NOT", "not self.traceback" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.success" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.return_value" ], [ "CALL_FUNCTION", "str(self.return_value)" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.exception" ], [ "CALL_FUNCTION", "str(self.exception)" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_ATTR", "json.loads" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.arguments" ], [ "CALL_FUNCTION", "json.loads(self.arguments)" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_ATTR", "json.loads" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.data" ], [ "CALL_FUNCTION", "json.loads(self.data)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.arguments_list" ], [ "LOAD_GLOBAL", "select_attrs" ], [ "LOAD_FAST", "call" ], [ "CALL_FUNCTION", "select_attrs(call, 'id function_id return_value traceback '\n 'exception start_time')" ], [ "CALL_FUNCTION_KW", "dict(arguments=call.arguments_list,\n **select_attrs(call, 'id function_id return_value traceback '\n 'exception start_time'))" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Integer" ], [ "LOAD_NAME", "Sequence" ], [ "CALL_FUNCTION", "Sequence('function_id_seq')" ], [ "CALL_FUNCTION", "Column(Integer, Sequence('function_id_seq'), primary_key=True)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_CLASSDEREF", "LongText" ], [ "CALL_FUNCTION", "Column(LongText)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Integer" ], [ "CALL_FUNCTION", "Column(Integer)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_CLASSDEREF", "LongText" ], [ "CALL_FUNCTION", "Column(LongText)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "String" ], [ "CALL_FUNCTION", "String(length=64)" ], [ "CALL_FUNCTION", "Column(String(length=64), index=True)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "String" ], [ "CALL_FUNCTION", "String(length=64)" ], [ "CALL_FUNCTION", "Column(String(length=64), index=True)" ], [ "LOAD_NAME", "UniqueConstraint" ], [ "CALL_FUNCTION", "UniqueConstraint('hash',\n name='everything_unique')" ], [ "LOAD_NAME", "Index" ], [ "CALL_FUNCTION", "Index('idx_file', 'file', mysql_length=256)" ], [ "LOAD_NAME", "Index" ], [ "CALL_FUNCTION", "Index('idx_name', 'name', mysql_length=32)" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "file" ], [ "LOAD_NAME", "name" ], [ "LOAD_NAME", "lineno" ], [ "LOAD_NAME", "hash" ], [ "LOAD_NAME", "body_hash" ], [ "LOAD_NAME", "type" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_ATTR", "json.loads" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.data" ], [ "CALL_FUNCTION", "json.loads(self.data)" ], [ "LOAD_GLOBAL", "select_attrs" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "select_attrs(func, 'file name lineno hash body_hash type')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.engine" ], [ "LOAD_ATTR", "self.engine.dialect" ], [ "LOAD_ATTR", "self.engine.dialect.has_table" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.engine" ], [ "LOAD_FAST", "table" ], [ "LOAD_ATTR", "table.__name__" ], [ "CALL_FUNCTION", "self.engine.dialect.has_table(self.engine, table.__name__)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.session_scope" ], [ "CALL_FUNCTION", "self.session_scope()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.Function" ], [ "LOAD_ATTR", "self.Function.file" ], [ "CALL_FUNCTION", "session.query(self.Function.file)" ], [ "LOAD_ATTR", "session.query(self.Function.file).distinct" ], [ "CALL_FUNCTION", "session.query(self.Function.file).distinct()" ], [ "LOAD_FAST", "paths" ], [ "LOAD_ATTR", "paths.sort" ], [ "CALL_FUNCTION", "paths.sort()" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "paths" ], [ "COMPARE_OP", "IPYTHON_FILE_PATH in paths" ], [ "LOAD_FAST", "paths" ], [ "LOAD_ATTR", "paths.remove" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "CALL_FUNCTION", "paths.remove(IPYTHON_FILE_PATH)" ], [ "LOAD_FAST", "paths" ], [ "LOAD_ATTR", "paths.insert" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "CALL_FUNCTION", "paths.insert(0, IPYTHON_FILE_PATH)" ], [ "LOAD_FAST", "paths" ], [ "LOAD_GLOBAL", "is_ipython_cell" ], [ "LOAD_FAST", "f" ], [ "BINARY_SUBSCR", "f[0]" ], [ "CALL_FUNCTION", "is_ipython_cell(f[0])" ], [ "LOAD_FAST", "f" ], [ "BINARY_SUBSCR", "f[0]" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.Call" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.Function" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._KeyValue" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.table_exists" ], [ "LOAD_FAST", "model" ], [ "CALL_FUNCTION", "self.table_exists(model)" ], [ "LOAD_FAST", "model" ], [ "LOAD_ATTR", "model.__table__" ], [ "LOAD_ATTR", "model.__table__.drop" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.engine" ], [ "CALL_FUNCTION", "model.__table__.drop(self.engine)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.Session" ], [ "CALL_FUNCTION", "self.Session()" ], [ "LOAD_FAST", "session" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.commit" ], [ "CALL_FUNCTION", "session.commit()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.rollback" ], [ "CALL_FUNCTION", "session.rollback()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.close" ], [ "CALL_FUNCTION", "session.close()" ], [ "LOAD_GLOBAL", "functools" ], [ "LOAD_ATTR", "functools.wraps" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "LOAD_GLOBAL", "retry_db" ], [ "LOAD_FAST", "wrapper" ], [ "CALL_FUNCTION", "retry_db(wrapper)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.session_scope" ], [ "CALL_FUNCTION", "self.session_scope()" ], [ "LOAD_DEREF", "func" ], [ "LOAD_FAST", "session" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "func(session, *args, **kwargs)" ] ], "executing.py": [ [ "LOAD_NAME", "sys" ], [ "LOAD_ATTR", "sys.version_info" ], [ "BINARY_SUBSCR", "sys.version_info[0]" ], [ "COMPARE_OP", "sys.version_info[0] == 3" ], [ "LOAD_NAME", "PY3" ], [ "LOAD_NAME", "lru_cache" ], [ "CALL_FUNCTION", "lru_cache(maxsize=None)" ], [ "LOAD_NAME", "str" ], [ "LOAD_NAME", "unicode" ], [ "LOAD_NAME", "dis" ], [ "LOAD_ATTR", "dis.get_instructions" ], [ "LOAD_NAME", "AttributeError" ], [ "LOAD_NAME", "namedtuple" ], [ "CALL_FUNCTION", "namedtuple('Instruction', 'offset argval opname')" ], [ "LOAD_NAME", "Exception" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.NodeVisitor" ], [ "LOAD_NAME", "sum" ], [ "LOAD_NAME", "__future__" ], [ "LOAD_ATTR", "__future__.all_feature_names" ], [ "CALL_FUNCTION", "sum(\n getattr(__future__, fname).compiler_flag\n for fname in __future__.all_feature_names\n)" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "RLock" ], [ "CALL_FUNCTION", "RLock()" ], [ "LOAD_NAME", "cache" ], [ "CALL_FUNCTION", "cache" ], [ "LOAD_GLOBAL", "functools" ], [ "LOAD_ATTR", "functools.wraps" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "LOAD_FAST", "wrapper" ], [ "LOAD_FAST", "args" ], [ "LOAD_DEREF", "d" ], [ "COMPARE_OP", "args in d" ], [ "LOAD_DEREF", "d" ], [ "LOAD_FAST", "args" ], [ "BINARY_SUBSCR", "d[args]" ], [ "LOAD_DEREF", "func" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION_VAR", "func(*args)" ], [ "LOAD_DEREF", "d" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "co" ], [ "LOAD_ATTR", "co.co_code" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "len(code)" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "i < n" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "code[i]" ], [ "LOAD_GLOBAL", "ord" ], [ "LOAD_FAST", "c" ], [ "CALL_FUNCTION", "ord(c)" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "LOAD_FAST", "op" ], [ "LOAD_GLOBAL", "HAVE_ARGUMENT" ], [ "COMPARE_OP", "op >= HAVE_ARGUMENT" ], [ "LOAD_GLOBAL", "ord" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "code[i]" ], [ "CALL_FUNCTION", "ord(code[i])" ], [ "LOAD_GLOBAL", "ord" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "code[i + 1]" ], [ "CALL_FUNCTION", "ord(code[i + 1])" ], [ "BINARY_MULTIPLY", "ord(code[i + 1]) * 256" ], [ "BINARY_ADD", "ord(code[i]) + ord(code[i + 1]) * 256" ], [ "LOAD_FAST", "extended_arg" ], [ "BINARY_ADD", "ord(code[i]) + ord(code[i + 1]) * 256 + extended_arg" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 2" ], [ "LOAD_FAST", "op" ], [ "LOAD_GLOBAL", "EXTENDED_ARG" ], [ "COMPARE_OP", "op == EXTENDED_ARG" ], [ "LOAD_FAST", "oparg" ], [ "BINARY_MULTIPLY", "oparg * 65536" ], [ "LOAD_FAST", "op" ], [ "LOAD_GLOBAL", "hasconst" ], [ "COMPARE_OP", "op in hasconst" ], [ "LOAD_FAST", "co" ], [ "LOAD_ATTR", "co.co_consts" ], [ "LOAD_FAST", "oparg" ], [ "BINARY_SUBSCR", "co.co_consts[oparg]" ], [ "LOAD_GLOBAL", "Instruction" ], [ "LOAD_FAST", "offset" ], [ "LOAD_FAST", "argval" ], [ "LOAD_GLOBAL", "opname" ], [ "LOAD_FAST", "op" ], [ "BINARY_SUBSCR", "opname[op]" ], [ "CALL_FUNCTION", "Instruction(offset, argval, opname[op])" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "it" ], [ "LOAD_GLOBAL", "Sized" ], [ "CALL_FUNCTION", "isinstance(it, Sized)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "len(it)" ], [ "COMPARE_OP", "len(it) != 1" ], [ "LOAD_GLOBAL", "NotOneValueFound" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "len(it)" ], [ "BINARY_MODULO", "'Expected one value, found %s' % len(it)" ], [ "CALL_FUNCTION", "NotOneValueFound('Expected one value, found %s' % len(it))" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "list(it)" ], [ "BINARY_SUBSCR", "list(it)[0]" ], [ "LOAD_GLOBAL", "tuple" ], [ "LOAD_GLOBAL", "islice" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "islice(it, 2)" ], [ "CALL_FUNCTION", "tuple(islice(it, 2))" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "lst" ], [ "CALL_FUNCTION", "len(lst)" ], [ "COMPARE_OP", "len(lst) == 0" ], [ "LOAD_GLOBAL", "NotOneValueFound" ], [ "CALL_FUNCTION", "NotOneValueFound('Expected one value, found 0')" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "lst" ], [ "CALL_FUNCTION", "len(lst)" ], [ "COMPARE_OP", "len(lst) > 1" ], [ "LOAD_GLOBAL", "NotOneValueFound" ], [ "CALL_FUNCTION", "NotOneValueFound('Expected one value, found several')" ], [ "LOAD_FAST", "lst" ], [ "BINARY_SUBSCR", "lst[0]" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "cache" ], [ "CALL_FUNCTION", "cache" ], [ "LOAD_NAME", "cache" ], [ "CALL_FUNCTION", "cache" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "text" ], [ "LOAD_GLOBAL", "text_type" ], [ "CALL_FUNCTION", "isinstance(text, text_type)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.decode_source" ], [ "LOAD_FAST", "text" ], [ "CALL_FUNCTION", "self.decode_source(text)" ], [ "LOAD_FAST", "text" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_FAST", "text" ], [ "LOAD_ATTR", "''.join" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "text" ], [ "LOAD_ATTR", "text.splitlines" ], [ "CALL_FUNCTION", "text.splitlines(True)" ], [ "CALL_FUNCTION", "enumerate(text.splitlines(True))" ], [ "CALL_FUNCTION", "''.join([\n '\\n' if i < 2 and encoding_pattern.match(line)\n else line\n for i, line in enumerate(text.splitlines(True))\n ])" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "defaultdict(list)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "text" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.parse" ], [ "LOAD_FAST", "ast_text" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "ast.parse(ast_text, filename=filename)" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "SyntaxError" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.walk" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tree" ], [ "CALL_FUNCTION", "ast.walk(self.tree)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.iter_child_nodes" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ast.iter_child_nodes(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "hasattr(node, 'lineno')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._nodes_by_line" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.lineno" ], [ "BINARY_SUBSCR", "self._nodes_by_line[node.lineno]" ], [ "LOAD_ATTR", "self._nodes_by_line[node.lineno].append" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "self._nodes_by_line[node.lineno].append(node)" ], [ "LOAD_GLOBAL", "QualnameVisitor" ], [ "CALL_FUNCTION", "QualnameVisitor()" ], [ "LOAD_FAST", "visitor" ], [ "LOAD_ATTR", "visitor.visit" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tree" ], [ "CALL_FUNCTION", "visitor.visit(self.tree)" ], [ "LOAD_FAST", "visitor" ], [ "LOAD_ATTR", "visitor.qualnames" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "i" ], [ "COMPARE_OP", "i < 2" ], [ "LOAD_GLOBAL", "encoding_pattern" ], [ "LOAD_ATTR", "encoding_pattern.match" ], [ "LOAD_FAST", "line" ], [ "CALL_FUNCTION", "encoding_pattern.match(line)" ], [ "LOAD_FAST", "line" ], [ "LOAD_FAST", "cls" ], [ "LOAD_ATTR", "cls.for_filename" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_filename" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "CALL_FUNCTION", "cls.for_filename(frame.f_code.co_filename, frame.f_globals or {})" ], [ "LOAD_FAST", "cls" ], [ "LOAD_ATTR", "cls._class_local" ], [ "CALL_FUNCTION", "cls._class_local('__source_cache', {})" ], [ "LOAD_FAST", "source_cache" ], [ "LOAD_FAST", "filename" ], [ "BINARY_SUBSCR", "source_cache[filename]" ], [ "LOAD_GLOBAL", "KeyError" ], [ "LOAD_GLOBAL", "linecache" ], [ "LOAD_ATTR", "linecache.getlines" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "module_globals" ], [ "CALL_FUNCTION", "linecache.getlines(filename, module_globals)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_FAST", "filename" ], [ "LOAD_ATTR", "''.join" ], [ "LOAD_FAST", "lines" ], [ "CALL_FUNCTION", "''.join(lines)" ], [ "CALL_FUNCTION", "cls(filename, ''.join(lines))" ], [ "LOAD_FAST", "source_cache" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_GLOBAL", "linecache" ], [ "CALL_FUNCTION", "hasattr(linecache, 'lazycache')" ], [ "LOAD_GLOBAL", "linecache" ], [ "LOAD_ATTR", "linecache.lazycache" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_filename" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "CALL_FUNCTION", "linecache.lazycache(frame.f_code.co_filename, frame.f_globals)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lasti" ], [ "LOAD_FAST", "cls" ], [ "LOAD_ATTR", "cls._class_local" ], [ "CALL_FUNCTION", "cls._class_local('__executing_cache', {})" ], [ "LOAD_FAST", "executing_cache" ], [ "LOAD_FAST", "key" ], [ "BINARY_SUBSCR", "executing_cache[key]" ], [ "LOAD_GLOBAL", "KeyError" ], [ "LOAD_FAST", "cls" ], [ "LOAD_ATTR", "cls.for_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "cls.for_frame(frame)" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.tree" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.statements_at_line" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lineno" ], [ "CALL_FUNCTION", "source.statements_at_line(frame.f_lineno)" ], [ "LOAD_GLOBAL", "NodeFinder" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "stmts" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.tree" ], [ "CALL_FUNCTION", "NodeFinder(frame, stmts, source.tree)" ], [ "LOAD_ATTR", "NodeFinder(frame, stmts, source.tree).result" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_GLOBAL", "statement_containing_node" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "statement_containing_node(node)" ], [ "LOAD_FAST", "new_stmts" ], [ "LOAD_FAST", "stmts" ], [ "COMPARE_OP", "new_stmts <= stmts" ], [ "LOAD_FAST", "new_stmts" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "stmts" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "executing_cache" ], [ "LOAD_FAST", "key" ], [ "LOAD_GLOBAL", "Executing" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION_VAR", "Executing(frame, *args)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_ATTR", "cls.__dict__" ], [ "LOAD_ATTR", "cls.__dict__.get" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "default" ], [ "CALL_FUNCTION", "cls.__dict__.get(name, default)" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_FAST", "cls" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "setattr(cls, name, result)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._nodes_by_line" ], [ "LOAD_FAST", "lineno" ], [ "BINARY_SUBSCR", "self._nodes_by_line[lineno]" ], [ "LOAD_GLOBAL", "statement_containing_node" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "statement_containing_node(node)" ], [ "LOAD_FAST", "ASTTokens" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.text" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tree" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.filename" ], [ "CALL_FUNCTION", "ASTTokens(\n self.text,\n tree=self.tree,\n filename=self.filename,\n )" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "source" ], [ "LOAD_GLOBAL", "bytes" ], [ "CALL_FUNCTION", "isinstance(source, bytes)" ], [ "LOAD_GLOBAL", "detect_encoding" ], [ "LOAD_GLOBAL", "io" ], [ "LOAD_ATTR", "io.BytesIO" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "io.BytesIO(source)" ], [ "LOAD_ATTR", "io.BytesIO(source).readline" ], [ "CALL_FUNCTION", "detect_encoding(io.BytesIO(source).readline)" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.decode" ], [ "LOAD_FAST", "encoding" ], [ "CALL_FUNCTION", "source.decode(encoding)" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_filename" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.filename" ], [ "COMPARE_OP", "code.co_filename == self.filename" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._qualnames" ], [ "LOAD_ATTR", "self._qualnames.get" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_firstlineno" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "CALL_FUNCTION", "self._qualnames.get((code.co_name, code.co_firstlineno), code.co_name)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "stmts" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.source" ], [ "LOAD_ATTR", "self.source.code_qualname" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_code" ], [ "CALL_FUNCTION", "self.source.code_qualname(self.frame.f_code)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.source" ], [ "LOAD_ATTR", "self.source.asttokens" ], [ "CALL_FUNCTION", "self.source.asttokens()" ], [ "LOAD_ATTR", "self.source.asttokens().get_text" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.node" ], [ "CALL_FUNCTION", "self.source.asttokens().get_text(self.node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.source" ], [ "LOAD_ATTR", "self.source.asttokens" ], [ "CALL_FUNCTION", "self.source.asttokens()" ], [ "LOAD_ATTR", "self.source.asttokens().get_text_range" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.node" ], [ "CALL_FUNCTION", "self.source.asttokens().get_text_range(self.node)" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "QualnameVisitor" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(QualnameVisitor, self)" ], [ "LOAD_ATTR", "super(QualnameVisitor, self).__init__" ], [ "CALL_FUNCTION", "super(QualnameVisitor, self).__init__()" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.name" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_ATTR", "self.stack.append" ], [ "LOAD_FAST", "name" ], [ "CALL_FUNCTION", "self.stack.append(name)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.qualnames" ], [ "LOAD_ATTR", "self.qualnames.setdefault" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.lineno" ], [ "LOAD_ATTR", "\".\".join" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "CALL_FUNCTION", "\".\".join(self.stack)" ], [ "CALL_FUNCTION", "self.qualnames.setdefault((name, node.lineno), \".\".join(self.stack))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_ATTR", "self.stack.append" ], [ "CALL_FUNCTION", "self.stack.append('')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Lambda" ], [ "CALL_FUNCTION", "isinstance(node, ast.Lambda)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.body" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.body" ], [ "LOAD_FAST", "children" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.visit" ], [ "LOAD_FAST", "child" ], [ "CALL_FUNCTION", "self.visit(child)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_ATTR", "self.stack.pop" ], [ "CALL_FUNCTION", "self.stack.pop()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_ATTR", "self.stack.pop" ], [ "CALL_FUNCTION", "self.stack.pop()" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.iter_fields" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ast.iter_fields(node)" ], [ "LOAD_FAST", "field" ], [ "COMPARE_OP", "field == 'body'" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.AST" ], [ "CALL_FUNCTION", "isinstance(child, ast.AST)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.visit" ], [ "LOAD_FAST", "child" ], [ "CALL_FUNCTION", "self.visit(child)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "isinstance(child, list)" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "grandchild" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.AST" ], [ "CALL_FUNCTION", "isinstance(grandchild, ast.AST)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.visit" ], [ "LOAD_FAST", "grandchild" ], [ "CALL_FUNCTION", "self.visit(grandchild)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.visit_FunctionDef" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "self.visit_FunctionDef(node, '')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_ATTR", "self.stack.append" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.name" ], [ "CALL_FUNCTION", "self.stack.append(node.name)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.generic_visit" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "self.generic_visit(node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_ATTR", "self.stack.pop" ], [ "CALL_FUNCTION", "self.stack.pop()" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "__future__" ], [ "LOAD_FAST", "fname" ], [ "CALL_FUNCTION", "getattr(__future__, fname)" ], [ "LOAD_ATTR", "getattr(__future__, fname).compiler_flag" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "matching_code" ], [ "LOAD_ATTR", "matching_code.co_filename" ], [ "LOAD_GLOBAL", "future_flags" ], [ "LOAD_FAST", "matching_code" ], [ "LOAD_ATTR", "matching_code.co_flags" ], [ "BINARY_AND", "future_flags & matching_code.co_flags" ], [ "CALL_FUNCTION", "compile(\n source,\n matching_code.co_filename,\n 'exec',\n flags=future_flags & matching_code.co_flags,\n dont_inherit=True,\n )" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "tree" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_code" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lasti" ], [ "BINARY_SUBSCR", "frame.f_code.co_code[frame.f_lasti]" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_GLOBAL", "ord" ], [ "LOAD_FAST", "b" ], [ "CALL_FUNCTION", "ord(b)" ], [ "LOAD_GLOBAL", "dis" ], [ "LOAD_ATTR", "dis.opname" ], [ "LOAD_FAST", "b" ], [ "BINARY_SUBSCR", "dis.opname[b]" ], [ "LOAD_FAST", "op_name" ], [ "LOAD_ATTR", "op_name.startswith" ], [ "CALL_FUNCTION", "op_name.startswith('CALL_')" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Call" ], [ "LOAD_FAST", "op_name" ], [ "COMPARE_OP", "op_name == 'BINARY_SUBSCR'" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Subscript" ], [ "LOAD_FAST", "op_name" ], [ "LOAD_ATTR", "op_name.startswith" ], [ "CALL_FUNCTION", "op_name.startswith('BINARY_')" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.BinOp" ], [ "LOAD_FAST", "op_name" ], [ "LOAD_ATTR", "op_name.startswith" ], [ "CALL_FUNCTION", "op_name.startswith('UNARY_')" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.UnaryOp" ], [ "LOAD_FAST", "op_name" ], [ "COMPARE_OP", "op_name in ('LOAD_ATTR', 'LOAD_METHOD', 'LOOKUP_METHOD')" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Attribute" ], [ "LOAD_FAST", "op_name" ], [ "COMPARE_OP", "op_name == 'COMPARE_OP'" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Compare" ], [ "LOAD_GLOBAL", "RuntimeError" ], [ "LOAD_FAST", "op_name" ], [ "CALL_FUNCTION", "RuntimeError(op_name)" ], [ "LOAD_GLOBAL", "lock" ], [ "LOAD_FAST", "stmts" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.matching_nodes" ], [ "LOAD_FAST", "exprs" ], [ "CALL_FUNCTION", "self.matching_nodes(exprs)" ], [ "CALL_FUNCTION", "list(self.matching_nodes(exprs))" ], [ "CALL_FUNCTION", "only(list(self.matching_nodes(exprs)))" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.walk" ], [ "LOAD_FAST", "stmt" ], [ "CALL_FUNCTION", "ast.walk(stmt)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "typ" ], [ "CALL_FUNCTION", "isinstance(node, typ)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "hasattr(node, \"ctx\")" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.ctx" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Load" ], [ "CALL_FUNCTION", "isinstance(node.ctx, ast.Load)" ], [ "UNARY_NOT", "not isinstance(node.ctx, ast.Load)" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "exprs" ], [ "CALL_FUNCTION", "enumerate(exprs)" ], [ "LOAD_GLOBAL", "get_setter" ], [ "LOAD_FAST", "expr" ], [ "CALL_FUNCTION", "get_setter(expr)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.BinOp" ], [ "LOAD_FAST", "expr" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Pow" ], [ "CALL_FUNCTION", "ast.Pow()" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Str" ], [ "LOAD_GLOBAL", "sentinel" ], [ "CALL_FUNCTION", "ast.Str(s=sentinel)" ], [ "CALL_FUNCTION", "ast.BinOp(\n left=expr,\n op=ast.Pow(),\n right=ast.Str(s=sentinel),\n )" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.fix_missing_locations" ], [ "LOAD_FAST", "replacement" ], [ "CALL_FUNCTION", "ast.fix_missing_locations(replacement)" ], [ "LOAD_FAST", "setter" ], [ "LOAD_FAST", "replacement" ], [ "CALL_FUNCTION", "setter(replacement)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.compile_instructions" ], [ "CALL_FUNCTION", "self.compile_instructions()" ], [ "LOAD_GLOBAL", "SyntaxError" ], [ "LOAD_FAST", "setter" ], [ "LOAD_FAST", "expr" ], [ "CALL_FUNCTION", "setter(expr)" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "instructions" ], [ "CALL_FUNCTION", "enumerate(instructions)" ], [ "LOAD_FAST", "indices" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_FAST", "indices" ], [ "CALL_FUNCTION", "only(indices)" ], [ "BINARY_SUBTRACT", "only(indices) - 1" ], [ "LOAD_FAST", "instructions" ], [ "LOAD_FAST", "arg_index" ], [ "BINARY_SUBSCR", "instructions[arg_index]" ], [ "LOAD_ATTR", "instructions[arg_index].opname" ], [ "COMPARE_OP", "instructions[arg_index].opname == 'EXTENDED_ARG'" ], [ "LOAD_FAST", "instructions" ], [ "LOAD_FAST", "arg_index" ], [ "BINARY_SUBSCR", "instructions[arg_index]" ], [ "LOAD_ATTR", "instructions[arg_index].offset" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_lasti" ], [ "COMPARE_OP", "instructions[arg_index].offset == self.frame.f_lasti" ], [ "LOAD_FAST", "expr" ], [ "LOAD_FAST", "instruction" ], [ "LOAD_ATTR", "instruction.argval" ], [ "LOAD_GLOBAL", "sentinel" ], [ "COMPARE_OP", "instruction.argval == sentinel" ], [ "LOAD_FAST", "i" ], [ "LOAD_GLOBAL", "compile_similar_to" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tree" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_code" ], [ "CALL_FUNCTION", "compile_similar_to(self.tree, self.frame.f_code)" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_GLOBAL", "find_codes" ], [ "LOAD_FAST", "module_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_code" ], [ "CALL_FUNCTION", "find_codes(module_code, self.frame.f_code)" ], [ "CALL_FUNCTION", "only(find_codes(module_code, self.frame.f_code))" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "get_instructions" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "get_instructions(code)" ], [ "CALL_FUNCTION", "list(get_instructions(code))" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.iter_fields" ], [ "LOAD_DEREF", "parent" ], [ "CALL_FUNCTION", "ast.iter_fields(parent)" ], [ "LOAD_DEREF", "field" ], [ "LOAD_FAST", "node" ], [ "COMPARE_OP", "field is node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_DEREF", "field" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "isinstance(field, list)" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_DEREF", "field" ], [ "CALL_FUNCTION", "enumerate(field)" ], [ "LOAD_FAST", "item" ], [ "LOAD_FAST", "node" ], [ "COMPARE_OP", "item is node" ], [ "LOAD_FAST", "setter" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_DEREF", "parent" ], [ "LOAD_DEREF", "name" ], [ "LOAD_FAST", "new_node" ], [ "CALL_FUNCTION", "setattr(parent, name, new_node)" ], [ "LOAD_FAST", "new_node" ], [ "LOAD_DEREF", "field" ], [ "LOAD_DEREF", "i" ], [ "LOAD_DEREF", "matches" ], [ "LOAD_FAST", "root_code" ], [ "CALL_FUNCTION", "matches(root_code)" ], [ "LOAD_DEREF", "code_options" ], [ "LOAD_ATTR", "code_options.append" ], [ "LOAD_FAST", "root_code" ], [ "CALL_FUNCTION", "code_options.append(root_code)" ], [ "LOAD_DEREF", "finder" ], [ "LOAD_FAST", "root_code" ], [ "CALL_FUNCTION", "finder(root_code)" ], [ "LOAD_DEREF", "code_options" ], [ "LOAD_GLOBAL", "all" ], [ "LOAD_GLOBAL", "attrgetter" ], [ "CALL_FUNCTION", "attrgetter('co_firstlineno')" ], [ "LOAD_GLOBAL", "attrgetter" ], [ "CALL_FUNCTION", "attrgetter('co_name')" ], [ "LOAD_GLOBAL", "code_names" ], [ "CALL_FUNCTION", "all(\n f(c) == f(matching)\n for f in [\n attrgetter('co_firstlineno'),\n attrgetter('co_name'),\n code_names,\n ]\n )" ], [ "LOAD_FAST", "f" ], [ "LOAD_DEREF", "c" ], [ "CALL_FUNCTION", "f(c)" ], [ "LOAD_FAST", "f" ], [ "LOAD_DEREF", "matching" ], [ "CALL_FUNCTION", "f(matching)" ], [ "COMPARE_OP", "f(c) == f(matching)" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_consts" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.iscode" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "inspect.iscode(const)" ], [ "LOAD_DEREF", "matches" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "matches(const)" ], [ "LOAD_DEREF", "code_options" ], [ "LOAD_ATTR", "code_options.append" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "code_options.append(const)" ], [ "LOAD_DEREF", "finder" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "finder(const)" ], [ "LOAD_GLOBAL", "frozenset" ], [ "CALL_FUNCTION", "frozenset()" ], [ "LOAD_ATTR", "frozenset().union" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_names" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_varnames" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_freevars" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_cellvars" ], [ "CALL_FUNCTION", "frozenset().union(\n code.co_names,\n code.co_varnames,\n code.co_freevars,\n code.co_cellvars,\n )" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "CALL_FUNCTION", "isinstance(node, ast.stmt)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_FAST", "node" ] ], "import_hook.py": [ [ "LOAD_NAME", "object" ], [ "LOAD_FAST", "spec" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "deep" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "eye" ], [ "LOAD_ATTR", "eye.exec_string" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.source" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._spec" ], [ "LOAD_ATTR", "self._spec.origin" ], [ "LOAD_FAST", "module" ], [ "LOAD_ATTR", "module.__dict__" ], [ "LOAD_FAST", "module" ], [ "LOAD_ATTR", "module.__dict__" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.deep" ], [ "CALL_FUNCTION", "eye.exec_string(\n source=self.source,\n filename=self._spec.origin,\n globs=module.__dict__,\n locs=module.__dict__,\n deep=self.deep,\n )" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._spec" ], [ "LOAD_ATTR", "self._spec.loader" ], [ "LOAD_ATTR", "self._spec.loader.get_filename" ], [ "LOAD_FAST", "fullname" ], [ "CALL_FUNCTION", "self._spec.loader.get_filename(fullname)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._spec" ], [ "LOAD_ATTR", "self._spec.loader" ], [ "LOAD_ATTR", "self._spec.loader.is_package" ], [ "LOAD_FAST", "fullname" ], [ "CALL_FUNCTION", "self._spec.loader.is_package(fullname)" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.meta_path" ], [ "LOAD_FAST", "finder" ], [ "LOAD_FAST", "self" ], [ "COMPARE_OP", "finder is self" ], [ "LOAD_FAST", "finder" ], [ "LOAD_ATTR", "finder.__module__" ], [ "COMPARE_OP", "'pytest' in finder.__module__" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "finder" ], [ "CALL_FUNCTION", "hasattr(finder, 'find_spec')" ], [ "LOAD_FAST", "finder" ], [ "LOAD_ATTR", "finder.find_spec" ], [ "LOAD_FAST", "fullname" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "target" ], [ "CALL_FUNCTION", "finder.find_spec(fullname, path, target=target)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "finder" ], [ "CALL_FUNCTION", "hasattr(finder, 'load_module')" ], [ "LOAD_GLOBAL", "spec_from_loader" ], [ "LOAD_FAST", "fullname" ], [ "LOAD_FAST", "finder" ], [ "CALL_FUNCTION", "spec_from_loader(fullname, finder)" ], [ "LOAD_FAST", "spec" ], [ "COMPARE_OP", "spec is not None" ], [ "LOAD_FAST", "spec" ], [ "LOAD_ATTR", "spec.origin" ], [ "COMPARE_OP", "spec.origin != 'builtin'" ], [ "LOAD_FAST", "spec" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._find_plain_spec" ], [ "LOAD_FAST", "fullname" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "target" ], [ "CALL_FUNCTION", "self._find_plain_spec(fullname, path, target)" ], [ "LOAD_FAST", "spec" ], [ "COMPARE_OP", "spec is None" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "spec" ], [ "LOAD_ATTR", "spec.loader" ], [ "CALL_FUNCTION", "hasattr(spec.loader, 'get_source')" ], [ "LOAD_GLOBAL", "callable" ], [ "LOAD_FAST", "spec" ], [ "LOAD_ATTR", "spec.loader" ], [ "LOAD_ATTR", "spec.loader.get_source" ], [ "CALL_FUNCTION", "callable(spec.loader.get_source)" ], [ "UNARY_NOT", "not (hasattr(spec.loader, 'get_source') and\n callable(spec.loader.get_source))" ], [ "LOAD_FAST", "fullname" ], [ "COMPARE_OP", "fullname != 'org'" ], [ "LOAD_GLOBAL", "logging" ], [ "LOAD_ATTR", "logging.debug" ], [ "LOAD_FAST", "fullname" ], [ "CALL_FUNCTION", "logging.debug('Failed finding spec for %s', fullname)" ], [ "LOAD_FAST", "spec" ], [ "LOAD_ATTR", "spec.loader" ], [ "LOAD_ATTR", "spec.loader.get_source" ], [ "LOAD_FAST", "fullname" ], [ "CALL_FUNCTION", "spec.loader.get_source(fullname)" ], [ "LOAD_GLOBAL", "ImportError" ], [ "LOAD_GLOBAL", "logging" ], [ "LOAD_ATTR", "logging.debug" ], [ "LOAD_FAST", "fullname" ], [ "CALL_FUNCTION", "logging.debug('Loader for %s was unable to find the sources',\n fullname)" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_GLOBAL", "logging" ], [ "LOAD_ATTR", "logging.exception" ], [ "LOAD_FAST", "fullname" ], [ "CALL_FUNCTION", "logging.exception('Loader for %s raised an error', fullname)" ], [ "LOAD_FAST", "source" ], [ "UNARY_NOT", "not source" ], [ "LOAD_FAST", "source" ], [ "COMPARE_OP", "'birdseye' not in source" ], [ "LOAD_GLOBAL", "should_trace" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "should_trace(source)" ], [ "LOAD_FAST", "trace_stmt" ], [ "LOAD_GLOBAL", "BirdsEyeLoader" ], [ "LOAD_FAST", "spec" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "deep" ], [ "CALL_FUNCTION", "BirdsEyeLoader(spec, source, deep)" ], [ "LOAD_GLOBAL", "spec_from_loader" ], [ "LOAD_FAST", "fullname" ], [ "LOAD_FAST", "loader" ], [ "CALL_FUNCTION", "spec_from_loader(fullname, loader)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.parse" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "ast.parse(source)" ], [ "LOAD_ATTR", "ast.parse(source).body" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Import" ], [ "CALL_FUNCTION", "isinstance(stmt, ast.Import)" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_ATTR", "stmt.names" ], [ "LOAD_FAST", "alias" ], [ "LOAD_ATTR", "alias.name" ], [ "LOAD_ATTR", "alias.name.startswith" ], [ "CALL_FUNCTION", "alias.name.startswith('birdseye.trace_module')" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_FAST", "alias" ], [ "LOAD_ATTR", "alias.name" ], [ "LOAD_ATTR", "alias.name.endswith" ], [ "CALL_FUNCTION", "alias.name.endswith('deep')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.ImportFrom" ], [ "CALL_FUNCTION", "isinstance(stmt, ast.ImportFrom)" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_ATTR", "stmt.module" ], [ "COMPARE_OP", "stmt.module == 'birdseye'" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_ATTR", "stmt.names" ], [ "LOAD_FAST", "alias" ], [ "LOAD_ATTR", "alias.name" ], [ "LOAD_ATTR", "alias.name.startswith" ], [ "CALL_FUNCTION", "alias.name.startswith('trace_module')" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_FAST", "alias" ], [ "LOAD_ATTR", "alias.name" ], [ "LOAD_ATTR", "alias.name.endswith" ], [ "CALL_FUNCTION", "alias.name.endswith('deep')" ], [ "LOAD_FAST", "deep" ], [ "LOAD_FAST", "trace_stmt" ] ], "ipython.py": [ [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "BytesIO" ], [ "LOAD_NAME", "StringIO" ], [ "LOAD_NAME", "stream_proxy" ], [ "LOAD_NAME", "sys" ], [ "LOAD_ATTR", "sys.stderr" ], [ "CALL_FUNCTION", "stream_proxy(sys.stderr)" ], [ "LOAD_NAME", "sys" ], [ "LOAD_NAME", "stream_proxy" ], [ "LOAD_NAME", "sys" ], [ "LOAD_ATTR", "sys.stdout" ], [ "CALL_FUNCTION", "stream_proxy(sys.stdout)" ], [ "LOAD_NAME", "sys" ], [ "LOAD_NAME", "Environment" ], [ "LOAD_NAME", "PackageLoader" ], [ "CALL_FUNCTION", "PackageLoader('birdseye', 'templates')" ], [ "LOAD_NAME", "select_autoescape" ], [ "CALL_FUNCTION", "select_autoescape(['html', 'xml'])" ], [ "CALL_FUNCTION", "Environment(\n loader=PackageLoader('birdseye', 'templates'),\n autoescape=select_autoescape(['html', 'xml'])\n)" ], [ "LOAD_NAME", "magics_class" ], [ "LOAD_NAME", "Magics" ], [ "CALL_FUNCTION", "magics_class" ], [ "LOAD_GLOBAL", "LocalProxy" ], [ "LOAD_FAST", "p" ], [ "CALL_FUNCTION", "LocalProxy(p)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.currentframe" ], [ "CALL_FUNCTION", "inspect.currentframe()" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_GLOBAL", "ThreadingMixIn" ], [ "LOAD_ATTR", "ThreadingMixIn.process_request_thread" ], [ "LOAD_ATTR", "ThreadingMixIn.process_request_thread.__code__" ], [ "COMPARE_OP", "frame.f_code == ThreadingMixIn.process_request_thread.__code__" ], [ "LOAD_GLOBAL", "fake_stream" ], [ "CALL_FUNCTION", "fake_stream()" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_GLOBAL", "thread_proxies" ], [ "LOAD_ATTR", "thread_proxies.get" ], [ "LOAD_GLOBAL", "currentThread" ], [ "CALL_FUNCTION", "currentThread()" ], [ "LOAD_ATTR", "currentThread().ident" ], [ "LOAD_DEREF", "original" ], [ "CALL_FUNCTION", "thread_proxies.get(currentThread().ident,\n original)" ], [ "LOAD_FAST", "show_server_output" ], [ "LOAD_GLOBAL", "fake_stream" ], [ "CALL_FUNCTION", "fake_stream()" ], [ "LOAD_GLOBAL", "thread_proxies" ], [ "LOAD_GLOBAL", "currentThread" ], [ "CALL_FUNCTION", "currentThread()" ], [ "LOAD_ATTR", "currentThread().ident" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_ATTR", "server.app" ], [ "LOAD_ATTR", "server.app.run" ], [ "LOAD_FAST", "port" ], [ "LOAD_FAST", "bind_host" ], [ "CALL_FUNCTION", "server.app.run(\n debug=True,\n port=port,\n host=bind_host,\n use_reloader=False,\n )" ], [ "LOAD_GLOBAL", "socket" ], [ "LOAD_ATTR", "socket.error" ], [ "LOAD_NAME", "Unicode" ], [ "CALL_FUNCTION", "Unicode(\n u'', config=True,\n help='If set, a server will not be automatically started by %%eye. '\n 'The iframe containing birdseye output will use this value as the base '\n 'of its URL.'\n )" ], [ "LOAD_NAME", "Int" ], [ "CALL_FUNCTION", "Int(\n 7777, config=True,\n help='Port number for the server started by %%eye.'\n )" ], [ "LOAD_NAME", "Unicode" ], [ "CALL_FUNCTION", "Unicode(\n '127.0.0.1', config=True,\n help='Host that the server started by %%eye listens on. '\n 'Set to 0.0.0.0 to make it accessible anywhere.'\n )" ], [ "LOAD_NAME", "Bool" ], [ "CALL_FUNCTION", "Bool(\n False, config=True,\n help='Set to True to show stdout and stderr from the server started by %%eye.'\n )" ], [ "LOAD_NAME", "Unicode" ], [ "CALL_FUNCTION", "Unicode(\n u'', config=True,\n help='The database URL that the server started by %%eye reads from. '\n 'Equivalent to the environment variable BIRDSEYE_DB.'\n )" ], [ "LOAD_NAME", "cell_magic" ], [ "CALL_FUNCTION", "cell_magic" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.server_url" ], [ "LOAD_GLOBAL", "Database" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.db_url" ], [ "CALL_FUNCTION", "Database(self.db_url)" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_ATTR", "server.db" ], [ "LOAD_ATTR", "server.db.Function" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_ATTR", "server.db" ], [ "LOAD_ATTR", "server.db.Call" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_ATTR", "server.db" ], [ "LOAD_ATTR", "server.db.Session" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_GLOBAL", "Thread" ], [ "LOAD_GLOBAL", "run_server" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.port" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.bind_host" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.show_server_output" ], [ "CALL_FUNCTION", "Thread(\n target=run_server,\n args=(\n self.port,\n self.bind_host,\n self.show_server_output,\n ),\n )" ], [ "LOAD_ATTR", "Thread(\n target=run_server,\n args=(\n self.port,\n self.bind_host,\n self.show_server_output,\n ),\n ).start" ], [ "CALL_FUNCTION", "Thread(\n target=run_server,\n args=(\n self.port,\n self.bind_host,\n self.show_server_output,\n ),\n ).start()" ], [ "LOAD_GLOBAL", "Database" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.db_url" ], [ "CALL_FUNCTION", "Database(self.db_url)" ], [ "LOAD_GLOBAL", "eye" ], [ "LOAD_GLOBAL", "eye" ], [ "LOAD_ATTR", "eye.exec_ipython_cell" ], [ "LOAD_FAST", "cell" ], [ "LOAD_FAST", "callback" ], [ "CALL_FUNCTION", "eye.exec_ipython_cell(cell, callback)" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "call_id" ], [ "COMPARE_OP", "call_id is None" ], [ "LOAD_GLOBAL", "HTML" ], [ "LOAD_GLOBAL", "templates_env" ], [ "LOAD_ATTR", "templates_env.get_template" ], [ "CALL_FUNCTION", "templates_env.get_template('ipython_iframe.html')" ], [ "LOAD_ATTR", "templates_env.get_template('ipython_iframe.html').render" ], [ "LOAD_FAST", "call_id" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.server_url" ], [ "LOAD_ATTR", "self.server_url.rstrip" ], [ "CALL_FUNCTION", "self.server_url.rstrip('/')" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.port" ], [ "LOAD_GLOBAL", "uuid4" ], [ "CALL_FUNCTION", "uuid4()" ], [ "LOAD_ATTR", "uuid4().hex" ], [ "CALL_FUNCTION", "templates_env.get_template('ipython_iframe.html').render(\n call_id=call_id,\n url=self.server_url.rstrip('/'),\n port=self.port,\n container_id=uuid4().hex,\n )" ], [ "CALL_FUNCTION", "HTML(templates_env.get_template('ipython_iframe.html').render(\n call_id=call_id,\n url=self.server_url.rstrip('/'),\n port=self.port,\n container_id=uuid4().hex,\n ))" ], [ "LOAD_GLOBAL", "display" ], [ "LOAD_FAST", "html" ], [ "CALL_FUNCTION", "display(html)" ] ], "server.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOAD_ATTR", "standard_library.install_aliases" ], [ "CALL_FUNCTION", "standard_library.install_aliases()" ], [ "LOAD_NAME", "Flask" ], [ "CALL_FUNCTION", "Flask('birdseye')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.jinja_env" ], [ "LOAD_NAME", "Humanize" ], [ "LOAD_NAME", "app" ], [ "CALL_FUNCTION", "Humanize(app)" ], [ "LOAD_NAME", "PathConverter" ], [ "LOAD_NAME", "FileConverter" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.url_map" ], [ "LOAD_ATTR", "app.url_map.converters" ], [ "LOAD_NAME", "Database" ], [ "CALL_FUNCTION", "Database()" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.Session" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.Function" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.Call" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION", "app.route('/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION", "app.route('/file/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/file/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION", "app.route('/file//__function__/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/file//__function__/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION", "app.route('/api/file//__function__//latest_call/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/api/file//__function__//latest_call/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION", "app.route('/call/')" ], [ "CALL_FUNCTION", "app.route('/call/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION", "app.route('/ipython_call/')" ], [ "CALL_FUNCTION", "app.route('/ipython_call/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION", "app.route('/ipython_iframe/')" ], [ "CALL_FUNCTION", "app.route('/ipython_iframe/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION", "app.route('/kill', methods=['POST'])" ], [ "CALL_FUNCTION", "app.route('/kill', methods=['POST'])" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION", "app.route('/api/call/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/api/call/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION", "app.route('/api/calls_by_body_hash/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/api/calls_by_body_hash/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION", "app.route('/api/body_hashes_present/', methods=['POST'])" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/api/body_hashes_present/', methods=['POST'])" ], [ "LOAD_NAME", "sys" ], [ "LOAD_ATTR", "sys.argv" ], [ "BINARY_SUBSCR", "sys.argv[1:]" ], [ "LOAD_NAME", "__name__" ], [ "COMPARE_OP", "__name__ == '__main__'" ], [ "LOAD_NAME", "main" ], [ "CALL_FUNCTION", "main()" ], [ "LOAD_GLOBAL", "db" ], [ "LOAD_ATTR", "db.all_file_paths" ], [ "CALL_FUNCTION", "db.all_file_paths()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_columns" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.basic_columns" ], [ "BINARY_ADD", "Call.basic_columns + Function.basic_columns" ], [ "CALL_FUNCTION_VAR", "session.query(*(Call.basic_columns + Function.basic_columns))" ], [ "LOAD_ATTR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_FUNCTION", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)" ], [ "LOAD_ATTR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .order_by" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.start_time" ], [ "LOAD_ATTR", "Call.start_time.desc" ], [ "CALL_FUNCTION", "Call.start_time.desc()" ], [ "CALL_FUNCTION", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .order_by(Call.start_time.desc())" ], [ "BINARY_SUBSCR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .order_by(Call.start_time.desc())[:100]" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "CALL_FUNCTION", "OrderedDict()" ], [ "LOAD_FAST", "recent_calls" ], [ "LOAD_GLOBAL", "is_ipython_cell" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.file" ], [ "CALL_FUNCTION", "is_ipython_cell(row.file)" ], [ "LOAD_FAST", "files" ], [ "LOAD_ATTR", "files.setdefault" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.file" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "CALL_FUNCTION", "OrderedDict()" ], [ "CALL_FUNCTION", "files.setdefault(\n row.file, OrderedDict()\n )" ], [ "LOAD_ATTR", "files.setdefault(\n row.file, OrderedDict()\n ).setdefault" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.name" ], [ "LOAD_FAST", "row" ], [ "CALL_FUNCTION", "files.setdefault(\n row.file, OrderedDict()\n ).setdefault(\n row.name, row\n )" ], [ "LOAD_FAST", "all_paths" ], [ "LOAD_FAST", "files" ], [ "LOAD_ATTR", "files.setdefault" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "CALL_FUNCTION", "OrderedDict()" ], [ "CALL_FUNCTION", "files.setdefault(\n path, OrderedDict()\n )" ], [ "LOAD_GLOBAL", "partial" ], [ "LOAD_GLOBAL", "short_path" ], [ "LOAD_FAST", "all_paths" ], [ "CALL_FUNCTION", "partial(short_path, all_paths=all_paths)" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "short" ], [ "LOAD_FAST", "files" ], [ "CALL_FUNCTION", "render_template('index.html',\n short=short,\n files=files)" ], [ "LOAD_GLOBAL", "fix_abs_path" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "fix_abs_path(path)" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_columns" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.basic_columns" ], [ "BINARY_ADD", "Call.basic_columns + Function.basic_columns" ], [ "CALL_FUNCTION_VAR", "session.query(*(Call.basic_columns + Function.basic_columns))" ], [ "LOAD_ATTR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_FUNCTION", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)" ], [ "LOAD_ATTR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path)" ], [ "LOAD_ATTR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path)\n .subquery" ], [ "CALL_FUNCTION", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path)\n .subquery('filtered_calls')" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.name" ], [ "LOAD_GLOBAL", "sqlalchemy" ], [ "LOAD_ATTR", "sqlalchemy.func" ], [ "LOAD_ATTR", "sqlalchemy.func.max" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.start_time" ], [ "CALL_FUNCTION", "sqlalchemy.func.max(filtered_calls.c.start_time)" ], [ "LOAD_ATTR", "sqlalchemy.func.max(filtered_calls.c.start_time).label" ], [ "CALL_FUNCTION", "sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')" ], [ "CALL_FUNCTION", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n )" ], [ "LOAD_ATTR", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n ).group_by" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.name" ], [ "CALL_FUNCTION", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n ).group_by(\n filtered_calls.c.name,\n )" ], [ "LOAD_ATTR", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n ).group_by(\n filtered_calls.c.name,\n ).subquery" ], [ "CALL_FUNCTION", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n ).group_by(\n filtered_calls.c.name,\n ).subquery('latest_calls')" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_FAST", "filtered_calls" ], [ "CALL_FUNCTION", "session.query(filtered_calls)" ], [ "LOAD_ATTR", "session.query(filtered_calls).join" ], [ "LOAD_FAST", "latest_calls" ], [ "LOAD_GLOBAL", "sqlalchemy" ], [ "LOAD_ATTR", "sqlalchemy.and_" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.name" ], [ "LOAD_FAST", "latest_calls" ], [ "LOAD_ATTR", "latest_calls.c" ], [ "LOAD_ATTR", "latest_calls.c.name" ], [ "COMPARE_OP", "filtered_calls.c.name == latest_calls.c.name" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.start_time" ], [ "LOAD_FAST", "latest_calls" ], [ "LOAD_ATTR", "latest_calls.c" ], [ "LOAD_ATTR", "latest_calls.c.maxtime" ], [ "COMPARE_OP", "filtered_calls.c.start_time == latest_calls.c.maxtime" ], [ "CALL_FUNCTION", "sqlalchemy.and_(\n filtered_calls.c.name == latest_calls.c.name,\n filtered_calls.c.start_time == latest_calls.c.maxtime,\n )" ], [ "CALL_FUNCTION", "session.query(filtered_calls).join(\n latest_calls,\n sqlalchemy.and_(\n filtered_calls.c.name == latest_calls.c.name,\n filtered_calls.c.start_time == latest_calls.c.maxtime,\n )\n )" ], [ "LOAD_ATTR", "session.query(filtered_calls).join(\n latest_calls,\n sqlalchemy.and_(\n filtered_calls.c.name == latest_calls.c.name,\n filtered_calls.c.start_time == latest_calls.c.maxtime,\n )\n ).order_by" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.start_time" ], [ "LOAD_ATTR", "filtered_calls.c.start_time.desc" ], [ "CALL_FUNCTION", "filtered_calls.c.start_time.desc()" ], [ "CALL_FUNCTION", "session.query(filtered_calls).join(\n latest_calls,\n sqlalchemy.and_(\n filtered_calls.c.name == latest_calls.c.name,\n filtered_calls.c.start_time == latest_calls.c.maxtime,\n )\n ).order_by(filtered_calls.c.start_time.desc())" ], [ "LOAD_GLOBAL", "group_by_attr" ], [ "LOAD_FAST", "query" ], [ "CALL_FUNCTION", "group_by_attr(query, 'type')" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.name" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.type" ], [ "CALL_FUNCTION", "session.query(Function.name, Function.type)" ], [ "LOAD_ATTR", "session.query(Function.name, Function.type)\n .filter_by" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "session.query(Function.name, Function.type)\n .filter_by(file=path)" ], [ "LOAD_ATTR", "session.query(Function.name, Function.type)\n .filter_by(file=path)\n .distinct" ], [ "CALL_FUNCTION", "session.query(Function.name, Function.type)\n .filter_by(file=path)\n .distinct()" ], [ "CALL_FUNCTION", "sorted(session.query(Function.name, Function.type)\n .filter_by(file=path)\n .distinct())" ], [ "LOAD_FAST", "query" ], [ "LOAD_FAST", "all_funcs" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.name" ], [ "LOAD_FAST", "func_names" ], [ "COMPARE_OP", "func.name not in func_names" ], [ "LOAD_FAST", "funcs" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.type" ], [ "BINARY_SUBSCR", "funcs[func.type]" ], [ "LOAD_ATTR", "funcs[func.type].append" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "funcs[func.type].append(func)" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "funcs" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "COMPARE_OP", "path == IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "basename" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "basename(path)" ], [ "CALL_FUNCTION", "render_template('file.html',\n funcs=funcs,\n is_ipython=path == IPYTHON_FILE_PATH,\n full_path=path,\n short_path=basename(path))" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.name" ], [ "LOAD_GLOBAL", "fix_abs_path" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "fix_abs_path(path)" ], [ "LOAD_GLOBAL", "get_calls" ], [ "LOAD_FAST", "session" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "func_name" ], [ "CALL_FUNCTION", "get_calls(session, path, func_name, 200)" ], [ "LOAD_FAST", "query" ], [ "LOAD_FAST", "query" ], [ "BINARY_SUBSCR", "query[0]" ], [ "LOAD_FAST", "query" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_FUNCTION", "session.query(Function)" ], [ "LOAD_ATTR", "session.query(Function).filter_by" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "func_name" ], [ "CALL_FUNCTION", "session.query(Function).filter_by(file=path, name=func_name)" ], [ "BINARY_SUBSCR", "session.query(Function).filter_by(file=path, name=func_name)[0]" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "func" ], [ "LOAD_GLOBAL", "basename" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "basename(path)" ], [ "LOAD_FAST", "calls" ], [ "CALL_FUNCTION", "render_template('function.html',\n func=func,\n short_path=basename(path),\n calls=calls)" ], [ "LOAD_GLOBAL", "withattrs" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_FUNCTION", "Call()" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row._asdict" ], [ "CALL_FUNCTION", "row._asdict()" ], [ "CALL_FUNCTION_KW", "withattrs(Call(), **row._asdict())" ], [ "LOAD_GLOBAL", "fix_abs_path" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "fix_abs_path(path)" ], [ "LOAD_GLOBAL", "get_calls" ], [ "LOAD_FAST", "session" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "func_name" ], [ "CALL_FUNCTION", "get_calls(session, path, func_name, 1)" ], [ "BINARY_SUBSCR", "get_calls(session, path, func_name, 1)[0]" ], [ "LOAD_GLOBAL", "jsonify" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.id" ], [ "LOAD_GLOBAL", "url_for" ], [ "LOAD_GLOBAL", "call_view" ], [ "LOAD_ATTR", "call_view.__name__" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.id" ], [ "CALL_FUNCTION", "url_for(call_view.__name__,\n call_id=call.id)" ], [ "CALL_FUNCTION", "dict(\n id=call.id,\n url=url_for(call_view.__name__,\n call_id=call.id),\n )" ], [ "CALL_FUNCTION", "jsonify(dict(\n id=call.id,\n url=url_for(call_view.__name__,\n call_id=call.id),\n ))" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_columns" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.basic_columns" ], [ "BINARY_ADD", "Call.basic_columns + Function.basic_columns" ], [ "CALL_FUNCTION_VAR", "session.query(*(Call.basic_columns + Function.basic_columns))" ], [ "LOAD_ATTR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_FUNCTION", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)" ], [ "LOAD_ATTR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "func_name" ], [ "CALL_FUNCTION", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path, name=func_name)" ], [ "LOAD_ATTR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path, name=func_name)\n .order_by" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.start_time" ], [ "LOAD_ATTR", "Call.start_time.desc" ], [ "CALL_FUNCTION", "Call.start_time.desc()" ], [ "CALL_FUNCTION", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path, name=func_name)\n .order_by(Call.start_time.desc())" ], [ "LOAD_FAST", "limit" ], [ "BINARY_SUBSCR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path, name=func_name)\n .order_by(Call.start_time.desc())[:limit]" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_FUNCTION", "session.query(Call)" ], [ "LOAD_ATTR", "session.query(Call).filter_by" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION", "session.query(Call).filter_by(id=call_id)" ], [ "LOAD_ATTR", "session.query(Call).filter_by(id=call_id).one" ], [ "CALL_FUNCTION", "session.query(Call).filter_by(id=call_id).one()" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.function" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "template" ], [ "LOAD_GLOBAL", "basename" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.file" ], [ "CALL_FUNCTION", "basename(func.file)" ], [ "LOAD_FAST", "call" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "render_template(template,\n short_path=basename(func.file),\n call=call,\n func=func)" ], [ "LOAD_GLOBAL", "base_call_view" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION", "base_call_view(call_id, 'call.html')" ], [ "LOAD_GLOBAL", "base_call_view" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION", "base_call_view(call_id, 'ipython_call.html')" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION", "render_template('ipython_iframe.html',\n container_id='1234',\n port=7777,\n call_id=call_id)" ], [ "LOAD_GLOBAL", "request" ], [ "LOAD_ATTR", "request.environ" ], [ "LOAD_ATTR", "request.environ.get" ], [ "CALL_FUNCTION", "request.environ.get('werkzeug.server.shutdown')" ], [ "LOAD_FAST", "func" ], [ "COMPARE_OP", "func is None" ], [ "LOAD_GLOBAL", "RuntimeError" ], [ "CALL_FUNCTION", "RuntimeError('Not running with the Werkzeug Server')" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "func()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_FUNCTION", "session.query(Call)" ], [ "LOAD_ATTR", "session.query(Call).filter_by" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION", "session.query(Call).filter_by(id=call_id)" ], [ "LOAD_ATTR", "session.query(Call).filter_by(id=call_id).one" ], [ "CALL_FUNCTION", "session.query(Call).filter_by(id=call_id).one()" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.function" ], [ "LOAD_GLOBAL", "DecentJSONEncoder" ], [ "CALL_FUNCTION", "DecentJSONEncoder()" ], [ "LOAD_ATTR", "DecentJSONEncoder().encode" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.parsed_data" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_dict" ], [ "LOAD_FAST", "call" ], [ "CALL_FUNCTION", "Call.basic_dict(call)" ], [ "CALL_FUNCTION_KW", "dict(data=call.parsed_data, **Call.basic_dict(call))" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.parsed_data" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.basic_dict" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "Function.basic_dict(func)" ], [ "CALL_FUNCTION_KW", "dict(data=func.parsed_data, **Function.basic_dict(func))" ], [ "CALL_FUNCTION", "dict(\n call=dict(data=call.parsed_data, **Call.basic_dict(call)),\n function=dict(data=func.parsed_data, **Function.basic_dict(func)))" ], [ "CALL_FUNCTION", "DecentJSONEncoder().encode(dict(\n call=dict(data=call.parsed_data, **Call.basic_dict(call)),\n function=dict(data=func.parsed_data, **Function.basic_dict(func))))" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_columns" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.data" ], [ "BINARY_ADD", "Call.basic_columns + (Function.data,)" ], [ "CALL_FUNCTION_VAR", "session.query(*Call.basic_columns + (Function.data,))" ], [ "LOAD_ATTR", "session.query(*Call.basic_columns + (Function.data,))\n .join" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_FUNCTION", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)" ], [ "LOAD_ATTR", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by" ], [ "LOAD_FAST", "body_hash" ], [ "CALL_FUNCTION", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by(body_hash=body_hash)" ], [ "LOAD_ATTR", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by(body_hash=body_hash)\n .order_by" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.start_time" ], [ "LOAD_ATTR", "Call.start_time.desc" ], [ "CALL_FUNCTION", "Call.start_time.desc()" ], [ "CALL_FUNCTION", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by(body_hash=body_hash)\n .order_by(Call.start_time.desc())" ], [ "BINARY_SUBSCR", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by(body_hash=body_hash)\n .order_by(Call.start_time.desc())[:200]" ], [ "LOAD_FAST", "query" ], [ "LOAD_FAST", "query" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "function_data_set" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_ATTR", "json.loads" ], [ "LOAD_DEREF", "function_data" ], [ "CALL_FUNCTION", "json.loads(function_data)" ], [ "LOAD_FAST", "add" ], [ "LOAD_FAST", "ranges" ], [ "CALL_FUNCTION", "add('node_ranges', ranges)" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "add" ], [ "LOAD_FAST", "current_loop_ranges" ], [ "CALL_FUNCTION", "add('loop_ranges', current_loop_ranges)" ], [ "LOAD_FAST", "loop_ranges" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "current_loop_ranges" ], [ "COMPARE_OP", "loop_ranges in (set(), current_loop_ranges)" ], [ "LOAD_FAST", "current_loop_ranges" ], [ "LOAD_FAST", "ranges" ], [ "LOAD_FAST", "loop_ranges" ], [ "LOAD_GLOBAL", "DecentJSONEncoder" ], [ "CALL_FUNCTION", "DecentJSONEncoder()" ], [ "LOAD_ATTR", "DecentJSONEncoder().encode" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "calls" ], [ "LOAD_FAST", "ranges" ], [ "LOAD_FAST", "loop_ranges" ], [ "CALL_FUNCTION", "dict(\n calls=calls, ranges=ranges, loop_ranges=loop_ranges)" ], [ "CALL_FUNCTION", "DecentJSONEncoder().encode(dict(\n calls=calls, ranges=ranges, loop_ranges=loop_ranges))" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_dict" ], [ "LOAD_GLOBAL", "withattrs" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_FUNCTION", "Call()" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row._asdict" ], [ "CALL_FUNCTION", "row._asdict()" ], [ "CALL_FUNCTION_KW", "withattrs(Call(), **row._asdict())" ], [ "CALL_FUNCTION", "Call.basic_dict(withattrs(Call(), **row._asdict()))" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.data" ], [ "LOAD_DEREF", "function_data" ], [ "LOAD_FAST", "key" ], [ "BINARY_SUBSCR", "function_data[key]" ], [ "LOAD_FAST", "ranges_set" ], [ "LOAD_ATTR", "ranges_set.add" ], [ "LOAD_FAST", "node" ], [ "BINARY_SUBSCR", "node['start']" ], [ "LOAD_FAST", "node" ], [ "BINARY_SUBSCR", "node['end']" ], [ "CALL_FUNCTION", "ranges_set.add((node['start'], node['end']))" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "CALL_FUNCTION", "dict(start=start, end=end)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "CALL_FUNCTION", "dict(start=start, end=end)" ], [ "LOAD_GLOBAL", "request" ], [ "LOAD_ATTR", "request.get_json" ], [ "CALL_FUNCTION", "request.get_json()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.body_hash" ], [ "LOAD_GLOBAL", "sqlalchemy" ], [ "LOAD_ATTR", "sqlalchemy.func" ], [ "LOAD_ATTR", "sqlalchemy.func.count" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.id" ], [ "CALL_FUNCTION", "sqlalchemy.func.count(Call.id)" ], [ "CALL_FUNCTION", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))" ], [ "LOAD_ATTR", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_FUNCTION", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)" ], [ "LOAD_ATTR", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)\n .filter" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.body_hash" ], [ "LOAD_ATTR", "Function.body_hash.in_" ], [ "LOAD_FAST", "hashes" ], [ "CALL_FUNCTION", "Function.body_hash.in_(hashes)" ], [ "CALL_FUNCTION", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)\n .filter(Function.body_hash.in_(hashes))" ], [ "LOAD_ATTR", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)\n .filter(Function.body_hash.in_(hashes))\n .group_by" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.body_hash" ], [ "CALL_FUNCTION", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)\n .filter(Function.body_hash.in_(hashes))\n .group_by(Function.body_hash)" ], [ "LOAD_GLOBAL", "DecentJSONEncoder" ], [ "CALL_FUNCTION", "DecentJSONEncoder()" ], [ "LOAD_ATTR", "DecentJSONEncoder().encode" ], [ "LOAD_FAST", "query" ], [ "CALL_FUNCTION", "DecentJSONEncoder().encode([\n dict(hash=h, count=count)\n for h, count in query\n ])" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "h" ], [ "LOAD_FAST", "count" ], [ "CALL_FUNCTION", "dict(hash=h, count=count)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "argv" ], [ "CALL_FUNCTION", "len(argv)" ], [ "COMPARE_OP", "len(argv) == 1" ], [ "LOAD_FAST", "argv" ], [ "BINARY_SUBSCR", "argv[0]" ], [ "LOAD_ATTR", "argv[0].isdigit" ], [ "CALL_FUNCTION", "argv[0].isdigit()" ], [ "LOAD_FAST", "argv" ], [ "LOAD_ATTR", "argv.insert" ], [ "CALL_FUNCTION", "argv.insert(0, '--port')" ], [ "LOAD_GLOBAL", "argparse" ], [ "LOAD_ATTR", "argparse.ArgumentParser" ], [ "CALL_FUNCTION", "argparse.ArgumentParser(description=\"Bird's Eye: A graphical Python debugger\")" ], [ "LOAD_FAST", "parser" ], [ "LOAD_ATTR", "parser.add_argument" ], [ "LOAD_GLOBAL", "int" ], [ "CALL_FUNCTION", "parser.add_argument('-p', '--port', help='HTTP port, default is 7777', default=7777, type=int)" ], [ "LOAD_FAST", "parser" ], [ "LOAD_ATTR", "parser.add_argument" ], [ "CALL_FUNCTION", "parser.add_argument('--host', help=\"HTTP host, default is 'localhost'\", default='localhost')" ], [ "LOAD_FAST", "parser" ], [ "LOAD_ATTR", "parser.parse_args" ], [ "LOAD_FAST", "argv" ], [ "CALL_FUNCTION", "parser.parse_args(argv)" ], [ "LOAD_GLOBAL", "app" ], [ "LOAD_ATTR", "app.run" ], [ "LOAD_FAST", "args" ], [ "LOAD_ATTR", "args.port" ], [ "LOAD_FAST", "args" ], [ "LOAD_ATTR", "args.host" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.environ" ], [ "LOAD_ATTR", "os.environ.get" ], [ "CALL_FUNCTION", "os.environ.get('BIRDSEYE_RELOADER')" ], [ "COMPARE_OP", "os.environ.get('BIRDSEYE_RELOADER') == '1'" ], [ "CALL_FUNCTION", "app.run(\n port=args.port,\n host=args.host,\n use_reloader=os.environ.get('BIRDSEYE_RELOADER') == '1',\n )" ] ], "tests.py": [ [ "LOAD_NAME", "unittest" ], [ "LOAD_ATTR", "unittest.TestCase" ], [ "LOAD_NAME", "unittest" ], [ "LOAD_ATTR", "unittest.TestCase" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "TestFile" ], [ "CALL_FUNCTION", "TestFile()" ], [ "LOAD_ATTR", "TestFile().test_file" ], [ "CALL_FUNCTION", "TestFile().test_file()" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "Tester" ], [ "CALL_FUNCTION", "Tester()" ], [ "LOAD_NAME", "tester" ], [ "CALL_FUNCTION", "tester([1, 2, 3])" ], [ "COMPARE_OP", "tester([1, 2, 3]) == [1, 2, 3]" ], [ "LOAD_NAME", "tester" ], [ "LOAD_ATTR", "tester.asd" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester.asd is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_SUBSCR", "tester[19]" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester[19] is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_POWER", "tester ** 4" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester ** 4 is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_MULTIPLY", "tester * 3" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester * 3 is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_SUBTRACT", "tester - 2" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester - 2 is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_ADD", "tester + 1" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester + 1 is tester" ], [ "LOAD_NAME", "tester" ], [ "UNARY_NEGATIVE", "-tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "-tester is tester" ], [ "LOAD_NAME", "tester" ], [ "UNARY_POSITIVE", "+tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "+tester is tester" ], [ "LOAD_NAME", "tester" ], [ "UNARY_INVERT", "~tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "~tester is tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester < 7" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "(tester < 7) is tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester >= 78" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "(tester >= 78) is tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester != 79" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "(tester != 79) is tester" ], [ "LOAD_NAME", "tester" ], [ "LOAD_ATTR", "tester.foo" ], [ "CALL_FUNCTION", "tester.foo(45, False)" ], [ "COMPARE_OP", "tester.foo(45, False) == 45" ], [ "LOAD_NAME", "__name__" ], [ "COMPARE_OP", "__name__ == '__main__'" ], [ "LOAD_NAME", "unittest" ], [ "LOAD_ATTR", "unittest.main" ], [ "CALL_FUNCTION", "unittest.main()" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(1)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(2)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(3)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(9\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n 8)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n 99\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(33)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([4,\n 5, 6, [\n 7]])" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "LOAD_GLOBAL", "decorator_with_args" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('123')" ], [ "LOAD_GLOBAL", "int" ], [ "CALL_FUNCTION", "int()" ], [ "CALL_FUNCTION", "decorator_with_args(tester('123'), x=int())" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "tuple([1, 2])" ], [ "CALL_FUNCTION", "list(tuple([1, 2]))" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "CALL_FUNCTION", "tester(list(tuple([1, 2])), returns=empty_decorator)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "tuple(\n [3, 4])" ], [ "CALL_FUNCTION", "list(\n tuple(\n [3, 4]))" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "CALL_FUNCTION", "tester(\n list(\n tuple(\n [3, 4])),\n returns=empty_decorator)" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "LOAD_GLOBAL", "decorator_with_args" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "str()" ], [ "LOAD_GLOBAL", "int" ], [ "CALL_FUNCTION", "int()" ], [ "CALL_FUNCTION", "decorator_with_args(\n str(),\n x=int())" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "tuple([5, 6])" ], [ "CALL_FUNCTION", "list(tuple([5, 6]))" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "CALL_FUNCTION", "tester(list(tuple([5, 6])), returns=empty_decorator)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "tuple([7, 8])" ], [ "CALL_FUNCTION", "list(tuple([7, 8]))" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "CALL_FUNCTION", "tester(list(tuple([7, 8])), returns=empty_decorator)" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "LOAD_GLOBAL", "decorator_with_args" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('sdf')" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('123234')" ], [ "CALL_FUNCTION", "decorator_with_args(tester('sdf'), x=tester('123234'))" ], [ "CALL_FUNCTION", "decorator_with_args(tester('sdf'), x=tester('123234'))" ], [ "CALL_FUNCTION", "empty_decorator" ], [ "CALL_FUNCTION", "tester(list(tuple([7, 8])), returns=empty_decorator)" ], [ "CALL_FUNCTION", "tester(list(tuple([5, 6])), returns=empty_decorator)" ], [ "CALL_FUNCTION", "decorator_with_args(\n str(),\n x=int())" ], [ "CALL_FUNCTION", "empty_decorator" ], [ "CALL_FUNCTION", "tester(\n list(\n tuple(\n [3, 4])),\n returns=empty_decorator)" ], [ "CALL_FUNCTION", "tester(list(tuple([1, 2])), returns=empty_decorator)" ], [ "CALL_FUNCTION", "decorator_with_args(tester('123'), x=int())" ], [ "CALL_FUNCTION", "empty_decorator" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "str([{tester(x) for x in [1]}, {tester(y) for y in [1]}])" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "str([{tester(x) for x in [1]},\n {tester(x) for x in [1]}])" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "list(tester(x) for x in [1])" ], [ "CALL_FUNCTION", "str([{tester(x) for x in [1]}, list(tester(x) for x in [1])])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "y" ], [ "CALL_FUNCTION", "tester(y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertEqual" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(3)" ], [ "CALL_FUNCTION", "(lambda x: (tester(x), tester(x)))(tester(3))" ], [ "CALL_FUNCTION", "self.assertEqual(\n (lambda x: (tester(x), tester(x)))(tester(3)),\n (3, 3),\n )" ], [ "CALL_FUNCTION", "(lambda: (lambda: tester(1))())()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertEqual" ], [ "CALL_FUNCTION", "(lambda: [tester(x) for x in tester([1, 2])])()" ], [ "CALL_FUNCTION", "self.assertEqual(\n (lambda: [tester(x) for x in tester([1, 2])])(),\n [1, 2],\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "CALL_FUNCTION", "(lambda: tester(1))()" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(1)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x): {tester(b+x): {tester(c+x) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_FAST", "foo" ], [ "CALL_FUNCTION", "foo()" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "CALL_FUNCTION", "tester(a+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "CALL_FUNCTION", "tester(b+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "CALL_FUNCTION", "tester(c+x)" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x): {tester(b+x): {tester(c+x) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+y): {tester(b+y): {tester(c+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x+y): {tester(b+x+y): {tester(c+x+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_FAST", "bar" ], [ "CALL_FUNCTION", "bar()" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "CALL_FUNCTION", "tester(a+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "CALL_FUNCTION", "tester(b+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "CALL_FUNCTION", "tester(c+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+y" ], [ "CALL_FUNCTION", "tester(a+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+y" ], [ "CALL_FUNCTION", "tester(b+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+y" ], [ "CALL_FUNCTION", "tester(c+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+x+y" ], [ "CALL_FUNCTION", "tester(a+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+x+y" ], [ "CALL_FUNCTION", "tester(b+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+x+y" ], [ "CALL_FUNCTION", "tester(c+x+y)" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x): {tester(b+x): {tester(c+x) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+y): {tester(b+y): {tester(c+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x+y): {tester(b+x+y): {tester(c+x+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x+y+z): {tester(b+x+y+z): {tester(c+x+y+z) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "CALL_FUNCTION", "tester(a+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "CALL_FUNCTION", "tester(b+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "CALL_FUNCTION", "tester(c+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+y" ], [ "CALL_FUNCTION", "tester(a+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+y" ], [ "CALL_FUNCTION", "tester(b+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+y" ], [ "CALL_FUNCTION", "tester(c+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+x+y" ], [ "CALL_FUNCTION", "tester(a+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+x+y" ], [ "CALL_FUNCTION", "tester(b+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+x+y" ], [ "CALL_FUNCTION", "tester(c+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+x+y" ], [ "LOAD_DEREF", "z" ], [ "BINARY_ADD", "a+x+y+z" ], [ "CALL_FUNCTION", "tester(a+x+y+z)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+x+y" ], [ "LOAD_DEREF", "z" ], [ "BINARY_ADD", "b+x+y+z" ], [ "CALL_FUNCTION", "tester(b+x+y+z)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+x+y" ], [ "LOAD_DEREF", "z" ], [ "BINARY_ADD", "c+x+y+z" ], [ "CALL_FUNCTION", "tester(c+x+y+z)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "dict(x=tester)" ], [ "BINARY_SUBSCR", "dict(x=tester)['x']" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "dict(x=tester)['x'](tester)" ], [ "CALL_FUNCTION", "dict(x=tester)['x'](tester)(3, check_func=False)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertRaises" ], [ "LOAD_GLOBAL", "TypeError" ], [ "CALL_FUNCTION", "self.assertRaises(TypeError)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2, 3])" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(0)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(4)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(5)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "tester(ValueError)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(9)" ], [ "LOAD_GLOBAL", "TypeError" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(10)" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "str()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertRaises" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "Exception" ], [ "CALL_FUNCTION", "tester(Exception)" ], [ "CALL_FUNCTION", "self.assertRaises(tester(Exception))" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(0)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(0)" ], [ "LOAD_GLOBAL", "tester" ], [ "BINARY_TRUE_DIVIDE", "1 / 0" ], [ "CALL_FUNCTION", "tester(1 / 0)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "gen" ], [ "CALL_FUNCTION", "gen()" ], [ "CALL_FUNCTION", "list(gen())" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "gen2" ], [ "CALL_FUNCTION", "list(gen2)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(4)" ], [ "LOAD_GLOBAL", "time" ], [ "LOAD_ATTR", "time.time" ], [ "CALL_FUNCTION", "time.time()" ], [ "LOAD_GLOBAL", "range" ], [ "CALL_FUNCTION", "range(10000)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_ATTR", "Source.executing" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.currentframe" ], [ "CALL_FUNCTION", "inspect.currentframe()" ], [ "CALL_FUNCTION", "Source.executing(inspect.currentframe())" ], [ "LOAD_ATTR", "Source.executing(inspect.currentframe()).node" ], [ "LOAD_FAST", "node" ], [ "COMPARE_OP", "node is None" ], [ "LOAD_FAST", "new_node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertIs" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "new_node" ], [ "CALL_FUNCTION", "self.assertIs(node, new_node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertLess" ], [ "LOAD_GLOBAL", "time" ], [ "LOAD_ATTR", "time.time" ], [ "CALL_FUNCTION", "time.time()" ], [ "LOAD_FAST", "start" ], [ "BINARY_SUBTRACT", "time.time() - start" ], [ "CALL_FUNCTION", "self.assertLess(time.time() - start, 1)" ], [ "LOAD_FAST", "check" ], [ "CALL_FUNCTION", "check(u'# coding=utf8\\n\u00e9', 'utf8')" ], [ "LOAD_FAST", "check" ], [ "CALL_FUNCTION", "check(u'# coding=gbk\\n\u00e9', 'gbk')" ], [ "LOAD_FAST", "check" ], [ "LOAD_GLOBAL", "UnicodeDecodeError" ], [ "CALL_FUNCTION", "check(u'# coding=utf8\\n\u00e9', 'gbk', exception=UnicodeDecodeError)" ], [ "LOAD_FAST", "check" ], [ "CALL_FUNCTION", "check(u'# coding=gbk\\n\u00e9', 'utf8', matches=False)" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_FAST", "check" ], [ "CALL_FUNCTION", "check(u'\u00e9', 'utf8')" ], [ "LOAD_FAST", "check" ], [ "LOAD_GLOBAL", "SyntaxError" ], [ "CALL_FUNCTION", "check(u'\u00e9', 'gbk', exception=SyntaxError)" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.encode" ], [ "LOAD_FAST", "encoding" ], [ "CALL_FUNCTION", "source.encode(encoding)" ], [ "LOAD_FAST", "exception" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.assertRaises" ], [ "LOAD_FAST", "exception" ], [ "CALL_FUNCTION", "self.assertRaises(exception)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_ATTR", "Source.decode_source" ], [ "LOAD_FAST", "encoded" ], [ "CALL_FUNCTION", "Source.decode_source(encoded)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_ATTR", "Source.decode_source" ], [ "LOAD_FAST", "encoded" ], [ "CALL_FUNCTION", "Source.decode_source(encoded)" ], [ "LOAD_FAST", "matches" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.assertEqual" ], [ "LOAD_FAST", "decoded" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "self.assertEqual(decoded, source)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.assertNotEqual" ], [ "LOAD_FAST", "decoded" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "self.assertNotEqual(decoded, source)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('a')" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('''\n ab''')" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('''\n abc\n def\n '''\n )" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n '''\n 123\n 456\n '''\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n '''\n 345\n 456786\n '''\n )" ], [ "CALL_FUNCTION", "str([\n tester(\n '''\n 123\n 456\n '''\n ),\n tester(\n '''\n 345\n 456786\n '''\n ),\n ])" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n [\n '''\n 123\n 456\n '''\n '''\n 345\n 456786\n '''\n ,\n '''\n 123\n 456\n ''',\n '''\n 345\n 456786\n '''\n ]\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(1)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(2)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(3)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_ATTR", "Source.for_filename" ], [ "LOAD_GLOBAL", "__file__" ], [ "CALL_FUNCTION", "Source.for_filename(__file__)" ], [ "LOAD_ATTR", "Source.for_filename(__file__).code_qualname" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.__code__" ], [ "CALL_FUNCTION", "Source.for_filename(__file__).code_qualname(func.__code__)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertEqual" ], [ "LOAD_FAST", "qn" ], [ "LOAD_FAST", "qualname" ], [ "CALL_FUNCTION", "self.assertEqual(qn, qualname)" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_FAST", "check_actual_qualname" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertEqual" ], [ "LOAD_FAST", "qn" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.__qualname__" ], [ "CALL_FUNCTION", "self.assertEqual(qn, func.__qualname__)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertTrue" ], [ "LOAD_FAST", "qn" ], [ "LOAD_ATTR", "qn.endswith" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.__name__" ], [ "CALL_FUNCTION", "qn.endswith(func.__name__)" ], [ "CALL_FUNCTION", "self.assertTrue(qn.endswith(func.__name__))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assert_qualname" ], [ "LOAD_GLOBAL", "C" ], [ "LOAD_ATTR", "C.f" ], [ "CALL_FUNCTION", "self.assert_qualname(C.f, 'C.f')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assert_qualname" ], [ "LOAD_GLOBAL", "C" ], [ "LOAD_ATTR", "C.D" ], [ "LOAD_ATTR", "C.D.g" ], [ "CALL_FUNCTION", "self.assert_qualname(C.D.g, 'C.D.g')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assert_qualname" ], [ "LOAD_GLOBAL", "f" ], [ "CALL_FUNCTION", "self.assert_qualname(f, 'f')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assert_qualname" ], [ "LOAD_GLOBAL", "f" ], [ "CALL_FUNCTION", "f()" ], [ "CALL_FUNCTION", "self.assert_qualname(f(), 'f..g')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assert_qualname" ], [ "LOAD_GLOBAL", "C" ], [ "LOAD_ATTR", "C.D" ], [ "LOAD_ATTR", "C.D.h" ], [ "CALL_FUNCTION", "C.D.h()" ], [ "CALL_FUNCTION", "self.assert_qualname(C.D.h(), 'C.D.h..i..j')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assert_qualname" ], [ "LOAD_GLOBAL", "lamb" ], [ "CALL_FUNCTION", "self.assert_qualname(lamb, '')" ], [ "LOAD_GLOBAL", "lambda_maker" ], [ "CALL_FUNCTION", "lambda_maker()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assert_qualname" ], [ "LOAD_FAST", "foo" ], [ "CALL_FUNCTION", "self.assert_qualname(foo, 'lambda_maker..foo')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assert_qualname" ], [ "LOAD_FAST", "foo" ], [ "LOAD_ATTR", "foo.x" ], [ "CALL_FUNCTION", "self.assert_qualname(foo.x, 'lambda_maker..')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assert_qualname" ], [ "LOAD_FAST", "foo" ], [ "CALL_FUNCTION", "foo()" ], [ "CALL_FUNCTION", "self.assert_qualname(foo(), 'lambda_maker..foo..')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assert_qualname" ], [ "LOAD_FAST", "foo" ], [ "CALL_FUNCTION", "foo()" ], [ "CALL_FUNCTION", "foo()()" ], [ "CALL_FUNCTION", "self.assert_qualname(foo()(), 'lambda_maker..foo..', check_actual_qualname=False)" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "range" ], [ "CALL_FUNCTION", "range(66000)" ], [ "CALL_FUNCTION", "list(range(66000))" ], [ "BINARY_MODULO", "'tester(6)\\n%s\\ntester(9)' % list(range(66000))" ], [ "LOAD_GLOBAL", "tempfile" ], [ "LOAD_ATTR", "tempfile.mkstemp" ], [ "CALL_FUNCTION", "tempfile.mkstemp()" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "compile(source, filename, 'exec')" ], [ "LOAD_GLOBAL", "open" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "open(filename, 'w')" ], [ "LOAD_FAST", "outfile" ], [ "LOAD_ATTR", "outfile.write" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "outfile.write(source)" ], [ "LOAD_GLOBAL", "exec" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "exec(code)" ], [ "LOAD_GLOBAL", "range" ], [ "CALL_FUNCTION", "range(5)" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "n" ], [ "CALL_FUNCTION", "range(n)" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "n == 1" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertEqual" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_FAST", "gen" ], [ "CALL_FUNCTION", "only(gen)" ], [ "CALL_FUNCTION", "self.assertEqual(only(gen), 0)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertRaises" ], [ "LOAD_GLOBAL", "NotOneValueFound" ], [ "CALL_FUNCTION", "self.assertRaises(NotOneValueFound)" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_FAST", "gen" ], [ "CALL_FUNCTION", "only(gen)" ], [ "LOAD_FAST", "i" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.join" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.dirname" ], [ "LOAD_GLOBAL", "__file__" ], [ "CALL_FUNCTION", "os.path.dirname(__file__)" ], [ "CALL_FUNCTION", "os.path.join(os.path.dirname(__file__), 'not_code.txt', )" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_ATTR", "Source.for_filename" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "Source.for_filename(path)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertIsNone" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.tree" ], [ "CALL_FUNCTION", "self.assertIsNone(source.tree)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.currentframe" ], [ "CALL_FUNCTION", "inspect.currentframe()" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_ATTR", "Source.executing" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "Source.executing(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertEqual" ], [ "LOAD_FAST", "executing" ], [ "LOAD_ATTR", "executing.code_qualname" ], [ "CALL_FUNCTION", "executing.code_qualname()" ], [ "CALL_FUNCTION", "self.assertEqual(executing.code_qualname(), 'TestStuff.test_executing_methods')" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.version" ], [ "LOAD_ATTR", "sys.version.lower" ], [ "CALL_FUNCTION", "sys.version.lower()" ], [ "COMPARE_OP", "'pypy' not in sys.version.lower()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertEqual" ], [ "LOAD_FAST", "executing" ], [ "LOAD_ATTR", "executing.text" ], [ "CALL_FUNCTION", "executing.text()" ], [ "LOAD_FAST", "text" ], [ "CALL_FUNCTION", "self.assertEqual(executing.text(), text)" ], [ "LOAD_FAST", "executing" ], [ "LOAD_ATTR", "executing.text_range" ], [ "CALL_FUNCTION", "executing.text_range()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertEqual" ], [ "LOAD_FAST", "executing" ], [ "LOAD_ATTR", "executing.source" ], [ "LOAD_ATTR", "executing.source.text" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "BINARY_SUBSCR", "executing.source.text[start:end]" ], [ "LOAD_FAST", "text" ], [ "CALL_FUNCTION", "self.assertEqual(executing.source.text[start:end], text)" ], [ "LOAD_GLOBAL", "C" ], [ "CALL_FUNCTION", "C()" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_FAST", "c" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.x" ], [ "LOAD_ATTR", "c.x.x" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.x" ], [ "LOAD_ATTR", "c.x.y" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.y" ], [ "LOAD_ATTR", "c.y.x" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.y" ], [ "LOAD_ATTR", "c.y.y" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.x" ], [ "LOAD_ATTR", "c.x.asd" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.y" ], [ "LOAD_ATTR", "c.y.qwe" ], [ "CALL_FUNCTION", "str((c.x.x, c.x.y, c.y.x, c.y.y, c.x.asd, c.y.qwe))" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_ATTR", "Source.for_frame" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.currentframe" ], [ "CALL_FUNCTION", "inspect.currentframe()" ], [ "CALL_FUNCTION", "Source.for_frame(inspect.currentframe())" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.text" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.filename" ], [ "CALL_FUNCTION", "compile(source.text, source.filename, 'exec')" ], [ "LOAD_GLOBAL", "get_instructions" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "get_instructions(code)" ], [ "LOAD_FAST", "instructions" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.starts_line" ], [ "COMPARE_OP", "inst.starts_line is not None" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.starts_line" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.opname" ], [ "LOAD_ATTR", "inst.opname.startswith" ], [ "CALL_FUNCTION", "inst.opname.startswith(\n ('BINARY_', 'UNARY_', 'LOAD_ATTR', 'LOAD_METHOD', 'LOOKUP_METHOD', 'COMPARE_OP'))" ], [ "LOAD_GLOBAL", "C" ], [ "CALL_FUNCTION", "C()" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.offset" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "frame" ], [ "LOAD_GLOBAL", "globals" ], [ "CALL_FUNCTION", "globals()" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "lineno" ], [ "LOAD_FAST", "frame" ], [ "LOAD_GLOBAL", "print" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.opname" ], [ "CALL_FUNCTION", "print(inst.opname)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_ATTR", "Source.executing" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "Source.executing(frame)" ], [ "LOAD_ATTR", "Source.executing(frame).node" ], [ "COMPARE_OP", "Source.executing(frame).node is not None" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_FAST", "i" ], [ "CALL_FUNCTION", "i()" ], [ "LOAD_FAST", "j" ], [ "LOAD_FAST", "g" ], [ "LOAD_FAST", "assign" ], [ "CALL_FUNCTION", "assign(lambda: 1)" ], [ "CALL_FUNCTION", "assign(lambda: 1)" ], [ "LOAD_FAST", "foo" ], [ "LOAD_FAST", "decorator" ], [ "LOAD_DEREF", "x" ], [ "LOAD_FAST", "func" ], [ "LOAD_FAST", "func" ], [ "LOAD_NAME", "__add__" ], [ "LOAD_NAME", "__invert__" ], [ "LOAD_NAME", "__lt__" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.currentframe" ], [ "CALL_FUNCTION", "inspect.currentframe()" ], [ "LOAD_ATTR", "inspect.currentframe().f_back" ], [ "LOAD_ATTR", "inspect.currentframe().f_back.f_back" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_ATTR", "Source.lazycache" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "Source.lazycache(frame)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_ATTR", "Source.executing" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "Source.executing(frame)" ], [ "LOAD_ATTR", "Source.executing(frame).node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "typ" ], [ "CALL_FUNCTION", "isinstance(node, typ)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "typ" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.currentframe" ], [ "CALL_FUNCTION", "inspect.currentframe()" ], [ "LOAD_ATTR", "inspect.currentframe().f_back" ], [ "LOAD_ATTR", "inspect.currentframe().f_back.f_back" ], [ "LOAD_GLOBAL", "eval" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Expression" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ast.Expression(node)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_filename" ], [ "CALL_FUNCTION", "compile(ast.Expression(node), frame.f_code.co_filename, 'eval')" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "CALL_FUNCTION", "eval(\n compile(ast.Expression(node), frame.f_code.co_filename, 'eval'),\n frame.f_globals,\n frame.f_locals,\n )" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "value" ], [ "COMPARE_OP", "result == value" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Call" ], [ "CALL_FUNCTION", "self.get_node(ast.Call)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.check" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.args" ], [ "BINARY_SUBSCR", "call.args[0]" ], [ "LOAD_FAST", "arg" ], [ "CALL_FUNCTION", "self.check(call.args[0], arg)" ], [ "LOAD_FAST", "check_func" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.check" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.func" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "self.check(call.func, self)" ], [ "LOAD_FAST", "returns" ], [ "COMPARE_OP", "returns is None" ], [ "LOAD_FAST", "arg" ], [ "LOAD_FAST", "returns" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Attribute" ], [ "CALL_FUNCTION", "self.get_node(ast.Attribute)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.value" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "self.check(node.value, self)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.attr" ], [ "LOAD_FAST", "item" ], [ "COMPARE_OP", "node.attr == item" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Subscript" ], [ "CALL_FUNCTION", "self.get_node(ast.Subscript)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.value" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "self.check(node.value, self)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.slice" ], [ "LOAD_ATTR", "node.slice.value" ], [ "LOAD_FAST", "item" ], [ "CALL_FUNCTION", "self.check(node.slice.value, item)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.BinOp" ], [ "CALL_FUNCTION", "self.get_node(ast.BinOp)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.left" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "self.check(node.left, self)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.right" ], [ "LOAD_FAST", "other" ], [ "CALL_FUNCTION", "self.check(node.right, other)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.UnaryOp" ], [ "CALL_FUNCTION", "self.get_node(ast.UnaryOp)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.operand" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "self.check(node.operand, self)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Compare" ], [ "CALL_FUNCTION", "self.get_node(ast.Compare)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.left" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "self.check(node.left, self)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.comparators" ], [ "BINARY_SUBSCR", "node.comparators[0]" ], [ "LOAD_FAST", "other" ], [ "CALL_FUNCTION", "self.check(node.comparators[0], other)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "func" ], [ "LOAD_GLOBAL", "empty_decorator" ] ], "tracer.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOAD_ATTR", "standard_library.install_aliases" ], [ "CALL_FUNCTION", "standard_library.install_aliases()" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "NamedTuple" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "Union" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "BINARY_SUBSCR", "Union[ast.expr, ast.stmt]" ], [ "BINARY_SUBSCR", "Optional[Union[ast.expr, ast.stmt]]" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.AST" ], [ "LOAD_NAME", "FrameType" ], [ "LOAD_NAME", "FrameType" ], [ "CALL_FUNCTION", "NamedTuple('EnterCallInfo', [\n\n # Node from where the call was made\n ('call_node', Optional[Union[ast.expr, ast.stmt]]),\n\n # Node where the call begins\n ('enter_node', ast.AST),\n\n # Frame from which the call was made\n ('caller_frame', FrameType),\n\n # Frame of the call\n ('current_frame', FrameType)])" ], [ "LOAD_NAME", "NamedTuple" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "Union" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "BINARY_SUBSCR", "Union[ast.expr, ast.stmt]" ], [ "BINARY_SUBSCR", "Optional[Union[ast.expr, ast.stmt]]" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.Return" ], [ "BINARY_SUBSCR", "Optional[ast.Return]" ], [ "LOAD_NAME", "FrameType" ], [ "LOAD_NAME", "FrameType" ], [ "LOAD_NAME", "Any" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "Exception" ], [ "BINARY_SUBSCR", "Optional[Exception]" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "TracebackType" ], [ "BINARY_SUBSCR", "Optional[TracebackType]" ], [ "CALL_FUNCTION", "NamedTuple('ExitCallInfo', [\n\n # Node from where the call was made\n ('call_node', Optional[Union[ast.expr, ast.stmt]]),\n\n # Node where the call explicitly returned\n ('return_node', Optional[ast.Return]),\n\n # Frame from which the call was made\n ('caller_frame', FrameType),\n\n # Frame of the call\n ('current_frame', FrameType),\n\n # Node where the call explicitly returned\n ('return_value', Any),\n\n # Exception raised in the call causing it to end,\n # will propagate to the caller\n ('exc_value', Optional[Exception]),\n\n # Traceback corresponding to exc_value\n ('exc_tb', Optional[TracebackType])])" ], [ "LOAD_NAME", "namedtuple" ], [ "CALL_FUNCTION", "namedtuple('ChangeValue', 'value')" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.NodeTransformer" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "Union" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "BINARY_SUBSCR", "Union[ast.For, ast.While, ast.comprehension]" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.PyCF_ONLY_AST" ], [ "LOAD_FAST", "flags" ], [ "BINARY_OR", "ast.PyCF_ONLY_AST | flags" ], [ "CALL_FUNCTION", "compile(source, filename, 'exec', ast.PyCF_ONLY_AST | flags, dont_inherit=True)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.set_basic_node_attributes" ], [ "CALL_FUNCTION", "self.set_basic_node_attributes()" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.parse_extra" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "tracer.parse_extra(self.root, source, filename)" ], [ "LOAD_FAST", "new_root" ], [ "COMPARE_OP", "new_root is not None" ], [ "LOAD_FAST", "new_root" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.set_basic_node_attributes" ], [ "CALL_FUNCTION", "self.set_basic_node_attributes()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.set_enter_call_nodes" ], [ "CALL_FUNCTION", "self.set_enter_call_nodes()" ], [ "LOAD_GLOBAL", "deepcopy" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "CALL_FUNCTION", "deepcopy(self.root)" ], [ "LOAD_GLOBAL", "_NodeVisitor" ], [ "CALL_FUNCTION", "_NodeVisitor()" ], [ "LOAD_ATTR", "_NodeVisitor().visit" ], [ "LOAD_FAST", "new_root" ], [ "CALL_FUNCTION", "_NodeVisitor().visit(new_root)" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "new_root" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "flags" ], [ "CALL_FUNCTION", "compile(new_root, filename, \"exec\", dont_inherit=True, flags=flags)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.walk" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "CALL_FUNCTION", "ast.walk(self.root)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.iter_child_nodes" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ast.iter_child_nodes(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.nodes" ], [ "CALL_FUNCTION", "len(self.nodes)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.nodes" ], [ "LOAD_ATTR", "self.nodes.append" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "self.nodes.append(node)" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "LOAD_ATTR", "self.root.body" ], [ "CALL_FUNCTION", "enumerate(self.root.body)" ], [ "LOAD_GLOBAL", "is_future_import" ], [ "LOAD_FAST", "stmt" ], [ "CALL_FUNCTION", "is_future_import(stmt)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "LOAD_ATTR", "self.root.body" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "self.root.body[:i + 1]" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.walk" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "ast.walk(s)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.nodes" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Module" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(node, (ast.Module, ast.FunctionDef))" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.body" ], [ "LOAD_GLOBAL", "is_future_import" ], [ "LOAD_FAST", "stmt" ], [ "CALL_FUNCTION", "is_future_import(stmt)" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_NAME", "lru_cache" ], [ "CALL_FUNCTION", "lru_cache()" ], [ "CALL_FUNCTION", "lru_cache()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "defaultdict(list)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "TracedFile" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "flags" ], [ "CALL_FUNCTION", "TracedFile(self, source, filename, flags)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._treetrace_hidden_with_stmt" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._treetrace_hidden_before_expr" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._treetrace_hidden_after_expr" ], [ "LOAD_GLOBAL", "partial" ], [ "LOAD_FAST", "f" ], [ "LOAD_DEREF", "traced_file" ], [ "CALL_FUNCTION", "partial(f, traced_file)" ], [ "LOAD_FAST", "f" ], [ "LOAD_ATTR", "f.__name__" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_DEREF", "func" ], [ "LOAD_GLOBAL", "FunctionType" ], [ "CALL_FUNCTION", "isinstance(func, FunctionType)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError('You can only trace user-defined functions. '\n 'The birdseye decorator must be applied first, '\n 'at the bottom of the list.')" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.iscoroutinefunction" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "inspect.iscoroutinefunction(func)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.isasyncgenfunction" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "inspect.isasyncgenfunction(func)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError('You cannot trace async functions')" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_GLOBAL", "is_lambda" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "is_lambda(func)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError('You cannot trace lambdas')" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.getsourcefile" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "inspect.getsourcefile(func)" ], [ "LOAD_GLOBAL", "is_ipython_cell" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "is_ipython_cell(filename)" ], [ "LOAD_FAST", "get_ipython" ], [ "CALL_FUNCTION", "get_ipython()" ], [ "LOAD_ATTR", "get_ipython().compile" ], [ "LOAD_ATTR", "get_ipython().compile.flags" ], [ "LOAD_ATTR", "''.join" ], [ "LOAD_FAST", "linecache" ], [ "LOAD_ATTR", "linecache.cache" ], [ "LOAD_FAST", "filename" ], [ "BINARY_SUBSCR", "linecache.cache[filename]" ], [ "BINARY_SUBSCR", "linecache.cache[filename][2]" ], [ "CALL_FUNCTION", "''.join(linecache.cache[filename][2])" ], [ "LOAD_GLOBAL", "read_source_file" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "read_source_file(filename)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "flags" ], [ "CALL_FUNCTION", "self.compile(source, filename, flags)" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__dict__" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError('The birdseye decorator must be applied first, '\n 'at the bottom of the list.')" ], [ "LOAD_DEREF", "find_code" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.code" ], [ "CALL_FUNCTION", "find_code(traced_file.code)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_DEREF", "code_options" ], [ "CALL_FUNCTION", "len(code_options)" ], [ "COMPARE_OP", "len(code_options) > 1" ], [ "LOAD_GLOBAL", "is_lambda" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "is_lambda(func)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError(\"Failed to trace lambda. Convert the function to a def.\")" ], [ "LOAD_DEREF", "code_options" ], [ "BINARY_SUBSCR", "code_options[0]" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__globals__" ], [ "LOAD_ATTR", "func.__globals__.update" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._trace_methods_dict" ], [ "LOAD_FAST", "traced_file" ], [ "CALL_FUNCTION", "self._trace_methods_dict(traced_file)" ], [ "CALL_FUNCTION", "func.__globals__.update(self._trace_methods_dict(traced_file))" ], [ "LOAD_GLOBAL", "FunctionType" ], [ "LOAD_FAST", "new_func_code" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__globals__" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__name__" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__defaults__" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__closure__" ], [ "CALL_FUNCTION", "FunctionType(new_func_code, func.__globals__, func.__name__, func.__defaults__, func.__closure__)" ], [ "LOAD_GLOBAL", "update_wrapper" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "update_wrapper(new_func, func)" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "getattr(func, '__kwdefaults__', None)" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_FAST", "root_code" ], [ "LOAD_ATTR", "root_code.co_consts" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.iscode" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "inspect.iscode(const)" ], [ "LOAD_FAST", "const" ], [ "LOAD_ATTR", "const.co_firstlineno" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__code__" ], [ "LOAD_ATTR", "func.__code__.co_firstlineno" ], [ "COMPARE_OP", "const.co_firstlineno == func.__code__.co_firstlineno" ], [ "LOAD_FAST", "const" ], [ "LOAD_ATTR", "const.co_name" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__code__" ], [ "LOAD_ATTR", "func.__code__.co_name" ], [ "COMPARE_OP", "const.co_name == func.__code__.co_name" ], [ "LOAD_FAST", "matches" ], [ "LOAD_DEREF", "code_options" ], [ "LOAD_ATTR", "code_options.append" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "code_options.append(const)" ], [ "LOAD_DEREF", "find_code" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "find_code(const)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.isclass" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "inspect.isclass(func)" ], [ "LOAD_GLOBAL", "TypeError" ], [ "CALL_FUNCTION", "TypeError('Decorating classes is no longer supported')" ], [ "LOAD_FAST", "func" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.trace_function" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "self.trace_function(func)" ], [ "LOAD_FAST", "optional" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.trace_function" ], [ "LOAD_FAST", "decorator" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.trace_function" ], [ "LOAD_DEREF", "actual_func" ], [ "CALL_FUNCTION", "self.trace_function(actual_func)" ], [ "LOAD_GLOBAL", "wraps" ], [ "LOAD_DEREF", "actual_func" ], [ "CALL_FUNCTION", "wraps(actual_func)" ], [ "CALL_FUNCTION", "wraps(actual_func)" ], [ "LOAD_FAST", "wrapper" ], [ "LOAD_FAST", "kwargs" ], [ "LOAD_ATTR", "kwargs.pop" ], [ "CALL_FUNCTION", "kwargs.pop('trace_call', False)" ], [ "LOAD_FAST", "trace_call" ], [ "LOAD_DEREF", "traced" ], [ "LOAD_DEREF", "actual_func" ], [ "LOAD_FAST", "f" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "f(*args, **kwargs)" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys._getframe" ], [ "CALL_FUNCTION", "sys._getframe(2)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.secondary_to_main_frames" ], [ "LOAD_ATTR", "self.secondary_to_main_frames.get" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "self.secondary_to_main_frames.get(frame)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "COMPARE_OP", "frame.f_code.co_name in ('', '', '')" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_GLOBAL", "ancestors" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ancestors(node)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Lambda" ], [ "CALL_FUNCTION", "isinstance(node, (ast.FunctionDef, ast.Lambda))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.ClassDef" ], [ "CALL_FUNCTION", "isinstance(node, ast.ClassDef)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "COMPARE_OP", "frame.f_code.co_name in ('', '')" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.secondary_to_main_frames" ], [ "LOAD_FAST", "original_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.main_to_secondary_frames" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.main_to_secondary_frames[frame]" ], [ "LOAD_ATTR", "self.main_to_secondary_frames[frame].append" ], [ "LOAD_FAST", "original_frame" ], [ "CALL_FUNCTION", "self.main_to_secondary_frames[frame].append(original_frame)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.nodes" ], [ "LOAD_FAST", "_tree_index" ], [ "BINARY_SUBSCR", "traced_file.nodes[_tree_index]" ], [ "LOAD_GLOBAL", "cast" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "cast(ast.stmt, node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._main_frame" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "self._main_frame(node)" ], [ "LOAD_GLOBAL", "_StmtContext" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "_StmtContext(self, node, frame)" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.nodes" ], [ "LOAD_FAST", "_tree_index" ], [ "BINARY_SUBSCR", "traced_file.nodes[_tree_index]" ], [ "LOAD_GLOBAL", "cast" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "cast(ast.expr, node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._main_frame" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "self._main_frame(node)" ], [ "LOAD_FAST", "frame" ], [ "COMPARE_OP", "frame is None" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_stack" ], [ "LOAD_ATTR", "frame_info.expression_stack.append" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "frame_info.expression_stack.append(node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.before_expr" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "self.before_expr(node, frame)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._main_frame" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "self._main_frame(node)" ], [ "LOAD_FAST", "frame" ], [ "COMPARE_OP", "frame is None" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._after_expr" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "self._after_expr(node, frame, value, None, None)" ], [ "LOAD_FAST", "result" ], [ "COMPARE_OP", "result is not None" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "ChangeValue" ], [ "CALL_FUNCTION", "isinstance(result, ChangeValue)" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.value" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_stack" ], [ "LOAD_ATTR", "frame_info.expression_stack.pop" ], [ "CALL_FUNCTION", "frame_info.expression_stack.pop()" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_values" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.after_expr" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "exc_value" ], [ "LOAD_FAST", "exc_tb" ], [ "CALL_FUNCTION", "self.after_expr(node, frame, value, exc_value, exc_tb)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._get_caller_stuff" ], [ "LOAD_FAST", "current_frame" ], [ "CALL_FUNCTION", "self._get_caller_stuff(current_frame)" ], [ "LOAD_GLOBAL", "FrameInfo" ], [ "CALL_FUNCTION", "FrameInfo()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "current_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.enter_call" ], [ "LOAD_GLOBAL", "EnterCallInfo" ], [ "LOAD_FAST", "call_node" ], [ "LOAD_FAST", "enter_node" ], [ "LOAD_FAST", "caller_frame" ], [ "LOAD_FAST", "current_frame" ], [ "CALL_FUNCTION", "EnterCallInfo(call_node, enter_node, caller_frame, current_frame)" ], [ "CALL_FUNCTION", "self.enter_call(EnterCallInfo(call_node, enter_node, caller_frame, current_frame))" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.secondary_to_main_frames" ], [ "LOAD_ATTR", "self.secondary_to_main_frames.get" ], [ "LOAD_FAST", "caller_frame" ], [ "CALL_FUNCTION", "self.secondary_to_main_frames.get(caller_frame)" ], [ "LOAD_FAST", "main_frame" ], [ "LOAD_FAST", "main_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "caller_frame" ], [ "BINARY_SUBSCR", "self.stack[caller_frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_stack" ], [ "LOAD_FAST", "expression_stack" ], [ "LOAD_FAST", "expression_stack" ], [ "BINARY_SUBSCR", "expression_stack[-1]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.statement_stack" ], [ "BINARY_SUBSCR", "frame_info.statement_stack[-1]" ], [ "LOAD_FAST", "caller_frame" ], [ "LOAD_FAST", "call_node" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "getattr(node, '_visit_ignore', False)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "CALL_FUNCTION", "isinstance(node, ast.expr)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "hasattr(node, \"ctx\")" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.ctx" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Load" ], [ "CALL_FUNCTION", "isinstance(node.ctx, ast.Load)" ], [ "UNARY_NOT", "not isinstance(node.ctx, ast.Load)" ], [ "UNARY_NOT", "not (hasattr(node, \"ctx\") and not isinstance(node.ctx, ast.Load))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "ast" ], [ "CALL_FUNCTION", "getattr(ast, 'Starred', ())" ], [ "CALL_FUNCTION", "isinstance(node, getattr(ast, 'Starred', ()))" ], [ "UNARY_NOT", "not isinstance(node, getattr(ast, 'Starred', ()))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.visit_expr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "self.visit_expr(node)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "CALL_FUNCTION", "isinstance(node, ast.stmt)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.visit_stmt" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "self.visit_stmt(node)" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "_NodeVisitor" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self)" ], [ "LOAD_ATTR", "super(_NodeVisitor, self).generic_visit" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self).generic_visit(node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._create_simple_marker_call" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "TreeTracerBase" ], [ "LOAD_ATTR", "TreeTracerBase._treetrace_hidden_before_expr" ], [ "CALL_FUNCTION", "self._create_simple_marker_call(node, TreeTracerBase._treetrace_hidden_before_expr)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.copy_location" ], [ "LOAD_FAST", "before_marker" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ast.copy_location(before_marker, node)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Call" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Name" ], [ "LOAD_GLOBAL", "TreeTracerBase" ], [ "LOAD_ATTR", "TreeTracerBase._treetrace_hidden_after_expr" ], [ "LOAD_ATTR", "TreeTracerBase._treetrace_hidden_after_expr.__name__" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Load" ], [ "CALL_FUNCTION", "ast.Load()" ], [ "CALL_FUNCTION", "ast.Name(id=TreeTracerBase._treetrace_hidden_after_expr.__name__,\n ctx=ast.Load())" ], [ "LOAD_FAST", "before_marker" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "_NodeVisitor" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self)" ], [ "LOAD_ATTR", "super(_NodeVisitor, self).generic_visit" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self).generic_visit(node)" ], [ "CALL_FUNCTION", "ast.Call(\n func=ast.Name(id=TreeTracerBase._treetrace_hidden_after_expr.__name__,\n ctx=ast.Load()),\n args=[\n before_marker,\n super(_NodeVisitor, self).generic_visit(node),\n ],\n keywords=[],\n )" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.copy_location" ], [ "LOAD_FAST", "after_marker" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ast.copy_location(after_marker, node)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.fix_missing_locations" ], [ "LOAD_FAST", "after_marker" ], [ "CALL_FUNCTION", "ast.fix_missing_locations(after_marker)" ], [ "LOAD_FAST", "after_marker" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._create_simple_marker_call" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "_NodeVisitor" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self)" ], [ "LOAD_ATTR", "super(_NodeVisitor, self).generic_visit" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self).generic_visit(node)" ], [ "LOAD_GLOBAL", "TreeTracerBase" ], [ "LOAD_ATTR", "TreeTracerBase._treetrace_hidden_with_stmt" ], [ "CALL_FUNCTION", "self._create_simple_marker_call(\n super(_NodeVisitor, self).generic_visit(node),\n TreeTracerBase._treetrace_hidden_with_stmt)" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.With" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.withitem" ], [ "LOAD_FAST", "context_expr" ], [ "CALL_FUNCTION", "ast.withitem(context_expr=context_expr)" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ast.With(\n items=[ast.withitem(context_expr=context_expr)],\n body=[node],\n )" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.With" ], [ "LOAD_FAST", "context_expr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ast.With(\n context_expr=context_expr,\n body=[node],\n )" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.copy_location" ], [ "LOAD_FAST", "wrapped" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ast.copy_location(wrapped, node)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.fix_missing_locations" ], [ "LOAD_FAST", "wrapped" ], [ "CALL_FUNCTION", "ast.fix_missing_locations(wrapped)" ], [ "LOAD_FAST", "wrapped" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Call" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Name" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.__name__" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Load" ], [ "CALL_FUNCTION", "ast.Load()" ], [ "CALL_FUNCTION", "ast.Name(id=func.__name__,\n ctx=ast.Load())" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Num" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "CALL_FUNCTION", "ast.Num(node._tree_index)" ], [ "CALL_FUNCTION", "ast.Call(\n func=ast.Name(id=func.__name__,\n ctx=ast.Load()),\n args=[ast.Num(node._tree_index)],\n keywords=[],\n )" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tracer" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "getattr(node, '_enter_call_node', False)" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer._enter_call" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "tracer._enter_call(node, frame)" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "tracer.stack[frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.statement_stack" ], [ "LOAD_ATTR", "frame_info.statement_stack.append" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "frame_info.statement_stack.append(node)" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.before_stmt" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "tracer.before_stmt(node, frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tracer" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "tracer.stack[frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.statement_stack" ], [ "LOAD_ATTR", "frame_info.statement_stack.pop" ], [ "CALL_FUNCTION", "frame_info.statement_stack.pop()" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.exc_value" ], [ "COMPARE_OP", "exc_val is not frame_info.exc_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_stack" ], [ "LOAD_FAST", "expression_stack" ], [ "LOAD_FAST", "expression_stack" ], [ "BINARY_SUBSCR", "expression_stack[-1]" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer._after_expr" ], [ "LOAD_FAST", "exc_node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "exc_tb" ], [ "CALL_FUNCTION", "tracer._after_expr(exc_node, frame, None, exc_val, exc_tb)" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.after_stmt" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "exc_tb" ], [ "LOAD_FAST", "exc_node" ], [ "CALL_FUNCTION", "tracer.after_stmt(node, frame, exc_val, exc_tb, exc_node)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Return" ], [ "CALL_FUNCTION", "isinstance(node, ast.Return)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.return_node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Module" ], [ "CALL_FUNCTION", "isinstance(parent, (ast.FunctionDef, ast.Module))" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.body" ], [ "BINARY_SUBSCR", "parent.body[-1]" ], [ "COMPARE_OP", "node is parent.body[-1]" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_FAST", "exiting" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer._get_caller_stuff" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "tracer._get_caller_stuff(frame)" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_ATTR", "return_node.value" ], [ "LOAD_FAST", "exc_val" ], [ "UNARY_NOT", "not exc_val" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_values" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_ATTR", "return_node.value" ], [ "BINARY_SUBSCR", "frame_info.expression_values[return_node.value]" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.exit_call" ], [ "LOAD_GLOBAL", "ExitCallInfo" ], [ "LOAD_FAST", "call_node" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_FAST", "caller_frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "return_value" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "exc_tb" ], [ "CALL_FUNCTION", "ExitCallInfo(call_node,\n return_node,\n caller_frame,\n frame,\n return_value,\n exc_val,\n exc_tb\n )" ], [ "CALL_FUNCTION", "tracer.exit_call(ExitCallInfo(call_node,\n return_node,\n caller_frame,\n frame,\n return_value,\n exc_val,\n exc_tb\n ))" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.stack" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tracer" ], [ "LOAD_ATTR", "self.tracer.main_to_secondary_frames" ], [ "LOAD_ATTR", "self.tracer.main_to_secondary_frames.pop" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "self.tracer.main_to_secondary_frames.pop(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tracer" ], [ "LOAD_ATTR", "self.tracer.secondary_to_main_frames" ], [ "LOAD_FAST", "secondary_frame" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(parent, ast.FunctionDef)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "CALL_FUNCTION", "isinstance(parent, ast.For)" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.iter" ], [ "LOAD_DEREF", "node" ], [ "COMPARE_OP", "parent.iter is not node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "CALL_FUNCTION", "isinstance(parent, ast.While)" ], [ "LOAD_DEREF", "node" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.orelse" ], [ "COMPARE_OP", "node not in parent.orelse" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "CALL_FUNCTION", "isinstance(parent, ast.comprehension)" ], [ "LOAD_DEREF", "node" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.ifs" ], [ "COMPARE_OP", "node in parent.ifs" ], [ "LOAD_FAST", "is_containing_loop" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.append" ], [ "LOAD_FAST", "parent" ], [ "CALL_FUNCTION", "result.append(parent)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.ListComp" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.GeneratorExp" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.DictComp" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.SetComp" ], [ "CALL_FUNCTION", "isinstance(parent, (ast.ListComp,\n ast.GeneratorExp,\n ast.DictComp,\n ast.SetComp))" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.generators" ], [ "LOAD_DEREF", "node" ], [ "LOAD_FAST", "generators" ], [ "COMPARE_OP", "node in generators" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "takewhile" ], [ "LOAD_FAST", "generators" ], [ "CALL_FUNCTION", "takewhile(lambda n: n != node, generators)" ], [ "CALL_FUNCTION", "list(takewhile(lambda n: n != node, generators))" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.extend" ], [ "LOAD_GLOBAL", "reversed" ], [ "LOAD_FAST", "generators" ], [ "CALL_FUNCTION", "reversed(generators)" ], [ "CALL_FUNCTION", "result.extend(reversed(generators))" ], [ "LOAD_FAST", "parent" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.reverse" ], [ "CALL_FUNCTION", "result.reverse()" ], [ "LOAD_GLOBAL", "tuple" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "tuple(result)" ], [ "LOAD_FAST", "n" ], [ "LOAD_DEREF", "node" ], [ "COMPARE_OP", "n != node" ] ], "tracer2.py": [ [ "LOAD_NAME", "find_repr_function" ], [ "LOAD_NAME", "six" ], [ "LOAD_ATTR", "six.text_type" ], [ "CALL_FUNCTION", "find_repr_function(six.text_type)" ], [ "LOAD_NAME", "find_repr_function" ], [ "LOAD_NAME", "six" ], [ "LOAD_ATTR", "six.binary_type" ], [ "CALL_FUNCTION", "find_repr_function(six.binary_type)" ], [ "LOAD_NAME", "find_repr_function" ], [ "LOAD_NAME", "object" ], [ "CALL_FUNCTION", "find_repr_function(object)" ], [ "LOAD_NAME", "find_repr_function" ], [ "LOAD_NAME", "int" ], [ "CALL_FUNCTION", "find_repr_function(int)" ], [ "LOAD_NAME", "cheap_repr" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "threading" ], [ "LOAD_ATTR", "threading.local" ], [ "CALL_FUNCTION", "threading.local()" ], [ "LOAD_NAME", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.dirname" ], [ "LOAD_ATTR", "(lambda: 0).__code__" ], [ "LOAD_ATTR", "(lambda: 0).__code__.co_filename" ], [ "CALL_FUNCTION", "os.path.dirname((lambda: 0).__code__.co_filename)" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.dirname" ], [ "LOAD_NAME", "birdseye" ], [ "LOAD_ATTR", "birdseye.__file__" ], [ "CALL_FUNCTION", "os.path.dirname(birdseye.__file__)" ], [ "LOAD_NAME", "type" ], [ "LOAD_NAME", "six" ], [ "LOAD_ATTR", "six.add_metaclass" ], [ "LOAD_NAME", "TracerMeta" ], [ "CALL_FUNCTION", "six.add_metaclass(TracerMeta)" ], [ "LOAD_NAME", "object" ], [ "CALL_FUNCTION", "six.add_metaclass(TracerMeta)" ], [ "LOAD_NAME", "object" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lineno" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "CALL_FUNCTION", "OrderedDict()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_ATTR", "Source.for_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "Source.for_frame(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_flags" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.CO_GENERATOR" ], [ "BINARY_AND", "frame.f_code.co_flags & inspect.CO_GENERATOR" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "is_comprehension_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "is_comprehension_frame(frame)" ], [ "LOAD_GLOBAL", "re" ], [ "LOAD_ATTR", "re.match" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "CALL_FUNCTION", "re.match(r'<(\\w+)comp>', frame.f_code.co_name)" ], [ "LOAD_ATTR", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group" ], [ "CALL_FUNCTION", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group(1)" ], [ "LOAD_ATTR", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group(1).title" ], [ "CALL_FUNCTION", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group(1).title()" ], [ "BINARY_ADD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group(1).title()\n + u' comprehension'" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_lineno" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.local_reprs" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.get_local_reprs" ], [ "LOAD_FAST", "watch" ], [ "LOAD_FAST", "watch_extras" ], [ "CALL_FUNCTION", "self.get_local_reprs(watch, watch_extras)" ], [ "CALL_FUNCTION", "OrderedDict(\n (source, my_cheap_repr(value))\n for source, value in\n self.get_local_reprs(watch, watch_extras)\n )" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.comprehension_type" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.local_reprs" ], [ "LOAD_ATTR", "self.local_reprs.items" ], [ "CALL_FUNCTION", "self.local_reprs.items()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.comprehension_variables" ], [ "LOAD_ATTR", "self.comprehension_variables.setdefault" ], [ "LOAD_FAST", "name" ], [ "CALL_FUNCTION", "self.comprehension_variables.setdefault(name, [])" ], [ "LOAD_FAST", "values" ], [ "UNARY_NOT", "not values" ], [ "LOAD_FAST", "values" ], [ "BINARY_SUBSCR", "values[-1]" ], [ "LOAD_FAST", "value_repr" ], [ "COMPARE_OP", "values[-1] != value_repr" ], [ "LOAD_FAST", "values" ], [ "LOAD_ATTR", "values.append" ], [ "LOAD_FAST", "value_repr" ], [ "CALL_FUNCTION", "values.append(value_repr)" ], [ "LOAD_GLOBAL", "truncate_list" ], [ "LOAD_FAST", "values" ], [ "CALL_FUNCTION", "truncate_list(values, 11)" ], [ "LOAD_FAST", "values" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event in ('return', 'exception')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.comprehension_variables" ], [ "LOAD_ATTR", "self.comprehension_variables.items" ], [ "CALL_FUNCTION", "self.comprehension_variables.items()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.local_reprs" ], [ "LOAD_ATTR", "self.local_reprs.items" ], [ "CALL_FUNCTION", "self.local_reprs.items()" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "old_local_reprs" ], [ "COMPARE_OP", "name not in old_local_reprs" ], [ "LOAD_FAST", "old_local_reprs" ], [ "LOAD_FAST", "name" ], [ "BINARY_SUBSCR", "old_local_reprs[name]" ], [ "LOAD_FAST", "value_repr" ], [ "COMPARE_OP", "old_local_reprs[name] != value_repr" ], [ "LOAD_FAST", "variables" ], [ "LOAD_ATTR", "variables.append" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "value_repr" ], [ "CALL_FUNCTION", "variables.append((name, value_repr))" ], [ "LOAD_FAST", "variables" ], [ "LOAD_FAST", "source" ], [ "LOAD_GLOBAL", "my_cheap_repr" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "my_cheap_repr(value)" ], [ "LOAD_FAST", "name" ], [ "LOAD_ATTR", "', '.join" ], [ "LOAD_FAST", "values" ], [ "CALL_FUNCTION", "', '.join(values)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_varnames" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_cellvars" ], [ "BINARY_ADD", "code.co_varnames + code.co_cellvars" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_freevars" ], [ "BINARY_ADD", "code.co_varnames + code.co_cellvars + code.co_freevars" ], [ "LOAD_GLOBAL", "tuple" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "LOAD_ATTR", "frame.f_locals.keys" ], [ "CALL_FUNCTION", "frame.f_locals.keys()" ], [ "CALL_FUNCTION", "tuple(frame.f_locals.keys())" ], [ "BINARY_ADD", "code.co_varnames + code.co_cellvars + code.co_freevars + tuple(frame.f_locals.keys())" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "LOAD_ATTR", "frame.f_locals.items" ], [ "CALL_FUNCTION", "frame.f_locals.items()" ], [ "CALL_FUNCTION", "sorted(\n frame.f_locals.items(),\n key=lambda key_value: vars_order.index(key_value[0])\n )" ], [ "LOAD_FAST", "watch" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_FAST", "variable" ], [ "LOAD_ATTR", "variable.items" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "variable.items(frame)" ], [ "CALL_FUNCTION", "sorted(variable.items(frame))" ], [ "LOAD_FAST", "result_items" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "watch_extras" ], [ "LOAD_FAST", "extra" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "extra(source, value)" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_FAST", "pair" ], [ "COMPARE_OP", "pair is not None" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "pair" ], [ "CALL_FUNCTION", "len(pair)" ], [ "COMPARE_OP", "len(pair) == 2" ], [ "LOAD_FAST", "pair" ], [ "LOAD_DEREF", "vars_order" ], [ "LOAD_ATTR", "vars_order.index" ], [ "LOAD_FAST", "key_value" ], [ "BINARY_SUBSCR", "key_value[0]" ], [ "CALL_FUNCTION", "vars_order.index(key_value[0])" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "TracerMeta" ], [ "LOAD_FAST", "mcs" ], [ "CALL_FUNCTION", "super(TracerMeta, mcs)" ], [ "LOAD_ATTR", "super(TracerMeta, mcs).__new__" ], [ "LOAD_FAST", "mcs" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "super(TracerMeta, mcs).__new__(mcs, *args, **kwargs)" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "result()" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "no_args_decorator" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION", "no_args_decorator(args, kwargs)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_ATTR", "cls.default" ], [ "LOAD_FAST", "args" ], [ "BINARY_SUBSCR", "args[0]" ], [ "CALL_FUNCTION", "cls.default(args[0])" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "TracerMeta" ], [ "LOAD_FAST", "cls" ], [ "CALL_FUNCTION", "super(TracerMeta, cls)" ], [ "LOAD_ATTR", "super(TracerMeta, cls).__call__" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "super(TracerMeta, cls).__call__(*args, **kwargs)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.default" ], [ "LOAD_ATTR", "self.default.__enter__" ], [ "CALL_FUNCTION", "self.default.__enter__(context=1)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.default" ], [ "LOAD_ATTR", "self.default.__exit__" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION_VAR", "self.default.__exit__(*args, context=1)" ], [ "LOAD_GLOBAL", "ensure_tuple" ], [ "LOAD_FAST", "watch" ], [ "CALL_FUNCTION", "ensure_tuple(watch)" ], [ "LOAD_GLOBAL", "ensure_tuple" ], [ "LOAD_FAST", "watch_explode" ], [ "CALL_FUNCTION", "ensure_tuple(watch_explode)" ], [ "BINARY_ADD", "[\n v if isinstance(v, BaseVariable) else CommonVariable(v)\n for v in ensure_tuple(watch)\n ] + [\n v if isinstance(v, BaseVariable) else Exploding(v)\n for v in ensure_tuple(watch_explode)\n ]" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "ArgDefaultDict" ], [ "LOAD_GLOBAL", "FrameInfo" ], [ "CALL_FUNCTION", "ArgDefaultDict(FrameInfo)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "depth" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.depth" ], [ "COMPARE_OP", "self.depth >= 1" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "BaseVariable" ], [ "CALL_FUNCTION", "isinstance(v, BaseVariable)" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "CommonVariable" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "CommonVariable(v)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "BaseVariable" ], [ "CALL_FUNCTION", "isinstance(v, BaseVariable)" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "Exploding" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "Exploding(v)" ], [ "LOAD_GLOBAL", "iscoroutinefunction" ], [ "LOAD_DEREF", "function" ], [ "CALL_FUNCTION", "iscoroutinefunction(function)" ], [ "LOAD_GLOBAL", "NotImplementedError" ], [ "CALL_FUNCTION", "NotImplementedError(\"coroutines are not supported, sorry!\")" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.target_codes" ], [ "LOAD_ATTR", "self.target_codes.add" ], [ "LOAD_DEREF", "function" ], [ "LOAD_ATTR", "function.__code__" ], [ "CALL_FUNCTION", "self.target_codes.add(function.__code__)" ], [ "LOAD_GLOBAL", "functools" ], [ "LOAD_ATTR", "functools.wraps" ], [ "LOAD_DEREF", "function" ], [ "CALL_FUNCTION", "functools.wraps(function)" ], [ "CALL_FUNCTION", "functools.wraps(function)" ], [ "LOAD_GLOBAL", "functools" ], [ "LOAD_ATTR", "functools.wraps" ], [ "LOAD_DEREF", "function" ], [ "CALL_FUNCTION", "functools.wraps(function)" ], [ "CALL_FUNCTION", "functools.wraps(function)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.isgeneratorfunction" ], [ "LOAD_DEREF", "function" ], [ "CALL_FUNCTION", "inspect.isgeneratorfunction(function)" ], [ "LOAD_FAST", "generator_wrapper" ], [ "LOAD_FAST", "simple_wrapper" ], [ "LOAD_DEREF", "self" ], [ "LOAD_DEREF", "function" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "function(*args, **kwargs)" ], [ "LOAD_DEREF", "function" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "function(*args, **kwargs)" ], [ "LOAD_FAST", "gen" ], [ "LOAD_ATTR", "gen.send" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "method" ], [ "LOAD_FAST", "incoming" ], [ "CALL_FUNCTION", "method(incoming)" ], [ "LOAD_GLOBAL", "StopIteration" ], [ "LOAD_FAST", "gen" ], [ "LOAD_ATTR", "gen.send" ], [ "LOAD_FAST", "outgoing" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_FAST", "gen" ], [ "LOAD_ATTR", "gen.throw" ], [ "LOAD_FAST", "e" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.enabled" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys._getframe" ], [ "LOAD_FAST", "context" ], [ "BINARY_ADD", "context + 1" ], [ "CALL_FUNCTION", "sys._getframe(context + 1)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._is_internal_frame" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_FUNCTION", "self._is_internal_frame(calling_frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.trace" ], [ "LOAD_FAST", "calling_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.target_frames" ], [ "LOAD_ATTR", "self.target_frames.add" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_FUNCTION", "self.target_frames.add(calling_frame)" ], [ "LOAD_FAST", "calling_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.trace" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_FUNCTION", "self.trace(calling_frame, 'enter', None)" ], [ "LOAD_GLOBAL", "thread_global" ], [ "LOAD_ATTR", "thread_global.__dict__" ], [ "LOAD_ATTR", "thread_global.__dict__.setdefault" ], [ "CALL_FUNCTION", "thread_global.__dict__.setdefault('original_trace_functions', [])" ], [ "LOAD_FAST", "stack" ], [ "LOAD_ATTR", "stack.append" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.gettrace" ], [ "CALL_FUNCTION", "sys.gettrace()" ], [ "CALL_FUNCTION", "stack.append(sys.gettrace())" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.settrace" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.trace" ], [ "CALL_FUNCTION", "sys.settrace(self.trace)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.enabled" ], [ "LOAD_GLOBAL", "thread_global" ], [ "LOAD_ATTR", "thread_global.original_trace_functions" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.settrace" ], [ "LOAD_FAST", "stack" ], [ "LOAD_ATTR", "stack.pop" ], [ "CALL_FUNCTION", "stack.pop()" ], [ "CALL_FUNCTION", "sys.settrace(stack.pop())" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys._getframe" ], [ "LOAD_FAST", "context" ], [ "BINARY_ADD", "context + 1" ], [ "CALL_FUNCTION", "sys._getframe(context + 1)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.trace" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_FUNCTION", "self.trace(calling_frame, 'exit', None)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.target_frames" ], [ "LOAD_ATTR", "self.target_frames.discard" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_FUNCTION", "self.target_frames.discard(calling_frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame_infos" ], [ "LOAD_ATTR", "self.frame_infos.pop" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_FUNCTION", "self.frame_infos.pop(calling_frame, None)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_filename" ], [ "LOAD_ATTR", "frame.f_code.co_filename.startswith" ], [ "LOAD_GLOBAL", "internal_directories" ], [ "CALL_FUNCTION", "frame.f_code.co_filename.startswith(internal_directories)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.target_codes" ], [ "COMPARE_OP", "frame.f_code in self.target_codes" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.target_frames" ], [ "COMPARE_OP", "frame in self.target_frames" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._is_traced_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "self._is_traced_frame(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.depth" ], [ "COMPARE_OP", "self.depth == 1" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._is_internal_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "self._is_internal_frame(frame)" ], [ "LOAD_GLOBAL", "is_comprehension_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "is_comprehension_frame(frame)" ], [ "UNARY_NOT", "not is_comprehension_frame(frame)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_GLOBAL", "is_comprehension_frame" ], [ "LOAD_FAST", "candidate" ], [ "CALL_FUNCTION", "is_comprehension_frame(candidate)" ], [ "LOAD_FAST", "candidate" ], [ "LOAD_ATTR", "candidate.f_back" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._is_traced_frame" ], [ "LOAD_FAST", "candidate" ], [ "CALL_FUNCTION", "self._is_traced_frame(candidate)" ], [ "LOAD_FAST", "candidate" ], [ "LOAD_ATTR", "candidate.f_back" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.depth" ], [ "COMPARE_OP", "i >= self.depth" ], [ "LOAD_FAST", "candidate" ], [ "COMPARE_OP", "candidate is None" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._is_internal_frame" ], [ "LOAD_FAST", "candidate" ], [ "CALL_FUNCTION", "self._is_internal_frame(candidate)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.thread_local" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_ATTR", "thread_local.__dict__" ], [ "LOAD_ATTR", "thread_local.__dict__.setdefault" ], [ "CALL_FUNCTION", "thread_local.__dict__.setdefault('depth', -1)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame_infos" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.frame_infos[frame]" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event in ('call', 'enter')" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.last_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.last_frame" ], [ "LOAD_FAST", "frame" ], [ "COMPARE_OP", "self.config.last_frame is not frame" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.last_line_no" ], [ "LOAD_GLOBAL", "Event" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "event" ], [ "LOAD_FAST", "arg" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_ATTR", "thread_local.depth" ], [ "LOAD_FAST", "line_no" ], [ "CALL_FUNCTION", "Event(frame_info, event, arg, thread_local.depth, line_no=line_no)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.formatter" ], [ "LOAD_ATTR", "self.config.formatter.format_line_only" ], [ "LOAD_FAST", "trace_event" ], [ "CALL_FUNCTION", "self.config.formatter.format_line_only(trace_event)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.write" ], [ "LOAD_FAST", "line" ], [ "CALL_FUNCTION", "self.config.write(line)" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event == 'exception'" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_GLOBAL", "Event" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "event" ], [ "LOAD_FAST", "arg" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_ATTR", "thread_local.depth" ], [ "CALL_FUNCTION", "Event(frame_info, event, arg, thread_local.depth)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "COMPARE_OP", "frame.f_code.co_name == ''" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event not in ('return', 'exception')" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.update_variables" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.watch" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.watch_extras" ], [ "LOAD_FAST", "event" ], [ "CALL_FUNCTION", "frame_info.update_variables(\n self.watch,\n self.config.watch_extras,\n event,\n )" ], [ "LOAD_FAST", "trace_event" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event in ('return', 'exit')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame_infos" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.formatter" ], [ "LOAD_ATTR", "self.config.formatter.format" ], [ "LOAD_FAST", "trace_event" ], [ "CALL_FUNCTION", "self.config.formatter.format(trace_event)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.write" ], [ "LOAD_FAST", "formatted" ], [ "CALL_FUNCTION", "self.config.write(formatted)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.trace" ], [ "LOAD_FAST", "config" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "NO_ASTTOKENS" ], [ "LOAD_GLOBAL", "Exception" ], [ "CALL_FUNCTION", "Exception(\"birdseye doesn't support this version of Python\")" ], [ "LOAD_GLOBAL", "ImportError" ], [ "LOAD_GLOBAL", "Exception" ], [ "CALL_FUNCTION", "Exception(\"You must install birdseye separately to use spy: pip install birdseye\")" ], [ "LOAD_GLOBAL", "no_args_decorator" ], [ "LOAD_DEREF", "args" ], [ "LOAD_DEREF", "kwargs" ], [ "CALL_FUNCTION", "no_args_decorator(args, kwargs)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._trace" ], [ "LOAD_DEREF", "args" ], [ "BINARY_SUBSCR", "args[0]" ], [ "CALL_FUNCTION", "self._trace(args[0])" ], [ "LOAD_FAST", "decorator" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._trace" ], [ "LOAD_FAST", "func" ], [ "LOAD_DEREF", "args" ], [ "LOAD_DEREF", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "self._trace(func, *args, **kwargs)" ], [ "LOAD_FAST", "eye" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "eye(func)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.snoop" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "self.config.snoop(*args, **kwargs)" ], [ "LOAD_DEREF", "traced" ], [ "CALL_FUNCTION", "self.config.snoop(*args, **kwargs)(traced)" ], [ "LOAD_GLOBAL", "functools" ], [ "LOAD_ATTR", "functools.wraps" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "LOAD_FAST", "wrapper" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.enabled" ], [ "LOAD_DEREF", "traced" ], [ "LOAD_DEREF", "func" ], [ "LOAD_FAST", "final_func" ], [ "LOAD_FAST", "func_args" ], [ "LOAD_FAST", "func_kwargs" ], [ "CALL_FUNCTION_VAR_KW", "final_func(*func_args, **func_kwargs)" ] ], "utils.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOAD_ATTR", "standard_library.install_aliases" ], [ "CALL_FUNCTION", "standard_library.install_aliases()" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "type" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "version_info" ], [ "LOAD_ATTR", "version_info.major" ], [ "COMPARE_OP", "version_info.major == 2" ], [ "LOAD_NAME", "PY2" ], [ "UNARY_NOT", "not PY2" ], [ "LOAD_NAME", "TypeVar" ], [ "CALL_FUNCTION", "TypeVar('T')" ], [ "LOAD_NAME", "TypeVar" ], [ "CALL_FUNCTION", "TypeVar('RT')" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "unicode" ], [ "LOAD_NAME", "str" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "type" ], [ "LOAD_NAME", "json" ], [ "LOAD_ATTR", "json.JSONEncoder" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_GLOBAL", "ntpath" ], [ "LOAD_ATTR", "ntpath.split" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "ntpath.split(path)" ], [ "LOAD_FAST", "tail" ], [ "LOAD_GLOBAL", "ntpath" ], [ "LOAD_ATTR", "ntpath.basename" ], [ "LOAD_FAST", "head" ], [ "CALL_FUNCTION", "ntpath.basename(head)" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.commonprefix" ], [ "LOAD_FAST", "paths" ], [ "CALL_FUNCTION", "os.path.commonprefix(paths)" ], [ "LOAD_GLOBAL", "ntpath" ], [ "LOAD_ATTR", "ntpath.split" ], [ "LOAD_FAST", "prefix" ], [ "CALL_FUNCTION", "ntpath.split(prefix)" ], [ "BINARY_SUBSCR", "ntpath.split(prefix)[0]" ], [ "LOAD_FAST", "paths" ], [ "BINARY_SUBSCR", "paths[0]" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "prefix" ], [ "CALL_FUNCTION", "len(prefix)" ], [ "BINARY_SUBSCR", "paths[0][len(prefix)]" ], [ "LOAD_FAST", "first_char_after" ], [ "COMPARE_OP", "first_char_after in r'\\/'" ], [ "LOAD_FAST", "first_char_after" ], [ "LOAD_FAST", "prefix" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "COMPARE_OP", "path == IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "all_paths" ], [ "LOAD_GLOBAL", "common_ancestor" ], [ "LOAD_FAST", "all_paths" ], [ "CALL_FUNCTION", "common_ancestor(all_paths)" ], [ "LOAD_FAST", "prefix" ], [ "COMPARE_OP", "prefix in r'\\/'" ], [ "LOAD_GLOBAL", "strip_required_prefix" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "prefix" ], [ "CALL_FUNCTION", "strip_required_prefix(path, prefix)" ], [ "LOAD_GLOBAL", "path_leaf" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "path_leaf(path)" ], [ "LOAD_FAST", "f" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "COMPARE_OP", "f != IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "f" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "COMPARE_OP", "path == IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.sep" ], [ "COMPARE_OP", "os.path.sep == '/'" ], [ "LOAD_FAST", "path" ], [ "LOAD_ATTR", "path.startswith" ], [ "CALL_FUNCTION", "path.startswith('/')" ], [ "UNARY_NOT", "not path.startswith('/')" ], [ "LOAD_FAST", "path" ], [ "BINARY_ADD", "'/' + path" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "type" ], [ "LOAD_FAST", "obj" ], [ "CALL_FUNCTION", "type(obj)" ], [ "LOAD_FAST", "t" ], [ "LOAD_GLOBAL", "types" ], [ "LOAD_ATTR", "types.InstanceType" ], [ "COMPARE_OP", "t is types.InstanceType" ], [ "LOAD_FAST", "obj" ], [ "LOAD_ATTR", "obj.__class__" ], [ "LOAD_FAST", "t" ], [ "LOAD_FAST", "iterable" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_DEREF", "type_or_tuple" ], [ "CALL_FUNCTION", "isinstance(x, type_or_tuple)" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "next" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "next(it)" ], [ "LOAD_GLOBAL", "StopIteration" ], [ "LOAD_GLOBAL", "raise_from" ], [ "LOAD_GLOBAL", "RuntimeError" ], [ "LOAD_FAST", "e" ], [ "CALL_FUNCTION", "raise_from(RuntimeError, e)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "expression" ], [ "CALL_FUNCTION", "hasattr(expression, 'one_or_none')" ], [ "LOAD_FAST", "expression" ], [ "LOAD_ATTR", "expression.one_or_none" ], [ "CALL_FUNCTION", "expression.one_or_none()" ], [ "LOAD_FAST", "expression" ], [ "LOAD_ATTR", "expression.all" ], [ "CALL_FUNCTION", "expression.all()" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "len(result)" ], [ "COMPARE_OP", "len(result) == 0" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "len(result)" ], [ "COMPARE_OP", "len(result) == 1" ], [ "LOAD_FAST", "result" ], [ "BINARY_SUBSCR", "result[0]" ], [ "LOAD_GLOBAL", "Exception" ], [ "CALL_FUNCTION", "Exception(\"There is more than one item returned for the supplied filter\")" ], [ "LOAD_FAST", "lst" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "isinstance(x, list)" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.extend" ], [ "LOAD_GLOBAL", "flatten_list" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "flatten_list(x)" ], [ "CALL_FUNCTION", "result.extend(flatten_list(x))" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.append" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "result.append(x)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "f" ], [ "LOAD_ATTR", "f.__code__" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "LOAD_ATTR", "(lambda: 0).__code__" ], [ "LOAD_ATTR", "(lambda: 0).__code__.co_name" ], [ "COMPARE_OP", "code.co_name == (lambda: 0).__code__.co_name" ], [ "LOAD_FAST", "o" ], [ "LOAD_ATTR", "o.as_json" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "ProtocolEncoder" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(ProtocolEncoder, self)" ], [ "LOAD_ATTR", "super(ProtocolEncoder, self).default" ], [ "LOAD_FAST", "o" ], [ "CALL_FUNCTION", "super(ProtocolEncoder, self).default(o)" ], [ "LOAD_FAST", "method" ], [ "CALL_FUNCTION", "method()" ], [ "LOAD_GLOBAL", "io" ], [ "LOAD_ATTR", "io.open" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "io.open(filename, 'rb')" ], [ "LOAD_GLOBAL", "detect_encoding" ], [ "LOAD_FAST", "fp" ], [ "LOAD_ATTR", "fp.readline" ], [ "CALL_FUNCTION", "detect_encoding(fp.readline)" ], [ "LOAD_FAST", "fp" ], [ "LOAD_ATTR", "fp.seek" ], [ "CALL_FUNCTION", "fp.seek(0)" ], [ "LOAD_GLOBAL", "io" ], [ "LOAD_ATTR", "io.TextIOWrapper" ], [ "LOAD_FAST", "fp" ], [ "LOAD_FAST", "encoding" ], [ "CALL_FUNCTION", "io.TextIOWrapper(fp, encoding, line_buffering=True)" ], [ "LOAD_FAST", "text" ], [ "LOAD_FAST", "text" ], [ "LOAD_FAST", "fp" ], [ "LOAD_ATTR", "fp.close" ], [ "CALL_FUNCTION", "fp.close()" ], [ "LOAD_FAST", "filename" ], [ "LOAD_ATTR", "filename.endswith" ], [ "CALL_FUNCTION", "filename.endswith('.pyc')" ], [ "LOAD_FAST", "filename" ], [ "BINARY_SUBSCR", "filename[:-1]" ], [ "LOAD_GLOBAL", "open_with_encoding_check" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "open_with_encoding_check(filename)" ], [ "LOAD_ATTR", "''.join" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "f" ], [ "CALL_FUNCTION", "enumerate(f)" ], [ "CALL_FUNCTION", "''.join([\n '\\n' if i < 2 and cookie_re.match(line)\n else line\n for i, line in enumerate(f)\n ])" ], [ "LOAD_FAST", "i" ], [ "COMPARE_OP", "i < 2" ], [ "LOAD_DEREF", "cookie_re" ], [ "LOAD_ATTR", "cookie_re.match" ], [ "LOAD_FAST", "line" ], [ "CALL_FUNCTION", "cookie_re.match(line)" ], [ "LOAD_FAST", "line" ], [ "LOAD_GLOBAL", "safe_next" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_ATTR", "tokens.get_tokens" ], [ "LOAD_FAST", "function_node" ], [ "CALL_FUNCTION", "tokens.get_tokens(function_node)" ], [ "CALL_FUNCTION", "safe_next(t for t in tokens.get_tokens(function_node)\n if t.string == 'def' and t.type == token.NAME)" ], [ "LOAD_FAST", "def_token" ], [ "LOAD_ATTR", "def_token.startpos" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_ATTR", "tokens.text" ], [ "LOAD_FAST", "startpos" ], [ "LOAD_FAST", "function_node" ], [ "LOAD_ATTR", "function_node.last_token" ], [ "LOAD_ATTR", "function_node.last_token.endpos" ], [ "BINARY_SUBSCR", "tokens.text[startpos:function_node.last_token.endpos]" ], [ "LOAD_ATTR", "tokens.text[startpos:function_node.last_token.endpos].rstrip" ], [ "CALL_FUNCTION", "tokens.text[startpos:function_node.last_token.endpos].rstrip()" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.startswith" ], [ "CALL_FUNCTION", "source.startswith('def')" ], [ "LOAD_FAST", "startpos" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "t" ], [ "LOAD_ATTR", "t.string" ], [ "COMPARE_OP", "t.string == 'def'" ], [ "LOAD_FAST", "t" ], [ "LOAD_ATTR", "t.type" ], [ "LOAD_GLOBAL", "token" ], [ "LOAD_ATTR", "token.NAME" ], [ "COMPARE_OP", "t.type == token.NAME" ], [ "LOAD_FAST", "t" ], [ "LOAD_FAST", "args" ], [ "LOAD_GLOBAL", "print" ], [ "LOAD_FAST", "arg" ], [ "CALL_FUNCTION", "print(arg)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION", "len(args)" ], [ "COMPARE_OP", "len(args) == 1" ], [ "LOAD_FAST", "args" ], [ "BINARY_SUBSCR", "args[0]" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "filename" ], [ "LOAD_ATTR", "filename.startswith" ], [ "CALL_FUNCTION", "filename.startswith(' max_length" ], [ "LOAD_FAST", "max_length" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "middle" ], [ "CALL_FUNCTION", "len(middle)" ], [ "BINARY_SUBTRACT", "max_length - len(middle)" ], [ "BINARY_FLOOR_DIVIDE", "(max_length - len(middle)) // 2" ], [ "LOAD_FAST", "max_length" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "middle" ], [ "CALL_FUNCTION", "len(middle)" ], [ "BINARY_SUBTRACT", "max_length - len(middle)" ], [ "LOAD_FAST", "left" ], [ "BINARY_SUBTRACT", "max_length - len(middle) - left" ], [ "LOAD_FAST", "seq" ], [ "LOAD_FAST", "left" ], [ "BINARY_SUBSCR", "seq[:left]" ], [ "LOAD_FAST", "middle" ], [ "BINARY_ADD", "seq[:left] + middle" ], [ "LOAD_FAST", "seq" ], [ "LOAD_FAST", "right" ], [ "UNARY_NEGATIVE", "-right" ], [ "BINARY_SUBSCR", "seq[-right:]" ], [ "BINARY_ADD", "seq[:left] + middle + seq[-right:]" ], [ "LOAD_FAST", "seq" ], [ "LOAD_GLOBAL", "truncate" ], [ "LOAD_FAST", "string" ], [ "LOAD_FAST", "max_length" ], [ "CALL_FUNCTION", "truncate(string, max_length, '...')" ], [ "LOAD_GLOBAL", "truncate" ], [ "LOAD_FAST", "lst" ], [ "LOAD_FAST", "max_length" ], [ "CALL_FUNCTION", "truncate(lst, max_length, ['...'])" ], [ "LOAD_FAST", "split" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "six" ], [ "LOAD_ATTR", "six.string_types" ], [ "CALL_FUNCTION", "isinstance(x, six.string_types)" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.replace" ], [ "CALL_FUNCTION", "x.replace(',', ' ')" ], [ "LOAD_ATTR", "x.replace(',', ' ').split" ], [ "CALL_FUNCTION", "x.replace(',', ' ').split()" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "set" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "isinstance(x, (list, set, tuple))" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "tuple" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tuple(x)" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.basename" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_filename" ], [ "CALL_FUNCTION", "os.path.basename(code.co_filename)" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.endswith" ], [ "CALL_FUNCTION", "result.endswith('.pyc')" ], [ "LOAD_FAST", "result" ], [ "BINARY_SUBSCR", "result[:-1]" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "COMPARE_OP", "frame.f_code.co_name in ('', '', '')" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "code('{}.x')" ], [ "LOAD_GLOBAL", "SyntaxError" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "code('({})')" ], [ "LOAD_FAST", "without_parens" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "code('({}).x')" ], [ "COMPARE_OP", "without_parens != code('({}).x')" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "s" ], [ "LOAD_ATTR", "s.format" ], [ "LOAD_DEREF", "source" ], [ "CALL_FUNCTION", "s.format(source)" ], [ "CALL_FUNCTION", "compile(s.format(source), '', 'eval')" ], [ "LOAD_ATTR", "compile(s.format(source), '', 'eval').co_code" ], [ "LOAD_GLOBAL", "needs_parentheses" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "needs_parentheses(source)" ], [ "LOAD_ATTR", "'({})'.format" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "'({})'.format(source)" ], [ "LOAD_FAST", "source" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "REPR_TARGET_LENGTH" ], [ "CALL_FUNCTION", "cheap_repr(x, target_length=REPR_TARGET_LENGTH)" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "ArgDefaultDict" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(ArgDefaultDict, self)" ], [ "LOAD_ATTR", "super(ArgDefaultDict, self).__init__" ], [ "CALL_FUNCTION", "super(ArgDefaultDict, self).__init__()" ], [ "LOAD_FAST", "factory" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.factory" ], [ "LOAD_FAST", "key" ], [ "CALL_FUNCTION", "self.factory(key)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "key" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "lst" ], [ "CALL_FUNCTION", "len(lst)" ], [ "COMPARE_OP", "len(lst) == 1" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "CALL_FUNCTION", "str(i + 1)" ], [ "BINARY_ADD", "' ' + str(i + 1)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_GLOBAL", "os" ], [ "CALL_FUNCTION", "hasattr(os, 'PathLike')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.PathLike" ], [ "CALL_FUNCTION", "isinstance(x, os.PathLike)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "hasattr(x, '__fspath__')" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "hasattr(x, 'open')" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.__class__" ], [ "LOAD_ATTR", "x.__class__.__name__" ], [ "LOAD_ATTR", "x.__class__.__name__.lower" ], [ "CALL_FUNCTION", "x.__class__.__name__.lower()" ], [ "COMPARE_OP", "'path' in x.__class__.__name__.lower()" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION", "len(args)" ], [ "COMPARE_OP", "len(args) == 1" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.isfunction" ], [ "LOAD_FAST", "args" ], [ "BINARY_SUBSCR", "args[0]" ], [ "CALL_FUNCTION", "inspect.isfunction(args[0])" ], [ "LOAD_FAST", "kwargs" ], [ "UNARY_NOT", "not kwargs" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_ADD", "max_length + 2" ], [ "COMPARE_OP", "length <= max_length + 2" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "range(length)" ], [ "LOAD_GLOBAL", "chain" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_FLOOR_DIVIDE", "max_length // 2" ], [ "CALL_FUNCTION", "range(max_length // 2)" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_FLOOR_DIVIDE", "max_length // 2" ], [ "BINARY_SUBTRACT", "length - max_length // 2" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "range(length - max_length // 2,\n length)" ], [ "CALL_FUNCTION", "chain(range(max_length // 2),\n range(length - max_length // 2,\n length))" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "len(x)" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "n == 0" ], [ "LOAD_GLOBAL", "repr" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "repr(x)" ], [ "LOAD_FAST", "helper" ], [ "LOAD_ATTR", "helper.level" ], [ "BINARY_SUBTRACT", "helper.level - 1" ], [ "LOAD_GLOBAL", "_repr_series_one_line" ], [ "LOAD_ATTR", "_repr_series_one_line.maxparts" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "n" ], [ "LOAD_FAST", "maxparts" ], [ "CALL_FUNCTION", "_sample_indices(n, maxparts)" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.index" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "x.index[i:i + 1]" ], [ "LOAD_ATTR", "x.index[i:i + 1].format" ], [ "CALL_FUNCTION", "x.index[i:i + 1].format(sparsify=False)" ], [ "BINARY_SUBSCR", "x.index[i:i + 1].format(sparsify=False)[0]" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.iloc" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "x.iloc[i]" ], [ "LOAD_FAST", "pieces" ], [ "LOAD_ATTR", "pieces.append" ], [ "LOAD_FAST", "k" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "v" ], [ "LOAD_FAST", "newlevel" ], [ "CALL_FUNCTION", "cheap_repr(v, newlevel)" ], [ "BINARY_MODULO", "'%s = %s' % (k, cheap_repr(v, newlevel))" ], [ "CALL_FUNCTION", "pieces.append('%s = %s' % (k, cheap_repr(v, newlevel)))" ], [ "LOAD_FAST", "n" ], [ "LOAD_FAST", "maxparts" ], [ "BINARY_ADD", "maxparts + 2" ], [ "COMPARE_OP", "n > maxparts + 2" ], [ "LOAD_FAST", "pieces" ], [ "LOAD_ATTR", "pieces.insert" ], [ "LOAD_FAST", "maxparts" ], [ "BINARY_FLOOR_DIVIDE", "maxparts // 2" ], [ "CALL_FUNCTION", "pieces.insert(maxparts // 2, '...')" ], [ "LOAD_ATTR", "'; '.join" ], [ "LOAD_FAST", "pieces" ], [ "CALL_FUNCTION", "'; '.join(pieces)" ] ] }executing-0.8.0/tests/sample_results/3.6.json000066400000000000000000021443621410133640400211270ustar00rootroot00000000000000{ "bird.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOAD_ATTR", "standard_library.install_aliases" ], [ "CALL_FUNCTION", "standard_library.install_aliases()" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "warn_if_outdated" ], [ "LOAD_NAME", "__version__" ], [ "CALL_FUNCTION", "warn_if_outdated('birdseye', __version__)" ], [ "LOAD_NAME", "namedtuple" ], [ "CALL_FUNCTION", "namedtuple('CodeInfo', 'db_func traced_file arg_names')" ], [ "LOAD_NAME", "TreeTracerBase" ], [ "LOAD_NAME", "BirdsEye" ], [ "CALL_FUNCTION", "BirdsEye()" ], [ "LOAD_NAME", "NamedTuple" ], [ "LOAD_NAME", "int" ], [ "LOAD_NAME", "bool" ], [ "LOAD_NAME", "int" ], [ "LOAD_NAME", "str" ], [ "CALL_FUNCTION", "NamedTuple('HTMLPosition', [\n ('index', int),\n ('is_start', bool),\n ('depth', int),\n ('html', str),\n])" ], [ "LOAD_NAME", "eye" ], [ "LOAD_ATTR", "eye.enter_call" ], [ "LOAD_ATTR", "eye.enter_call.__code__" ], [ "LOAD_NAME", "eye" ], [ "LOAD_ATTR", "eye.exit_call" ], [ "LOAD_ATTR", "eye.exit_call.__code__" ], [ "LOAD_NAME", "eye" ], [ "LOAD_ATTR", "eye.after_expr" ], [ "LOAD_ATTR", "eye.after_expr.__code__" ], [ "LOAD_NAME", "eye" ], [ "LOAD_ATTR", "eye.after_stmt" ], [ "LOAD_ATTR", "eye.after_stmt.__code__" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "Iterable" ], [ "LOAD_NAME", "Iteration" ], [ "BINARY_SUBSCR", "Iterable[Iteration]" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "TypeRegistry" ], [ "CALL_FUNCTION", "TypeRegistry()" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "try_register_repr" ], [ "CALL_FUNCTION", "try_register_repr('pandas', 'Series')" ], [ "CALL_FUNCTION", "try_register_repr('pandas', 'Series')" ], [ "LOAD_NAME", "cached_property" ], [ "CALL_FUNCTION", "cached_property" ], [ "LOAD_NAME", "lru_cache" ], [ "CALL_FUNCTION", "lru_cache()" ], [ "CALL_FUNCTION", "lru_cache()" ], [ "LOAD_NAME", "retry_db" ], [ "CALL_FUNCTION", "retry_db" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "BirdsEye" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(BirdsEye, self)" ], [ "LOAD_ATTR", "super(BirdsEye, self).__init__" ], [ "CALL_FUNCTION", "super(BirdsEye, self).__init__()" ], [ "LOAD_FAST", "db_uri" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "num_samples" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "dict" ], [ "CALL_FUNCTION_KW", "dict(\n attributes=50,\n dict=50,\n list=30,\n set=30,\n pandas_rows=20,\n pandas_cols=100,\n )" ], [ "LOAD_GLOBAL", "dict" ], [ "CALL_FUNCTION_KW", "dict(\n attributes=50,\n dict=10,\n list=6,\n set=6,\n pandas_rows=6,\n pandas_cols=10,\n )" ], [ "CALL_FUNCTION_KW", "dict(\n big=dict(\n attributes=50,\n dict=50,\n list=30,\n set=30,\n pandas_rows=20,\n pandas_cols=100,\n ),\n small=dict(\n attributes=50,\n dict=10,\n list=6,\n set=6,\n pandas_rows=6,\n pandas_cols=10,\n ),\n )" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "Database" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._db_uri" ], [ "CALL_FUNCTION", "Database(self._db_uri)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.walk" ], [ "LOAD_FAST", "root" ], [ "CALL_FUNCTION", "ast.walk(root)" ], [ "LOAD_GLOBAL", "tracer" ], [ "LOAD_ATTR", "tracer.loops" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "tracer.loops(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "CALL_FUNCTION", "isinstance(node, ast.expr)" ], [ "LOAD_GLOBAL", "is_interesting_expression" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "is_interesting_expression(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "BirdsEye" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(BirdsEye, self)" ], [ "LOAD_ATTR", "super(BirdsEye, self).compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "flags" ], [ "CALL_FUNCTION", "super(BirdsEye, self).compile(source, filename, flags)" ], [ "LOAD_GLOBAL", "ASTTokens" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.root" ], [ "CALL_FUNCTION_KW", "ASTTokens(source, tree=traced_file.root)" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.For)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.body" ], [ "BINARY_SUBSCR", "node.parent.body[0]" ], [ "COMPARE_OP", "node is node.parent.body[0]" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._add_iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "self._add_iteration(node._loops, frame)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.While)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.test" ], [ "COMPARE_OP", "node is node.parent.test" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._add_iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "self._add_iteration(node._loops, frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_ATTR", "self.stack[frame].iteration" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "loops" ], [ "CALL_FUNCTION", "enumerate(loops)" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.loops" ], [ "LOAD_FAST", "loop_node" ], [ "LOAD_ATTR", "loop_node._tree_index" ], [ "BINARY_SUBSCR", "iteration.loops[loop_node._tree_index]" ], [ "LOAD_FAST", "i" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "loops" ], [ "CALL_FUNCTION", "len(loops)" ], [ "BINARY_SUBTRACT", "len(loops) - 1" ], [ "COMPARE_OP", "i == len(loops) - 1" ], [ "LOAD_FAST", "loop" ], [ "LOAD_ATTR", "loop.append" ], [ "LOAD_GLOBAL", "Iteration" ], [ "CALL_FUNCTION", "Iteration()" ], [ "CALL_FUNCTION", "loop.append(Iteration())" ], [ "LOAD_FAST", "loop" ], [ "LOAD_ATTR", "loop.last" ], [ "CALL_FUNCTION", "loop.last()" ], [ "LOAD_GLOBAL", "_tracing_recursively" ], [ "LOAD_DEREF", "frame" ], [ "CALL_FUNCTION", "_tracing_recursively(frame)" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._is_interesting_expression" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "BINARY_SUBSCR", "self._code_infos[frame.f_code]" ], [ "LOAD_ATTR", "self._code_infos[frame.f_code].traced_file" ], [ "LOAD_ATTR", "self._code_infos[frame.f_code].traced_file.is_ipython_cell" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Expr" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.Expr)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.parent" ], [ "LOAD_ATTR", "node.parent.parent.body" ], [ "BINARY_SUBSCR", "node.parent.parent.body[-1]" ], [ "COMPARE_OP", "node.parent is node.parent.parent.body[-1]" ], [ "LOAD_DEREF", "value" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "is_obvious_builtin" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_DEREF", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_ATTR", "self.stack[frame].expression_values" ], [ "LOAD_FAST", "node" ], [ "BINARY_SUBSCR", "self.stack[frame].expression_values[node]" ], [ "CALL_FUNCTION", "is_obvious_builtin(node, self.stack[frame].expression_values[node])" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_DEREF", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_FAST", "exc_value" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._exception_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_FAST", "exc_value" ], [ "CALL_FUNCTION", "self._exception_value(node, frame, exc_value)" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOAD_ATTR", "NodeValue.expression" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.num_samples" ], [ "LOAD_DEREF", "value" ], [ "LOAD_GLOBAL", "max" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "CALL_FUNCTION", "len(node._loops)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._is_first_loop_iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "frame" ], [ "CALL_FUNCTION", "self._is_first_loop_iteration(node, frame)" ], [ "UNARY_NOT", "not self._is_first_loop_iteration(node, frame)" ], [ "BINARY_MULTIPLY", "len(node._loops) * (not self._is_first_loop_iteration(node, frame))" ], [ "BINARY_SUBTRACT", "3 - len(node._loops) * (not self._is_first_loop_iteration(node, frame))" ], [ "CALL_FUNCTION", "max(1, 3 - len(node._loops) * (not self._is_first_loop_iteration(node, frame)))" ], [ "CALL_FUNCTION_KW", "NodeValue.expression(\n self.num_samples,\n value,\n level=max(1, 3 - len(node._loops) * (not self._is_first_loop_iteration(node, frame))),\n )" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._set_node_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_FAST", "node_value" ], [ "CALL_FUNCTION", "self._set_node_value(node, frame, node_value)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._check_inner_call" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node_value" ], [ "CALL_FUNCTION", "self._check_inner_call(frame_info, node, node_value)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.comprehension)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.iter" ], [ "COMPARE_OP", "node is node.parent.iter" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.GeneratorExp" ], [ "CALL_FUNCTION", "isinstance(node.parent.parent, ast.GeneratorExp)" ], [ "UNARY_NOT", "not isinstance(node.parent.parent, ast.GeneratorExp)" ], [ "LOAD_FAST", "is_special_comprehension_iter" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._set_node_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOAD_ATTR", "NodeValue.covered" ], [ "CALL_FUNCTION", "NodeValue.covered()" ], [ "CALL_FUNCTION", "self._set_node_value(node.parent, frame, NodeValue.covered())" ], [ "LOAD_FAST", "exc_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "BINARY_ADD", "node._loops + (node.parent,)" ], [ "LOAD_GLOBAL", "ChangeValue" ], [ "LOAD_FAST", "comprehension_iter_proxy" ], [ "CALL_FUNCTION", "comprehension_iter_proxy()" ], [ "CALL_FUNCTION", "ChangeValue(comprehension_iter_proxy())" ], [ "LOAD_DEREF", "value" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._add_iteration" ], [ "LOAD_DEREF", "loops" ], [ "LOAD_DEREF", "frame" ], [ "CALL_FUNCTION", "self._add_iteration(loops, frame)" ], [ "LOAD_FAST", "item" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.inner_calls" ], [ "LOAD_ATTR", "frame_info.inner_calls.pop" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "frame_info.inner_calls.pop(node, None)" ], [ "LOAD_FAST", "inner_calls" ], [ "LOAD_FAST", "node_value" ], [ "LOAD_ATTR", "node_value.set_meta" ], [ "LOAD_FAST", "inner_calls" ], [ "CALL_FUNCTION", "node_value.set_meta('inner_calls', inner_calls)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_ATTR", "self.stack[frame].iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.loops" ], [ "LOAD_FAST", "loop_node" ], [ "LOAD_ATTR", "loop_node._tree_index" ], [ "BINARY_SUBSCR", "iteration.loops[loop_node._tree_index]" ], [ "LOAD_FAST", "loop" ], [ "LOAD_ATTR", "loop.last" ], [ "CALL_FUNCTION", "loop.last()" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.index" ], [ "COMPARE_OP", "iteration.index > 0" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_ATTR", "self.stack[frame].iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.loops" ], [ "LOAD_FAST", "loop_node" ], [ "LOAD_ATTR", "loop_node._tree_index" ], [ "BINARY_SUBSCR", "iteration.loops[loop_node._tree_index]" ], [ "LOAD_FAST", "loop" ], [ "LOAD_ATTR", "loop.recorded_node" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "loop.recorded_node(node)" ], [ "LOAD_FAST", "loop" ], [ "LOAD_ATTR", "loop.last" ], [ "CALL_FUNCTION", "loop.last()" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.vals" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOAD_ATTR", "NodeValue.exception" ], [ "LOAD_FAST", "exc_value" ], [ "CALL_FUNCTION", "NodeValue.exception(exc_value)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._set_node_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "self._set_node_value(node, frame, value)" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_GLOBAL", "_tracing_recursively" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "_tracing_recursively(frame)" ], [ "LOAD_FAST", "exc_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "exc_node" ], [ "COMPARE_OP", "node is exc_node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._exception_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "exc_value" ], [ "CALL_FUNCTION", "self._exception_value(node, frame, exc_value)" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOAD_ATTR", "NodeValue.covered" ], [ "CALL_FUNCTION", "NodeValue.covered()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._set_node_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "self._set_node_value(node, frame, value)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._check_inner_call" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "self._check_inner_call(self.stack[frame], node, value)" ], [ "LOAD_FAST", "enter_info" ], [ "LOAD_ATTR", "enter_info.current_frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_GLOBAL", "_tracing_recursively" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "_tracing_recursively(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_GLOBAL", "get_unfrozen_datetime" ], [ "CALL_FUNCTION", "get_unfrozen_datetime()" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_GLOBAL", "Iteration" ], [ "CALL_FUNCTION", "Iteration()" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "BINARY_SUBSCR", "self._code_infos[frame.f_code]" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "enter_info" ], [ "LOAD_ATTR", "enter_info.enter_node" ], [ "LOAD_ATTR", "enter_info.enter_node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Module" ], [ "CALL_FUNCTION", "isinstance(enter_info.enter_node.parent, ast.Module)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "LOAD_ATTR", "frame.f_locals.copy" ], [ "CALL_FUNCTION", "frame.f_locals.copy()" ], [ "LOAD_FAST", "code_info" ], [ "LOAD_ATTR", "code_info.arg_names" ], [ "LOAD_DEREF", "f_locals" ], [ "LOAD_ATTR", "f_locals.items" ], [ "CALL_FUNCTION", "f_locals.items()" ], [ "BINARY_ADD", "[(name, f_locals.pop(name))\n for name in code_info.arg_names\n if name] + [\n\n # Local variables other than actual arguments. These are variables from\n # the enclosing scope. It's handy to treat them like arguments in the UI\n it for it in f_locals.items()\n if it[0][0] != '.' # Appears when using nested tuple arguments\n ]" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_ATTR", "json.dumps" ], [ "LOAD_FAST", "arguments" ], [ "CALL_FUNCTION", "json.dumps([[k, cheap_repr(v)] for k, v in arguments])" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._call_id" ], [ "CALL_FUNCTION", "self._call_id()" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "defaultdict(list)" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_ATTR", "self.stack.get" ], [ "LOAD_FAST", "enter_info" ], [ "LOAD_ATTR", "enter_info.caller_frame" ], [ "CALL_FUNCTION", "self.stack.get(enter_info.caller_frame)" ], [ "LOAD_FAST", "prev" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "prev" ], [ "CALL_FUNCTION", "getattr(prev, 'inner_calls', None)" ], [ "LOAD_FAST", "inner_calls" ], [ "COMPARE_OP", "inner_calls is not None" ], [ "LOAD_FAST", "inner_calls" ], [ "LOAD_FAST", "enter_info" ], [ "LOAD_ATTR", "enter_info.call_node" ], [ "BINARY_SUBSCR", "inner_calls[enter_info.call_node]" ], [ "LOAD_ATTR", "inner_calls[enter_info.call_node].append" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.call_id" ], [ "CALL_FUNCTION", "inner_calls[enter_info.call_node].append(frame_info.call_id)" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "name" ], [ "LOAD_DEREF", "f_locals" ], [ "LOAD_ATTR", "f_locals.pop" ], [ "LOAD_FAST", "name" ], [ "CALL_FUNCTION", "f_locals.pop(name)" ], [ "LOAD_FAST", "it" ], [ "BINARY_SUBSCR", "it[0]" ], [ "BINARY_SUBSCR", "it[0][0]" ], [ "COMPARE_OP", "it[0][0] != '.'" ], [ "LOAD_FAST", "it" ], [ "LOAD_FAST", "k" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "cheap_repr(v)" ], [ "LOAD_GLOBAL", "uuid4" ], [ "CALL_FUNCTION", "uuid4()" ], [ "LOAD_ATTR", "uuid4().hex" ], [ "LOAD_DEREF", "exit_info" ], [ "LOAD_ATTR", "exit_info.current_frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_GLOBAL", "_tracing_recursively" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "_tracing_recursively(frame)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.iteration" ], [ "LOAD_GLOBAL", "_deep_dict" ], [ "CALL_FUNCTION", "_deep_dict()" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._extract_node_values" ], [ "LOAD_DEREF", "top_iteration" ], [ "LOAD_DEREF", "node_values" ], [ "CALL_FUNCTION", "self._extract_node_values(top_iteration, (), node_values)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "BINARY_SUBSCR", "self._code_infos[frame.f_code]" ], [ "LOAD_ATTR", "self._code_infos[frame.f_code].db_func" ], [ "LOAD_DEREF", "exit_info" ], [ "LOAD_ATTR", "exit_info.exc_value" ], [ "LOAD_FAST", "exc" ], [ "LOAD_ATTR", "''.join" ], [ "LOAD_GLOBAL", "traceback" ], [ "LOAD_ATTR", "traceback.format_exception" ], [ "LOAD_GLOBAL", "type" ], [ "LOAD_FAST", "exc" ], [ "CALL_FUNCTION", "type(exc)" ], [ "LOAD_FAST", "exc" ], [ "LOAD_DEREF", "exit_info" ], [ "LOAD_ATTR", "exit_info.exc_tb" ], [ "CALL_FUNCTION", "traceback.format_exception(type(exc), exc, exit_info.exc_tb)" ], [ "CALL_FUNCTION", "''.join(traceback.format_exception(type(exc), exc, exit_info.exc_tb))" ], [ "LOAD_GLOBAL", "exception_string" ], [ "LOAD_FAST", "exc" ], [ "CALL_FUNCTION", "exception_string(exc)" ], [ "LOAD_GLOBAL", "retry_db" ], [ "CALL_FUNCTION", "retry_db" ], [ "LOAD_FAST", "add_call" ], [ "CALL_FUNCTION", "add_call()" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.call_id" ], [ "LOAD_DEREF", "self" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.db" ], [ "LOAD_ATTR", "self.db.Call" ], [ "LOAD_FAST", "Call" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.call_id" ], [ "LOAD_DEREF", "db_func" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.arguments" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_DEREF", "exit_info" ], [ "LOAD_ATTR", "exit_info.return_value" ], [ "CALL_FUNCTION", "cheap_repr(exit_info.return_value)" ], [ "LOAD_DEREF", "exception" ], [ "LOAD_DEREF", "traceback_str" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_ATTR", "json.dumps" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_DEREF", "node_values" ], [ "LOAD_DEREF", "top_iteration" ], [ "LOAD_ATTR", "top_iteration.extract_iterations" ], [ "CALL_FUNCTION", "top_iteration.extract_iterations()" ], [ "BINARY_SUBSCR", "top_iteration.extract_iterations()['loops']" ], [ "LOAD_GLOBAL", "type_registry" ], [ "LOAD_ATTR", "type_registry.names" ], [ "CALL_FUNCTION", "type_registry.names()" ], [ "LOAD_GLOBAL", "type_registry" ], [ "LOAD_ATTR", "type_registry.num_special_types" ], [ "CALL_FUNCTION_KW", "dict(\n node_values=node_values,\n loop_iterations=top_iteration.extract_iterations()['loops'],\n type_names=type_registry.names(),\n num_special_types=type_registry.num_special_types,\n )" ], [ "LOAD_GLOBAL", "ProtocolEncoder" ], [ "CALL_FUNCTION_KW", "json.dumps(\n dict(\n node_values=node_values,\n loop_iterations=top_iteration.extract_iterations()['loops'],\n type_names=type_registry.names(),\n num_special_types=type_registry.num_special_types,\n ),\n cls=ProtocolEncoder,\n separators=(',', ':')\n )" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.start_time" ], [ "CALL_FUNCTION_KW", "Call(id=frame_info.call_id,\n function_id=db_func,\n arguments=frame_info.arguments,\n return_value=cheap_repr(exit_info.return_value),\n exception=exception,\n traceback=traceback_str,\n data=json.dumps(\n dict(\n node_values=node_values,\n loop_iterations=top_iteration.extract_iterations()['loops'],\n type_names=type_registry.names(),\n num_special_types=type_registry.num_special_types,\n ),\n cls=ProtocolEncoder,\n separators=(',', ':')\n ),\n start_time=frame_info.start_time)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.db" ], [ "LOAD_ATTR", "self.db.session_scope" ], [ "CALL_FUNCTION", "self.db.session_scope()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.add" ], [ "LOAD_FAST", "call" ], [ "CALL_FUNCTION", "session.add(call)" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.vals" ], [ "LOAD_ATTR", "iteration.vals.items" ], [ "CALL_FUNCTION", "iteration.vals.items()" ], [ "LOAD_FAST", "tree_index" ], [ "LOAD_FAST", "path" ], [ "BINARY_ADD", "(tree_index,) + path" ], [ "LOAD_FAST", "node_values" ], [ "LOAD_FAST", "full_path" ], [ "BINARY_SUBSCR", "full_path[:-1]" ], [ "LOAD_FAST", "d" ], [ "LOAD_FAST", "path_k" ], [ "BINARY_SUBSCR", "d[path_k]" ], [ "LOAD_FAST", "node_value" ], [ "LOAD_FAST", "d" ], [ "LOAD_FAST", "full_path" ], [ "BINARY_SUBSCR", "full_path[-1]" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.loops" ], [ "LOAD_ATTR", "iteration.loops.values" ], [ "CALL_FUNCTION", "iteration.loops.values()" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "loop" ], [ "CALL_FUNCTION", "enumerate(loop)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._extract_node_values" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "path + (i,)" ], [ "LOAD_FAST", "node_values" ], [ "CALL_FUNCTION", "self._extract_node_values(iteration, path + (i,), node_values)" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "BirdsEye" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(BirdsEye, self)" ], [ "LOAD_ATTR", "super(BirdsEye, self).trace_function" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "super(BirdsEye, self).trace_function(func)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_ATTR", "self._code_infos.get" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_ATTR", "new_func.__code__" ], [ "CALL_FUNCTION", "self._code_infos.get(new_func.__code__)" ], [ "LOAD_FAST", "code_info" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.getsourcelines" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "inspect.getsourcelines(func)" ], [ "LOAD_FAST", "start_lineno" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "lines" ], [ "CALL_FUNCTION", "len(lines)" ], [ "BINARY_ADD", "start_lineno + len(lines)" ], [ "LOAD_GLOBAL", "safe_qualname" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "safe_qualname(func)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.getsourcefile" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "inspect.getsourcefile(func)" ], [ "LOAD_FAST", "source_file" ], [ "LOAD_ATTR", "source_file.startswith" ], [ "CALL_FUNCTION", "source_file.startswith('= 0" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.getsourcefile" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "inspect.getsourcefile(frame)" ], [ "LOAD_FAST", "filename" ], [ "COMPARE_OP", "filename is not None" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.abspath" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "os.path.abspath(filename)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "LOAD_ATTR", "frame.f_globals.get" ], [ "CALL_FUNCTION", "frame.f_globals.get('__name__')" ], [ "COMPARE_OP", "frame.f_globals.get('__name__') != '__main__'" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._treetrace_hidden_with_stmt" ], [ "LOAD_ATTR", "self._treetrace_hidden_with_stmt.__name__" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "COMPARE_OP", "self._treetrace_hidden_with_stmt.__name__ not in frame.f_globals" ], [ "LOAD_GLOBAL", "RuntimeError" ], [ "CALL_FUNCTION", "RuntimeError(\n 'To trace an imported module, you must import birdseye before '\n 'importing that module.')" ], [ "LOAD_GLOBAL", "read_source_file" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "read_source_file(filename)" ], [ "LOAD_ATTR", "read_source_file(filename).splitlines" ], [ "CALL_FUNCTION", "read_source_file(filename).splitlines()" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lineno" ], [ "BINARY_MULTIPLY", "[''] * frame.f_lineno" ], [ "LOAD_FAST", "lines" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lineno" ], [ "LOAD_ATTR", "'\\n'.join" ], [ "LOAD_FAST", "lines" ], [ "CALL_FUNCTION", "'\\n'.join(lines)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.exec_string" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "LOAD_FAST", "deep" ], [ "CALL_FUNCTION", "self.exec_string(source, filename, frame.f_globals, frame.f_locals, deep)" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.exit" ], [ "CALL_FUNCTION", "sys.exit(0)" ], [ "LOAD_FAST", "globs" ], [ "LOAD_FAST", "locs" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.compile" ], [ "LOAD_DEREF", "source" ], [ "LOAD_DEREF", "filename" ], [ "CALL_FUNCTION", "self.compile(source, filename)" ], [ "LOAD_FAST", "globs" ], [ "LOAD_ATTR", "globs.update" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._trace_methods_dict" ], [ "LOAD_DEREF", "traced_file" ], [ "CALL_FUNCTION", "self._trace_methods_dict(traced_file)" ], [ "CALL_FUNCTION", "globs.update(self._trace_methods_dict(traced_file))" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._trace" ], [ "LOAD_GLOBAL", "FILE_SENTINEL_NAME" ], [ "LOAD_DEREF", "filename" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.code" ], [ "LOAD_DEREF", "source" ], [ "CALL_FUNCTION", "self._trace(FILE_SENTINEL_NAME, filename, traced_file, traced_file.code, 'module', source)" ], [ "LOAD_FAST", "deep" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.nodes" ], [ "LOAD_DEREF", "find_code" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.code" ], [ "CALL_FUNCTION", "find_code(traced_file.code)" ], [ "LOAD_GLOBAL", "exec" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.code" ], [ "LOAD_FAST", "globs" ], [ "LOAD_FAST", "locs" ], [ "CALL_FUNCTION", "exec(traced_file.code, globs, locs)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(node, ast.FunctionDef)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.lineno" ], [ "LOAD_FAST", "root_code" ], [ "LOAD_ATTR", "root_code.co_consts" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.iscode" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "inspect.iscode(code)" ], [ "UNARY_NOT", "not inspect.iscode(code)" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "LOAD_ATTR", "code.co_name.startswith" ], [ "CALL_FUNCTION", "code.co_name.startswith('<')" ], [ "LOAD_DEREF", "find_code" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "find_code(code)" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_firstlineno" ], [ "LOAD_DEREF", "nodes_by_lineno" ], [ "LOAD_ATTR", "nodes_by_lineno.get" ], [ "LOAD_FAST", "lineno" ], [ "CALL_FUNCTION", "nodes_by_lineno.get(lineno)" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._trace" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "LOAD_DEREF", "filename" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_FAST", "code" ], [ "LOAD_DEREF", "source" ], [ "LOAD_FAST", "lineno" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.last_token" ], [ "LOAD_ATTR", "node.last_token.end" ], [ "BINARY_SUBSCR", "node.last_token.end[0]" ], [ "BINARY_ADD", "node.last_token.end[0] + 1" ], [ "CALL_FUNCTION_KW", "self._trace(\n code.co_name, filename, traced_file, code,\n typ='function',\n source=source,\n start_lineno=lineno,\n end_lineno=node.last_token.end[0] + 1,\n )" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_DEREF", "start_lineno" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.splitlines" ], [ "CALL_FUNCTION", "source.splitlines()" ], [ "CALL_FUNCTION", "len(source.splitlines())" ], [ "BINARY_ADD", "start_lineno + len(source.splitlines())" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._nodes_of_interest" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_DEREF", "start_lineno" ], [ "LOAD_FAST", "end_lineno" ], [ "CALL_FUNCTION", "self._nodes_of_interest(traced_file, start_lineno, end_lineno)" ], [ "CALL_FUNCTION", "list(self._nodes_of_interest(traced_file, start_lineno, end_lineno))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._nodes_html" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_DEREF", "start_lineno" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_FAST", "traced_file" ], [ "CALL_FUNCTION", "self._nodes_html(nodes, start_lineno, end_lineno, traced_file)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "nodes" ], [ "CALL_FUNCTION_KW", "dict(\n # This maps each node to the loops enclosing that node\n node_loops={\n node._tree_index: [n._tree_index for n in node._loops]\n for node, _ in nodes\n if node._loops\n },\n )" ], [ "LOAD_FAST", "typ" ], [ "COMPARE_OP", "typ == 'function'" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.tokens" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_FAST", "nodes" ], [ "CALL_FUNCTION", "only(node\n for node, _ in nodes\n if isinstance(node, ast.FunctionDef)\n and node.first_token.start[0] == start_lineno)" ], [ "LOAD_GLOBAL", "source_without_decorators" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_FAST", "func_node" ], [ "CALL_FUNCTION", "source_without_decorators(tokens, func_node)" ], [ "LOAD_FAST", "data_dict" ], [ "LOAD_ATTR", "data_dict.update" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._node_ranges" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_FAST", "func_startpos" ], [ "CALL_FUNCTION", "self._node_ranges(nodes, tokens, func_startpos)" ], [ "CALL_FUNCTION", "list(self._node_ranges(nodes, tokens, func_startpos))" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._loop_ranges" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_FAST", "func_startpos" ], [ "CALL_FUNCTION", "self._loop_ranges(nodes, tokens, func_startpos)" ], [ "CALL_FUNCTION", "list(self._loop_ranges(nodes, tokens, func_startpos))" ], [ "CALL_FUNCTION_KW", "data_dict.update(\n node_ranges=list(self._node_ranges(nodes, tokens, func_startpos)),\n loop_ranges=list(self._loop_ranges(nodes, tokens, func_startpos)),\n )" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_ATTR", "json.dumps" ], [ "LOAD_FAST", "data_dict" ], [ "CALL_FUNCTION_KW", "json.dumps(data_dict, sort_keys=True)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._db_func" ], [ "LOAD_FAST", "data" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "html_body" ], [ "LOAD_FAST", "name" ], [ "LOAD_DEREF", "start_lineno" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "typ" ], [ "CALL_FUNCTION", "self._db_func(data, filename, html_body, name, start_lineno, source, typ)" ], [ "LOAD_GLOBAL", "CodeInfo" ], [ "LOAD_FAST", "db_func" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_FAST", "arg_names" ], [ "CALL_FUNCTION", "CodeInfo(db_func, traced_file, arg_names)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_FAST", "n" ], [ "LOAD_ATTR", "n._tree_index" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(node, ast.FunctionDef)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.first_token" ], [ "LOAD_ATTR", "node.first_token.start" ], [ "BINARY_SUBSCR", "node.first_token.start[0]" ], [ "LOAD_DEREF", "start_lineno" ], [ "COMPARE_OP", "node.first_token.start[0] == start_lineno" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "classes" ], [ "COMPARE_OP", "'loop' not in classes" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.target" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.test" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_ATTR", "tokens.get_text_range" ], [ "LOAD_FAST", "target" ], [ "CALL_FUNCTION", "tokens.get_text_range(target)" ], [ "LOAD_FAST", "func_start" ], [ "LOAD_FAST", "func_start" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "CALL_FUNCTION_KW", "dict(\n tree_index=node._tree_index,\n start=start,\n end=end\n )" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_ATTR", "tokens.get_text_range" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "tokens.get_text_range(node)" ], [ "LOAD_FAST", "func_start" ], [ "LOAD_FAST", "func_start" ], [ "LOAD_FAST", "start" ], [ "COMPARE_OP", "start < 0" ], [ "LOAD_FAST", "end" ], [ "COMPARE_OP", "end < 0" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(node, ast.FunctionDef)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._depth" ], [ "LOAD_FAST", "classes" ], [ "CALL_FUNCTION_KW", "dict(\n tree_index=node._tree_index,\n start=start,\n end=end,\n depth=node._depth,\n classes=classes,\n )" ], [ "LOAD_FAST", "h" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "name" ], [ "BINARY_ADD", "filename + name" ], [ "LOAD_FAST", "html_body" ], [ "BINARY_ADD", "filename + name + html_body" ], [ "LOAD_FAST", "data" ], [ "BINARY_ADD", "filename + name + html_body + data" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "start_lineno" ], [ "CALL_FUNCTION", "str(start_lineno)" ], [ "BINARY_ADD", "filename + name + html_body + data + str(start_lineno)" ], [ "CALL_FUNCTION", "h(filename + name + html_body + data + str(start_lineno))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.db" ], [ "LOAD_ATTR", "self.db.Function" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.db" ], [ "LOAD_ATTR", "self.db.session_scope" ], [ "CALL_FUNCTION", "self.db.session_scope()" ], [ "LOAD_GLOBAL", "one_or_none" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_FAST", "Function" ], [ "CALL_FUNCTION", "session.query(Function)" ], [ "LOAD_ATTR", "session.query(Function).filter_by" ], [ "LOAD_FAST", "function_hash" ], [ "CALL_FUNCTION_KW", "session.query(Function).filter_by(hash=function_hash)" ], [ "CALL_FUNCTION", "one_or_none(session.query(Function).filter_by(hash=function_hash))" ], [ "LOAD_FAST", "db_func" ], [ "LOAD_FAST", "Function" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "typ" ], [ "LOAD_FAST", "html_body" ], [ "LOAD_FAST", "start_lineno" ], [ "LOAD_FAST", "data" ], [ "LOAD_FAST", "h" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "h(source)" ], [ "LOAD_FAST", "function_hash" ], [ "CALL_FUNCTION_KW", "Function(file=filename,\n name=name,\n type=typ,\n html_body=html_body,\n lineno=start_lineno,\n data=data,\n body_hash=h(source),\n hash=function_hash)" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.add" ], [ "LOAD_FAST", "db_func" ], [ "CALL_FUNCTION", "session.add(db_func)" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.commit" ], [ "CALL_FUNCTION", "session.commit()" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "db_func" ], [ "LOAD_ATTR", "db_func.id" ], [ "LOAD_GLOBAL", "int" ], [ "CALL_FUNCTION", "isinstance(db_func.id, int)" ], [ "LOAD_FAST", "db_func" ], [ "LOAD_ATTR", "db_func.id" ], [ "LOAD_GLOBAL", "hashlib" ], [ "LOAD_ATTR", "hashlib.sha256" ], [ "LOAD_FAST", "s" ], [ "LOAD_ATTR", "s.encode" ], [ "CALL_FUNCTION", "s.encode('utf8')" ], [ "CALL_FUNCTION", "hashlib.sha256(s.encode('utf8'))" ], [ "LOAD_ATTR", "hashlib.sha256(s.encode('utf8')).hexdigest" ], [ "CALL_FUNCTION", "hashlib.sha256(s.encode('utf8')).hexdigest()" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.nodes" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "CALL_FUNCTION", "isinstance(node, (ast.While, ast.For, ast.comprehension))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.GeneratorExp" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.GeneratorExp)" ], [ "UNARY_NOT", "not isinstance(node.parent, ast.GeneratorExp)" ], [ "LOAD_FAST", "classes" ], [ "LOAD_ATTR", "classes.append" ], [ "CALL_FUNCTION", "classes.append('loop')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "CALL_FUNCTION", "isinstance(node, ast.stmt)" ], [ "LOAD_FAST", "classes" ], [ "LOAD_ATTR", "classes.append" ], [ "CALL_FUNCTION", "classes.append('stmt')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "CALL_FUNCTION", "isinstance(node, ast.expr)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._is_interesting_expression" ], [ "LOAD_FAST", "classes" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.AST" ], [ "CALL_FUNCTION", "isinstance(node, ast.AST)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "hasattr(node, 'first_token')" ], [ "LOAD_FAST", "start_lineno" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.first_token" ], [ "LOAD_ATTR", "node.first_token.start" ], [ "BINARY_SUBSCR", "node.first_token.start[0]" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.tokens" ], [ "LOAD_ATTR", "traced_file.tokens.get_text_range" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "traced_file.tokens.get_text_range(node)" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "classes" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.root" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.walk" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.root" ], [ "CALL_FUNCTION", "ast.walk(traced_file.root)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.iter_child_nodes" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ast.iter_child_nodes(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._depth" ], [ "BINARY_ADD", "node._depth + 1" ], [ "LOAD_FAST", "child" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "positions" ], [ "LOAD_ATTR", "positions.extend" ], [ "LOAD_GLOBAL", "map" ], [ "LOAD_GLOBAL", "HTMLPosition" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._depth" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._depth" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_ATTR", "' '.join" ], [ "LOAD_FAST", "classes" ], [ "CALL_FUNCTION", "' '.join(classes)" ], [ "BINARY_MODULO", "'' % (node._tree_index, ' '.join(classes))" ], [ "CALL_FUNCTION", "map(\n HTMLPosition,\n [start, end],\n [True, False], # is_start\n [node._depth, node._depth],\n ['' % (node._tree_index, ' '.join(classes)),\n ''])" ], [ "CALL_FUNCTION", "positions.extend(map(\n HTMLPosition,\n [start, end],\n [True, False], # is_start\n [node._depth, node._depth],\n ['' % (node._tree_index, ' '.join(classes)),\n '']))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._separate_comprehensions" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_FAST", "positions" ], [ "LOAD_FAST", "traced_file" ], [ "CALL_FUNCTION", "self._separate_comprehensions(\n [n[0] for n in nodes],\n end_lineno, positions, traced_file)" ], [ "LOAD_FAST", "positions" ], [ "LOAD_ATTR", "positions.append" ], [ "LOAD_GLOBAL", "HTMLPosition" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.source" ], [ "CALL_FUNCTION", "len(traced_file.source)" ], [ "CALL_FUNCTION", "HTMLPosition(len(traced_file.source), False, 0, '')" ], [ "CALL_FUNCTION", "positions.append(HTMLPosition(len(traced_file.source), False, 0, ''))" ], [ "LOAD_FAST", "positions" ], [ "LOAD_ATTR", "positions.sort" ], [ "CALL_FUNCTION", "positions.sort()" ], [ "LOAD_FAST", "positions" ], [ "LOAD_FAST", "html_parts" ], [ "LOAD_ATTR", "html_parts.append" ], [ "LOAD_GLOBAL", "html" ], [ "LOAD_ATTR", "html.escape" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.source" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "position" ], [ "LOAD_ATTR", "position.index" ], [ "BINARY_SUBSCR", "traced_file.source[start:position.index]" ], [ "CALL_FUNCTION", "html.escape(traced_file.source[start:position.index])" ], [ "CALL_FUNCTION", "html_parts.append(html.escape(traced_file.source[start:position.index]))" ], [ "LOAD_FAST", "html_parts" ], [ "LOAD_ATTR", "html_parts.append" ], [ "LOAD_FAST", "position" ], [ "LOAD_ATTR", "position.html" ], [ "CALL_FUNCTION", "html_parts.append(position.html)" ], [ "LOAD_FAST", "position" ], [ "LOAD_ATTR", "position.index" ], [ "LOAD_ATTR", "''.join" ], [ "LOAD_FAST", "html_parts" ], [ "CALL_FUNCTION", "''.join(html_parts)" ], [ "LOAD_ATTR", "'\\n'.join" ], [ "LOAD_FAST", "html_body" ], [ "LOAD_ATTR", "html_body.split" ], [ "CALL_FUNCTION", "html_body.split('\\n')" ], [ "LOAD_FAST", "start_lineno" ], [ "BINARY_SUBTRACT", "start_lineno - 1" ], [ "LOAD_FAST", "end_lineno" ], [ "BINARY_SUBTRACT", "end_lineno - 1" ], [ "BINARY_SUBSCR", "html_body.split('\\n')[start_lineno - 1:end_lineno - 1]" ], [ "CALL_FUNCTION", "'\\n'.join(html_body.split('\\n')[start_lineno - 1:end_lineno - 1])" ], [ "LOAD_FAST", "html_body" ], [ "LOAD_ATTR", "html_body.strip" ], [ "CALL_FUNCTION", "html_body.strip('\\n')" ], [ "LOAD_FAST", "n" ], [ "BINARY_SUBSCR", "n[0]" ], [ "LOAD_GLOBAL", "group_by_key_func" ], [ "LOAD_GLOBAL", "of_type" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "LOAD_FAST", "nodes" ], [ "CALL_FUNCTION", "of_type((ast.comprehension, ast.While, ast.For), nodes)" ], [ "CALL_FUNCTION", "group_by_key_func(of_type((ast.comprehension, ast.While, ast.For), nodes),\n lambda c: c.first_token.start[0]\n )" ], [ "LOAD_FAST", "comprehensions" ], [ "LOAD_ATTR", "comprehensions.values" ], [ "CALL_FUNCTION", "comprehensions.values()" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_FAST", "comp_list" ], [ "CALL_FUNCTION_KW", "sorted(comp_list, key=lambda c: c.first_token.startpos)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "comp" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "CALL_FUNCTION", "isinstance(comp, ast.comprehension)" ], [ "LOAD_FAST", "comp" ], [ "LOAD_FAST", "comp" ], [ "LOAD_ATTR", "comp.parent" ], [ "LOAD_ATTR", "comp.parent.generators" ], [ "BINARY_SUBSCR", "comp.parent.generators[0]" ], [ "COMPARE_OP", "comp is comp.parent.generators[0]" ], [ "LOAD_FAST", "get_start" ], [ "LOAD_FAST", "comp" ], [ "LOAD_ATTR", "comp.parent" ], [ "CALL_FUNCTION", "get_start(comp.parent)" ], [ "LOAD_FAST", "prev_start" ], [ "COMPARE_OP", "prev_start is not None" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "prev_start" ], [ "COMPARE_OP", "start < prev_start" ], [ "LOAD_FAST", "get_start" ], [ "LOAD_FAST", "comp" ], [ "CALL_FUNCTION", "get_start(comp)" ], [ "LOAD_FAST", "get_start" ], [ "LOAD_FAST", "comp" ], [ "CALL_FUNCTION", "get_start(comp)" ], [ "LOAD_FAST", "prev_start" ], [ "COMPARE_OP", "prev_start is not None" ], [ "LOAD_FAST", "positions" ], [ "LOAD_ATTR", "positions.append" ], [ "LOAD_GLOBAL", "HTMLPosition" ], [ "LOAD_FAST", "start" ], [ "CALL_FUNCTION", "HTMLPosition(start, True, 0, '\\n ')" ], [ "CALL_FUNCTION", "positions.append(HTMLPosition(start, True, 0, '\\n '))" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.first_token" ], [ "LOAD_ATTR", "c.first_token.start" ], [ "BINARY_SUBSCR", "c.first_token.start[0]" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.tokens" ], [ "LOAD_ATTR", "traced_file.tokens.get_text_range" ], [ "LOAD_FAST", "n" ], [ "CALL_FUNCTION", "traced_file.tokens.get_text_range(n)" ], [ "BINARY_SUBSCR", "traced_file.tokens.get_text_range(n)[0]" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.first_token" ], [ "LOAD_ATTR", "c.first_token.startpos" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "_deep_dict" ], [ "CALL_FUNCTION", "defaultdict(_deep_dict)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_GLOBAL", "_bad_codes" ], [ "COMPARE_OP", "frame.f_code in _bad_codes" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "IterationList" ], [ "CALL_FUNCTION", "defaultdict(IterationList)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.index" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.loops" ], [ "LOAD_ATTR", "self.loops.items" ], [ "CALL_FUNCTION", "self.loops.items()" ], [ "LOAD_FAST", "iteration_list" ], [ "LOAD_FAST", "tree_index" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.extract_iterations" ], [ "CALL_FUNCTION", "iteration.extract_iterations()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "deque" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.side_len" ], [ "CALL_FUNCTION_KW", "deque(maxlen=self.side_len)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "Counter" ], [ "CALL_FUNCTION", "Counter()" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.length" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.side_len" ], [ "COMPARE_OP", "self.length < self.side_len" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start" ], [ "LOAD_ATTR", "self.start.append" ], [ "LOAD_FAST", "iteration" ], [ "CALL_FUNCTION", "self.start.append(iteration)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "CALL_FUNCTION", "len(self.end)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.side_len" ], [ "COMPARE_OP", "len(self.end) >= self.side_len" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "BINARY_SUBSCR", "self.end[0]" ], [ "LOAD_ATTR", "self.end[0].keep" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start" ], [ "LOAD_ATTR", "self.start.append" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "BINARY_SUBSCR", "self.end[0]" ], [ "CALL_FUNCTION", "self.start.append(self.end[0])" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "LOAD_ATTR", "self.end.append" ], [ "LOAD_FAST", "iteration" ], [ "CALL_FUNCTION", "self.end.append(iteration)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.length" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "chain" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "CALL_FUNCTION", "chain(self.start, self.end)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "BINARY_SUBSCR", "self.end[-1]" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start" ], [ "BINARY_SUBSCR", "self.start[-1]" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.recorded" ], [ "LOAD_FAST", "node" ], [ "BINARY_SUBSCR", "self.recorded[node]" ], [ "COMPARE_OP", "self.recorded[node] >= 2" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.last" ], [ "CALL_FUNCTION", "self.last()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.recorded" ], [ "LOAD_FAST", "node" ], [ "LOAD_NAME", "type" ], [ "CALL_FUNCTION", "type(None)" ], [ "LOAD_NAME", "bool" ], [ "LOAD_NAME", "int" ], [ "LOAD_NAME", "float" ], [ "LOAD_NAME", "complex" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "long" ], [ "LOAD_NAME", "basic_types" ], [ "LOAD_NAME", "list" ], [ "LOAD_NAME", "dict" ], [ "LOAD_NAME", "tuple" ], [ "LOAD_NAME", "set" ], [ "LOAD_NAME", "frozenset" ], [ "LOAD_NAME", "str" ], [ "BINARY_ADD", "basic_types + (list, dict, tuple, set, frozenset, str)" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "unicode" ], [ "LOAD_NAME", "bytes" ], [ "LOAD_NAME", "len" ], [ "LOAD_NAME", "special_types" ], [ "CALL_FUNCTION", "len(special_types)" ], [ "LOAD_GLOBAL", "Lock" ], [ "CALL_FUNCTION", "Lock()" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "CALL_FUNCTION", "defaultdict(lambda: len(self.data))" ], [ "LOAD_DEREF", "self" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.special_types" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.data" ], [ "LOAD_FAST", "t" ], [ "BINARY_SUBSCR", "self.data[t]" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.data" ], [ "CALL_FUNCTION", "len(self.data)" ], [ "LOAD_GLOBAL", "correct_type" ], [ "LOAD_FAST", "item" ], [ "CALL_FUNCTION", "correct_type(item)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.lock" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.data" ], [ "LOAD_FAST", "t" ], [ "BINARY_SUBSCR", "self.data[t]" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.data" ], [ "LOAD_ATTR", "self.data.items" ], [ "CALL_FUNCTION", "self.data.items()" ], [ "CALL_FUNCTION", "dict((v, k) for k, v in self.data.items())" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_DEREF", "rev" ], [ "CALL_FUNCTION", "len(rev)" ], [ "CALL_FUNCTION", "range(len(rev))" ], [ "LOAD_FAST", "v" ], [ "LOAD_FAST", "k" ], [ "LOAD_GLOBAL", "safe_qualname" ], [ "LOAD_DEREF", "rev" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "rev[i]" ], [ "CALL_FUNCTION", "safe_qualname(rev[i])" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_FAST", "val_repr" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "type_index" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.meta" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.meta" ], [ "LOAD_FAST", "key" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.children" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.children" ], [ "LOAD_ATTR", "self.children.append" ], [ "LOAD_FAST", "key" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOAD_ATTR", "NodeValue.expression" ], [ "LOAD_FAST", "samples" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "level" ], [ "CALL_FUNCTION", "NodeValue.expression(samples, value, level)" ], [ "CALL_FUNCTION", "self.children.append((key, NodeValue.expression(samples, value, level)))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.val_repr" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.type_index" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.meta" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.children" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.extend" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.children" ], [ "CALL_FUNCTION", "result.extend(self.children)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "cls" ], [ "CALL_FUNCTION", "cls('', -2)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_GLOBAL", "exception_string" ], [ "LOAD_FAST", "exc_value" ], [ "CALL_FUNCTION", "exception_string(exc_value)" ], [ "CALL_FUNCTION", "cls(exception_string(exc_value), -1)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "cheap_repr(val)" ], [ "LOAD_GLOBAL", "type_registry" ], [ "LOAD_FAST", "val" ], [ "BINARY_SUBSCR", "type_registry[val]" ], [ "CALL_FUNCTION", "cls(cheap_repr(val), type_registry[val])" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "TypeRegistry" ], [ "LOAD_ATTR", "TypeRegistry.basic_types" ], [ "LOAD_GLOBAL", "BirdsEye" ], [ "CALL_FUNCTION", "isinstance(val, (TypeRegistry.basic_types, BirdsEye))" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "QuerySet" ], [ "CALL_FUNCTION", "isinstance(val, QuerySet)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "len(val)" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.set_meta" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "result.set_meta('len', length)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "ModuleType" ], [ "CALL_FUNCTION", "isinstance(val, ModuleType)" ], [ "LOAD_GLOBAL", "min" ], [ "LOAD_FAST", "level" ], [ "CALL_FUNCTION", "min(level, 2)" ], [ "LOAD_GLOBAL", "partial" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.add_child" ], [ "LOAD_FAST", "samples" ], [ "LOAD_FAST", "level" ], [ "BINARY_SUBTRACT", "level - 1" ], [ "CALL_FUNCTION", "partial(result.add_child, samples, level - 1)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Series" ], [ "LOAD_GLOBAL", "ndarray" ], [ "CALL_FUNCTION", "isinstance(val, (Series, ndarray))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "ndarray" ], [ "CALL_FUNCTION", "isinstance(val, ndarray)" ], [ "LOAD_FAST", "attrs" ], [ "LOAD_ATTR", "attrs.append" ], [ "CALL_FUNCTION", "attrs.append('shape')" ], [ "LOAD_FAST", "attrs" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "val" ], [ "LOAD_FAST", "name" ], [ "CALL_FUNCTION", "getattr(val, name)" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "attr" ], [ "CALL_FUNCTION", "add_child(name, attr)" ], [ "LOAD_FAST", "level" ], [ "COMPARE_OP", "level >= 3" ], [ "LOAD_FAST", "level" ], [ "COMPARE_OP", "level >= 2" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Series" ], [ "CALL_FUNCTION", "isinstance(val, Series)" ], [ "LOAD_FAST", "samples" ], [ "LOAD_FAST", "sample_type" ], [ "BINARY_SUBSCR", "samples[sample_type]" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "DataFrame" ], [ "CALL_FUNCTION", "isinstance(val, DataFrame)" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.set_meta" ], [ "LOAD_FAST", "meta" ], [ "CALL_FUNCTION", "result.set_meta('dataframe', meta)" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['pandas_rows']" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['pandas_cols']" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_rows" ], [ "BINARY_ADD", "max_rows + 2" ], [ "COMPARE_OP", "length > max_rows + 2" ], [ "LOAD_FAST", "max_rows" ], [ "BINARY_FLOOR_DIVIDE", "max_rows // 2" ], [ "LOAD_FAST", "meta" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.columns" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "columns" ], [ "CALL_FUNCTION", "len(columns)" ], [ "LOAD_FAST", "num_cols" ], [ "LOAD_FAST", "max_cols" ], [ "BINARY_ADD", "max_cols + 2" ], [ "COMPARE_OP", "num_cols > max_cols + 2" ], [ "LOAD_FAST", "max_cols" ], [ "BINARY_FLOOR_DIVIDE", "max_cols // 2" ], [ "LOAD_FAST", "meta" ], [ "LOAD_GLOBAL", "set" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "num_cols" ], [ "LOAD_FAST", "max_cols" ], [ "CALL_FUNCTION", "_sample_indices(num_cols, max_cols)" ], [ "CALL_FUNCTION", "set(_sample_indices(num_cols, max_cols))" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_GLOBAL", "zip" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.columns" ], [ "LOAD_ATTR", "val.columns.format" ], [ "CALL_FUNCTION_KW", "val.columns.format(sparsify=False)" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.columns" ], [ "CALL_FUNCTION", "zip(val.columns.format(sparsify=False),\n val.columns)" ], [ "CALL_FUNCTION", "enumerate(zip(val.columns.format(sparsify=False),\n val.columns))" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "indices" ], [ "COMPARE_OP", "i in indices" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_FAST", "formatted_name" ], [ "LOAD_FAST", "val" ], [ "LOAD_FAST", "label" ], [ "BINARY_SUBSCR", "val[label]" ], [ "CALL_FUNCTION", "add_child(formatted_name, val[label])" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Series" ], [ "CALL_FUNCTION", "isinstance(val, Series)" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['pandas_rows']" ], [ "CALL_FUNCTION", "_sample_indices(length, samples['pandas_rows'])" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.index" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "val.index[i:i + 1]" ], [ "LOAD_ATTR", "val.index[i:i + 1].format" ], [ "CALL_FUNCTION_KW", "val.index[i:i + 1].format(sparsify=False)" ], [ "BINARY_SUBSCR", "val.index[i:i + 1].format(sparsify=False)[0]" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.iloc" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "val.iloc[i]" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_FAST", "k" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child(k, v)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "level" ], [ "COMPARE_OP", "level <= 0" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "bytes" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "unicode" ], [ "LOAD_GLOBAL", "xrange" ], [ "CALL_FUNCTION", "isinstance(val,\n (str, bytes, range)\n if PY3 else\n (str, unicode, xrange))" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Sequence" ], [ "LOAD_GLOBAL", "ndarray" ], [ "CALL_FUNCTION", "isinstance(val, (Sequence, ndarray))" ], [ "LOAD_FAST", "length" ], [ "COMPARE_OP", "length is not None" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['list']" ], [ "CALL_FUNCTION", "_sample_indices(length, samples['list'])" ], [ "LOAD_FAST", "val" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "val[i]" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "i" ], [ "CALL_FUNCTION", "str(i)" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child(str(i), v)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Mapping" ], [ "CALL_FUNCTION", "isinstance(val, Mapping)" ], [ "LOAD_GLOBAL", "islice" ], [ "LOAD_GLOBAL", "_safe_iter" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "iteritems" ], [ "CALL_FUNCTION", "_safe_iter(val, iteritems)" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['dict']" ], [ "CALL_FUNCTION", "islice(_safe_iter(val, iteritems), samples['dict'])" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "k" ], [ "CALL_FUNCTION", "cheap_repr(k)" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child(cheap_repr(k), v)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Set" ], [ "CALL_FUNCTION", "isinstance(val, Set)" ], [ "LOAD_GLOBAL", "_safe_iter" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "_safe_iter(val)" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['set']" ], [ "LOAD_FAST", "length" ], [ "COMPARE_OP", "length is None" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "num_items" ], [ "BINARY_ADD", "num_items + 2" ], [ "COMPARE_OP", "length > num_items + 2" ], [ "LOAD_GLOBAL", "islice" ], [ "LOAD_FAST", "vals" ], [ "LOAD_FAST", "num_items" ], [ "CALL_FUNCTION", "islice(vals, num_items)" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "vals" ], [ "CALL_FUNCTION", "enumerate(vals)" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_FAST", "i" ], [ "BINARY_MODULO", "'<%s>' % i" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child('<%s>' % i, v)" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "getattr(val, '__dict__', None)" ], [ "LOAD_FAST", "d" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_GLOBAL", "islice" ], [ "LOAD_GLOBAL", "_safe_iter" ], [ "LOAD_FAST", "d" ], [ "CALL_FUNCTION", "_safe_iter(d)" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['attributes']" ], [ "CALL_FUNCTION", "islice(_safe_iter(d),\n samples['attributes'])" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION_KW", "sorted(islice(_safe_iter(d),\n samples['attributes']),\n key=str)" ], [ "LOAD_FAST", "d" ], [ "LOAD_FAST", "k" ], [ "BINARY_SUBSCR", "d[k]" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "TracedFile" ], [ "CALL_FUNCTION", "isinstance(v, TracedFile)" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "k" ], [ "CALL_FUNCTION", "str(k)" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child(str(k), v)" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "type" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "type(val)" ], [ "CALL_FUNCTION", "getattr(type(val), '__slots__', None)" ], [ "CALL_FUNCTION", "sorted(getattr(type(val), '__slots__', None) or ())" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "val" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "getattr(val, s)" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "str(s)" ], [ "LOAD_FAST", "attr" ], [ "CALL_FUNCTION", "add_child(str(s), attr)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "x" ], [ "LOAD_FAST", "f" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "f(val)" ], [ "LOAD_FAST", "x" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_ADD", "max_length + 2" ], [ "COMPARE_OP", "length <= max_length + 2" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "range(length)" ], [ "LOAD_GLOBAL", "chain" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_FLOOR_DIVIDE", "max_length // 2" ], [ "CALL_FUNCTION", "range(max_length // 2)" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_FLOOR_DIVIDE", "max_length // 2" ], [ "BINARY_SUBTRACT", "length - max_length // 2" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "range(length - max_length // 2,\n length)" ], [ "CALL_FUNCTION", "chain(range(max_length // 2),\n range(length - max_length // 2,\n length))" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "len(x)" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "n == 0" ], [ "LOAD_GLOBAL", "repr" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "repr(x)" ], [ "LOAD_FAST", "helper" ], [ "LOAD_ATTR", "helper.level" ], [ "BINARY_SUBTRACT", "helper.level - 1" ], [ "LOAD_GLOBAL", "_repr_series_one_line" ], [ "LOAD_ATTR", "_repr_series_one_line.maxparts" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "n" ], [ "LOAD_FAST", "maxparts" ], [ "CALL_FUNCTION", "_sample_indices(n, maxparts)" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.index" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "x.index[i:i + 1]" ], [ "LOAD_ATTR", "x.index[i:i + 1].format" ], [ "CALL_FUNCTION_KW", "x.index[i:i + 1].format(sparsify=False)" ], [ "BINARY_SUBSCR", "x.index[i:i + 1].format(sparsify=False)[0]" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.iloc" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "x.iloc[i]" ], [ "LOAD_FAST", "pieces" ], [ "LOAD_ATTR", "pieces.append" ], [ "LOAD_FAST", "k" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "v" ], [ "LOAD_FAST", "newlevel" ], [ "CALL_FUNCTION", "cheap_repr(v, newlevel)" ], [ "BINARY_MODULO", "'%s = %s' % (k, cheap_repr(v, newlevel))" ], [ "CALL_FUNCTION", "pieces.append('%s = %s' % (k, cheap_repr(v, newlevel)))" ], [ "LOAD_FAST", "n" ], [ "LOAD_FAST", "maxparts" ], [ "BINARY_ADD", "maxparts + 2" ], [ "COMPARE_OP", "n > maxparts + 2" ], [ "LOAD_FAST", "pieces" ], [ "LOAD_ATTR", "pieces.insert" ], [ "LOAD_FAST", "maxparts" ], [ "BINARY_FLOOR_DIVIDE", "maxparts // 2" ], [ "CALL_FUNCTION", "pieces.insert(maxparts // 2, '...')" ], [ "LOAD_ATTR", "'; '.join" ], [ "LOAD_FAST", "pieces" ], [ "CALL_FUNCTION", "'; '.join(pieces)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "CALL_FUNCTION", "isinstance(node, ast.expr)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Num" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Str" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "ast" ], [ "CALL_FUNCTION", "getattr(ast, 'NameConstant', ())" ], [ "CALL_FUNCTION", "isinstance(node, (ast.Num, ast.Str, getattr(ast, 'NameConstant', ())))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "getattr(node, 'ctx', None)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Store" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Del" ], [ "CALL_FUNCTION", "isinstance(getattr(node, 'ctx', None),\n (ast.Store, ast.Del))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.UnaryOp" ], [ "CALL_FUNCTION", "isinstance(node, ast.UnaryOp)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.op" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.UAdd" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.USub" ], [ "CALL_FUNCTION", "isinstance(node.op, (ast.UAdd, ast.USub))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.operand" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Num" ], [ "CALL_FUNCTION", "isinstance(node.operand, ast.Num)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.List" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Tuple" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Dict" ], [ "CALL_FUNCTION", "isinstance(node, (ast.List, ast.Tuple, ast.Dict))" ], [ "LOAD_GLOBAL", "any" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.iter_child_nodes" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ast.iter_child_nodes(node)" ], [ "CALL_FUNCTION", "any(is_interesting_expression(n) for n in ast.iter_child_nodes(node))" ], [ "UNARY_NOT", "not any(is_interesting_expression(n) for n in ast.iter_child_nodes(node))" ], [ "UNARY_NOT", "not (isinstance(node, (ast.Num, ast.Str, getattr(ast, 'NameConstant', ()))) or\n isinstance(getattr(node, 'ctx', None),\n (ast.Store, ast.Del)) or\n (isinstance(node, ast.UnaryOp) and\n isinstance(node.op, (ast.UAdd, ast.USub)) and\n isinstance(node.operand, ast.Num)) or\n (isinstance(node, (ast.List, ast.Tuple, ast.Dict)) and\n not any(is_interesting_expression(n) for n in ast.iter_child_nodes(node))))" ], [ "LOAD_GLOBAL", "is_interesting_expression" ], [ "LOAD_FAST", "n" ], [ "CALL_FUNCTION", "is_interesting_expression(n)" ], [ "LOAD_GLOBAL", "cast" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "__builtins__" ], [ "CALL_FUNCTION", "cast(dict, __builtins__)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Name" ], [ "CALL_FUNCTION", "isinstance(node, ast.Name)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.id" ], [ "LOAD_FAST", "builtins" ], [ "COMPARE_OP", "node.id in builtins" ], [ "LOAD_FAST", "builtins" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.id" ], [ "BINARY_SUBSCR", "builtins[node.id]" ], [ "LOAD_FAST", "value" ], [ "COMPARE_OP", "builtins[node.id] is value" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "ast" ], [ "CALL_FUNCTION", "getattr(ast, 'NameConstant', ())" ], [ "CALL_FUNCTION", "isinstance(node, getattr(ast, 'NameConstant', ()))" ] ], "configuration.py": [ [ "LOAD_NAME", "ctypes" ], [ "LOAD_ATTR", "ctypes.windll" ], [ "LOAD_ATTR", "ctypes.windll.kernel32" ], [ "LOAD_NAME", "kernel32" ], [ "LOAD_ATTR", "kernel32.SetConsoleMode" ], [ "LOAD_NAME", "kernel32" ], [ "LOAD_ATTR", "kernel32.GetStdHandle" ], [ "CALL_FUNCTION", "kernel32.GetStdHandle(-11)" ], [ "CALL_FUNCTION", "kernel32.SetConsoleMode(kernel32.GetStdHandle(-11), 7)" ], [ "LOAD_NAME", "Exception" ], [ "LOAD_NAME", "os" ], [ "LOAD_ATTR", "os.name" ], [ "COMPARE_OP", "os.name != 'nt'" ], [ "LOAD_NAME", "DefaultFormatter" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "object" ], [ "LOAD_FAST", "builtins" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_GLOBAL", "builtins_module" ], [ "LOAD_FAST", "snoop" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.snoop" ], [ "CALL_FUNCTION", "setattr(builtins_module, snoop, package.snoop)" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_GLOBAL", "builtins_module" ], [ "LOAD_FAST", "pp" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.pp" ], [ "CALL_FUNCTION", "setattr(builtins_module, pp, package.pp)" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_GLOBAL", "builtins_module" ], [ "LOAD_FAST", "spy" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.spy" ], [ "CALL_FUNCTION", "setattr(builtins_module, spy, package.spy)" ], [ "LOAD_GLOBAL", "Config" ], [ "LOAD_FAST", "out" ], [ "LOAD_FAST", "prefix" ], [ "LOAD_FAST", "columns" ], [ "LOAD_FAST", "overwrite" ], [ "LOAD_FAST", "color" ], [ "LOAD_FAST", "enabled" ], [ "LOAD_FAST", "watch_extras" ], [ "LOAD_FAST", "replace_watch_extras" ], [ "LOAD_FAST", "formatter_class" ], [ "CALL_FUNCTION_KW", "Config(\n out=out,\n prefix=prefix,\n columns=columns,\n overwrite=overwrite,\n color=color,\n enabled=enabled,\n watch_extras=watch_extras,\n replace_watch_extras=replace_watch_extras,\n formatter_class=formatter_class,\n )" ], [ "LOAD_FAST", "config" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.snoop" ], [ "LOAD_FAST", "config" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.pp" ], [ "LOAD_FAST", "config" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.spy" ], [ "LOAD_NAME", "DefaultFormatter" ], [ "LOAD_GLOBAL", "can_color" ], [ "LOAD_FAST", "color" ], [ "COMPARE_OP", "color is None" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "out" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.stderr" ], [ "CALL_FUNCTION", "getattr(out or sys.stderr, 'isatty', lambda: False)" ], [ "LOAD_GLOBAL", "bool" ], [ "LOAD_FAST", "isatty" ], [ "CALL_FUNCTION", "isatty()" ], [ "CALL_FUNCTION", "bool(isatty())" ], [ "LOAD_GLOBAL", "get_write_function" ], [ "LOAD_FAST", "out" ], [ "LOAD_FAST", "overwrite" ], [ "CALL_FUNCTION", "get_write_function(out, overwrite)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "formatter_class" ], [ "LOAD_FAST", "prefix" ], [ "LOAD_FAST", "columns" ], [ "LOAD_FAST", "color" ], [ "CALL_FUNCTION", "formatter_class(prefix, columns, color)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "enabled" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "PP" ], [ "LOAD_DEREF", "self" ], [ "CALL_FUNCTION", "PP(self)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "Tracer" ], [ "LOAD_FAST", "ConfiguredTracer" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "Spy" ], [ "LOAD_DEREF", "self" ], [ "CALL_FUNCTION", "Spy(self)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "threading" ], [ "LOAD_ATTR", "threading.local" ], [ "CALL_FUNCTION", "threading.local()" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "replace_watch_extras" ], [ "COMPARE_OP", "replace_watch_extras is not None" ], [ "LOAD_GLOBAL", "ensure_tuple" ], [ "LOAD_FAST", "replace_watch_extras" ], [ "CALL_FUNCTION", "ensure_tuple(replace_watch_extras)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "len_shape_watch" ], [ "LOAD_GLOBAL", "dtype_watch" ], [ "LOAD_GLOBAL", "ensure_tuple" ], [ "LOAD_FAST", "watch_extras" ], [ "CALL_FUNCTION", "ensure_tuple(watch_extras)" ], [ "BINARY_ADD", "(len_shape_watch, dtype_watch) + ensure_tuple(watch_extras)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_CLASSDEREF", "self" ], [ "LOAD_FAST", "value" ], [ "LOAD_ATTR", "value.shape" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.ismethod" ], [ "LOAD_FAST", "shape" ], [ "CALL_FUNCTION", "inspect.ismethod(shape)" ], [ "LOAD_ATTR", "'{}.shape'.format" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "'{}.shape'.format(source)" ], [ "LOAD_FAST", "shape" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "value" ], [ "LOAD_GLOBAL", "QuerySet" ], [ "CALL_FUNCTION", "isinstance(value, QuerySet)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "len(value)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "value" ], [ "LOAD_GLOBAL", "six" ], [ "LOAD_ATTR", "six.string_types" ], [ "CALL_FUNCTION", "isinstance(value, six.string_types)" ], [ "LOAD_FAST", "length" ], [ "COMPARE_OP", "length < 50" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "value" ], [ "LOAD_GLOBAL", "Mapping" ], [ "LOAD_GLOBAL", "Set" ], [ "LOAD_GLOBAL", "Sequence" ], [ "CALL_FUNCTION", "isinstance(value, (Mapping, Set, Sequence))" ], [ "LOAD_FAST", "length" ], [ "COMPARE_OP", "length == 0" ], [ "LOAD_ATTR", "'len({})'.format" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "'len({})'.format(source)" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "value" ], [ "LOAD_ATTR", "value.dtype" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.ismethod" ], [ "LOAD_FAST", "dtype" ], [ "CALL_FUNCTION", "inspect.ismethod(dtype)" ], [ "LOAD_ATTR", "'{}.dtype'.format" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "'{}.dtype'.format(source)" ], [ "LOAD_FAST", "dtype" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_DEREF", "output" ], [ "LOAD_GLOBAL", "six" ], [ "LOAD_ATTR", "six.string_types" ], [ "CALL_FUNCTION", "isinstance(output, six.string_types)" ], [ "LOAD_GLOBAL", "is_pathlike" ], [ "LOAD_DEREF", "output" ], [ "CALL_FUNCTION", "is_pathlike(output)" ], [ "LOAD_FAST", "is_path" ], [ "LOAD_GLOBAL", "FileWriter" ], [ "LOAD_DEREF", "output" ], [ "LOAD_FAST", "overwrite" ], [ "CALL_FUNCTION", "FileWriter(output, overwrite)" ], [ "LOAD_ATTR", "FileWriter(output, overwrite).write" ], [ "LOAD_GLOBAL", "callable" ], [ "LOAD_DEREF", "output" ], [ "CALL_FUNCTION", "callable(output)" ], [ "LOAD_DEREF", "output" ], [ "LOAD_FAST", "write" ], [ "LOAD_DEREF", "output" ], [ "LOAD_FAST", "stream" ], [ "COMPARE_OP", "stream is None" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.stderr" ], [ "LOAD_FAST", "stream" ], [ "LOAD_ATTR", "stream.write" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "stream.write(s)" ], [ "LOAD_GLOBAL", "UnicodeEncodeError" ], [ "LOAD_FAST", "stream" ], [ "LOAD_ATTR", "stream.write" ], [ "LOAD_GLOBAL", "shitcode" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "shitcode(s)" ], [ "CALL_FUNCTION", "stream.write(shitcode(s))" ], [ "LOAD_GLOBAL", "six" ], [ "LOAD_ATTR", "six.text_type" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "six.text_type(path)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "overwrite" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "open" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.path" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.overwrite" ], [ "CALL_FUNCTION_KW", "open(self.path, 'w' if self.overwrite else 'a', encoding='utf-8')" ], [ "LOAD_FAST", "f" ], [ "LOAD_ATTR", "f.write" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "f.write(s)" ], [ "LOAD_FAST", "self" ] ], "db.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOAD_ATTR", "standard_library.install_aliases" ], [ "CALL_FUNCTION", "standard_library.install_aliases()" ], [ "LOAD_NAME", "RESERVED_WORDS" ], [ "LOAD_ATTR", "RESERVED_WORDS.add" ], [ "CALL_FUNCTION", "RESERVED_WORDS.add('function')" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "retry" ], [ "LOAD_NAME", "InterfaceError" ], [ "LOAD_NAME", "OperationalError" ], [ "LOAD_NAME", "InternalError" ], [ "LOAD_NAME", "ProgrammingError" ], [ "CALL_FUNCTION", "retry(3, (InterfaceError, OperationalError, InternalError, ProgrammingError))" ], [ "LOAD_NAME", "contextmanager" ], [ "CALL_FUNCTION", "contextmanager" ], [ "LOAD_FAST", "db_uri" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.environ" ], [ "LOAD_ATTR", "os.environ.get" ], [ "CALL_FUNCTION", "os.environ.get('BIRDSEYE_DB')" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.join" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.expanduser" ], [ "CALL_FUNCTION", "os.path.expanduser('~')" ], [ "CALL_FUNCTION", "os.path.join(os.path.expanduser('~'),\n '.birdseye.db')" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "dict" ], [ "CALL_FUNCTION_KW", "dict(\n pool_recycle=280,\n echo=False, # for convenience when debugging\n )" ], [ "LOAD_GLOBAL", "create_engine" ], [ "LOAD_FAST", "db_uri" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "create_engine(db_uri, **kwargs)" ], [ "LOAD_GLOBAL", "ArgumentError" ], [ "LOAD_FAST", "db_uri" ], [ "BINARY_ADD", "'sqlite:///' + db_uri" ], [ "LOAD_GLOBAL", "create_engine" ], [ "LOAD_FAST", "db_uri" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "create_engine(db_uri, **kwargs)" ], [ "LOAD_FAST", "engine" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "sessionmaker" ], [ "LOAD_FAST", "engine" ], [ "CALL_FUNCTION_KW", "sessionmaker(bind=engine)" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "object" ], [ "LOAD_GLOBAL", "declarative_base" ], [ "LOAD_FAST", "Base" ], [ "CALL_FUNCTION_KW", "declarative_base(cls=Base)" ], [ "LOAD_FAST", "Base" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "object" ], [ "LOAD_FAST", "engine" ], [ "LOAD_ATTR", "engine.name" ], [ "COMPARE_OP", "engine.name == 'mysql'" ], [ "LOAD_GLOBAL", "LONGTEXT" ], [ "LOAD_GLOBAL", "Text" ], [ "LOAD_FAST", "Base" ], [ "LOAD_FAST", "Base" ], [ "LOAD_FAST", "Call" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "Function" ], [ "LOAD_FAST", "self" ], [ "LOAD_DEREF", "KeyValue" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "KeyValueStore" ], [ "CALL_FUNCTION", "KeyValueStore()" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "_skip_version_check" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.table_exists" ], [ "LOAD_FAST", "Function" ], [ "CALL_FUNCTION", "self.table_exists(Function)" ], [ "LOAD_FAST", "Base" ], [ "LOAD_ATTR", "Base.metadata" ], [ "LOAD_ATTR", "Base.metadata.create_all" ], [ "LOAD_FAST", "engine" ], [ "CALL_FUNCTION", "Base.metadata.create_all(engine)" ], [ "LOAD_GLOBAL", "DB_VERSION" ], [ "LOAD_FAST", "kv" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.table_exists" ], [ "LOAD_DEREF", "KeyValue" ], [ "CALL_FUNCTION", "self.table_exists(KeyValue)" ], [ "UNARY_NOT", "not self.table_exists(KeyValue)" ], [ "LOAD_GLOBAL", "int" ], [ "LOAD_FAST", "kv" ], [ "LOAD_ATTR", "kv.version" ], [ "CALL_FUNCTION", "int(kv.version)" ], [ "LOAD_GLOBAL", "DB_VERSION" ], [ "COMPARE_OP", "int(kv.version) < DB_VERSION" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.exit" ], [ "CALL_FUNCTION", "sys.exit('The birdseye database schema is out of date. '\n 'Run \"python -m birdseye.clear_db\" to delete the existing tables.')" ], [ "LOAD_NAME", "declared_attr" ], [ "CALL_FUNCTION", "declared_attr" ], [ "LOAD_FAST", "cls" ], [ "LOAD_ATTR", "cls.__name__" ], [ "LOAD_ATTR", "cls.__name__.lower" ], [ "CALL_FUNCTION", "cls.__name__.lower()" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "String" ], [ "CALL_FUNCTION", "String(50)" ], [ "CALL_FUNCTION_KW", "Column(String(50), primary_key=True)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "__getitem__" ], [ "LOAD_NAME", "__setitem__" ], [ "LOAD_DEREF", "db_self" ], [ "LOAD_ATTR", "db_self.session_scope" ], [ "CALL_FUNCTION", "db_self.session_scope()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session\n .query" ], [ "LOAD_DEREF", "KeyValue" ], [ "LOAD_ATTR", "KeyValue.value" ], [ "CALL_FUNCTION", "session\n .query(KeyValue.value)" ], [ "LOAD_ATTR", "session\n .query(KeyValue.value)\n .filter_by" ], [ "LOAD_FAST", "item" ], [ "CALL_FUNCTION_KW", "session\n .query(KeyValue.value)\n .filter_by(key=item)" ], [ "LOAD_ATTR", "session\n .query(KeyValue.value)\n .filter_by(key=item)\n .scalar" ], [ "CALL_FUNCTION", "session\n .query(KeyValue.value)\n .filter_by(key=item)\n .scalar()" ], [ "LOAD_DEREF", "db_self" ], [ "LOAD_ATTR", "db_self.session_scope" ], [ "CALL_FUNCTION", "db_self.session_scope()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_DEREF", "KeyValue" ], [ "CALL_FUNCTION", "session.query(KeyValue)" ], [ "LOAD_ATTR", "session.query(KeyValue).filter_by" ], [ "LOAD_FAST", "key" ], [ "CALL_FUNCTION_KW", "session.query(KeyValue).filter_by(key=key)" ], [ "LOAD_ATTR", "session.query(KeyValue).filter_by(key=key).delete" ], [ "CALL_FUNCTION", "session.query(KeyValue).filter_by(key=key).delete()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.add" ], [ "LOAD_DEREF", "KeyValue" ], [ "LOAD_FAST", "key" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "str(value)" ], [ "CALL_FUNCTION_KW", "KeyValue(key=key, value=str(value))" ], [ "CALL_FUNCTION", "session.add(KeyValue(key=key, value=str(value)))" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "String" ], [ "CALL_FUNCTION_KW", "String(length=32)" ], [ "CALL_FUNCTION_KW", "Column(String(length=32), primary_key=True)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Integer" ], [ "LOAD_NAME", "ForeignKey" ], [ "CALL_FUNCTION", "ForeignKey('function.id')" ], [ "CALL_FUNCTION_KW", "Column(Integer, ForeignKey('function.id'), index=True)" ], [ "LOAD_NAME", "relationship" ], [ "LOAD_NAME", "backref" ], [ "CALL_FUNCTION_KW", "backref('calls', lazy='dynamic')" ], [ "CALL_FUNCTION_KW", "relationship('Function', backref=backref('calls', lazy='dynamic'))" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_CLASSDEREF", "LongText" ], [ "CALL_FUNCTION", "Column(LongText)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "DateTime" ], [ "CALL_FUNCTION_KW", "Column(DateTime, index=True)" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "id" ], [ "LOAD_NAME", "function_id" ], [ "LOAD_NAME", "return_value" ], [ "LOAD_NAME", "traceback" ], [ "LOAD_NAME", "exception" ], [ "LOAD_NAME", "start_time" ], [ "LOAD_NAME", "arguments" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._pretty_time" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start_time" ], [ "CALL_FUNCTION", "self._pretty_time(self.start_time)" ], [ "LOAD_FAST", "dt" ], [ "LOAD_GLOBAL", "Markup" ], [ "LOAD_FAST", "dt" ], [ "LOAD_ATTR", "dt.strftime" ], [ "CALL_FUNCTION", "dt.strftime('%Y-%m-%d %H:%M:%S')" ], [ "LOAD_GLOBAL", "naturaltime" ], [ "LOAD_FAST", "dt" ], [ "CALL_FUNCTION", "naturaltime(dt)" ], [ "BINARY_MODULO", "'%s (%s)' % (\n dt.strftime('%Y-%m-%d %H:%M:%S'),\n naturaltime(dt))" ], [ "CALL_FUNCTION", "Markup('%s (%s)' % (\n dt.strftime('%Y-%m-%d %H:%M:%S'),\n naturaltime(dt)))" ], [ "LOAD_GLOBAL", "Markup" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.success" ], [ "BINARY_MODULO", "'' % (\n ('ok', 'green') if self.success else\n ('remove', 'red'))" ], [ "CALL_FUNCTION", "Markup('' % (\n ('ok', 'green') if self.success else\n ('remove', 'red')))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.exception" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.traceback" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.return_value" ], [ "COMPARE_OP", "self.return_value == 'None'" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.traceback" ], [ "UNARY_NOT", "not self.traceback" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.success" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.return_value" ], [ "CALL_FUNCTION", "str(self.return_value)" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.exception" ], [ "CALL_FUNCTION", "str(self.exception)" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_ATTR", "json.loads" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.arguments" ], [ "CALL_FUNCTION", "json.loads(self.arguments)" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_ATTR", "json.loads" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.data" ], [ "CALL_FUNCTION", "json.loads(self.data)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.arguments_list" ], [ "LOAD_GLOBAL", "select_attrs" ], [ "LOAD_FAST", "call" ], [ "CALL_FUNCTION", "select_attrs(call, 'id function_id return_value traceback '\n 'exception start_time')" ], [ "CALL_FUNCTION_EX", "dict(arguments=call.arguments_list,\n **select_attrs(call, 'id function_id return_value traceback '\n 'exception start_time'))" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Integer" ], [ "LOAD_NAME", "Sequence" ], [ "CALL_FUNCTION", "Sequence('function_id_seq')" ], [ "CALL_FUNCTION_KW", "Column(Integer, Sequence('function_id_seq'), primary_key=True)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_CLASSDEREF", "LongText" ], [ "CALL_FUNCTION", "Column(LongText)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Integer" ], [ "CALL_FUNCTION", "Column(Integer)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_CLASSDEREF", "LongText" ], [ "CALL_FUNCTION", "Column(LongText)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "String" ], [ "CALL_FUNCTION_KW", "String(length=64)" ], [ "CALL_FUNCTION_KW", "Column(String(length=64), index=True)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "String" ], [ "CALL_FUNCTION_KW", "String(length=64)" ], [ "CALL_FUNCTION_KW", "Column(String(length=64), index=True)" ], [ "LOAD_NAME", "UniqueConstraint" ], [ "CALL_FUNCTION_KW", "UniqueConstraint('hash',\n name='everything_unique')" ], [ "LOAD_NAME", "Index" ], [ "CALL_FUNCTION_KW", "Index('idx_file', 'file', mysql_length=256)" ], [ "LOAD_NAME", "Index" ], [ "CALL_FUNCTION_KW", "Index('idx_name', 'name', mysql_length=32)" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "file" ], [ "LOAD_NAME", "name" ], [ "LOAD_NAME", "lineno" ], [ "LOAD_NAME", "hash" ], [ "LOAD_NAME", "body_hash" ], [ "LOAD_NAME", "type" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_ATTR", "json.loads" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.data" ], [ "CALL_FUNCTION", "json.loads(self.data)" ], [ "LOAD_GLOBAL", "select_attrs" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "select_attrs(func, 'file name lineno hash body_hash type')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.engine" ], [ "LOAD_ATTR", "self.engine.dialect" ], [ "LOAD_ATTR", "self.engine.dialect.has_table" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.engine" ], [ "LOAD_FAST", "table" ], [ "LOAD_ATTR", "table.__name__" ], [ "CALL_FUNCTION", "self.engine.dialect.has_table(self.engine, table.__name__)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.session_scope" ], [ "CALL_FUNCTION", "self.session_scope()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.Function" ], [ "LOAD_ATTR", "self.Function.file" ], [ "CALL_FUNCTION", "session.query(self.Function.file)" ], [ "LOAD_ATTR", "session.query(self.Function.file).distinct" ], [ "CALL_FUNCTION", "session.query(self.Function.file).distinct()" ], [ "LOAD_FAST", "paths" ], [ "LOAD_ATTR", "paths.sort" ], [ "CALL_FUNCTION", "paths.sort()" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "paths" ], [ "COMPARE_OP", "IPYTHON_FILE_PATH in paths" ], [ "LOAD_FAST", "paths" ], [ "LOAD_ATTR", "paths.remove" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "CALL_FUNCTION", "paths.remove(IPYTHON_FILE_PATH)" ], [ "LOAD_FAST", "paths" ], [ "LOAD_ATTR", "paths.insert" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "CALL_FUNCTION", "paths.insert(0, IPYTHON_FILE_PATH)" ], [ "LOAD_FAST", "paths" ], [ "LOAD_GLOBAL", "is_ipython_cell" ], [ "LOAD_FAST", "f" ], [ "BINARY_SUBSCR", "f[0]" ], [ "CALL_FUNCTION", "is_ipython_cell(f[0])" ], [ "LOAD_FAST", "f" ], [ "BINARY_SUBSCR", "f[0]" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.Call" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.Function" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._KeyValue" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.table_exists" ], [ "LOAD_FAST", "model" ], [ "CALL_FUNCTION", "self.table_exists(model)" ], [ "LOAD_FAST", "model" ], [ "LOAD_ATTR", "model.__table__" ], [ "LOAD_ATTR", "model.__table__.drop" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.engine" ], [ "CALL_FUNCTION", "model.__table__.drop(self.engine)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.Session" ], [ "CALL_FUNCTION", "self.Session()" ], [ "LOAD_FAST", "session" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.commit" ], [ "CALL_FUNCTION", "session.commit()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.rollback" ], [ "CALL_FUNCTION", "session.rollback()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.close" ], [ "CALL_FUNCTION", "session.close()" ], [ "LOAD_GLOBAL", "functools" ], [ "LOAD_ATTR", "functools.wraps" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "LOAD_GLOBAL", "retry_db" ], [ "LOAD_FAST", "wrapper" ], [ "CALL_FUNCTION", "retry_db(wrapper)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.session_scope" ], [ "CALL_FUNCTION", "self.session_scope()" ], [ "LOAD_DEREF", "func" ], [ "LOAD_FAST", "session" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "func(session, *args, **kwargs)" ] ], "executing.py": [ [ "LOAD_NAME", "sys" ], [ "LOAD_ATTR", "sys.version_info" ], [ "BINARY_SUBSCR", "sys.version_info[0]" ], [ "COMPARE_OP", "sys.version_info[0] == 3" ], [ "LOAD_NAME", "PY3" ], [ "LOAD_NAME", "lru_cache" ], [ "CALL_FUNCTION_KW", "lru_cache(maxsize=None)" ], [ "LOAD_NAME", "str" ], [ "LOAD_NAME", "unicode" ], [ "LOAD_NAME", "dis" ], [ "LOAD_ATTR", "dis.get_instructions" ], [ "LOAD_NAME", "AttributeError" ], [ "LOAD_NAME", "namedtuple" ], [ "CALL_FUNCTION", "namedtuple('Instruction', 'offset argval opname')" ], [ "LOAD_NAME", "Exception" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.NodeVisitor" ], [ "LOAD_NAME", "sum" ], [ "LOAD_NAME", "__future__" ], [ "LOAD_ATTR", "__future__.all_feature_names" ], [ "CALL_FUNCTION", "sum(\n getattr(__future__, fname).compiler_flag\n for fname in __future__.all_feature_names\n)" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "RLock" ], [ "CALL_FUNCTION", "RLock()" ], [ "LOAD_NAME", "cache" ], [ "CALL_FUNCTION", "cache" ], [ "LOAD_GLOBAL", "functools" ], [ "LOAD_ATTR", "functools.wraps" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "LOAD_FAST", "wrapper" ], [ "LOAD_FAST", "args" ], [ "LOAD_DEREF", "d" ], [ "COMPARE_OP", "args in d" ], [ "LOAD_DEREF", "d" ], [ "LOAD_FAST", "args" ], [ "BINARY_SUBSCR", "d[args]" ], [ "LOAD_DEREF", "func" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION_EX", "func(*args)" ], [ "LOAD_DEREF", "d" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "co" ], [ "LOAD_ATTR", "co.co_code" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "len(code)" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "i < n" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "code[i]" ], [ "LOAD_GLOBAL", "ord" ], [ "LOAD_FAST", "c" ], [ "CALL_FUNCTION", "ord(c)" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "LOAD_FAST", "op" ], [ "LOAD_GLOBAL", "HAVE_ARGUMENT" ], [ "COMPARE_OP", "op >= HAVE_ARGUMENT" ], [ "LOAD_GLOBAL", "ord" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "code[i]" ], [ "CALL_FUNCTION", "ord(code[i])" ], [ "LOAD_GLOBAL", "ord" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "code[i + 1]" ], [ "CALL_FUNCTION", "ord(code[i + 1])" ], [ "BINARY_MULTIPLY", "ord(code[i + 1]) * 256" ], [ "BINARY_ADD", "ord(code[i]) + ord(code[i + 1]) * 256" ], [ "LOAD_FAST", "extended_arg" ], [ "BINARY_ADD", "ord(code[i]) + ord(code[i + 1]) * 256 + extended_arg" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 2" ], [ "LOAD_FAST", "op" ], [ "LOAD_GLOBAL", "EXTENDED_ARG" ], [ "COMPARE_OP", "op == EXTENDED_ARG" ], [ "LOAD_FAST", "oparg" ], [ "BINARY_MULTIPLY", "oparg * 65536" ], [ "LOAD_FAST", "op" ], [ "LOAD_GLOBAL", "hasconst" ], [ "COMPARE_OP", "op in hasconst" ], [ "LOAD_FAST", "co" ], [ "LOAD_ATTR", "co.co_consts" ], [ "LOAD_FAST", "oparg" ], [ "BINARY_SUBSCR", "co.co_consts[oparg]" ], [ "LOAD_GLOBAL", "Instruction" ], [ "LOAD_FAST", "offset" ], [ "LOAD_FAST", "argval" ], [ "LOAD_GLOBAL", "opname" ], [ "LOAD_FAST", "op" ], [ "BINARY_SUBSCR", "opname[op]" ], [ "CALL_FUNCTION", "Instruction(offset, argval, opname[op])" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "it" ], [ "LOAD_GLOBAL", "Sized" ], [ "CALL_FUNCTION", "isinstance(it, Sized)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "len(it)" ], [ "COMPARE_OP", "len(it) != 1" ], [ "LOAD_GLOBAL", "NotOneValueFound" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "len(it)" ], [ "BINARY_MODULO", "'Expected one value, found %s' % len(it)" ], [ "CALL_FUNCTION", "NotOneValueFound('Expected one value, found %s' % len(it))" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "list(it)" ], [ "BINARY_SUBSCR", "list(it)[0]" ], [ "LOAD_GLOBAL", "tuple" ], [ "LOAD_GLOBAL", "islice" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "islice(it, 2)" ], [ "CALL_FUNCTION", "tuple(islice(it, 2))" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "lst" ], [ "CALL_FUNCTION", "len(lst)" ], [ "COMPARE_OP", "len(lst) == 0" ], [ "LOAD_GLOBAL", "NotOneValueFound" ], [ "CALL_FUNCTION", "NotOneValueFound('Expected one value, found 0')" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "lst" ], [ "CALL_FUNCTION", "len(lst)" ], [ "COMPARE_OP", "len(lst) > 1" ], [ "LOAD_GLOBAL", "NotOneValueFound" ], [ "CALL_FUNCTION", "NotOneValueFound('Expected one value, found several')" ], [ "LOAD_FAST", "lst" ], [ "BINARY_SUBSCR", "lst[0]" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "cache" ], [ "CALL_FUNCTION", "cache" ], [ "LOAD_NAME", "cache" ], [ "CALL_FUNCTION", "cache" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "text" ], [ "LOAD_GLOBAL", "text_type" ], [ "CALL_FUNCTION", "isinstance(text, text_type)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.decode_source" ], [ "LOAD_FAST", "text" ], [ "CALL_FUNCTION", "self.decode_source(text)" ], [ "LOAD_FAST", "text" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_FAST", "text" ], [ "LOAD_ATTR", "''.join" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "text" ], [ "LOAD_ATTR", "text.splitlines" ], [ "CALL_FUNCTION", "text.splitlines(True)" ], [ "CALL_FUNCTION", "enumerate(text.splitlines(True))" ], [ "CALL_FUNCTION", "''.join([\n '\\n' if i < 2 and encoding_pattern.match(line)\n else line\n for i, line in enumerate(text.splitlines(True))\n ])" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "defaultdict(list)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "text" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.parse" ], [ "LOAD_FAST", "ast_text" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION_KW", "ast.parse(ast_text, filename=filename)" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "SyntaxError" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.walk" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tree" ], [ "CALL_FUNCTION", "ast.walk(self.tree)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.iter_child_nodes" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ast.iter_child_nodes(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "hasattr(node, 'lineno')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._nodes_by_line" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.lineno" ], [ "BINARY_SUBSCR", "self._nodes_by_line[node.lineno]" ], [ "LOAD_ATTR", "self._nodes_by_line[node.lineno].append" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "self._nodes_by_line[node.lineno].append(node)" ], [ "LOAD_GLOBAL", "QualnameVisitor" ], [ "CALL_FUNCTION", "QualnameVisitor()" ], [ "LOAD_FAST", "visitor" ], [ "LOAD_ATTR", "visitor.visit" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tree" ], [ "CALL_FUNCTION", "visitor.visit(self.tree)" ], [ "LOAD_FAST", "visitor" ], [ "LOAD_ATTR", "visitor.qualnames" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "i" ], [ "COMPARE_OP", "i < 2" ], [ "LOAD_GLOBAL", "encoding_pattern" ], [ "LOAD_ATTR", "encoding_pattern.match" ], [ "LOAD_FAST", "line" ], [ "CALL_FUNCTION", "encoding_pattern.match(line)" ], [ "LOAD_FAST", "line" ], [ "LOAD_FAST", "cls" ], [ "LOAD_ATTR", "cls.for_filename" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_filename" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "CALL_FUNCTION", "cls.for_filename(frame.f_code.co_filename, frame.f_globals or {})" ], [ "LOAD_FAST", "cls" ], [ "LOAD_ATTR", "cls._class_local" ], [ "CALL_FUNCTION", "cls._class_local('__source_cache', {})" ], [ "LOAD_FAST", "source_cache" ], [ "LOAD_FAST", "filename" ], [ "BINARY_SUBSCR", "source_cache[filename]" ], [ "LOAD_GLOBAL", "KeyError" ], [ "LOAD_GLOBAL", "linecache" ], [ "LOAD_ATTR", "linecache.getlines" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "module_globals" ], [ "CALL_FUNCTION", "linecache.getlines(filename, module_globals)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_FAST", "filename" ], [ "LOAD_ATTR", "''.join" ], [ "LOAD_FAST", "lines" ], [ "CALL_FUNCTION", "''.join(lines)" ], [ "CALL_FUNCTION", "cls(filename, ''.join(lines))" ], [ "LOAD_FAST", "source_cache" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_GLOBAL", "linecache" ], [ "CALL_FUNCTION", "hasattr(linecache, 'lazycache')" ], [ "LOAD_GLOBAL", "linecache" ], [ "LOAD_ATTR", "linecache.lazycache" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_filename" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "CALL_FUNCTION", "linecache.lazycache(frame.f_code.co_filename, frame.f_globals)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lasti" ], [ "LOAD_FAST", "cls" ], [ "LOAD_ATTR", "cls._class_local" ], [ "CALL_FUNCTION", "cls._class_local('__executing_cache', {})" ], [ "LOAD_FAST", "executing_cache" ], [ "LOAD_FAST", "key" ], [ "BINARY_SUBSCR", "executing_cache[key]" ], [ "LOAD_GLOBAL", "KeyError" ], [ "LOAD_FAST", "cls" ], [ "LOAD_ATTR", "cls.for_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "cls.for_frame(frame)" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.tree" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.statements_at_line" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lineno" ], [ "CALL_FUNCTION", "source.statements_at_line(frame.f_lineno)" ], [ "LOAD_GLOBAL", "NodeFinder" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "stmts" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.tree" ], [ "CALL_FUNCTION", "NodeFinder(frame, stmts, source.tree)" ], [ "LOAD_ATTR", "NodeFinder(frame, stmts, source.tree).result" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_GLOBAL", "statement_containing_node" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "statement_containing_node(node)" ], [ "LOAD_FAST", "new_stmts" ], [ "LOAD_FAST", "stmts" ], [ "COMPARE_OP", "new_stmts <= stmts" ], [ "LOAD_FAST", "new_stmts" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "stmts" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "executing_cache" ], [ "LOAD_FAST", "key" ], [ "LOAD_GLOBAL", "Executing" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION_EX", "Executing(frame, *args)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_ATTR", "cls.__dict__" ], [ "LOAD_ATTR", "cls.__dict__.get" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "default" ], [ "CALL_FUNCTION", "cls.__dict__.get(name, default)" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_FAST", "cls" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "setattr(cls, name, result)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._nodes_by_line" ], [ "LOAD_FAST", "lineno" ], [ "BINARY_SUBSCR", "self._nodes_by_line[lineno]" ], [ "LOAD_GLOBAL", "statement_containing_node" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "statement_containing_node(node)" ], [ "LOAD_FAST", "ASTTokens" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.text" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tree" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.filename" ], [ "CALL_FUNCTION_KW", "ASTTokens(\n self.text,\n tree=self.tree,\n filename=self.filename,\n )" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "source" ], [ "LOAD_GLOBAL", "bytes" ], [ "CALL_FUNCTION", "isinstance(source, bytes)" ], [ "LOAD_GLOBAL", "detect_encoding" ], [ "LOAD_GLOBAL", "io" ], [ "LOAD_ATTR", "io.BytesIO" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "io.BytesIO(source)" ], [ "LOAD_ATTR", "io.BytesIO(source).readline" ], [ "CALL_FUNCTION", "detect_encoding(io.BytesIO(source).readline)" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.decode" ], [ "LOAD_FAST", "encoding" ], [ "CALL_FUNCTION", "source.decode(encoding)" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_filename" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.filename" ], [ "COMPARE_OP", "code.co_filename == self.filename" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._qualnames" ], [ "LOAD_ATTR", "self._qualnames.get" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_firstlineno" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "CALL_FUNCTION", "self._qualnames.get((code.co_name, code.co_firstlineno), code.co_name)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "stmts" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.source" ], [ "LOAD_ATTR", "self.source.code_qualname" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_code" ], [ "CALL_FUNCTION", "self.source.code_qualname(self.frame.f_code)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.source" ], [ "LOAD_ATTR", "self.source.asttokens" ], [ "CALL_FUNCTION", "self.source.asttokens()" ], [ "LOAD_ATTR", "self.source.asttokens().get_text" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.node" ], [ "CALL_FUNCTION", "self.source.asttokens().get_text(self.node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.source" ], [ "LOAD_ATTR", "self.source.asttokens" ], [ "CALL_FUNCTION", "self.source.asttokens()" ], [ "LOAD_ATTR", "self.source.asttokens().get_text_range" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.node" ], [ "CALL_FUNCTION", "self.source.asttokens().get_text_range(self.node)" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "QualnameVisitor" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(QualnameVisitor, self)" ], [ "LOAD_ATTR", "super(QualnameVisitor, self).__init__" ], [ "CALL_FUNCTION", "super(QualnameVisitor, self).__init__()" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.name" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_ATTR", "self.stack.append" ], [ "LOAD_FAST", "name" ], [ "CALL_FUNCTION", "self.stack.append(name)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.qualnames" ], [ "LOAD_ATTR", "self.qualnames.setdefault" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.lineno" ], [ "LOAD_ATTR", "\".\".join" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "CALL_FUNCTION", "\".\".join(self.stack)" ], [ "CALL_FUNCTION", "self.qualnames.setdefault((name, node.lineno), \".\".join(self.stack))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_ATTR", "self.stack.append" ], [ "CALL_FUNCTION", "self.stack.append('')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Lambda" ], [ "CALL_FUNCTION", "isinstance(node, ast.Lambda)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.body" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.body" ], [ "LOAD_FAST", "children" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.visit" ], [ "LOAD_FAST", "child" ], [ "CALL_FUNCTION", "self.visit(child)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_ATTR", "self.stack.pop" ], [ "CALL_FUNCTION", "self.stack.pop()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_ATTR", "self.stack.pop" ], [ "CALL_FUNCTION", "self.stack.pop()" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.iter_fields" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ast.iter_fields(node)" ], [ "LOAD_FAST", "field" ], [ "COMPARE_OP", "field == 'body'" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.AST" ], [ "CALL_FUNCTION", "isinstance(child, ast.AST)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.visit" ], [ "LOAD_FAST", "child" ], [ "CALL_FUNCTION", "self.visit(child)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "isinstance(child, list)" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "grandchild" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.AST" ], [ "CALL_FUNCTION", "isinstance(grandchild, ast.AST)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.visit" ], [ "LOAD_FAST", "grandchild" ], [ "CALL_FUNCTION", "self.visit(grandchild)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.visit_FunctionDef" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "self.visit_FunctionDef(node, '')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_ATTR", "self.stack.append" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.name" ], [ "CALL_FUNCTION", "self.stack.append(node.name)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.generic_visit" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "self.generic_visit(node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_ATTR", "self.stack.pop" ], [ "CALL_FUNCTION", "self.stack.pop()" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "__future__" ], [ "LOAD_FAST", "fname" ], [ "CALL_FUNCTION", "getattr(__future__, fname)" ], [ "LOAD_ATTR", "getattr(__future__, fname).compiler_flag" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "matching_code" ], [ "LOAD_ATTR", "matching_code.co_filename" ], [ "LOAD_GLOBAL", "future_flags" ], [ "LOAD_FAST", "matching_code" ], [ "LOAD_ATTR", "matching_code.co_flags" ], [ "BINARY_AND", "future_flags & matching_code.co_flags" ], [ "CALL_FUNCTION_KW", "compile(\n source,\n matching_code.co_filename,\n 'exec',\n flags=future_flags & matching_code.co_flags,\n dont_inherit=True,\n )" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "tree" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_code" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lasti" ], [ "BINARY_SUBSCR", "frame.f_code.co_code[frame.f_lasti]" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_GLOBAL", "ord" ], [ "LOAD_FAST", "b" ], [ "CALL_FUNCTION", "ord(b)" ], [ "LOAD_GLOBAL", "dis" ], [ "LOAD_ATTR", "dis.opname" ], [ "LOAD_FAST", "b" ], [ "BINARY_SUBSCR", "dis.opname[b]" ], [ "LOAD_FAST", "op_name" ], [ "LOAD_ATTR", "op_name.startswith" ], [ "CALL_FUNCTION", "op_name.startswith('CALL_')" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Call" ], [ "LOAD_FAST", "op_name" ], [ "COMPARE_OP", "op_name == 'BINARY_SUBSCR'" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Subscript" ], [ "LOAD_FAST", "op_name" ], [ "LOAD_ATTR", "op_name.startswith" ], [ "CALL_FUNCTION", "op_name.startswith('BINARY_')" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.BinOp" ], [ "LOAD_FAST", "op_name" ], [ "LOAD_ATTR", "op_name.startswith" ], [ "CALL_FUNCTION", "op_name.startswith('UNARY_')" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.UnaryOp" ], [ "LOAD_FAST", "op_name" ], [ "COMPARE_OP", "op_name in ('LOAD_ATTR', 'LOAD_METHOD', 'LOOKUP_METHOD')" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Attribute" ], [ "LOAD_FAST", "op_name" ], [ "COMPARE_OP", "op_name == 'COMPARE_OP'" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Compare" ], [ "LOAD_GLOBAL", "RuntimeError" ], [ "LOAD_FAST", "op_name" ], [ "CALL_FUNCTION", "RuntimeError(op_name)" ], [ "LOAD_GLOBAL", "lock" ], [ "LOAD_FAST", "stmts" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.matching_nodes" ], [ "LOAD_FAST", "exprs" ], [ "CALL_FUNCTION", "self.matching_nodes(exprs)" ], [ "CALL_FUNCTION", "list(self.matching_nodes(exprs))" ], [ "CALL_FUNCTION", "only(list(self.matching_nodes(exprs)))" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.walk" ], [ "LOAD_FAST", "stmt" ], [ "CALL_FUNCTION", "ast.walk(stmt)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "typ" ], [ "CALL_FUNCTION", "isinstance(node, typ)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "hasattr(node, \"ctx\")" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.ctx" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Load" ], [ "CALL_FUNCTION", "isinstance(node.ctx, ast.Load)" ], [ "UNARY_NOT", "not isinstance(node.ctx, ast.Load)" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "exprs" ], [ "CALL_FUNCTION", "enumerate(exprs)" ], [ "LOAD_GLOBAL", "get_setter" ], [ "LOAD_FAST", "expr" ], [ "CALL_FUNCTION", "get_setter(expr)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.BinOp" ], [ "LOAD_FAST", "expr" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Pow" ], [ "CALL_FUNCTION", "ast.Pow()" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Str" ], [ "LOAD_GLOBAL", "sentinel" ], [ "CALL_FUNCTION_KW", "ast.Str(s=sentinel)" ], [ "CALL_FUNCTION_KW", "ast.BinOp(\n left=expr,\n op=ast.Pow(),\n right=ast.Str(s=sentinel),\n )" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.fix_missing_locations" ], [ "LOAD_FAST", "replacement" ], [ "CALL_FUNCTION", "ast.fix_missing_locations(replacement)" ], [ "LOAD_FAST", "setter" ], [ "LOAD_FAST", "replacement" ], [ "CALL_FUNCTION", "setter(replacement)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.compile_instructions" ], [ "CALL_FUNCTION", "self.compile_instructions()" ], [ "LOAD_GLOBAL", "SyntaxError" ], [ "LOAD_FAST", "setter" ], [ "LOAD_FAST", "expr" ], [ "CALL_FUNCTION", "setter(expr)" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "instructions" ], [ "CALL_FUNCTION", "enumerate(instructions)" ], [ "LOAD_FAST", "indices" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_FAST", "indices" ], [ "CALL_FUNCTION", "only(indices)" ], [ "BINARY_SUBTRACT", "only(indices) - 1" ], [ "LOAD_FAST", "instructions" ], [ "LOAD_FAST", "arg_index" ], [ "BINARY_SUBSCR", "instructions[arg_index]" ], [ "LOAD_ATTR", "instructions[arg_index].opname" ], [ "COMPARE_OP", "instructions[arg_index].opname == 'EXTENDED_ARG'" ], [ "LOAD_FAST", "instructions" ], [ "LOAD_FAST", "arg_index" ], [ "BINARY_SUBSCR", "instructions[arg_index]" ], [ "LOAD_ATTR", "instructions[arg_index].offset" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_lasti" ], [ "COMPARE_OP", "instructions[arg_index].offset == self.frame.f_lasti" ], [ "LOAD_FAST", "expr" ], [ "LOAD_FAST", "instruction" ], [ "LOAD_ATTR", "instruction.argval" ], [ "LOAD_GLOBAL", "sentinel" ], [ "COMPARE_OP", "instruction.argval == sentinel" ], [ "LOAD_FAST", "i" ], [ "LOAD_GLOBAL", "compile_similar_to" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tree" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_code" ], [ "CALL_FUNCTION", "compile_similar_to(self.tree, self.frame.f_code)" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_GLOBAL", "find_codes" ], [ "LOAD_FAST", "module_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_code" ], [ "CALL_FUNCTION", "find_codes(module_code, self.frame.f_code)" ], [ "CALL_FUNCTION", "only(find_codes(module_code, self.frame.f_code))" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "get_instructions" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "get_instructions(code)" ], [ "CALL_FUNCTION", "list(get_instructions(code))" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.iter_fields" ], [ "LOAD_DEREF", "parent" ], [ "CALL_FUNCTION", "ast.iter_fields(parent)" ], [ "LOAD_DEREF", "field" ], [ "LOAD_FAST", "node" ], [ "COMPARE_OP", "field is node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_DEREF", "field" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "isinstance(field, list)" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_DEREF", "field" ], [ "CALL_FUNCTION", "enumerate(field)" ], [ "LOAD_FAST", "item" ], [ "LOAD_FAST", "node" ], [ "COMPARE_OP", "item is node" ], [ "LOAD_FAST", "setter" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_DEREF", "parent" ], [ "LOAD_DEREF", "name" ], [ "LOAD_FAST", "new_node" ], [ "CALL_FUNCTION", "setattr(parent, name, new_node)" ], [ "LOAD_FAST", "new_node" ], [ "LOAD_DEREF", "field" ], [ "LOAD_DEREF", "i" ], [ "LOAD_DEREF", "matches" ], [ "LOAD_FAST", "root_code" ], [ "CALL_FUNCTION", "matches(root_code)" ], [ "LOAD_DEREF", "code_options" ], [ "LOAD_ATTR", "code_options.append" ], [ "LOAD_FAST", "root_code" ], [ "CALL_FUNCTION", "code_options.append(root_code)" ], [ "LOAD_DEREF", "finder" ], [ "LOAD_FAST", "root_code" ], [ "CALL_FUNCTION", "finder(root_code)" ], [ "LOAD_DEREF", "code_options" ], [ "LOAD_GLOBAL", "all" ], [ "LOAD_GLOBAL", "attrgetter" ], [ "CALL_FUNCTION", "attrgetter('co_firstlineno')" ], [ "LOAD_GLOBAL", "attrgetter" ], [ "CALL_FUNCTION", "attrgetter('co_name')" ], [ "LOAD_GLOBAL", "code_names" ], [ "CALL_FUNCTION", "all(\n f(c) == f(matching)\n for f in [\n attrgetter('co_firstlineno'),\n attrgetter('co_name'),\n code_names,\n ]\n )" ], [ "LOAD_FAST", "f" ], [ "LOAD_DEREF", "c" ], [ "CALL_FUNCTION", "f(c)" ], [ "LOAD_FAST", "f" ], [ "LOAD_DEREF", "matching" ], [ "CALL_FUNCTION", "f(matching)" ], [ "COMPARE_OP", "f(c) == f(matching)" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_consts" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.iscode" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "inspect.iscode(const)" ], [ "LOAD_DEREF", "matches" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "matches(const)" ], [ "LOAD_DEREF", "code_options" ], [ "LOAD_ATTR", "code_options.append" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "code_options.append(const)" ], [ "LOAD_DEREF", "finder" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "finder(const)" ], [ "LOAD_GLOBAL", "frozenset" ], [ "CALL_FUNCTION", "frozenset()" ], [ "LOAD_ATTR", "frozenset().union" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_names" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_varnames" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_freevars" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_cellvars" ], [ "CALL_FUNCTION", "frozenset().union(\n code.co_names,\n code.co_varnames,\n code.co_freevars,\n code.co_cellvars,\n )" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "CALL_FUNCTION", "isinstance(node, ast.stmt)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_FAST", "node" ] ], "import_hook.py": [ [ "LOAD_NAME", "object" ], [ "LOAD_FAST", "spec" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "deep" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "eye" ], [ "LOAD_ATTR", "eye.exec_string" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.source" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._spec" ], [ "LOAD_ATTR", "self._spec.origin" ], [ "LOAD_FAST", "module" ], [ "LOAD_ATTR", "module.__dict__" ], [ "LOAD_FAST", "module" ], [ "LOAD_ATTR", "module.__dict__" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.deep" ], [ "CALL_FUNCTION_KW", "eye.exec_string(\n source=self.source,\n filename=self._spec.origin,\n globs=module.__dict__,\n locs=module.__dict__,\n deep=self.deep,\n )" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._spec" ], [ "LOAD_ATTR", "self._spec.loader" ], [ "LOAD_ATTR", "self._spec.loader.get_filename" ], [ "LOAD_FAST", "fullname" ], [ "CALL_FUNCTION", "self._spec.loader.get_filename(fullname)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._spec" ], [ "LOAD_ATTR", "self._spec.loader" ], [ "LOAD_ATTR", "self._spec.loader.is_package" ], [ "LOAD_FAST", "fullname" ], [ "CALL_FUNCTION", "self._spec.loader.is_package(fullname)" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.meta_path" ], [ "LOAD_FAST", "finder" ], [ "LOAD_FAST", "self" ], [ "COMPARE_OP", "finder is self" ], [ "LOAD_FAST", "finder" ], [ "LOAD_ATTR", "finder.__module__" ], [ "COMPARE_OP", "'pytest' in finder.__module__" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "finder" ], [ "CALL_FUNCTION", "hasattr(finder, 'find_spec')" ], [ "LOAD_FAST", "finder" ], [ "LOAD_ATTR", "finder.find_spec" ], [ "LOAD_FAST", "fullname" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "target" ], [ "CALL_FUNCTION_KW", "finder.find_spec(fullname, path, target=target)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "finder" ], [ "CALL_FUNCTION", "hasattr(finder, 'load_module')" ], [ "LOAD_GLOBAL", "spec_from_loader" ], [ "LOAD_FAST", "fullname" ], [ "LOAD_FAST", "finder" ], [ "CALL_FUNCTION", "spec_from_loader(fullname, finder)" ], [ "LOAD_FAST", "spec" ], [ "COMPARE_OP", "spec is not None" ], [ "LOAD_FAST", "spec" ], [ "LOAD_ATTR", "spec.origin" ], [ "COMPARE_OP", "spec.origin != 'builtin'" ], [ "LOAD_FAST", "spec" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._find_plain_spec" ], [ "LOAD_FAST", "fullname" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "target" ], [ "CALL_FUNCTION", "self._find_plain_spec(fullname, path, target)" ], [ "LOAD_FAST", "spec" ], [ "COMPARE_OP", "spec is None" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "spec" ], [ "LOAD_ATTR", "spec.loader" ], [ "CALL_FUNCTION", "hasattr(spec.loader, 'get_source')" ], [ "LOAD_GLOBAL", "callable" ], [ "LOAD_FAST", "spec" ], [ "LOAD_ATTR", "spec.loader" ], [ "LOAD_ATTR", "spec.loader.get_source" ], [ "CALL_FUNCTION", "callable(spec.loader.get_source)" ], [ "UNARY_NOT", "not (hasattr(spec.loader, 'get_source') and\n callable(spec.loader.get_source))" ], [ "LOAD_FAST", "fullname" ], [ "COMPARE_OP", "fullname != 'org'" ], [ "LOAD_GLOBAL", "logging" ], [ "LOAD_ATTR", "logging.debug" ], [ "LOAD_FAST", "fullname" ], [ "CALL_FUNCTION", "logging.debug('Failed finding spec for %s', fullname)" ], [ "LOAD_FAST", "spec" ], [ "LOAD_ATTR", "spec.loader" ], [ "LOAD_ATTR", "spec.loader.get_source" ], [ "LOAD_FAST", "fullname" ], [ "CALL_FUNCTION", "spec.loader.get_source(fullname)" ], [ "LOAD_GLOBAL", "ImportError" ], [ "LOAD_GLOBAL", "logging" ], [ "LOAD_ATTR", "logging.debug" ], [ "LOAD_FAST", "fullname" ], [ "CALL_FUNCTION", "logging.debug('Loader for %s was unable to find the sources',\n fullname)" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_GLOBAL", "logging" ], [ "LOAD_ATTR", "logging.exception" ], [ "LOAD_FAST", "fullname" ], [ "CALL_FUNCTION", "logging.exception('Loader for %s raised an error', fullname)" ], [ "LOAD_FAST", "source" ], [ "UNARY_NOT", "not source" ], [ "LOAD_FAST", "source" ], [ "COMPARE_OP", "'birdseye' not in source" ], [ "LOAD_GLOBAL", "should_trace" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "should_trace(source)" ], [ "LOAD_FAST", "trace_stmt" ], [ "LOAD_GLOBAL", "BirdsEyeLoader" ], [ "LOAD_FAST", "spec" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "deep" ], [ "CALL_FUNCTION", "BirdsEyeLoader(spec, source, deep)" ], [ "LOAD_GLOBAL", "spec_from_loader" ], [ "LOAD_FAST", "fullname" ], [ "LOAD_FAST", "loader" ], [ "CALL_FUNCTION", "spec_from_loader(fullname, loader)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.parse" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "ast.parse(source)" ], [ "LOAD_ATTR", "ast.parse(source).body" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Import" ], [ "CALL_FUNCTION", "isinstance(stmt, ast.Import)" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_ATTR", "stmt.names" ], [ "LOAD_FAST", "alias" ], [ "LOAD_ATTR", "alias.name" ], [ "LOAD_ATTR", "alias.name.startswith" ], [ "CALL_FUNCTION", "alias.name.startswith('birdseye.trace_module')" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_FAST", "alias" ], [ "LOAD_ATTR", "alias.name" ], [ "LOAD_ATTR", "alias.name.endswith" ], [ "CALL_FUNCTION", "alias.name.endswith('deep')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.ImportFrom" ], [ "CALL_FUNCTION", "isinstance(stmt, ast.ImportFrom)" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_ATTR", "stmt.module" ], [ "COMPARE_OP", "stmt.module == 'birdseye'" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_ATTR", "stmt.names" ], [ "LOAD_FAST", "alias" ], [ "LOAD_ATTR", "alias.name" ], [ "LOAD_ATTR", "alias.name.startswith" ], [ "CALL_FUNCTION", "alias.name.startswith('trace_module')" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_FAST", "alias" ], [ "LOAD_ATTR", "alias.name" ], [ "LOAD_ATTR", "alias.name.endswith" ], [ "CALL_FUNCTION", "alias.name.endswith('deep')" ], [ "LOAD_FAST", "deep" ], [ "LOAD_FAST", "trace_stmt" ] ], "ipython.py": [ [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "BytesIO" ], [ "LOAD_NAME", "StringIO" ], [ "LOAD_NAME", "stream_proxy" ], [ "LOAD_NAME", "sys" ], [ "LOAD_ATTR", "sys.stderr" ], [ "CALL_FUNCTION", "stream_proxy(sys.stderr)" ], [ "LOAD_NAME", "sys" ], [ "LOAD_NAME", "stream_proxy" ], [ "LOAD_NAME", "sys" ], [ "LOAD_ATTR", "sys.stdout" ], [ "CALL_FUNCTION", "stream_proxy(sys.stdout)" ], [ "LOAD_NAME", "sys" ], [ "LOAD_NAME", "Environment" ], [ "LOAD_NAME", "PackageLoader" ], [ "CALL_FUNCTION", "PackageLoader('birdseye', 'templates')" ], [ "LOAD_NAME", "select_autoescape" ], [ "CALL_FUNCTION", "select_autoescape(['html', 'xml'])" ], [ "CALL_FUNCTION_KW", "Environment(\n loader=PackageLoader('birdseye', 'templates'),\n autoescape=select_autoescape(['html', 'xml'])\n)" ], [ "LOAD_NAME", "magics_class" ], [ "LOAD_NAME", "Magics" ], [ "CALL_FUNCTION", "magics_class" ], [ "LOAD_GLOBAL", "LocalProxy" ], [ "LOAD_FAST", "p" ], [ "CALL_FUNCTION", "LocalProxy(p)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.currentframe" ], [ "CALL_FUNCTION", "inspect.currentframe()" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_GLOBAL", "ThreadingMixIn" ], [ "LOAD_ATTR", "ThreadingMixIn.process_request_thread" ], [ "LOAD_ATTR", "ThreadingMixIn.process_request_thread.__code__" ], [ "COMPARE_OP", "frame.f_code == ThreadingMixIn.process_request_thread.__code__" ], [ "LOAD_GLOBAL", "fake_stream" ], [ "CALL_FUNCTION", "fake_stream()" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_GLOBAL", "thread_proxies" ], [ "LOAD_ATTR", "thread_proxies.get" ], [ "LOAD_GLOBAL", "currentThread" ], [ "CALL_FUNCTION", "currentThread()" ], [ "LOAD_ATTR", "currentThread().ident" ], [ "LOAD_DEREF", "original" ], [ "CALL_FUNCTION", "thread_proxies.get(currentThread().ident,\n original)" ], [ "LOAD_FAST", "show_server_output" ], [ "LOAD_GLOBAL", "fake_stream" ], [ "CALL_FUNCTION", "fake_stream()" ], [ "LOAD_GLOBAL", "thread_proxies" ], [ "LOAD_GLOBAL", "currentThread" ], [ "CALL_FUNCTION", "currentThread()" ], [ "LOAD_ATTR", "currentThread().ident" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_ATTR", "server.app" ], [ "LOAD_ATTR", "server.app.run" ], [ "LOAD_FAST", "port" ], [ "LOAD_FAST", "bind_host" ], [ "CALL_FUNCTION_KW", "server.app.run(\n debug=True,\n port=port,\n host=bind_host,\n use_reloader=False,\n )" ], [ "LOAD_GLOBAL", "socket" ], [ "LOAD_ATTR", "socket.error" ], [ "LOAD_NAME", "Unicode" ], [ "CALL_FUNCTION_KW", "Unicode(\n u'', config=True,\n help='If set, a server will not be automatically started by %%eye. '\n 'The iframe containing birdseye output will use this value as the base '\n 'of its URL.'\n )" ], [ "LOAD_NAME", "Int" ], [ "CALL_FUNCTION_KW", "Int(\n 7777, config=True,\n help='Port number for the server started by %%eye.'\n )" ], [ "LOAD_NAME", "Unicode" ], [ "CALL_FUNCTION_KW", "Unicode(\n '127.0.0.1', config=True,\n help='Host that the server started by %%eye listens on. '\n 'Set to 0.0.0.0 to make it accessible anywhere.'\n )" ], [ "LOAD_NAME", "Bool" ], [ "CALL_FUNCTION_KW", "Bool(\n False, config=True,\n help='Set to True to show stdout and stderr from the server started by %%eye.'\n )" ], [ "LOAD_NAME", "Unicode" ], [ "CALL_FUNCTION_KW", "Unicode(\n u'', config=True,\n help='The database URL that the server started by %%eye reads from. '\n 'Equivalent to the environment variable BIRDSEYE_DB.'\n )" ], [ "LOAD_NAME", "cell_magic" ], [ "CALL_FUNCTION", "cell_magic" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.server_url" ], [ "LOAD_GLOBAL", "Database" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.db_url" ], [ "CALL_FUNCTION", "Database(self.db_url)" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_ATTR", "server.db" ], [ "LOAD_ATTR", "server.db.Function" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_ATTR", "server.db" ], [ "LOAD_ATTR", "server.db.Call" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_ATTR", "server.db" ], [ "LOAD_ATTR", "server.db.Session" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_GLOBAL", "Thread" ], [ "LOAD_GLOBAL", "run_server" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.port" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.bind_host" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.show_server_output" ], [ "CALL_FUNCTION_KW", "Thread(\n target=run_server,\n args=(\n self.port,\n self.bind_host,\n self.show_server_output,\n ),\n )" ], [ "LOAD_ATTR", "Thread(\n target=run_server,\n args=(\n self.port,\n self.bind_host,\n self.show_server_output,\n ),\n ).start" ], [ "CALL_FUNCTION", "Thread(\n target=run_server,\n args=(\n self.port,\n self.bind_host,\n self.show_server_output,\n ),\n ).start()" ], [ "LOAD_GLOBAL", "Database" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.db_url" ], [ "CALL_FUNCTION", "Database(self.db_url)" ], [ "LOAD_GLOBAL", "eye" ], [ "LOAD_GLOBAL", "eye" ], [ "LOAD_ATTR", "eye.exec_ipython_cell" ], [ "LOAD_FAST", "cell" ], [ "LOAD_FAST", "callback" ], [ "CALL_FUNCTION", "eye.exec_ipython_cell(cell, callback)" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "call_id" ], [ "COMPARE_OP", "call_id is None" ], [ "LOAD_GLOBAL", "HTML" ], [ "LOAD_GLOBAL", "templates_env" ], [ "LOAD_ATTR", "templates_env.get_template" ], [ "CALL_FUNCTION", "templates_env.get_template('ipython_iframe.html')" ], [ "LOAD_ATTR", "templates_env.get_template('ipython_iframe.html').render" ], [ "LOAD_FAST", "call_id" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.server_url" ], [ "LOAD_ATTR", "self.server_url.rstrip" ], [ "CALL_FUNCTION", "self.server_url.rstrip('/')" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.port" ], [ "LOAD_GLOBAL", "uuid4" ], [ "CALL_FUNCTION", "uuid4()" ], [ "LOAD_ATTR", "uuid4().hex" ], [ "CALL_FUNCTION_KW", "templates_env.get_template('ipython_iframe.html').render(\n call_id=call_id,\n url=self.server_url.rstrip('/'),\n port=self.port,\n container_id=uuid4().hex,\n )" ], [ "CALL_FUNCTION", "HTML(templates_env.get_template('ipython_iframe.html').render(\n call_id=call_id,\n url=self.server_url.rstrip('/'),\n port=self.port,\n container_id=uuid4().hex,\n ))" ], [ "LOAD_GLOBAL", "display" ], [ "LOAD_FAST", "html" ], [ "CALL_FUNCTION", "display(html)" ] ], "server.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOAD_ATTR", "standard_library.install_aliases" ], [ "CALL_FUNCTION", "standard_library.install_aliases()" ], [ "LOAD_NAME", "Flask" ], [ "CALL_FUNCTION", "Flask('birdseye')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.jinja_env" ], [ "LOAD_NAME", "Humanize" ], [ "LOAD_NAME", "app" ], [ "CALL_FUNCTION", "Humanize(app)" ], [ "LOAD_NAME", "PathConverter" ], [ "LOAD_NAME", "FileConverter" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.url_map" ], [ "LOAD_ATTR", "app.url_map.converters" ], [ "LOAD_NAME", "Database" ], [ "CALL_FUNCTION", "Database()" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.Session" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.Function" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.Call" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION", "app.route('/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION", "app.route('/file/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/file/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION", "app.route('/file//__function__/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/file//__function__/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION", "app.route('/api/file//__function__//latest_call/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/api/file//__function__//latest_call/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION", "app.route('/call/')" ], [ "CALL_FUNCTION", "app.route('/call/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION", "app.route('/ipython_call/')" ], [ "CALL_FUNCTION", "app.route('/ipython_call/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION", "app.route('/ipython_iframe/')" ], [ "CALL_FUNCTION", "app.route('/ipython_iframe/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION_KW", "app.route('/kill', methods=['POST'])" ], [ "CALL_FUNCTION", "app.route('/kill', methods=['POST'])" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION", "app.route('/api/call/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/api/call/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION", "app.route('/api/calls_by_body_hash/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/api/calls_by_body_hash/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION_KW", "app.route('/api/body_hashes_present/', methods=['POST'])" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/api/body_hashes_present/', methods=['POST'])" ], [ "LOAD_NAME", "sys" ], [ "LOAD_ATTR", "sys.argv" ], [ "BINARY_SUBSCR", "sys.argv[1:]" ], [ "LOAD_NAME", "__name__" ], [ "COMPARE_OP", "__name__ == '__main__'" ], [ "LOAD_NAME", "main" ], [ "CALL_FUNCTION", "main()" ], [ "LOAD_GLOBAL", "db" ], [ "LOAD_ATTR", "db.all_file_paths" ], [ "CALL_FUNCTION", "db.all_file_paths()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_columns" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.basic_columns" ], [ "BINARY_ADD", "Call.basic_columns + Function.basic_columns" ], [ "CALL_FUNCTION_EX", "session.query(*(Call.basic_columns + Function.basic_columns))" ], [ "LOAD_ATTR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_FUNCTION", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)" ], [ "LOAD_ATTR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .order_by" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.start_time" ], [ "LOAD_ATTR", "Call.start_time.desc" ], [ "CALL_FUNCTION", "Call.start_time.desc()" ], [ "CALL_FUNCTION", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .order_by(Call.start_time.desc())" ], [ "BINARY_SUBSCR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .order_by(Call.start_time.desc())[:100]" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "CALL_FUNCTION", "OrderedDict()" ], [ "LOAD_FAST", "recent_calls" ], [ "LOAD_GLOBAL", "is_ipython_cell" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.file" ], [ "CALL_FUNCTION", "is_ipython_cell(row.file)" ], [ "LOAD_FAST", "files" ], [ "LOAD_ATTR", "files.setdefault" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.file" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "CALL_FUNCTION", "OrderedDict()" ], [ "CALL_FUNCTION", "files.setdefault(\n row.file, OrderedDict()\n )" ], [ "LOAD_ATTR", "files.setdefault(\n row.file, OrderedDict()\n ).setdefault" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.name" ], [ "LOAD_FAST", "row" ], [ "CALL_FUNCTION", "files.setdefault(\n row.file, OrderedDict()\n ).setdefault(\n row.name, row\n )" ], [ "LOAD_FAST", "all_paths" ], [ "LOAD_FAST", "files" ], [ "LOAD_ATTR", "files.setdefault" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "CALL_FUNCTION", "OrderedDict()" ], [ "CALL_FUNCTION", "files.setdefault(\n path, OrderedDict()\n )" ], [ "LOAD_GLOBAL", "partial" ], [ "LOAD_GLOBAL", "short_path" ], [ "LOAD_FAST", "all_paths" ], [ "CALL_FUNCTION_KW", "partial(short_path, all_paths=all_paths)" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "short" ], [ "LOAD_FAST", "files" ], [ "CALL_FUNCTION_KW", "render_template('index.html',\n short=short,\n files=files)" ], [ "LOAD_GLOBAL", "fix_abs_path" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "fix_abs_path(path)" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_columns" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.basic_columns" ], [ "BINARY_ADD", "Call.basic_columns + Function.basic_columns" ], [ "CALL_FUNCTION_EX", "session.query(*(Call.basic_columns + Function.basic_columns))" ], [ "LOAD_ATTR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_FUNCTION", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)" ], [ "LOAD_ATTR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION_KW", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path)" ], [ "LOAD_ATTR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path)\n .subquery" ], [ "CALL_FUNCTION", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path)\n .subquery('filtered_calls')" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.name" ], [ "LOAD_GLOBAL", "sqlalchemy" ], [ "LOAD_ATTR", "sqlalchemy.func" ], [ "LOAD_ATTR", "sqlalchemy.func.max" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.start_time" ], [ "CALL_FUNCTION", "sqlalchemy.func.max(filtered_calls.c.start_time)" ], [ "LOAD_ATTR", "sqlalchemy.func.max(filtered_calls.c.start_time).label" ], [ "CALL_FUNCTION", "sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')" ], [ "CALL_FUNCTION", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n )" ], [ "LOAD_ATTR", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n ).group_by" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.name" ], [ "CALL_FUNCTION", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n ).group_by(\n filtered_calls.c.name,\n )" ], [ "LOAD_ATTR", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n ).group_by(\n filtered_calls.c.name,\n ).subquery" ], [ "CALL_FUNCTION", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n ).group_by(\n filtered_calls.c.name,\n ).subquery('latest_calls')" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_FAST", "filtered_calls" ], [ "CALL_FUNCTION", "session.query(filtered_calls)" ], [ "LOAD_ATTR", "session.query(filtered_calls).join" ], [ "LOAD_FAST", "latest_calls" ], [ "LOAD_GLOBAL", "sqlalchemy" ], [ "LOAD_ATTR", "sqlalchemy.and_" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.name" ], [ "LOAD_FAST", "latest_calls" ], [ "LOAD_ATTR", "latest_calls.c" ], [ "LOAD_ATTR", "latest_calls.c.name" ], [ "COMPARE_OP", "filtered_calls.c.name == latest_calls.c.name" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.start_time" ], [ "LOAD_FAST", "latest_calls" ], [ "LOAD_ATTR", "latest_calls.c" ], [ "LOAD_ATTR", "latest_calls.c.maxtime" ], [ "COMPARE_OP", "filtered_calls.c.start_time == latest_calls.c.maxtime" ], [ "CALL_FUNCTION", "sqlalchemy.and_(\n filtered_calls.c.name == latest_calls.c.name,\n filtered_calls.c.start_time == latest_calls.c.maxtime,\n )" ], [ "CALL_FUNCTION", "session.query(filtered_calls).join(\n latest_calls,\n sqlalchemy.and_(\n filtered_calls.c.name == latest_calls.c.name,\n filtered_calls.c.start_time == latest_calls.c.maxtime,\n )\n )" ], [ "LOAD_ATTR", "session.query(filtered_calls).join(\n latest_calls,\n sqlalchemy.and_(\n filtered_calls.c.name == latest_calls.c.name,\n filtered_calls.c.start_time == latest_calls.c.maxtime,\n )\n ).order_by" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.start_time" ], [ "LOAD_ATTR", "filtered_calls.c.start_time.desc" ], [ "CALL_FUNCTION", "filtered_calls.c.start_time.desc()" ], [ "CALL_FUNCTION", "session.query(filtered_calls).join(\n latest_calls,\n sqlalchemy.and_(\n filtered_calls.c.name == latest_calls.c.name,\n filtered_calls.c.start_time == latest_calls.c.maxtime,\n )\n ).order_by(filtered_calls.c.start_time.desc())" ], [ "LOAD_GLOBAL", "group_by_attr" ], [ "LOAD_FAST", "query" ], [ "CALL_FUNCTION", "group_by_attr(query, 'type')" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.name" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.type" ], [ "CALL_FUNCTION", "session.query(Function.name, Function.type)" ], [ "LOAD_ATTR", "session.query(Function.name, Function.type)\n .filter_by" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION_KW", "session.query(Function.name, Function.type)\n .filter_by(file=path)" ], [ "LOAD_ATTR", "session.query(Function.name, Function.type)\n .filter_by(file=path)\n .distinct" ], [ "CALL_FUNCTION", "session.query(Function.name, Function.type)\n .filter_by(file=path)\n .distinct()" ], [ "CALL_FUNCTION", "sorted(session.query(Function.name, Function.type)\n .filter_by(file=path)\n .distinct())" ], [ "LOAD_FAST", "query" ], [ "LOAD_FAST", "all_funcs" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.name" ], [ "LOAD_FAST", "func_names" ], [ "COMPARE_OP", "func.name not in func_names" ], [ "LOAD_FAST", "funcs" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.type" ], [ "BINARY_SUBSCR", "funcs[func.type]" ], [ "LOAD_ATTR", "funcs[func.type].append" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "funcs[func.type].append(func)" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "funcs" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "COMPARE_OP", "path == IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "basename" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "basename(path)" ], [ "CALL_FUNCTION_KW", "render_template('file.html',\n funcs=funcs,\n is_ipython=path == IPYTHON_FILE_PATH,\n full_path=path,\n short_path=basename(path))" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.name" ], [ "LOAD_GLOBAL", "fix_abs_path" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "fix_abs_path(path)" ], [ "LOAD_GLOBAL", "get_calls" ], [ "LOAD_FAST", "session" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "func_name" ], [ "CALL_FUNCTION", "get_calls(session, path, func_name, 200)" ], [ "LOAD_FAST", "query" ], [ "LOAD_FAST", "query" ], [ "BINARY_SUBSCR", "query[0]" ], [ "LOAD_FAST", "query" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_FUNCTION", "session.query(Function)" ], [ "LOAD_ATTR", "session.query(Function).filter_by" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "func_name" ], [ "CALL_FUNCTION_KW", "session.query(Function).filter_by(file=path, name=func_name)" ], [ "BINARY_SUBSCR", "session.query(Function).filter_by(file=path, name=func_name)[0]" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "func" ], [ "LOAD_GLOBAL", "basename" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "basename(path)" ], [ "LOAD_FAST", "calls" ], [ "CALL_FUNCTION_KW", "render_template('function.html',\n func=func,\n short_path=basename(path),\n calls=calls)" ], [ "LOAD_GLOBAL", "withattrs" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_FUNCTION", "Call()" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row._asdict" ], [ "CALL_FUNCTION", "row._asdict()" ], [ "CALL_FUNCTION_EX", "withattrs(Call(), **row._asdict())" ], [ "LOAD_GLOBAL", "fix_abs_path" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "fix_abs_path(path)" ], [ "LOAD_GLOBAL", "get_calls" ], [ "LOAD_FAST", "session" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "func_name" ], [ "CALL_FUNCTION", "get_calls(session, path, func_name, 1)" ], [ "BINARY_SUBSCR", "get_calls(session, path, func_name, 1)[0]" ], [ "LOAD_GLOBAL", "jsonify" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.id" ], [ "LOAD_GLOBAL", "url_for" ], [ "LOAD_GLOBAL", "call_view" ], [ "LOAD_ATTR", "call_view.__name__" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.id" ], [ "CALL_FUNCTION_KW", "url_for(call_view.__name__,\n call_id=call.id)" ], [ "CALL_FUNCTION_KW", "dict(\n id=call.id,\n url=url_for(call_view.__name__,\n call_id=call.id),\n )" ], [ "CALL_FUNCTION", "jsonify(dict(\n id=call.id,\n url=url_for(call_view.__name__,\n call_id=call.id),\n ))" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_columns" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.basic_columns" ], [ "BINARY_ADD", "Call.basic_columns + Function.basic_columns" ], [ "CALL_FUNCTION_EX", "session.query(*(Call.basic_columns + Function.basic_columns))" ], [ "LOAD_ATTR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_FUNCTION", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)" ], [ "LOAD_ATTR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "func_name" ], [ "CALL_FUNCTION_KW", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path, name=func_name)" ], [ "LOAD_ATTR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path, name=func_name)\n .order_by" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.start_time" ], [ "LOAD_ATTR", "Call.start_time.desc" ], [ "CALL_FUNCTION", "Call.start_time.desc()" ], [ "CALL_FUNCTION", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path, name=func_name)\n .order_by(Call.start_time.desc())" ], [ "LOAD_FAST", "limit" ], [ "BINARY_SUBSCR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path, name=func_name)\n .order_by(Call.start_time.desc())[:limit]" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_FUNCTION", "session.query(Call)" ], [ "LOAD_ATTR", "session.query(Call).filter_by" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION_KW", "session.query(Call).filter_by(id=call_id)" ], [ "LOAD_ATTR", "session.query(Call).filter_by(id=call_id).one" ], [ "CALL_FUNCTION", "session.query(Call).filter_by(id=call_id).one()" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.function" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "template" ], [ "LOAD_GLOBAL", "basename" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.file" ], [ "CALL_FUNCTION", "basename(func.file)" ], [ "LOAD_FAST", "call" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION_KW", "render_template(template,\n short_path=basename(func.file),\n call=call,\n func=func)" ], [ "LOAD_GLOBAL", "base_call_view" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION", "base_call_view(call_id, 'call.html')" ], [ "LOAD_GLOBAL", "base_call_view" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION", "base_call_view(call_id, 'ipython_call.html')" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION_KW", "render_template('ipython_iframe.html',\n container_id='1234',\n port=7777,\n call_id=call_id)" ], [ "LOAD_GLOBAL", "request" ], [ "LOAD_ATTR", "request.environ" ], [ "LOAD_ATTR", "request.environ.get" ], [ "CALL_FUNCTION", "request.environ.get('werkzeug.server.shutdown')" ], [ "LOAD_FAST", "func" ], [ "COMPARE_OP", "func is None" ], [ "LOAD_GLOBAL", "RuntimeError" ], [ "CALL_FUNCTION", "RuntimeError('Not running with the Werkzeug Server')" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "func()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_FUNCTION", "session.query(Call)" ], [ "LOAD_ATTR", "session.query(Call).filter_by" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION_KW", "session.query(Call).filter_by(id=call_id)" ], [ "LOAD_ATTR", "session.query(Call).filter_by(id=call_id).one" ], [ "CALL_FUNCTION", "session.query(Call).filter_by(id=call_id).one()" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.function" ], [ "LOAD_GLOBAL", "DecentJSONEncoder" ], [ "CALL_FUNCTION", "DecentJSONEncoder()" ], [ "LOAD_ATTR", "DecentJSONEncoder().encode" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.parsed_data" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_dict" ], [ "LOAD_FAST", "call" ], [ "CALL_FUNCTION", "Call.basic_dict(call)" ], [ "CALL_FUNCTION_EX", "dict(data=call.parsed_data, **Call.basic_dict(call))" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.parsed_data" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.basic_dict" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "Function.basic_dict(func)" ], [ "CALL_FUNCTION_EX", "dict(data=func.parsed_data, **Function.basic_dict(func))" ], [ "CALL_FUNCTION_KW", "dict(\n call=dict(data=call.parsed_data, **Call.basic_dict(call)),\n function=dict(data=func.parsed_data, **Function.basic_dict(func)))" ], [ "CALL_FUNCTION", "DecentJSONEncoder().encode(dict(\n call=dict(data=call.parsed_data, **Call.basic_dict(call)),\n function=dict(data=func.parsed_data, **Function.basic_dict(func))))" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_columns" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.data" ], [ "BINARY_ADD", "Call.basic_columns + (Function.data,)" ], [ "CALL_FUNCTION_EX", "session.query(*Call.basic_columns + (Function.data,))" ], [ "LOAD_ATTR", "session.query(*Call.basic_columns + (Function.data,))\n .join" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_FUNCTION", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)" ], [ "LOAD_ATTR", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by" ], [ "LOAD_FAST", "body_hash" ], [ "CALL_FUNCTION_KW", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by(body_hash=body_hash)" ], [ "LOAD_ATTR", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by(body_hash=body_hash)\n .order_by" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.start_time" ], [ "LOAD_ATTR", "Call.start_time.desc" ], [ "CALL_FUNCTION", "Call.start_time.desc()" ], [ "CALL_FUNCTION", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by(body_hash=body_hash)\n .order_by(Call.start_time.desc())" ], [ "BINARY_SUBSCR", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by(body_hash=body_hash)\n .order_by(Call.start_time.desc())[:200]" ], [ "LOAD_FAST", "query" ], [ "LOAD_FAST", "query" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "function_data_set" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_ATTR", "json.loads" ], [ "LOAD_DEREF", "function_data" ], [ "CALL_FUNCTION", "json.loads(function_data)" ], [ "LOAD_FAST", "add" ], [ "LOAD_FAST", "ranges" ], [ "CALL_FUNCTION", "add('node_ranges', ranges)" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "add" ], [ "LOAD_FAST", "current_loop_ranges" ], [ "CALL_FUNCTION", "add('loop_ranges', current_loop_ranges)" ], [ "LOAD_FAST", "loop_ranges" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "current_loop_ranges" ], [ "COMPARE_OP", "loop_ranges in (set(), current_loop_ranges)" ], [ "LOAD_FAST", "current_loop_ranges" ], [ "LOAD_FAST", "ranges" ], [ "LOAD_FAST", "loop_ranges" ], [ "LOAD_GLOBAL", "DecentJSONEncoder" ], [ "CALL_FUNCTION", "DecentJSONEncoder()" ], [ "LOAD_ATTR", "DecentJSONEncoder().encode" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "calls" ], [ "LOAD_FAST", "ranges" ], [ "LOAD_FAST", "loop_ranges" ], [ "CALL_FUNCTION_KW", "dict(\n calls=calls, ranges=ranges, loop_ranges=loop_ranges)" ], [ "CALL_FUNCTION", "DecentJSONEncoder().encode(dict(\n calls=calls, ranges=ranges, loop_ranges=loop_ranges))" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_dict" ], [ "LOAD_GLOBAL", "withattrs" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_FUNCTION", "Call()" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row._asdict" ], [ "CALL_FUNCTION", "row._asdict()" ], [ "CALL_FUNCTION_EX", "withattrs(Call(), **row._asdict())" ], [ "CALL_FUNCTION", "Call.basic_dict(withattrs(Call(), **row._asdict()))" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.data" ], [ "LOAD_DEREF", "function_data" ], [ "LOAD_FAST", "key" ], [ "BINARY_SUBSCR", "function_data[key]" ], [ "LOAD_FAST", "ranges_set" ], [ "LOAD_ATTR", "ranges_set.add" ], [ "LOAD_FAST", "node" ], [ "BINARY_SUBSCR", "node['start']" ], [ "LOAD_FAST", "node" ], [ "BINARY_SUBSCR", "node['end']" ], [ "CALL_FUNCTION", "ranges_set.add((node['start'], node['end']))" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "CALL_FUNCTION_KW", "dict(start=start, end=end)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "CALL_FUNCTION_KW", "dict(start=start, end=end)" ], [ "LOAD_GLOBAL", "request" ], [ "LOAD_ATTR", "request.get_json" ], [ "CALL_FUNCTION", "request.get_json()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.body_hash" ], [ "LOAD_GLOBAL", "sqlalchemy" ], [ "LOAD_ATTR", "sqlalchemy.func" ], [ "LOAD_ATTR", "sqlalchemy.func.count" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.id" ], [ "CALL_FUNCTION", "sqlalchemy.func.count(Call.id)" ], [ "CALL_FUNCTION", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))" ], [ "LOAD_ATTR", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_FUNCTION", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)" ], [ "LOAD_ATTR", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)\n .filter" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.body_hash" ], [ "LOAD_ATTR", "Function.body_hash.in_" ], [ "LOAD_FAST", "hashes" ], [ "CALL_FUNCTION", "Function.body_hash.in_(hashes)" ], [ "CALL_FUNCTION", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)\n .filter(Function.body_hash.in_(hashes))" ], [ "LOAD_ATTR", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)\n .filter(Function.body_hash.in_(hashes))\n .group_by" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.body_hash" ], [ "CALL_FUNCTION", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)\n .filter(Function.body_hash.in_(hashes))\n .group_by(Function.body_hash)" ], [ "LOAD_GLOBAL", "DecentJSONEncoder" ], [ "CALL_FUNCTION", "DecentJSONEncoder()" ], [ "LOAD_ATTR", "DecentJSONEncoder().encode" ], [ "LOAD_FAST", "query" ], [ "CALL_FUNCTION", "DecentJSONEncoder().encode([\n dict(hash=h, count=count)\n for h, count in query\n ])" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "h" ], [ "LOAD_FAST", "count" ], [ "CALL_FUNCTION_KW", "dict(hash=h, count=count)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "argv" ], [ "CALL_FUNCTION", "len(argv)" ], [ "COMPARE_OP", "len(argv) == 1" ], [ "LOAD_FAST", "argv" ], [ "BINARY_SUBSCR", "argv[0]" ], [ "LOAD_ATTR", "argv[0].isdigit" ], [ "CALL_FUNCTION", "argv[0].isdigit()" ], [ "LOAD_FAST", "argv" ], [ "LOAD_ATTR", "argv.insert" ], [ "CALL_FUNCTION", "argv.insert(0, '--port')" ], [ "LOAD_GLOBAL", "argparse" ], [ "LOAD_ATTR", "argparse.ArgumentParser" ], [ "CALL_FUNCTION_KW", "argparse.ArgumentParser(description=\"Bird's Eye: A graphical Python debugger\")" ], [ "LOAD_FAST", "parser" ], [ "LOAD_ATTR", "parser.add_argument" ], [ "LOAD_GLOBAL", "int" ], [ "CALL_FUNCTION_KW", "parser.add_argument('-p', '--port', help='HTTP port, default is 7777', default=7777, type=int)" ], [ "LOAD_FAST", "parser" ], [ "LOAD_ATTR", "parser.add_argument" ], [ "CALL_FUNCTION_KW", "parser.add_argument('--host', help=\"HTTP host, default is 'localhost'\", default='localhost')" ], [ "LOAD_FAST", "parser" ], [ "LOAD_ATTR", "parser.parse_args" ], [ "LOAD_FAST", "argv" ], [ "CALL_FUNCTION", "parser.parse_args(argv)" ], [ "LOAD_GLOBAL", "app" ], [ "LOAD_ATTR", "app.run" ], [ "LOAD_FAST", "args" ], [ "LOAD_ATTR", "args.port" ], [ "LOAD_FAST", "args" ], [ "LOAD_ATTR", "args.host" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.environ" ], [ "LOAD_ATTR", "os.environ.get" ], [ "CALL_FUNCTION", "os.environ.get('BIRDSEYE_RELOADER')" ], [ "COMPARE_OP", "os.environ.get('BIRDSEYE_RELOADER') == '1'" ], [ "CALL_FUNCTION_KW", "app.run(\n port=args.port,\n host=args.host,\n use_reloader=os.environ.get('BIRDSEYE_RELOADER') == '1',\n )" ] ], "tests.py": [ [ "LOAD_NAME", "unittest" ], [ "LOAD_ATTR", "unittest.TestCase" ], [ "LOAD_NAME", "unittest" ], [ "LOAD_ATTR", "unittest.TestCase" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "TestFile" ], [ "CALL_FUNCTION", "TestFile()" ], [ "LOAD_ATTR", "TestFile().test_file" ], [ "CALL_FUNCTION", "TestFile().test_file()" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "Tester" ], [ "CALL_FUNCTION", "Tester()" ], [ "LOAD_NAME", "tester" ], [ "CALL_FUNCTION", "tester([1, 2, 3])" ], [ "COMPARE_OP", "tester([1, 2, 3]) == [1, 2, 3]" ], [ "LOAD_NAME", "tester" ], [ "LOAD_ATTR", "tester.asd" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester.asd is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_SUBSCR", "tester[19]" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester[19] is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_POWER", "tester ** 4" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester ** 4 is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_MULTIPLY", "tester * 3" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester * 3 is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_SUBTRACT", "tester - 2" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester - 2 is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_ADD", "tester + 1" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester + 1 is tester" ], [ "LOAD_NAME", "tester" ], [ "UNARY_NEGATIVE", "-tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "-tester is tester" ], [ "LOAD_NAME", "tester" ], [ "UNARY_POSITIVE", "+tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "+tester is tester" ], [ "LOAD_NAME", "tester" ], [ "UNARY_INVERT", "~tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "~tester is tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester < 7" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "(tester < 7) is tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester >= 78" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "(tester >= 78) is tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester != 79" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "(tester != 79) is tester" ], [ "LOAD_NAME", "tester" ], [ "LOAD_ATTR", "tester.foo" ], [ "CALL_FUNCTION", "tester.foo(45, False)" ], [ "COMPARE_OP", "tester.foo(45, False) == 45" ], [ "LOAD_NAME", "__name__" ], [ "COMPARE_OP", "__name__ == '__main__'" ], [ "LOAD_NAME", "unittest" ], [ "LOAD_ATTR", "unittest.main" ], [ "CALL_FUNCTION", "unittest.main()" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(1)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(2)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(3)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(9\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n 8)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n 99\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(33)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([4,\n 5, 6, [\n 7]])" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "LOAD_GLOBAL", "decorator_with_args" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('123')" ], [ "LOAD_GLOBAL", "int" ], [ "CALL_FUNCTION", "int()" ], [ "CALL_FUNCTION_KW", "decorator_with_args(tester('123'), x=int())" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "tuple([1, 2])" ], [ "CALL_FUNCTION", "list(tuple([1, 2]))" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "CALL_FUNCTION_KW", "tester(list(tuple([1, 2])), returns=empty_decorator)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "tuple(\n [3, 4])" ], [ "CALL_FUNCTION", "list(\n tuple(\n [3, 4]))" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "CALL_FUNCTION_KW", "tester(\n list(\n tuple(\n [3, 4])),\n returns=empty_decorator)" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "LOAD_GLOBAL", "decorator_with_args" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "str()" ], [ "LOAD_GLOBAL", "int" ], [ "CALL_FUNCTION", "int()" ], [ "CALL_FUNCTION_KW", "decorator_with_args(\n str(),\n x=int())" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "tuple([5, 6])" ], [ "CALL_FUNCTION", "list(tuple([5, 6]))" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "CALL_FUNCTION_KW", "tester(list(tuple([5, 6])), returns=empty_decorator)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "tuple([7, 8])" ], [ "CALL_FUNCTION", "list(tuple([7, 8]))" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "CALL_FUNCTION_KW", "tester(list(tuple([7, 8])), returns=empty_decorator)" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "LOAD_GLOBAL", "decorator_with_args" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('sdf')" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('123234')" ], [ "CALL_FUNCTION_KW", "decorator_with_args(tester('sdf'), x=tester('123234'))" ], [ "CALL_FUNCTION", "decorator_with_args(tester('sdf'), x=tester('123234'))" ], [ "CALL_FUNCTION", "empty_decorator" ], [ "CALL_FUNCTION", "tester(list(tuple([7, 8])), returns=empty_decorator)" ], [ "CALL_FUNCTION", "tester(list(tuple([5, 6])), returns=empty_decorator)" ], [ "CALL_FUNCTION", "decorator_with_args(\n str(),\n x=int())" ], [ "CALL_FUNCTION", "empty_decorator" ], [ "CALL_FUNCTION", "tester(\n list(\n tuple(\n [3, 4])),\n returns=empty_decorator)" ], [ "CALL_FUNCTION", "tester(list(tuple([1, 2])), returns=empty_decorator)" ], [ "CALL_FUNCTION", "decorator_with_args(tester('123'), x=int())" ], [ "CALL_FUNCTION", "empty_decorator" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "str([{tester(x) for x in [1]}, {tester(y) for y in [1]}])" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "str([{tester(x) for x in [1]},\n {tester(x) for x in [1]}])" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "list(tester(x) for x in [1])" ], [ "CALL_FUNCTION", "str([{tester(x) for x in [1]}, list(tester(x) for x in [1])])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "y" ], [ "CALL_FUNCTION", "tester(y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertEqual" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(3)" ], [ "CALL_FUNCTION", "(lambda x: (tester(x), tester(x)))(tester(3))" ], [ "CALL_FUNCTION", "self.assertEqual(\n (lambda x: (tester(x), tester(x)))(tester(3)),\n (3, 3),\n )" ], [ "CALL_FUNCTION", "(lambda: (lambda: tester(1))())()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertEqual" ], [ "CALL_FUNCTION", "(lambda: [tester(x) for x in tester([1, 2])])()" ], [ "CALL_FUNCTION", "self.assertEqual(\n (lambda: [tester(x) for x in tester([1, 2])])(),\n [1, 2],\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "CALL_FUNCTION", "(lambda: tester(1))()" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(1)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x): {tester(b+x): {tester(c+x) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_FAST", "foo" ], [ "CALL_FUNCTION", "foo()" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "CALL_FUNCTION", "tester(a+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "CALL_FUNCTION", "tester(b+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "CALL_FUNCTION", "tester(c+x)" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x): {tester(b+x): {tester(c+x) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+y): {tester(b+y): {tester(c+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x+y): {tester(b+x+y): {tester(c+x+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_FAST", "bar" ], [ "CALL_FUNCTION", "bar()" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "CALL_FUNCTION", "tester(a+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "CALL_FUNCTION", "tester(b+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "CALL_FUNCTION", "tester(c+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+y" ], [ "CALL_FUNCTION", "tester(a+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+y" ], [ "CALL_FUNCTION", "tester(b+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+y" ], [ "CALL_FUNCTION", "tester(c+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+x+y" ], [ "CALL_FUNCTION", "tester(a+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+x+y" ], [ "CALL_FUNCTION", "tester(b+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+x+y" ], [ "CALL_FUNCTION", "tester(c+x+y)" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x): {tester(b+x): {tester(c+x) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+y): {tester(b+y): {tester(c+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x+y): {tester(b+x+y): {tester(c+x+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x+y+z): {tester(b+x+y+z): {tester(c+x+y+z) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "CALL_FUNCTION", "tester(a+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "CALL_FUNCTION", "tester(b+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "CALL_FUNCTION", "tester(c+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+y" ], [ "CALL_FUNCTION", "tester(a+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+y" ], [ "CALL_FUNCTION", "tester(b+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+y" ], [ "CALL_FUNCTION", "tester(c+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+x+y" ], [ "CALL_FUNCTION", "tester(a+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+x+y" ], [ "CALL_FUNCTION", "tester(b+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+x+y" ], [ "CALL_FUNCTION", "tester(c+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+x+y" ], [ "LOAD_DEREF", "z" ], [ "BINARY_ADD", "a+x+y+z" ], [ "CALL_FUNCTION", "tester(a+x+y+z)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+x+y" ], [ "LOAD_DEREF", "z" ], [ "BINARY_ADD", "b+x+y+z" ], [ "CALL_FUNCTION", "tester(b+x+y+z)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+x+y" ], [ "LOAD_DEREF", "z" ], [ "BINARY_ADD", "c+x+y+z" ], [ "CALL_FUNCTION", "tester(c+x+y+z)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION_KW", "dict(x=tester)" ], [ "BINARY_SUBSCR", "dict(x=tester)['x']" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "dict(x=tester)['x'](tester)" ], [ "CALL_FUNCTION_KW", "dict(x=tester)['x'](tester)(3, check_func=False)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertRaises" ], [ "LOAD_GLOBAL", "TypeError" ], [ "CALL_FUNCTION", "self.assertRaises(TypeError)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2, 3])" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(0)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(4)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(5)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "tester(ValueError)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(9)" ], [ "LOAD_GLOBAL", "TypeError" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(10)" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "str()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertRaises" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "Exception" ], [ "CALL_FUNCTION", "tester(Exception)" ], [ "CALL_FUNCTION", "self.assertRaises(tester(Exception))" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(0)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(0)" ], [ "LOAD_GLOBAL", "tester" ], [ "BINARY_TRUE_DIVIDE", "1 / 0" ], [ "CALL_FUNCTION", "tester(1 / 0)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "gen" ], [ "CALL_FUNCTION", "gen()" ], [ "CALL_FUNCTION", "list(gen())" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "gen2" ], [ "CALL_FUNCTION", "list(gen2)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(4)" ], [ "LOAD_GLOBAL", "time" ], [ "LOAD_ATTR", "time.time" ], [ "CALL_FUNCTION", "time.time()" ], [ "LOAD_GLOBAL", "range" ], [ "CALL_FUNCTION", "range(10000)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_ATTR", "Source.executing" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.currentframe" ], [ "CALL_FUNCTION", "inspect.currentframe()" ], [ "CALL_FUNCTION", "Source.executing(inspect.currentframe())" ], [ "LOAD_ATTR", "Source.executing(inspect.currentframe()).node" ], [ "LOAD_FAST", "node" ], [ "COMPARE_OP", "node is None" ], [ "LOAD_FAST", "new_node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertIs" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "new_node" ], [ "CALL_FUNCTION", "self.assertIs(node, new_node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertLess" ], [ "LOAD_GLOBAL", "time" ], [ "LOAD_ATTR", "time.time" ], [ "CALL_FUNCTION", "time.time()" ], [ "LOAD_FAST", "start" ], [ "BINARY_SUBTRACT", "time.time() - start" ], [ "CALL_FUNCTION", "self.assertLess(time.time() - start, 1)" ], [ "LOAD_FAST", "check" ], [ "CALL_FUNCTION", "check(u'# coding=utf8\\n\u00e9', 'utf8')" ], [ "LOAD_FAST", "check" ], [ "CALL_FUNCTION", "check(u'# coding=gbk\\n\u00e9', 'gbk')" ], [ "LOAD_FAST", "check" ], [ "LOAD_GLOBAL", "UnicodeDecodeError" ], [ "CALL_FUNCTION_KW", "check(u'# coding=utf8\\n\u00e9', 'gbk', exception=UnicodeDecodeError)" ], [ "LOAD_FAST", "check" ], [ "CALL_FUNCTION_KW", "check(u'# coding=gbk\\n\u00e9', 'utf8', matches=False)" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_FAST", "check" ], [ "CALL_FUNCTION", "check(u'\u00e9', 'utf8')" ], [ "LOAD_FAST", "check" ], [ "LOAD_GLOBAL", "SyntaxError" ], [ "CALL_FUNCTION_KW", "check(u'\u00e9', 'gbk', exception=SyntaxError)" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.encode" ], [ "LOAD_FAST", "encoding" ], [ "CALL_FUNCTION", "source.encode(encoding)" ], [ "LOAD_FAST", "exception" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.assertRaises" ], [ "LOAD_FAST", "exception" ], [ "CALL_FUNCTION", "self.assertRaises(exception)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_ATTR", "Source.decode_source" ], [ "LOAD_FAST", "encoded" ], [ "CALL_FUNCTION", "Source.decode_source(encoded)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_ATTR", "Source.decode_source" ], [ "LOAD_FAST", "encoded" ], [ "CALL_FUNCTION", "Source.decode_source(encoded)" ], [ "LOAD_FAST", "matches" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.assertEqual" ], [ "LOAD_FAST", "decoded" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "self.assertEqual(decoded, source)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.assertNotEqual" ], [ "LOAD_FAST", "decoded" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "self.assertNotEqual(decoded, source)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('a')" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('''\n ab''')" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('''\n abc\n def\n '''\n )" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n '''\n 123\n 456\n '''\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n '''\n 345\n 456786\n '''\n )" ], [ "CALL_FUNCTION", "str([\n tester(\n '''\n 123\n 456\n '''\n ),\n tester(\n '''\n 345\n 456786\n '''\n ),\n ])" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n [\n '''\n 123\n 456\n '''\n '''\n 345\n 456786\n '''\n ,\n '''\n 123\n 456\n ''',\n '''\n 345\n 456786\n '''\n ]\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(1)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(2)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(3)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_ATTR", "Source.for_filename" ], [ "LOAD_GLOBAL", "__file__" ], [ "CALL_FUNCTION", "Source.for_filename(__file__)" ], [ "LOAD_ATTR", "Source.for_filename(__file__).code_qualname" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.__code__" ], [ "CALL_FUNCTION", "Source.for_filename(__file__).code_qualname(func.__code__)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertEqual" ], [ "LOAD_FAST", "qn" ], [ "LOAD_FAST", "qualname" ], [ "CALL_FUNCTION", "self.assertEqual(qn, qualname)" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_FAST", "check_actual_qualname" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertEqual" ], [ "LOAD_FAST", "qn" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.__qualname__" ], [ "CALL_FUNCTION", "self.assertEqual(qn, func.__qualname__)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertTrue" ], [ "LOAD_FAST", "qn" ], [ "LOAD_ATTR", "qn.endswith" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.__name__" ], [ "CALL_FUNCTION", "qn.endswith(func.__name__)" ], [ "CALL_FUNCTION", "self.assertTrue(qn.endswith(func.__name__))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assert_qualname" ], [ "LOAD_GLOBAL", "C" ], [ "LOAD_ATTR", "C.f" ], [ "CALL_FUNCTION", "self.assert_qualname(C.f, 'C.f')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assert_qualname" ], [ "LOAD_GLOBAL", "C" ], [ "LOAD_ATTR", "C.D" ], [ "LOAD_ATTR", "C.D.g" ], [ "CALL_FUNCTION", "self.assert_qualname(C.D.g, 'C.D.g')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assert_qualname" ], [ "LOAD_GLOBAL", "f" ], [ "CALL_FUNCTION", "self.assert_qualname(f, 'f')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assert_qualname" ], [ "LOAD_GLOBAL", "f" ], [ "CALL_FUNCTION", "f()" ], [ "CALL_FUNCTION", "self.assert_qualname(f(), 'f..g')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assert_qualname" ], [ "LOAD_GLOBAL", "C" ], [ "LOAD_ATTR", "C.D" ], [ "LOAD_ATTR", "C.D.h" ], [ "CALL_FUNCTION", "C.D.h()" ], [ "CALL_FUNCTION", "self.assert_qualname(C.D.h(), 'C.D.h..i..j')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assert_qualname" ], [ "LOAD_GLOBAL", "lamb" ], [ "CALL_FUNCTION", "self.assert_qualname(lamb, '')" ], [ "LOAD_GLOBAL", "lambda_maker" ], [ "CALL_FUNCTION", "lambda_maker()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assert_qualname" ], [ "LOAD_FAST", "foo" ], [ "CALL_FUNCTION", "self.assert_qualname(foo, 'lambda_maker..foo')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assert_qualname" ], [ "LOAD_FAST", "foo" ], [ "LOAD_ATTR", "foo.x" ], [ "CALL_FUNCTION", "self.assert_qualname(foo.x, 'lambda_maker..')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assert_qualname" ], [ "LOAD_FAST", "foo" ], [ "CALL_FUNCTION", "foo()" ], [ "CALL_FUNCTION", "self.assert_qualname(foo(), 'lambda_maker..foo..')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assert_qualname" ], [ "LOAD_FAST", "foo" ], [ "CALL_FUNCTION", "foo()" ], [ "CALL_FUNCTION", "foo()()" ], [ "CALL_FUNCTION_KW", "self.assert_qualname(foo()(), 'lambda_maker..foo..', check_actual_qualname=False)" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "range" ], [ "CALL_FUNCTION", "range(66000)" ], [ "CALL_FUNCTION", "list(range(66000))" ], [ "BINARY_MODULO", "'tester(6)\\n%s\\ntester(9)' % list(range(66000))" ], [ "LOAD_GLOBAL", "tempfile" ], [ "LOAD_ATTR", "tempfile.mkstemp" ], [ "CALL_FUNCTION", "tempfile.mkstemp()" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "compile(source, filename, 'exec')" ], [ "LOAD_GLOBAL", "open" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "open(filename, 'w')" ], [ "LOAD_FAST", "outfile" ], [ "LOAD_ATTR", "outfile.write" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "outfile.write(source)" ], [ "LOAD_GLOBAL", "exec" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "exec(code)" ], [ "LOAD_GLOBAL", "range" ], [ "CALL_FUNCTION", "range(5)" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "n" ], [ "CALL_FUNCTION", "range(n)" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "n == 1" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertEqual" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_FAST", "gen" ], [ "CALL_FUNCTION", "only(gen)" ], [ "CALL_FUNCTION", "self.assertEqual(only(gen), 0)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertRaises" ], [ "LOAD_GLOBAL", "NotOneValueFound" ], [ "CALL_FUNCTION", "self.assertRaises(NotOneValueFound)" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_FAST", "gen" ], [ "CALL_FUNCTION", "only(gen)" ], [ "LOAD_FAST", "i" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.join" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.dirname" ], [ "LOAD_GLOBAL", "__file__" ], [ "CALL_FUNCTION", "os.path.dirname(__file__)" ], [ "CALL_FUNCTION", "os.path.join(os.path.dirname(__file__), 'not_code.txt', )" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_ATTR", "Source.for_filename" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "Source.for_filename(path)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertIsNone" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.tree" ], [ "CALL_FUNCTION", "self.assertIsNone(source.tree)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.currentframe" ], [ "CALL_FUNCTION", "inspect.currentframe()" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_ATTR", "Source.executing" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "Source.executing(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertEqual" ], [ "LOAD_FAST", "executing" ], [ "LOAD_ATTR", "executing.code_qualname" ], [ "CALL_FUNCTION", "executing.code_qualname()" ], [ "CALL_FUNCTION", "self.assertEqual(executing.code_qualname(), 'TestStuff.test_executing_methods')" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.version" ], [ "LOAD_ATTR", "sys.version.lower" ], [ "CALL_FUNCTION", "sys.version.lower()" ], [ "COMPARE_OP", "'pypy' not in sys.version.lower()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertEqual" ], [ "LOAD_FAST", "executing" ], [ "LOAD_ATTR", "executing.text" ], [ "CALL_FUNCTION", "executing.text()" ], [ "LOAD_FAST", "text" ], [ "CALL_FUNCTION", "self.assertEqual(executing.text(), text)" ], [ "LOAD_FAST", "executing" ], [ "LOAD_ATTR", "executing.text_range" ], [ "CALL_FUNCTION", "executing.text_range()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assertEqual" ], [ "LOAD_FAST", "executing" ], [ "LOAD_ATTR", "executing.source" ], [ "LOAD_ATTR", "executing.source.text" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "BINARY_SUBSCR", "executing.source.text[start:end]" ], [ "LOAD_FAST", "text" ], [ "CALL_FUNCTION", "self.assertEqual(executing.source.text[start:end], text)" ], [ "LOAD_GLOBAL", "C" ], [ "CALL_FUNCTION", "C()" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_FAST", "c" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.x" ], [ "LOAD_ATTR", "c.x.x" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.x" ], [ "LOAD_ATTR", "c.x.y" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.y" ], [ "LOAD_ATTR", "c.y.x" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.y" ], [ "LOAD_ATTR", "c.y.y" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.x" ], [ "LOAD_ATTR", "c.x.asd" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.y" ], [ "LOAD_ATTR", "c.y.qwe" ], [ "CALL_FUNCTION", "str((c.x.x, c.x.y, c.y.x, c.y.y, c.x.asd, c.y.qwe))" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_ATTR", "Source.for_frame" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.currentframe" ], [ "CALL_FUNCTION", "inspect.currentframe()" ], [ "CALL_FUNCTION", "Source.for_frame(inspect.currentframe())" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.text" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.filename" ], [ "CALL_FUNCTION", "compile(source.text, source.filename, 'exec')" ], [ "LOAD_GLOBAL", "get_instructions" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "get_instructions(code)" ], [ "LOAD_FAST", "instructions" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.starts_line" ], [ "COMPARE_OP", "inst.starts_line is not None" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.starts_line" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.opname" ], [ "LOAD_ATTR", "inst.opname.startswith" ], [ "CALL_FUNCTION", "inst.opname.startswith(\n ('BINARY_', 'UNARY_', 'LOAD_ATTR', 'LOAD_METHOD', 'LOOKUP_METHOD', 'COMPARE_OP'))" ], [ "LOAD_GLOBAL", "C" ], [ "CALL_FUNCTION", "C()" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.offset" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "frame" ], [ "LOAD_GLOBAL", "globals" ], [ "CALL_FUNCTION", "globals()" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "lineno" ], [ "LOAD_FAST", "frame" ], [ "LOAD_GLOBAL", "print" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.opname" ], [ "CALL_FUNCTION", "print(inst.opname)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_ATTR", "Source.executing" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "Source.executing(frame)" ], [ "LOAD_ATTR", "Source.executing(frame).node" ], [ "COMPARE_OP", "Source.executing(frame).node is not None" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_FAST", "i" ], [ "CALL_FUNCTION", "i()" ], [ "LOAD_FAST", "j" ], [ "LOAD_FAST", "g" ], [ "LOAD_FAST", "assign" ], [ "CALL_FUNCTION", "assign(lambda: 1)" ], [ "CALL_FUNCTION", "assign(lambda: 1)" ], [ "LOAD_FAST", "foo" ], [ "LOAD_FAST", "decorator" ], [ "LOAD_DEREF", "x" ], [ "LOAD_FAST", "func" ], [ "LOAD_FAST", "func" ], [ "LOAD_NAME", "__add__" ], [ "LOAD_NAME", "__invert__" ], [ "LOAD_NAME", "__lt__" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.currentframe" ], [ "CALL_FUNCTION", "inspect.currentframe()" ], [ "LOAD_ATTR", "inspect.currentframe().f_back" ], [ "LOAD_ATTR", "inspect.currentframe().f_back.f_back" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_ATTR", "Source.lazycache" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "Source.lazycache(frame)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_ATTR", "Source.executing" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "Source.executing(frame)" ], [ "LOAD_ATTR", "Source.executing(frame).node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "typ" ], [ "CALL_FUNCTION", "isinstance(node, typ)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "typ" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.currentframe" ], [ "CALL_FUNCTION", "inspect.currentframe()" ], [ "LOAD_ATTR", "inspect.currentframe().f_back" ], [ "LOAD_ATTR", "inspect.currentframe().f_back.f_back" ], [ "LOAD_GLOBAL", "eval" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Expression" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ast.Expression(node)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_filename" ], [ "CALL_FUNCTION", "compile(ast.Expression(node), frame.f_code.co_filename, 'eval')" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "CALL_FUNCTION", "eval(\n compile(ast.Expression(node), frame.f_code.co_filename, 'eval'),\n frame.f_globals,\n frame.f_locals,\n )" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "value" ], [ "COMPARE_OP", "result == value" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Call" ], [ "CALL_FUNCTION", "self.get_node(ast.Call)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.check" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.args" ], [ "BINARY_SUBSCR", "call.args[0]" ], [ "LOAD_FAST", "arg" ], [ "CALL_FUNCTION", "self.check(call.args[0], arg)" ], [ "LOAD_FAST", "check_func" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.check" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.func" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "self.check(call.func, self)" ], [ "LOAD_FAST", "returns" ], [ "COMPARE_OP", "returns is None" ], [ "LOAD_FAST", "arg" ], [ "LOAD_FAST", "returns" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Attribute" ], [ "CALL_FUNCTION", "self.get_node(ast.Attribute)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.value" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "self.check(node.value, self)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.attr" ], [ "LOAD_FAST", "item" ], [ "COMPARE_OP", "node.attr == item" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Subscript" ], [ "CALL_FUNCTION", "self.get_node(ast.Subscript)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.value" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "self.check(node.value, self)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.slice" ], [ "LOAD_ATTR", "node.slice.value" ], [ "LOAD_FAST", "item" ], [ "CALL_FUNCTION", "self.check(node.slice.value, item)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.BinOp" ], [ "CALL_FUNCTION", "self.get_node(ast.BinOp)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.left" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "self.check(node.left, self)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.right" ], [ "LOAD_FAST", "other" ], [ "CALL_FUNCTION", "self.check(node.right, other)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.UnaryOp" ], [ "CALL_FUNCTION", "self.get_node(ast.UnaryOp)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.operand" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "self.check(node.operand, self)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Compare" ], [ "CALL_FUNCTION", "self.get_node(ast.Compare)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.left" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "self.check(node.left, self)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.comparators" ], [ "BINARY_SUBSCR", "node.comparators[0]" ], [ "LOAD_FAST", "other" ], [ "CALL_FUNCTION", "self.check(node.comparators[0], other)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "func" ], [ "LOAD_GLOBAL", "empty_decorator" ] ], "tracer.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOAD_ATTR", "standard_library.install_aliases" ], [ "CALL_FUNCTION", "standard_library.install_aliases()" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "NamedTuple" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "Union" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "BINARY_SUBSCR", "Union[ast.expr, ast.stmt]" ], [ "BINARY_SUBSCR", "Optional[Union[ast.expr, ast.stmt]]" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.AST" ], [ "LOAD_NAME", "FrameType" ], [ "LOAD_NAME", "FrameType" ], [ "CALL_FUNCTION", "NamedTuple('EnterCallInfo', [\n\n # Node from where the call was made\n ('call_node', Optional[Union[ast.expr, ast.stmt]]),\n\n # Node where the call begins\n ('enter_node', ast.AST),\n\n # Frame from which the call was made\n ('caller_frame', FrameType),\n\n # Frame of the call\n ('current_frame', FrameType)])" ], [ "LOAD_NAME", "NamedTuple" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "Union" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "BINARY_SUBSCR", "Union[ast.expr, ast.stmt]" ], [ "BINARY_SUBSCR", "Optional[Union[ast.expr, ast.stmt]]" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.Return" ], [ "BINARY_SUBSCR", "Optional[ast.Return]" ], [ "LOAD_NAME", "FrameType" ], [ "LOAD_NAME", "FrameType" ], [ "LOAD_NAME", "Any" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "Exception" ], [ "BINARY_SUBSCR", "Optional[Exception]" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "TracebackType" ], [ "BINARY_SUBSCR", "Optional[TracebackType]" ], [ "CALL_FUNCTION", "NamedTuple('ExitCallInfo', [\n\n # Node from where the call was made\n ('call_node', Optional[Union[ast.expr, ast.stmt]]),\n\n # Node where the call explicitly returned\n ('return_node', Optional[ast.Return]),\n\n # Frame from which the call was made\n ('caller_frame', FrameType),\n\n # Frame of the call\n ('current_frame', FrameType),\n\n # Node where the call explicitly returned\n ('return_value', Any),\n\n # Exception raised in the call causing it to end,\n # will propagate to the caller\n ('exc_value', Optional[Exception]),\n\n # Traceback corresponding to exc_value\n ('exc_tb', Optional[TracebackType])])" ], [ "LOAD_NAME", "namedtuple" ], [ "CALL_FUNCTION", "namedtuple('ChangeValue', 'value')" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.NodeTransformer" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "Union" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "BINARY_SUBSCR", "Union[ast.For, ast.While, ast.comprehension]" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.PyCF_ONLY_AST" ], [ "LOAD_FAST", "flags" ], [ "BINARY_OR", "ast.PyCF_ONLY_AST | flags" ], [ "CALL_FUNCTION_KW", "compile(source, filename, 'exec', ast.PyCF_ONLY_AST | flags, dont_inherit=True)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.set_basic_node_attributes" ], [ "CALL_FUNCTION", "self.set_basic_node_attributes()" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.parse_extra" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "tracer.parse_extra(self.root, source, filename)" ], [ "LOAD_FAST", "new_root" ], [ "COMPARE_OP", "new_root is not None" ], [ "LOAD_FAST", "new_root" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.set_basic_node_attributes" ], [ "CALL_FUNCTION", "self.set_basic_node_attributes()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.set_enter_call_nodes" ], [ "CALL_FUNCTION", "self.set_enter_call_nodes()" ], [ "LOAD_GLOBAL", "deepcopy" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "CALL_FUNCTION", "deepcopy(self.root)" ], [ "LOAD_GLOBAL", "_NodeVisitor" ], [ "CALL_FUNCTION", "_NodeVisitor()" ], [ "LOAD_ATTR", "_NodeVisitor().visit" ], [ "LOAD_FAST", "new_root" ], [ "CALL_FUNCTION", "_NodeVisitor().visit(new_root)" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "new_root" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "flags" ], [ "CALL_FUNCTION_KW", "compile(new_root, filename, \"exec\", dont_inherit=True, flags=flags)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.walk" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "CALL_FUNCTION", "ast.walk(self.root)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.iter_child_nodes" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ast.iter_child_nodes(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.nodes" ], [ "CALL_FUNCTION", "len(self.nodes)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.nodes" ], [ "LOAD_ATTR", "self.nodes.append" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "self.nodes.append(node)" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "LOAD_ATTR", "self.root.body" ], [ "CALL_FUNCTION", "enumerate(self.root.body)" ], [ "LOAD_GLOBAL", "is_future_import" ], [ "LOAD_FAST", "stmt" ], [ "CALL_FUNCTION", "is_future_import(stmt)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "LOAD_ATTR", "self.root.body" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "self.root.body[:i + 1]" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.walk" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "ast.walk(s)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.nodes" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Module" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(node, (ast.Module, ast.FunctionDef))" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.body" ], [ "LOAD_GLOBAL", "is_future_import" ], [ "LOAD_FAST", "stmt" ], [ "CALL_FUNCTION", "is_future_import(stmt)" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_NAME", "lru_cache" ], [ "CALL_FUNCTION", "lru_cache()" ], [ "CALL_FUNCTION", "lru_cache()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "defaultdict(list)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "TracedFile" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "flags" ], [ "CALL_FUNCTION", "TracedFile(self, source, filename, flags)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._treetrace_hidden_with_stmt" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._treetrace_hidden_before_expr" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._treetrace_hidden_after_expr" ], [ "LOAD_GLOBAL", "partial" ], [ "LOAD_FAST", "f" ], [ "LOAD_DEREF", "traced_file" ], [ "CALL_FUNCTION", "partial(f, traced_file)" ], [ "LOAD_FAST", "f" ], [ "LOAD_ATTR", "f.__name__" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_DEREF", "func" ], [ "LOAD_GLOBAL", "FunctionType" ], [ "CALL_FUNCTION", "isinstance(func, FunctionType)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError('You can only trace user-defined functions. '\n 'The birdseye decorator must be applied first, '\n 'at the bottom of the list.')" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.iscoroutinefunction" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "inspect.iscoroutinefunction(func)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.isasyncgenfunction" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "inspect.isasyncgenfunction(func)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError('You cannot trace async functions')" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_GLOBAL", "is_lambda" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "is_lambda(func)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError('You cannot trace lambdas')" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.getsourcefile" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "inspect.getsourcefile(func)" ], [ "LOAD_GLOBAL", "is_ipython_cell" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "is_ipython_cell(filename)" ], [ "LOAD_FAST", "get_ipython" ], [ "CALL_FUNCTION", "get_ipython()" ], [ "LOAD_ATTR", "get_ipython().compile" ], [ "LOAD_ATTR", "get_ipython().compile.flags" ], [ "LOAD_ATTR", "''.join" ], [ "LOAD_FAST", "linecache" ], [ "LOAD_ATTR", "linecache.cache" ], [ "LOAD_FAST", "filename" ], [ "BINARY_SUBSCR", "linecache.cache[filename]" ], [ "BINARY_SUBSCR", "linecache.cache[filename][2]" ], [ "CALL_FUNCTION", "''.join(linecache.cache[filename][2])" ], [ "LOAD_GLOBAL", "read_source_file" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "read_source_file(filename)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "flags" ], [ "CALL_FUNCTION", "self.compile(source, filename, flags)" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__dict__" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError('The birdseye decorator must be applied first, '\n 'at the bottom of the list.')" ], [ "LOAD_DEREF", "find_code" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.code" ], [ "CALL_FUNCTION", "find_code(traced_file.code)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_DEREF", "code_options" ], [ "CALL_FUNCTION", "len(code_options)" ], [ "COMPARE_OP", "len(code_options) > 1" ], [ "LOAD_GLOBAL", "is_lambda" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "is_lambda(func)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError(\"Failed to trace lambda. Convert the function to a def.\")" ], [ "LOAD_DEREF", "code_options" ], [ "BINARY_SUBSCR", "code_options[0]" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__globals__" ], [ "LOAD_ATTR", "func.__globals__.update" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._trace_methods_dict" ], [ "LOAD_FAST", "traced_file" ], [ "CALL_FUNCTION", "self._trace_methods_dict(traced_file)" ], [ "CALL_FUNCTION", "func.__globals__.update(self._trace_methods_dict(traced_file))" ], [ "LOAD_GLOBAL", "FunctionType" ], [ "LOAD_FAST", "new_func_code" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__globals__" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__name__" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__defaults__" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__closure__" ], [ "CALL_FUNCTION", "FunctionType(new_func_code, func.__globals__, func.__name__, func.__defaults__, func.__closure__)" ], [ "LOAD_GLOBAL", "update_wrapper" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "update_wrapper(new_func, func)" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "getattr(func, '__kwdefaults__', None)" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_FAST", "root_code" ], [ "LOAD_ATTR", "root_code.co_consts" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.iscode" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "inspect.iscode(const)" ], [ "LOAD_FAST", "const" ], [ "LOAD_ATTR", "const.co_firstlineno" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__code__" ], [ "LOAD_ATTR", "func.__code__.co_firstlineno" ], [ "COMPARE_OP", "const.co_firstlineno == func.__code__.co_firstlineno" ], [ "LOAD_FAST", "const" ], [ "LOAD_ATTR", "const.co_name" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__code__" ], [ "LOAD_ATTR", "func.__code__.co_name" ], [ "COMPARE_OP", "const.co_name == func.__code__.co_name" ], [ "LOAD_FAST", "matches" ], [ "LOAD_DEREF", "code_options" ], [ "LOAD_ATTR", "code_options.append" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "code_options.append(const)" ], [ "LOAD_DEREF", "find_code" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "find_code(const)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.isclass" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "inspect.isclass(func)" ], [ "LOAD_GLOBAL", "TypeError" ], [ "CALL_FUNCTION", "TypeError('Decorating classes is no longer supported')" ], [ "LOAD_FAST", "func" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.trace_function" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "self.trace_function(func)" ], [ "LOAD_FAST", "optional" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.trace_function" ], [ "LOAD_FAST", "decorator" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.trace_function" ], [ "LOAD_DEREF", "actual_func" ], [ "CALL_FUNCTION", "self.trace_function(actual_func)" ], [ "LOAD_GLOBAL", "wraps" ], [ "LOAD_DEREF", "actual_func" ], [ "CALL_FUNCTION", "wraps(actual_func)" ], [ "CALL_FUNCTION", "wraps(actual_func)" ], [ "LOAD_FAST", "wrapper" ], [ "LOAD_FAST", "kwargs" ], [ "LOAD_ATTR", "kwargs.pop" ], [ "CALL_FUNCTION", "kwargs.pop('trace_call', False)" ], [ "LOAD_FAST", "trace_call" ], [ "LOAD_DEREF", "traced" ], [ "LOAD_DEREF", "actual_func" ], [ "LOAD_FAST", "f" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "f(*args, **kwargs)" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys._getframe" ], [ "CALL_FUNCTION", "sys._getframe(2)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.secondary_to_main_frames" ], [ "LOAD_ATTR", "self.secondary_to_main_frames.get" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "self.secondary_to_main_frames.get(frame)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "COMPARE_OP", "frame.f_code.co_name in ('', '', '')" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_GLOBAL", "ancestors" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ancestors(node)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Lambda" ], [ "CALL_FUNCTION", "isinstance(node, (ast.FunctionDef, ast.Lambda))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.ClassDef" ], [ "CALL_FUNCTION", "isinstance(node, ast.ClassDef)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "COMPARE_OP", "frame.f_code.co_name in ('', '')" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.secondary_to_main_frames" ], [ "LOAD_FAST", "original_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.main_to_secondary_frames" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.main_to_secondary_frames[frame]" ], [ "LOAD_ATTR", "self.main_to_secondary_frames[frame].append" ], [ "LOAD_FAST", "original_frame" ], [ "CALL_FUNCTION", "self.main_to_secondary_frames[frame].append(original_frame)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.nodes" ], [ "LOAD_FAST", "_tree_index" ], [ "BINARY_SUBSCR", "traced_file.nodes[_tree_index]" ], [ "LOAD_GLOBAL", "cast" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "cast(ast.stmt, node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._main_frame" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "self._main_frame(node)" ], [ "LOAD_GLOBAL", "_StmtContext" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "_StmtContext(self, node, frame)" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.nodes" ], [ "LOAD_FAST", "_tree_index" ], [ "BINARY_SUBSCR", "traced_file.nodes[_tree_index]" ], [ "LOAD_GLOBAL", "cast" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "cast(ast.expr, node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._main_frame" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "self._main_frame(node)" ], [ "LOAD_FAST", "frame" ], [ "COMPARE_OP", "frame is None" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_stack" ], [ "LOAD_ATTR", "frame_info.expression_stack.append" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "frame_info.expression_stack.append(node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.before_expr" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "self.before_expr(node, frame)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._main_frame" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "self._main_frame(node)" ], [ "LOAD_FAST", "frame" ], [ "COMPARE_OP", "frame is None" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._after_expr" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "self._after_expr(node, frame, value, None, None)" ], [ "LOAD_FAST", "result" ], [ "COMPARE_OP", "result is not None" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "ChangeValue" ], [ "CALL_FUNCTION", "isinstance(result, ChangeValue)" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.value" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_stack" ], [ "LOAD_ATTR", "frame_info.expression_stack.pop" ], [ "CALL_FUNCTION", "frame_info.expression_stack.pop()" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_values" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.after_expr" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "exc_value" ], [ "LOAD_FAST", "exc_tb" ], [ "CALL_FUNCTION", "self.after_expr(node, frame, value, exc_value, exc_tb)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._get_caller_stuff" ], [ "LOAD_FAST", "current_frame" ], [ "CALL_FUNCTION", "self._get_caller_stuff(current_frame)" ], [ "LOAD_GLOBAL", "FrameInfo" ], [ "CALL_FUNCTION", "FrameInfo()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "current_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.enter_call" ], [ "LOAD_GLOBAL", "EnterCallInfo" ], [ "LOAD_FAST", "call_node" ], [ "LOAD_FAST", "enter_node" ], [ "LOAD_FAST", "caller_frame" ], [ "LOAD_FAST", "current_frame" ], [ "CALL_FUNCTION", "EnterCallInfo(call_node, enter_node, caller_frame, current_frame)" ], [ "CALL_FUNCTION", "self.enter_call(EnterCallInfo(call_node, enter_node, caller_frame, current_frame))" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.secondary_to_main_frames" ], [ "LOAD_ATTR", "self.secondary_to_main_frames.get" ], [ "LOAD_FAST", "caller_frame" ], [ "CALL_FUNCTION", "self.secondary_to_main_frames.get(caller_frame)" ], [ "LOAD_FAST", "main_frame" ], [ "LOAD_FAST", "main_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "caller_frame" ], [ "BINARY_SUBSCR", "self.stack[caller_frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_stack" ], [ "LOAD_FAST", "expression_stack" ], [ "LOAD_FAST", "expression_stack" ], [ "BINARY_SUBSCR", "expression_stack[-1]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.statement_stack" ], [ "BINARY_SUBSCR", "frame_info.statement_stack[-1]" ], [ "LOAD_FAST", "caller_frame" ], [ "LOAD_FAST", "call_node" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "getattr(node, '_visit_ignore', False)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "CALL_FUNCTION", "isinstance(node, ast.expr)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "hasattr(node, \"ctx\")" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.ctx" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Load" ], [ "CALL_FUNCTION", "isinstance(node.ctx, ast.Load)" ], [ "UNARY_NOT", "not isinstance(node.ctx, ast.Load)" ], [ "UNARY_NOT", "not (hasattr(node, \"ctx\") and not isinstance(node.ctx, ast.Load))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "ast" ], [ "CALL_FUNCTION", "getattr(ast, 'Starred', ())" ], [ "CALL_FUNCTION", "isinstance(node, getattr(ast, 'Starred', ()))" ], [ "UNARY_NOT", "not isinstance(node, getattr(ast, 'Starred', ()))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.visit_expr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "self.visit_expr(node)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "CALL_FUNCTION", "isinstance(node, ast.stmt)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.visit_stmt" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "self.visit_stmt(node)" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "_NodeVisitor" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self)" ], [ "LOAD_ATTR", "super(_NodeVisitor, self).generic_visit" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self).generic_visit(node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._create_simple_marker_call" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "TreeTracerBase" ], [ "LOAD_ATTR", "TreeTracerBase._treetrace_hidden_before_expr" ], [ "CALL_FUNCTION", "self._create_simple_marker_call(node, TreeTracerBase._treetrace_hidden_before_expr)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.copy_location" ], [ "LOAD_FAST", "before_marker" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ast.copy_location(before_marker, node)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Call" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Name" ], [ "LOAD_GLOBAL", "TreeTracerBase" ], [ "LOAD_ATTR", "TreeTracerBase._treetrace_hidden_after_expr" ], [ "LOAD_ATTR", "TreeTracerBase._treetrace_hidden_after_expr.__name__" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Load" ], [ "CALL_FUNCTION", "ast.Load()" ], [ "CALL_FUNCTION_KW", "ast.Name(id=TreeTracerBase._treetrace_hidden_after_expr.__name__,\n ctx=ast.Load())" ], [ "LOAD_FAST", "before_marker" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "_NodeVisitor" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self)" ], [ "LOAD_ATTR", "super(_NodeVisitor, self).generic_visit" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self).generic_visit(node)" ], [ "CALL_FUNCTION_KW", "ast.Call(\n func=ast.Name(id=TreeTracerBase._treetrace_hidden_after_expr.__name__,\n ctx=ast.Load()),\n args=[\n before_marker,\n super(_NodeVisitor, self).generic_visit(node),\n ],\n keywords=[],\n )" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.copy_location" ], [ "LOAD_FAST", "after_marker" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ast.copy_location(after_marker, node)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.fix_missing_locations" ], [ "LOAD_FAST", "after_marker" ], [ "CALL_FUNCTION", "ast.fix_missing_locations(after_marker)" ], [ "LOAD_FAST", "after_marker" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._create_simple_marker_call" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "_NodeVisitor" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self)" ], [ "LOAD_ATTR", "super(_NodeVisitor, self).generic_visit" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self).generic_visit(node)" ], [ "LOAD_GLOBAL", "TreeTracerBase" ], [ "LOAD_ATTR", "TreeTracerBase._treetrace_hidden_with_stmt" ], [ "CALL_FUNCTION", "self._create_simple_marker_call(\n super(_NodeVisitor, self).generic_visit(node),\n TreeTracerBase._treetrace_hidden_with_stmt)" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.With" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.withitem" ], [ "LOAD_FAST", "context_expr" ], [ "CALL_FUNCTION_KW", "ast.withitem(context_expr=context_expr)" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION_KW", "ast.With(\n items=[ast.withitem(context_expr=context_expr)],\n body=[node],\n )" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.With" ], [ "LOAD_FAST", "context_expr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION_KW", "ast.With(\n context_expr=context_expr,\n body=[node],\n )" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.copy_location" ], [ "LOAD_FAST", "wrapped" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ast.copy_location(wrapped, node)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.fix_missing_locations" ], [ "LOAD_FAST", "wrapped" ], [ "CALL_FUNCTION", "ast.fix_missing_locations(wrapped)" ], [ "LOAD_FAST", "wrapped" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Call" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Name" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.__name__" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Load" ], [ "CALL_FUNCTION", "ast.Load()" ], [ "CALL_FUNCTION_KW", "ast.Name(id=func.__name__,\n ctx=ast.Load())" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Num" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "CALL_FUNCTION", "ast.Num(node._tree_index)" ], [ "CALL_FUNCTION_KW", "ast.Call(\n func=ast.Name(id=func.__name__,\n ctx=ast.Load()),\n args=[ast.Num(node._tree_index)],\n keywords=[],\n )" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tracer" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "getattr(node, '_enter_call_node', False)" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer._enter_call" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "tracer._enter_call(node, frame)" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "tracer.stack[frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.statement_stack" ], [ "LOAD_ATTR", "frame_info.statement_stack.append" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "frame_info.statement_stack.append(node)" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.before_stmt" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "tracer.before_stmt(node, frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tracer" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "tracer.stack[frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.statement_stack" ], [ "LOAD_ATTR", "frame_info.statement_stack.pop" ], [ "CALL_FUNCTION", "frame_info.statement_stack.pop()" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.exc_value" ], [ "COMPARE_OP", "exc_val is not frame_info.exc_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_stack" ], [ "LOAD_FAST", "expression_stack" ], [ "LOAD_FAST", "expression_stack" ], [ "BINARY_SUBSCR", "expression_stack[-1]" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer._after_expr" ], [ "LOAD_FAST", "exc_node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "exc_tb" ], [ "CALL_FUNCTION", "tracer._after_expr(exc_node, frame, None, exc_val, exc_tb)" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.after_stmt" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "exc_tb" ], [ "LOAD_FAST", "exc_node" ], [ "CALL_FUNCTION", "tracer.after_stmt(node, frame, exc_val, exc_tb, exc_node)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Return" ], [ "CALL_FUNCTION", "isinstance(node, ast.Return)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.return_node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Module" ], [ "CALL_FUNCTION", "isinstance(parent, (ast.FunctionDef, ast.Module))" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.body" ], [ "BINARY_SUBSCR", "parent.body[-1]" ], [ "COMPARE_OP", "node is parent.body[-1]" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_FAST", "exiting" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer._get_caller_stuff" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "tracer._get_caller_stuff(frame)" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_ATTR", "return_node.value" ], [ "LOAD_FAST", "exc_val" ], [ "UNARY_NOT", "not exc_val" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_values" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_ATTR", "return_node.value" ], [ "BINARY_SUBSCR", "frame_info.expression_values[return_node.value]" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.exit_call" ], [ "LOAD_GLOBAL", "ExitCallInfo" ], [ "LOAD_FAST", "call_node" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_FAST", "caller_frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "return_value" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "exc_tb" ], [ "CALL_FUNCTION", "ExitCallInfo(call_node,\n return_node,\n caller_frame,\n frame,\n return_value,\n exc_val,\n exc_tb\n )" ], [ "CALL_FUNCTION", "tracer.exit_call(ExitCallInfo(call_node,\n return_node,\n caller_frame,\n frame,\n return_value,\n exc_val,\n exc_tb\n ))" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.stack" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tracer" ], [ "LOAD_ATTR", "self.tracer.main_to_secondary_frames" ], [ "LOAD_ATTR", "self.tracer.main_to_secondary_frames.pop" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "self.tracer.main_to_secondary_frames.pop(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tracer" ], [ "LOAD_ATTR", "self.tracer.secondary_to_main_frames" ], [ "LOAD_FAST", "secondary_frame" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(parent, ast.FunctionDef)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "CALL_FUNCTION", "isinstance(parent, ast.For)" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.iter" ], [ "LOAD_DEREF", "node" ], [ "COMPARE_OP", "parent.iter is not node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "CALL_FUNCTION", "isinstance(parent, ast.While)" ], [ "LOAD_DEREF", "node" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.orelse" ], [ "COMPARE_OP", "node not in parent.orelse" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "CALL_FUNCTION", "isinstance(parent, ast.comprehension)" ], [ "LOAD_DEREF", "node" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.ifs" ], [ "COMPARE_OP", "node in parent.ifs" ], [ "LOAD_FAST", "is_containing_loop" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.append" ], [ "LOAD_FAST", "parent" ], [ "CALL_FUNCTION", "result.append(parent)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.ListComp" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.GeneratorExp" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.DictComp" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.SetComp" ], [ "CALL_FUNCTION", "isinstance(parent, (ast.ListComp,\n ast.GeneratorExp,\n ast.DictComp,\n ast.SetComp))" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.generators" ], [ "LOAD_DEREF", "node" ], [ "LOAD_FAST", "generators" ], [ "COMPARE_OP", "node in generators" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "takewhile" ], [ "LOAD_FAST", "generators" ], [ "CALL_FUNCTION", "takewhile(lambda n: n != node, generators)" ], [ "CALL_FUNCTION", "list(takewhile(lambda n: n != node, generators))" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.extend" ], [ "LOAD_GLOBAL", "reversed" ], [ "LOAD_FAST", "generators" ], [ "CALL_FUNCTION", "reversed(generators)" ], [ "CALL_FUNCTION", "result.extend(reversed(generators))" ], [ "LOAD_FAST", "parent" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.reverse" ], [ "CALL_FUNCTION", "result.reverse()" ], [ "LOAD_GLOBAL", "tuple" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "tuple(result)" ], [ "LOAD_FAST", "n" ], [ "LOAD_DEREF", "node" ], [ "COMPARE_OP", "n != node" ] ], "tracer2.py": [ [ "LOAD_NAME", "find_repr_function" ], [ "LOAD_NAME", "six" ], [ "LOAD_ATTR", "six.text_type" ], [ "CALL_FUNCTION", "find_repr_function(six.text_type)" ], [ "LOAD_NAME", "find_repr_function" ], [ "LOAD_NAME", "six" ], [ "LOAD_ATTR", "six.binary_type" ], [ "CALL_FUNCTION", "find_repr_function(six.binary_type)" ], [ "LOAD_NAME", "find_repr_function" ], [ "LOAD_NAME", "object" ], [ "CALL_FUNCTION", "find_repr_function(object)" ], [ "LOAD_NAME", "find_repr_function" ], [ "LOAD_NAME", "int" ], [ "CALL_FUNCTION", "find_repr_function(int)" ], [ "LOAD_NAME", "cheap_repr" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "threading" ], [ "LOAD_ATTR", "threading.local" ], [ "CALL_FUNCTION", "threading.local()" ], [ "LOAD_NAME", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.dirname" ], [ "LOAD_ATTR", "(lambda: 0).__code__" ], [ "LOAD_ATTR", "(lambda: 0).__code__.co_filename" ], [ "CALL_FUNCTION", "os.path.dirname((lambda: 0).__code__.co_filename)" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.dirname" ], [ "LOAD_NAME", "birdseye" ], [ "LOAD_ATTR", "birdseye.__file__" ], [ "CALL_FUNCTION", "os.path.dirname(birdseye.__file__)" ], [ "LOAD_NAME", "type" ], [ "LOAD_NAME", "six" ], [ "LOAD_ATTR", "six.add_metaclass" ], [ "LOAD_NAME", "TracerMeta" ], [ "CALL_FUNCTION", "six.add_metaclass(TracerMeta)" ], [ "LOAD_NAME", "object" ], [ "CALL_FUNCTION", "six.add_metaclass(TracerMeta)" ], [ "LOAD_NAME", "object" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lineno" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "CALL_FUNCTION", "OrderedDict()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_ATTR", "Source.for_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "Source.for_frame(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_flags" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.CO_GENERATOR" ], [ "BINARY_AND", "frame.f_code.co_flags & inspect.CO_GENERATOR" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "is_comprehension_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "is_comprehension_frame(frame)" ], [ "LOAD_GLOBAL", "re" ], [ "LOAD_ATTR", "re.match" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "CALL_FUNCTION", "re.match(r'<(\\w+)comp>', frame.f_code.co_name)" ], [ "LOAD_ATTR", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group" ], [ "CALL_FUNCTION", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group(1)" ], [ "LOAD_ATTR", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group(1).title" ], [ "CALL_FUNCTION", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group(1).title()" ], [ "BINARY_ADD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group(1).title()\n + u' comprehension'" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_lineno" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.local_reprs" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.get_local_reprs" ], [ "LOAD_FAST", "watch" ], [ "LOAD_FAST", "watch_extras" ], [ "CALL_FUNCTION", "self.get_local_reprs(watch, watch_extras)" ], [ "CALL_FUNCTION", "OrderedDict(\n (source, my_cheap_repr(value))\n for source, value in\n self.get_local_reprs(watch, watch_extras)\n )" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.comprehension_type" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.local_reprs" ], [ "LOAD_ATTR", "self.local_reprs.items" ], [ "CALL_FUNCTION", "self.local_reprs.items()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.comprehension_variables" ], [ "LOAD_ATTR", "self.comprehension_variables.setdefault" ], [ "LOAD_FAST", "name" ], [ "CALL_FUNCTION", "self.comprehension_variables.setdefault(name, [])" ], [ "LOAD_FAST", "values" ], [ "UNARY_NOT", "not values" ], [ "LOAD_FAST", "values" ], [ "BINARY_SUBSCR", "values[-1]" ], [ "LOAD_FAST", "value_repr" ], [ "COMPARE_OP", "values[-1] != value_repr" ], [ "LOAD_FAST", "values" ], [ "LOAD_ATTR", "values.append" ], [ "LOAD_FAST", "value_repr" ], [ "CALL_FUNCTION", "values.append(value_repr)" ], [ "LOAD_GLOBAL", "truncate_list" ], [ "LOAD_FAST", "values" ], [ "CALL_FUNCTION", "truncate_list(values, 11)" ], [ "LOAD_FAST", "values" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event in ('return', 'exception')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.comprehension_variables" ], [ "LOAD_ATTR", "self.comprehension_variables.items" ], [ "CALL_FUNCTION", "self.comprehension_variables.items()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.local_reprs" ], [ "LOAD_ATTR", "self.local_reprs.items" ], [ "CALL_FUNCTION", "self.local_reprs.items()" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "old_local_reprs" ], [ "COMPARE_OP", "name not in old_local_reprs" ], [ "LOAD_FAST", "old_local_reprs" ], [ "LOAD_FAST", "name" ], [ "BINARY_SUBSCR", "old_local_reprs[name]" ], [ "LOAD_FAST", "value_repr" ], [ "COMPARE_OP", "old_local_reprs[name] != value_repr" ], [ "LOAD_FAST", "variables" ], [ "LOAD_ATTR", "variables.append" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "value_repr" ], [ "CALL_FUNCTION", "variables.append((name, value_repr))" ], [ "LOAD_FAST", "variables" ], [ "LOAD_FAST", "source" ], [ "LOAD_GLOBAL", "my_cheap_repr" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "my_cheap_repr(value)" ], [ "LOAD_FAST", "name" ], [ "LOAD_ATTR", "', '.join" ], [ "LOAD_FAST", "values" ], [ "CALL_FUNCTION", "', '.join(values)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_varnames" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_cellvars" ], [ "BINARY_ADD", "code.co_varnames + code.co_cellvars" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_freevars" ], [ "BINARY_ADD", "code.co_varnames + code.co_cellvars + code.co_freevars" ], [ "LOAD_GLOBAL", "tuple" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "LOAD_ATTR", "frame.f_locals.keys" ], [ "CALL_FUNCTION", "frame.f_locals.keys()" ], [ "CALL_FUNCTION", "tuple(frame.f_locals.keys())" ], [ "BINARY_ADD", "code.co_varnames + code.co_cellvars + code.co_freevars + tuple(frame.f_locals.keys())" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "LOAD_ATTR", "frame.f_locals.items" ], [ "CALL_FUNCTION", "frame.f_locals.items()" ], [ "CALL_FUNCTION_KW", "sorted(\n frame.f_locals.items(),\n key=lambda key_value: vars_order.index(key_value[0])\n )" ], [ "LOAD_FAST", "watch" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_FAST", "variable" ], [ "LOAD_ATTR", "variable.items" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "variable.items(frame)" ], [ "CALL_FUNCTION", "sorted(variable.items(frame))" ], [ "LOAD_FAST", "result_items" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "watch_extras" ], [ "LOAD_FAST", "extra" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "extra(source, value)" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_FAST", "pair" ], [ "COMPARE_OP", "pair is not None" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "pair" ], [ "CALL_FUNCTION", "len(pair)" ], [ "COMPARE_OP", "len(pair) == 2" ], [ "LOAD_FAST", "pair" ], [ "LOAD_DEREF", "vars_order" ], [ "LOAD_ATTR", "vars_order.index" ], [ "LOAD_FAST", "key_value" ], [ "BINARY_SUBSCR", "key_value[0]" ], [ "CALL_FUNCTION", "vars_order.index(key_value[0])" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "TracerMeta" ], [ "LOAD_FAST", "mcs" ], [ "CALL_FUNCTION", "super(TracerMeta, mcs)" ], [ "LOAD_ATTR", "super(TracerMeta, mcs).__new__" ], [ "LOAD_FAST", "mcs" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "super(TracerMeta, mcs).__new__(mcs, *args, **kwargs)" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "result()" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "no_args_decorator" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION", "no_args_decorator(args, kwargs)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_ATTR", "cls.default" ], [ "LOAD_FAST", "args" ], [ "BINARY_SUBSCR", "args[0]" ], [ "CALL_FUNCTION", "cls.default(args[0])" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "TracerMeta" ], [ "LOAD_FAST", "cls" ], [ "CALL_FUNCTION", "super(TracerMeta, cls)" ], [ "LOAD_ATTR", "super(TracerMeta, cls).__call__" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "super(TracerMeta, cls).__call__(*args, **kwargs)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.default" ], [ "LOAD_ATTR", "self.default.__enter__" ], [ "CALL_FUNCTION_KW", "self.default.__enter__(context=1)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.default" ], [ "LOAD_ATTR", "self.default.__exit__" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION_EX", "self.default.__exit__(*args, context=1)" ], [ "LOAD_GLOBAL", "ensure_tuple" ], [ "LOAD_FAST", "watch" ], [ "CALL_FUNCTION", "ensure_tuple(watch)" ], [ "LOAD_GLOBAL", "ensure_tuple" ], [ "LOAD_FAST", "watch_explode" ], [ "CALL_FUNCTION", "ensure_tuple(watch_explode)" ], [ "BINARY_ADD", "[\n v if isinstance(v, BaseVariable) else CommonVariable(v)\n for v in ensure_tuple(watch)\n ] + [\n v if isinstance(v, BaseVariable) else Exploding(v)\n for v in ensure_tuple(watch_explode)\n ]" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "ArgDefaultDict" ], [ "LOAD_GLOBAL", "FrameInfo" ], [ "CALL_FUNCTION", "ArgDefaultDict(FrameInfo)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "depth" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.depth" ], [ "COMPARE_OP", "self.depth >= 1" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "BaseVariable" ], [ "CALL_FUNCTION", "isinstance(v, BaseVariable)" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "CommonVariable" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "CommonVariable(v)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "BaseVariable" ], [ "CALL_FUNCTION", "isinstance(v, BaseVariable)" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "Exploding" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "Exploding(v)" ], [ "LOAD_GLOBAL", "iscoroutinefunction" ], [ "LOAD_DEREF", "function" ], [ "CALL_FUNCTION", "iscoroutinefunction(function)" ], [ "LOAD_GLOBAL", "NotImplementedError" ], [ "CALL_FUNCTION", "NotImplementedError(\"coroutines are not supported, sorry!\")" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.target_codes" ], [ "LOAD_ATTR", "self.target_codes.add" ], [ "LOAD_DEREF", "function" ], [ "LOAD_ATTR", "function.__code__" ], [ "CALL_FUNCTION", "self.target_codes.add(function.__code__)" ], [ "LOAD_GLOBAL", "functools" ], [ "LOAD_ATTR", "functools.wraps" ], [ "LOAD_DEREF", "function" ], [ "CALL_FUNCTION", "functools.wraps(function)" ], [ "CALL_FUNCTION", "functools.wraps(function)" ], [ "LOAD_GLOBAL", "functools" ], [ "LOAD_ATTR", "functools.wraps" ], [ "LOAD_DEREF", "function" ], [ "CALL_FUNCTION", "functools.wraps(function)" ], [ "CALL_FUNCTION", "functools.wraps(function)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.isgeneratorfunction" ], [ "LOAD_DEREF", "function" ], [ "CALL_FUNCTION", "inspect.isgeneratorfunction(function)" ], [ "LOAD_FAST", "generator_wrapper" ], [ "LOAD_FAST", "simple_wrapper" ], [ "LOAD_DEREF", "self" ], [ "LOAD_DEREF", "function" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "function(*args, **kwargs)" ], [ "LOAD_DEREF", "function" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "function(*args, **kwargs)" ], [ "LOAD_FAST", "gen" ], [ "LOAD_ATTR", "gen.send" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "method" ], [ "LOAD_FAST", "incoming" ], [ "CALL_FUNCTION", "method(incoming)" ], [ "LOAD_GLOBAL", "StopIteration" ], [ "LOAD_FAST", "gen" ], [ "LOAD_ATTR", "gen.send" ], [ "LOAD_FAST", "outgoing" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_FAST", "gen" ], [ "LOAD_ATTR", "gen.throw" ], [ "LOAD_FAST", "e" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.enabled" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys._getframe" ], [ "LOAD_FAST", "context" ], [ "BINARY_ADD", "context + 1" ], [ "CALL_FUNCTION", "sys._getframe(context + 1)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._is_internal_frame" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_FUNCTION", "self._is_internal_frame(calling_frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.trace" ], [ "LOAD_FAST", "calling_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.target_frames" ], [ "LOAD_ATTR", "self.target_frames.add" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_FUNCTION", "self.target_frames.add(calling_frame)" ], [ "LOAD_FAST", "calling_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.trace" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_FUNCTION", "self.trace(calling_frame, 'enter', None)" ], [ "LOAD_GLOBAL", "thread_global" ], [ "LOAD_ATTR", "thread_global.__dict__" ], [ "LOAD_ATTR", "thread_global.__dict__.setdefault" ], [ "CALL_FUNCTION", "thread_global.__dict__.setdefault('original_trace_functions', [])" ], [ "LOAD_FAST", "stack" ], [ "LOAD_ATTR", "stack.append" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.gettrace" ], [ "CALL_FUNCTION", "sys.gettrace()" ], [ "CALL_FUNCTION", "stack.append(sys.gettrace())" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.settrace" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.trace" ], [ "CALL_FUNCTION", "sys.settrace(self.trace)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.enabled" ], [ "LOAD_GLOBAL", "thread_global" ], [ "LOAD_ATTR", "thread_global.original_trace_functions" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.settrace" ], [ "LOAD_FAST", "stack" ], [ "LOAD_ATTR", "stack.pop" ], [ "CALL_FUNCTION", "stack.pop()" ], [ "CALL_FUNCTION", "sys.settrace(stack.pop())" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys._getframe" ], [ "LOAD_FAST", "context" ], [ "BINARY_ADD", "context + 1" ], [ "CALL_FUNCTION", "sys._getframe(context + 1)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.trace" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_FUNCTION", "self.trace(calling_frame, 'exit', None)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.target_frames" ], [ "LOAD_ATTR", "self.target_frames.discard" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_FUNCTION", "self.target_frames.discard(calling_frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame_infos" ], [ "LOAD_ATTR", "self.frame_infos.pop" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_FUNCTION", "self.frame_infos.pop(calling_frame, None)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_filename" ], [ "LOAD_ATTR", "frame.f_code.co_filename.startswith" ], [ "LOAD_GLOBAL", "internal_directories" ], [ "CALL_FUNCTION", "frame.f_code.co_filename.startswith(internal_directories)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.target_codes" ], [ "COMPARE_OP", "frame.f_code in self.target_codes" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.target_frames" ], [ "COMPARE_OP", "frame in self.target_frames" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._is_traced_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "self._is_traced_frame(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.depth" ], [ "COMPARE_OP", "self.depth == 1" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._is_internal_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "self._is_internal_frame(frame)" ], [ "LOAD_GLOBAL", "is_comprehension_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "is_comprehension_frame(frame)" ], [ "UNARY_NOT", "not is_comprehension_frame(frame)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_GLOBAL", "is_comprehension_frame" ], [ "LOAD_FAST", "candidate" ], [ "CALL_FUNCTION", "is_comprehension_frame(candidate)" ], [ "LOAD_FAST", "candidate" ], [ "LOAD_ATTR", "candidate.f_back" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._is_traced_frame" ], [ "LOAD_FAST", "candidate" ], [ "CALL_FUNCTION", "self._is_traced_frame(candidate)" ], [ "LOAD_FAST", "candidate" ], [ "LOAD_ATTR", "candidate.f_back" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.depth" ], [ "COMPARE_OP", "i >= self.depth" ], [ "LOAD_FAST", "candidate" ], [ "COMPARE_OP", "candidate is None" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._is_internal_frame" ], [ "LOAD_FAST", "candidate" ], [ "CALL_FUNCTION", "self._is_internal_frame(candidate)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.thread_local" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_ATTR", "thread_local.__dict__" ], [ "LOAD_ATTR", "thread_local.__dict__.setdefault" ], [ "CALL_FUNCTION", "thread_local.__dict__.setdefault('depth', -1)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame_infos" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.frame_infos[frame]" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event in ('call', 'enter')" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.last_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.last_frame" ], [ "LOAD_FAST", "frame" ], [ "COMPARE_OP", "self.config.last_frame is not frame" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.last_line_no" ], [ "LOAD_GLOBAL", "Event" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "event" ], [ "LOAD_FAST", "arg" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_ATTR", "thread_local.depth" ], [ "LOAD_FAST", "line_no" ], [ "CALL_FUNCTION_KW", "Event(frame_info, event, arg, thread_local.depth, line_no=line_no)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.formatter" ], [ "LOAD_ATTR", "self.config.formatter.format_line_only" ], [ "LOAD_FAST", "trace_event" ], [ "CALL_FUNCTION", "self.config.formatter.format_line_only(trace_event)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.write" ], [ "LOAD_FAST", "line" ], [ "CALL_FUNCTION", "self.config.write(line)" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event == 'exception'" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_GLOBAL", "Event" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "event" ], [ "LOAD_FAST", "arg" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_ATTR", "thread_local.depth" ], [ "CALL_FUNCTION", "Event(frame_info, event, arg, thread_local.depth)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "COMPARE_OP", "frame.f_code.co_name == ''" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event not in ('return', 'exception')" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.update_variables" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.watch" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.watch_extras" ], [ "LOAD_FAST", "event" ], [ "CALL_FUNCTION", "frame_info.update_variables(\n self.watch,\n self.config.watch_extras,\n event,\n )" ], [ "LOAD_FAST", "trace_event" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event in ('return', 'exit')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame_infos" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.formatter" ], [ "LOAD_ATTR", "self.config.formatter.format" ], [ "LOAD_FAST", "trace_event" ], [ "CALL_FUNCTION", "self.config.formatter.format(trace_event)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.write" ], [ "LOAD_FAST", "formatted" ], [ "CALL_FUNCTION", "self.config.write(formatted)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.trace" ], [ "LOAD_FAST", "config" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "NO_ASTTOKENS" ], [ "LOAD_GLOBAL", "Exception" ], [ "CALL_FUNCTION", "Exception(\"birdseye doesn't support this version of Python\")" ], [ "LOAD_GLOBAL", "ImportError" ], [ "LOAD_GLOBAL", "Exception" ], [ "CALL_FUNCTION", "Exception(\"You must install birdseye separately to use spy: pip install birdseye\")" ], [ "LOAD_GLOBAL", "no_args_decorator" ], [ "LOAD_DEREF", "args" ], [ "LOAD_DEREF", "kwargs" ], [ "CALL_FUNCTION", "no_args_decorator(args, kwargs)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._trace" ], [ "LOAD_DEREF", "args" ], [ "BINARY_SUBSCR", "args[0]" ], [ "CALL_FUNCTION", "self._trace(args[0])" ], [ "LOAD_FAST", "decorator" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._trace" ], [ "LOAD_FAST", "func" ], [ "LOAD_DEREF", "args" ], [ "LOAD_DEREF", "kwargs" ], [ "CALL_FUNCTION_EX", "self._trace(func, *args, **kwargs)" ], [ "LOAD_FAST", "eye" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "eye(func)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.snoop" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "self.config.snoop(*args, **kwargs)" ], [ "LOAD_DEREF", "traced" ], [ "CALL_FUNCTION", "self.config.snoop(*args, **kwargs)(traced)" ], [ "LOAD_GLOBAL", "functools" ], [ "LOAD_ATTR", "functools.wraps" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "LOAD_FAST", "wrapper" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.enabled" ], [ "LOAD_DEREF", "traced" ], [ "LOAD_DEREF", "func" ], [ "LOAD_FAST", "final_func" ], [ "LOAD_FAST", "func_args" ], [ "LOAD_FAST", "func_kwargs" ], [ "CALL_FUNCTION_EX", "final_func(*func_args, **func_kwargs)" ] ], "utils.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOAD_ATTR", "standard_library.install_aliases" ], [ "CALL_FUNCTION", "standard_library.install_aliases()" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "type" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "version_info" ], [ "LOAD_ATTR", "version_info.major" ], [ "COMPARE_OP", "version_info.major == 2" ], [ "LOAD_NAME", "PY2" ], [ "UNARY_NOT", "not PY2" ], [ "LOAD_NAME", "TypeVar" ], [ "CALL_FUNCTION", "TypeVar('T')" ], [ "LOAD_NAME", "TypeVar" ], [ "CALL_FUNCTION", "TypeVar('RT')" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "unicode" ], [ "LOAD_NAME", "str" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "type" ], [ "LOAD_NAME", "json" ], [ "LOAD_ATTR", "json.JSONEncoder" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_GLOBAL", "ntpath" ], [ "LOAD_ATTR", "ntpath.split" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "ntpath.split(path)" ], [ "LOAD_FAST", "tail" ], [ "LOAD_GLOBAL", "ntpath" ], [ "LOAD_ATTR", "ntpath.basename" ], [ "LOAD_FAST", "head" ], [ "CALL_FUNCTION", "ntpath.basename(head)" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.commonprefix" ], [ "LOAD_FAST", "paths" ], [ "CALL_FUNCTION", "os.path.commonprefix(paths)" ], [ "LOAD_GLOBAL", "ntpath" ], [ "LOAD_ATTR", "ntpath.split" ], [ "LOAD_FAST", "prefix" ], [ "CALL_FUNCTION", "ntpath.split(prefix)" ], [ "BINARY_SUBSCR", "ntpath.split(prefix)[0]" ], [ "LOAD_FAST", "paths" ], [ "BINARY_SUBSCR", "paths[0]" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "prefix" ], [ "CALL_FUNCTION", "len(prefix)" ], [ "BINARY_SUBSCR", "paths[0][len(prefix)]" ], [ "LOAD_FAST", "first_char_after" ], [ "COMPARE_OP", "first_char_after in r'\\/'" ], [ "LOAD_FAST", "first_char_after" ], [ "LOAD_FAST", "prefix" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "COMPARE_OP", "path == IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "all_paths" ], [ "LOAD_GLOBAL", "common_ancestor" ], [ "LOAD_FAST", "all_paths" ], [ "CALL_FUNCTION", "common_ancestor(all_paths)" ], [ "LOAD_FAST", "prefix" ], [ "COMPARE_OP", "prefix in r'\\/'" ], [ "LOAD_GLOBAL", "strip_required_prefix" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "prefix" ], [ "CALL_FUNCTION", "strip_required_prefix(path, prefix)" ], [ "LOAD_GLOBAL", "path_leaf" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "path_leaf(path)" ], [ "LOAD_FAST", "f" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "COMPARE_OP", "f != IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "f" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "COMPARE_OP", "path == IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.sep" ], [ "COMPARE_OP", "os.path.sep == '/'" ], [ "LOAD_FAST", "path" ], [ "LOAD_ATTR", "path.startswith" ], [ "CALL_FUNCTION", "path.startswith('/')" ], [ "UNARY_NOT", "not path.startswith('/')" ], [ "LOAD_FAST", "path" ], [ "BINARY_ADD", "'/' + path" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "type" ], [ "LOAD_FAST", "obj" ], [ "CALL_FUNCTION", "type(obj)" ], [ "LOAD_FAST", "t" ], [ "LOAD_GLOBAL", "types" ], [ "LOAD_ATTR", "types.InstanceType" ], [ "COMPARE_OP", "t is types.InstanceType" ], [ "LOAD_FAST", "obj" ], [ "LOAD_ATTR", "obj.__class__" ], [ "LOAD_FAST", "t" ], [ "LOAD_FAST", "iterable" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_DEREF", "type_or_tuple" ], [ "CALL_FUNCTION", "isinstance(x, type_or_tuple)" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "next" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "next(it)" ], [ "LOAD_GLOBAL", "StopIteration" ], [ "LOAD_GLOBAL", "raise_from" ], [ "LOAD_GLOBAL", "RuntimeError" ], [ "LOAD_FAST", "e" ], [ "CALL_FUNCTION", "raise_from(RuntimeError, e)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "expression" ], [ "CALL_FUNCTION", "hasattr(expression, 'one_or_none')" ], [ "LOAD_FAST", "expression" ], [ "LOAD_ATTR", "expression.one_or_none" ], [ "CALL_FUNCTION", "expression.one_or_none()" ], [ "LOAD_FAST", "expression" ], [ "LOAD_ATTR", "expression.all" ], [ "CALL_FUNCTION", "expression.all()" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "len(result)" ], [ "COMPARE_OP", "len(result) == 0" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "len(result)" ], [ "COMPARE_OP", "len(result) == 1" ], [ "LOAD_FAST", "result" ], [ "BINARY_SUBSCR", "result[0]" ], [ "LOAD_GLOBAL", "Exception" ], [ "CALL_FUNCTION", "Exception(\"There is more than one item returned for the supplied filter\")" ], [ "LOAD_FAST", "lst" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "isinstance(x, list)" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.extend" ], [ "LOAD_GLOBAL", "flatten_list" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "flatten_list(x)" ], [ "CALL_FUNCTION", "result.extend(flatten_list(x))" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.append" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "result.append(x)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "f" ], [ "LOAD_ATTR", "f.__code__" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "LOAD_ATTR", "(lambda: 0).__code__" ], [ "LOAD_ATTR", "(lambda: 0).__code__.co_name" ], [ "COMPARE_OP", "code.co_name == (lambda: 0).__code__.co_name" ], [ "LOAD_FAST", "o" ], [ "LOAD_ATTR", "o.as_json" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "ProtocolEncoder" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(ProtocolEncoder, self)" ], [ "LOAD_ATTR", "super(ProtocolEncoder, self).default" ], [ "LOAD_FAST", "o" ], [ "CALL_FUNCTION", "super(ProtocolEncoder, self).default(o)" ], [ "LOAD_FAST", "method" ], [ "CALL_FUNCTION", "method()" ], [ "LOAD_GLOBAL", "io" ], [ "LOAD_ATTR", "io.open" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "io.open(filename, 'rb')" ], [ "LOAD_GLOBAL", "detect_encoding" ], [ "LOAD_FAST", "fp" ], [ "LOAD_ATTR", "fp.readline" ], [ "CALL_FUNCTION", "detect_encoding(fp.readline)" ], [ "LOAD_FAST", "fp" ], [ "LOAD_ATTR", "fp.seek" ], [ "CALL_FUNCTION", "fp.seek(0)" ], [ "LOAD_GLOBAL", "io" ], [ "LOAD_ATTR", "io.TextIOWrapper" ], [ "LOAD_FAST", "fp" ], [ "LOAD_FAST", "encoding" ], [ "CALL_FUNCTION_KW", "io.TextIOWrapper(fp, encoding, line_buffering=True)" ], [ "LOAD_FAST", "text" ], [ "LOAD_FAST", "text" ], [ "LOAD_FAST", "fp" ], [ "LOAD_ATTR", "fp.close" ], [ "CALL_FUNCTION", "fp.close()" ], [ "LOAD_FAST", "filename" ], [ "LOAD_ATTR", "filename.endswith" ], [ "CALL_FUNCTION", "filename.endswith('.pyc')" ], [ "LOAD_FAST", "filename" ], [ "BINARY_SUBSCR", "filename[:-1]" ], [ "LOAD_GLOBAL", "open_with_encoding_check" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "open_with_encoding_check(filename)" ], [ "LOAD_ATTR", "''.join" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "f" ], [ "CALL_FUNCTION", "enumerate(f)" ], [ "CALL_FUNCTION", "''.join([\n '\\n' if i < 2 and cookie_re.match(line)\n else line\n for i, line in enumerate(f)\n ])" ], [ "LOAD_FAST", "i" ], [ "COMPARE_OP", "i < 2" ], [ "LOAD_DEREF", "cookie_re" ], [ "LOAD_ATTR", "cookie_re.match" ], [ "LOAD_FAST", "line" ], [ "CALL_FUNCTION", "cookie_re.match(line)" ], [ "LOAD_FAST", "line" ], [ "LOAD_GLOBAL", "safe_next" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_ATTR", "tokens.get_tokens" ], [ "LOAD_FAST", "function_node" ], [ "CALL_FUNCTION", "tokens.get_tokens(function_node)" ], [ "CALL_FUNCTION", "safe_next(t for t in tokens.get_tokens(function_node)\n if t.string == 'def' and t.type == token.NAME)" ], [ "LOAD_FAST", "def_token" ], [ "LOAD_ATTR", "def_token.startpos" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_ATTR", "tokens.text" ], [ "LOAD_FAST", "startpos" ], [ "LOAD_FAST", "function_node" ], [ "LOAD_ATTR", "function_node.last_token" ], [ "LOAD_ATTR", "function_node.last_token.endpos" ], [ "BINARY_SUBSCR", "tokens.text[startpos:function_node.last_token.endpos]" ], [ "LOAD_ATTR", "tokens.text[startpos:function_node.last_token.endpos].rstrip" ], [ "CALL_FUNCTION", "tokens.text[startpos:function_node.last_token.endpos].rstrip()" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.startswith" ], [ "CALL_FUNCTION", "source.startswith('def')" ], [ "LOAD_FAST", "startpos" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "t" ], [ "LOAD_ATTR", "t.string" ], [ "COMPARE_OP", "t.string == 'def'" ], [ "LOAD_FAST", "t" ], [ "LOAD_ATTR", "t.type" ], [ "LOAD_GLOBAL", "token" ], [ "LOAD_ATTR", "token.NAME" ], [ "COMPARE_OP", "t.type == token.NAME" ], [ "LOAD_FAST", "t" ], [ "LOAD_FAST", "args" ], [ "LOAD_GLOBAL", "print" ], [ "LOAD_FAST", "arg" ], [ "CALL_FUNCTION", "print(arg)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION", "len(args)" ], [ "COMPARE_OP", "len(args) == 1" ], [ "LOAD_FAST", "args" ], [ "BINARY_SUBSCR", "args[0]" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "filename" ], [ "LOAD_ATTR", "filename.startswith" ], [ "CALL_FUNCTION", "filename.startswith(' max_length" ], [ "LOAD_FAST", "max_length" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "middle" ], [ "CALL_FUNCTION", "len(middle)" ], [ "BINARY_SUBTRACT", "max_length - len(middle)" ], [ "BINARY_FLOOR_DIVIDE", "(max_length - len(middle)) // 2" ], [ "LOAD_FAST", "max_length" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "middle" ], [ "CALL_FUNCTION", "len(middle)" ], [ "BINARY_SUBTRACT", "max_length - len(middle)" ], [ "LOAD_FAST", "left" ], [ "BINARY_SUBTRACT", "max_length - len(middle) - left" ], [ "LOAD_FAST", "seq" ], [ "LOAD_FAST", "left" ], [ "BINARY_SUBSCR", "seq[:left]" ], [ "LOAD_FAST", "middle" ], [ "BINARY_ADD", "seq[:left] + middle" ], [ "LOAD_FAST", "seq" ], [ "LOAD_FAST", "right" ], [ "UNARY_NEGATIVE", "-right" ], [ "BINARY_SUBSCR", "seq[-right:]" ], [ "BINARY_ADD", "seq[:left] + middle + seq[-right:]" ], [ "LOAD_FAST", "seq" ], [ "LOAD_GLOBAL", "truncate" ], [ "LOAD_FAST", "string" ], [ "LOAD_FAST", "max_length" ], [ "CALL_FUNCTION", "truncate(string, max_length, '...')" ], [ "LOAD_GLOBAL", "truncate" ], [ "LOAD_FAST", "lst" ], [ "LOAD_FAST", "max_length" ], [ "CALL_FUNCTION", "truncate(lst, max_length, ['...'])" ], [ "LOAD_FAST", "split" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "six" ], [ "LOAD_ATTR", "six.string_types" ], [ "CALL_FUNCTION", "isinstance(x, six.string_types)" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.replace" ], [ "CALL_FUNCTION", "x.replace(',', ' ')" ], [ "LOAD_ATTR", "x.replace(',', ' ').split" ], [ "CALL_FUNCTION", "x.replace(',', ' ').split()" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "set" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "isinstance(x, (list, set, tuple))" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "tuple" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tuple(x)" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.basename" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_filename" ], [ "CALL_FUNCTION", "os.path.basename(code.co_filename)" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.endswith" ], [ "CALL_FUNCTION", "result.endswith('.pyc')" ], [ "LOAD_FAST", "result" ], [ "BINARY_SUBSCR", "result[:-1]" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "COMPARE_OP", "frame.f_code.co_name in ('', '', '')" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "code('{}.x')" ], [ "LOAD_GLOBAL", "SyntaxError" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "code('({})')" ], [ "LOAD_FAST", "without_parens" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "code('({}).x')" ], [ "COMPARE_OP", "without_parens != code('({}).x')" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "s" ], [ "LOAD_ATTR", "s.format" ], [ "LOAD_DEREF", "source" ], [ "CALL_FUNCTION", "s.format(source)" ], [ "CALL_FUNCTION", "compile(s.format(source), '', 'eval')" ], [ "LOAD_ATTR", "compile(s.format(source), '', 'eval').co_code" ], [ "LOAD_GLOBAL", "needs_parentheses" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "needs_parentheses(source)" ], [ "LOAD_ATTR", "'({})'.format" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "'({})'.format(source)" ], [ "LOAD_FAST", "source" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "REPR_TARGET_LENGTH" ], [ "CALL_FUNCTION_KW", "cheap_repr(x, target_length=REPR_TARGET_LENGTH)" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "ArgDefaultDict" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(ArgDefaultDict, self)" ], [ "LOAD_ATTR", "super(ArgDefaultDict, self).__init__" ], [ "CALL_FUNCTION", "super(ArgDefaultDict, self).__init__()" ], [ "LOAD_FAST", "factory" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.factory" ], [ "LOAD_FAST", "key" ], [ "CALL_FUNCTION", "self.factory(key)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "key" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "lst" ], [ "CALL_FUNCTION", "len(lst)" ], [ "COMPARE_OP", "len(lst) == 1" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "CALL_FUNCTION", "str(i + 1)" ], [ "BINARY_ADD", "' ' + str(i + 1)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_GLOBAL", "os" ], [ "CALL_FUNCTION", "hasattr(os, 'PathLike')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.PathLike" ], [ "CALL_FUNCTION", "isinstance(x, os.PathLike)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "hasattr(x, '__fspath__')" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "hasattr(x, 'open')" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.__class__" ], [ "LOAD_ATTR", "x.__class__.__name__" ], [ "LOAD_ATTR", "x.__class__.__name__.lower" ], [ "CALL_FUNCTION", "x.__class__.__name__.lower()" ], [ "COMPARE_OP", "'path' in x.__class__.__name__.lower()" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION", "len(args)" ], [ "COMPARE_OP", "len(args) == 1" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.isfunction" ], [ "LOAD_FAST", "args" ], [ "BINARY_SUBSCR", "args[0]" ], [ "CALL_FUNCTION", "inspect.isfunction(args[0])" ], [ "LOAD_FAST", "kwargs" ], [ "UNARY_NOT", "not kwargs" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_ADD", "max_length + 2" ], [ "COMPARE_OP", "length <= max_length + 2" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "range(length)" ], [ "LOAD_GLOBAL", "chain" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_FLOOR_DIVIDE", "max_length // 2" ], [ "CALL_FUNCTION", "range(max_length // 2)" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_FLOOR_DIVIDE", "max_length // 2" ], [ "BINARY_SUBTRACT", "length - max_length // 2" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "range(length - max_length // 2,\n length)" ], [ "CALL_FUNCTION", "chain(range(max_length // 2),\n range(length - max_length // 2,\n length))" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "len(x)" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "n == 0" ], [ "LOAD_GLOBAL", "repr" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "repr(x)" ], [ "LOAD_FAST", "helper" ], [ "LOAD_ATTR", "helper.level" ], [ "BINARY_SUBTRACT", "helper.level - 1" ], [ "LOAD_GLOBAL", "_repr_series_one_line" ], [ "LOAD_ATTR", "_repr_series_one_line.maxparts" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "n" ], [ "LOAD_FAST", "maxparts" ], [ "CALL_FUNCTION", "_sample_indices(n, maxparts)" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.index" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "x.index[i:i + 1]" ], [ "LOAD_ATTR", "x.index[i:i + 1].format" ], [ "CALL_FUNCTION_KW", "x.index[i:i + 1].format(sparsify=False)" ], [ "BINARY_SUBSCR", "x.index[i:i + 1].format(sparsify=False)[0]" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.iloc" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "x.iloc[i]" ], [ "LOAD_FAST", "pieces" ], [ "LOAD_ATTR", "pieces.append" ], [ "LOAD_FAST", "k" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "v" ], [ "LOAD_FAST", "newlevel" ], [ "CALL_FUNCTION", "cheap_repr(v, newlevel)" ], [ "BINARY_MODULO", "'%s = %s' % (k, cheap_repr(v, newlevel))" ], [ "CALL_FUNCTION", "pieces.append('%s = %s' % (k, cheap_repr(v, newlevel)))" ], [ "LOAD_FAST", "n" ], [ "LOAD_FAST", "maxparts" ], [ "BINARY_ADD", "maxparts + 2" ], [ "COMPARE_OP", "n > maxparts + 2" ], [ "LOAD_FAST", "pieces" ], [ "LOAD_ATTR", "pieces.insert" ], [ "LOAD_FAST", "maxparts" ], [ "BINARY_FLOOR_DIVIDE", "maxparts // 2" ], [ "CALL_FUNCTION", "pieces.insert(maxparts // 2, '...')" ], [ "LOAD_ATTR", "'; '.join" ], [ "LOAD_FAST", "pieces" ], [ "CALL_FUNCTION", "'; '.join(pieces)" ] ] }executing-0.8.0/tests/sample_results/3.7.json000066400000000000000000021416501410133640400211250ustar00rootroot00000000000000{ "bird.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOAD_METHOD", "standard_library.install_aliases" ], [ "CALL_METHOD", "standard_library.install_aliases()" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "warn_if_outdated" ], [ "LOAD_NAME", "__version__" ], [ "CALL_FUNCTION", "warn_if_outdated('birdseye', __version__)" ], [ "LOAD_NAME", "namedtuple" ], [ "CALL_FUNCTION", "namedtuple('CodeInfo', 'db_func traced_file arg_names')" ], [ "LOAD_NAME", "TreeTracerBase" ], [ "LOAD_NAME", "BirdsEye" ], [ "CALL_FUNCTION", "BirdsEye()" ], [ "LOAD_NAME", "NamedTuple" ], [ "LOAD_NAME", "int" ], [ "LOAD_NAME", "bool" ], [ "LOAD_NAME", "int" ], [ "LOAD_NAME", "str" ], [ "CALL_FUNCTION", "NamedTuple('HTMLPosition', [\n ('index', int),\n ('is_start', bool),\n ('depth', int),\n ('html', str),\n])" ], [ "LOAD_NAME", "eye" ], [ "LOAD_ATTR", "eye.enter_call" ], [ "LOAD_ATTR", "eye.enter_call.__code__" ], [ "LOAD_NAME", "eye" ], [ "LOAD_ATTR", "eye.exit_call" ], [ "LOAD_ATTR", "eye.exit_call.__code__" ], [ "LOAD_NAME", "eye" ], [ "LOAD_ATTR", "eye.after_expr" ], [ "LOAD_ATTR", "eye.after_expr.__code__" ], [ "LOAD_NAME", "eye" ], [ "LOAD_ATTR", "eye.after_stmt" ], [ "LOAD_ATTR", "eye.after_stmt.__code__" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "Iterable" ], [ "LOAD_NAME", "Iteration" ], [ "BINARY_SUBSCR", "Iterable[Iteration]" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "TypeRegistry" ], [ "CALL_FUNCTION", "TypeRegistry()" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "try_register_repr" ], [ "CALL_FUNCTION", "try_register_repr('pandas', 'Series')" ], [ "CALL_FUNCTION", "try_register_repr('pandas', 'Series')" ], [ "LOAD_NAME", "cached_property" ], [ "CALL_FUNCTION", "cached_property" ], [ "LOAD_NAME", "lru_cache" ], [ "CALL_FUNCTION", "lru_cache()" ], [ "CALL_FUNCTION", "lru_cache()" ], [ "LOAD_NAME", "retry_db" ], [ "CALL_FUNCTION", "retry_db" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "BirdsEye" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(BirdsEye, self)" ], [ "LOAD_METHOD", "super(BirdsEye, self).__init__" ], [ "CALL_METHOD", "super(BirdsEye, self).__init__()" ], [ "LOAD_FAST", "db_uri" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "num_samples" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "dict" ], [ "CALL_FUNCTION_KW", "dict(\n attributes=50,\n dict=50,\n list=30,\n set=30,\n pandas_rows=20,\n pandas_cols=100,\n )" ], [ "LOAD_GLOBAL", "dict" ], [ "CALL_FUNCTION_KW", "dict(\n attributes=50,\n dict=10,\n list=6,\n set=6,\n pandas_rows=6,\n pandas_cols=10,\n )" ], [ "CALL_FUNCTION_KW", "dict(\n big=dict(\n attributes=50,\n dict=50,\n list=30,\n set=30,\n pandas_rows=20,\n pandas_cols=100,\n ),\n small=dict(\n attributes=50,\n dict=10,\n list=6,\n set=6,\n pandas_rows=6,\n pandas_cols=10,\n ),\n )" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "Database" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._db_uri" ], [ "CALL_FUNCTION", "Database(self._db_uri)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.walk" ], [ "LOAD_FAST", "root" ], [ "CALL_METHOD", "ast.walk(root)" ], [ "LOAD_GLOBAL", "tracer" ], [ "LOAD_METHOD", "tracer.loops" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "tracer.loops(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "CALL_FUNCTION", "isinstance(node, ast.expr)" ], [ "LOAD_GLOBAL", "is_interesting_expression" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "is_interesting_expression(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "BirdsEye" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(BirdsEye, self)" ], [ "LOAD_METHOD", "super(BirdsEye, self).compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "flags" ], [ "CALL_METHOD", "super(BirdsEye, self).compile(source, filename, flags)" ], [ "LOAD_GLOBAL", "ASTTokens" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.root" ], [ "CALL_FUNCTION_KW", "ASTTokens(source, tree=traced_file.root)" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.For)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.body" ], [ "BINARY_SUBSCR", "node.parent.body[0]" ], [ "COMPARE_OP", "node is node.parent.body[0]" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._add_iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self._add_iteration(node._loops, frame)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.While)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.test" ], [ "COMPARE_OP", "node is node.parent.test" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._add_iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self._add_iteration(node._loops, frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_ATTR", "self.stack[frame].iteration" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "loops" ], [ "CALL_FUNCTION", "enumerate(loops)" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.loops" ], [ "LOAD_FAST", "loop_node" ], [ "LOAD_ATTR", "loop_node._tree_index" ], [ "BINARY_SUBSCR", "iteration.loops[loop_node._tree_index]" ], [ "LOAD_FAST", "i" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "loops" ], [ "CALL_FUNCTION", "len(loops)" ], [ "BINARY_SUBTRACT", "len(loops) - 1" ], [ "COMPARE_OP", "i == len(loops) - 1" ], [ "LOAD_FAST", "loop" ], [ "LOAD_METHOD", "loop.append" ], [ "LOAD_GLOBAL", "Iteration" ], [ "CALL_FUNCTION", "Iteration()" ], [ "CALL_METHOD", "loop.append(Iteration())" ], [ "LOAD_FAST", "loop" ], [ "LOAD_METHOD", "loop.last" ], [ "CALL_METHOD", "loop.last()" ], [ "LOAD_GLOBAL", "_tracing_recursively" ], [ "LOAD_DEREF", "frame" ], [ "CALL_FUNCTION", "_tracing_recursively(frame)" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._is_interesting_expression" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "BINARY_SUBSCR", "self._code_infos[frame.f_code]" ], [ "LOAD_ATTR", "self._code_infos[frame.f_code].traced_file" ], [ "LOAD_ATTR", "self._code_infos[frame.f_code].traced_file.is_ipython_cell" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Expr" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.Expr)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.parent" ], [ "LOAD_ATTR", "node.parent.parent.body" ], [ "BINARY_SUBSCR", "node.parent.parent.body[-1]" ], [ "COMPARE_OP", "node.parent is node.parent.parent.body[-1]" ], [ "LOAD_DEREF", "value" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "is_obvious_builtin" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_DEREF", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_ATTR", "self.stack[frame].expression_values" ], [ "LOAD_FAST", "node" ], [ "BINARY_SUBSCR", "self.stack[frame].expression_values[node]" ], [ "CALL_FUNCTION", "is_obvious_builtin(node, self.stack[frame].expression_values[node])" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_DEREF", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_FAST", "exc_value" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self._exception_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_FAST", "exc_value" ], [ "CALL_METHOD", "self._exception_value(node, frame, exc_value)" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOAD_ATTR", "NodeValue.expression" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.num_samples" ], [ "LOAD_DEREF", "value" ], [ "LOAD_GLOBAL", "max" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "CALL_FUNCTION", "len(node._loops)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self._is_first_loop_iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "frame" ], [ "CALL_METHOD", "self._is_first_loop_iteration(node, frame)" ], [ "UNARY_NOT", "not self._is_first_loop_iteration(node, frame)" ], [ "BINARY_MULTIPLY", "len(node._loops) * (not self._is_first_loop_iteration(node, frame))" ], [ "BINARY_SUBTRACT", "3 - len(node._loops) * (not self._is_first_loop_iteration(node, frame))" ], [ "CALL_FUNCTION", "max(1, 3 - len(node._loops) * (not self._is_first_loop_iteration(node, frame)))" ], [ "CALL_FUNCTION_KW", "NodeValue.expression(\n self.num_samples,\n value,\n level=max(1, 3 - len(node._loops) * (not self._is_first_loop_iteration(node, frame))),\n )" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self._set_node_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_FAST", "node_value" ], [ "CALL_METHOD", "self._set_node_value(node, frame, node_value)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self._check_inner_call" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node_value" ], [ "CALL_METHOD", "self._check_inner_call(frame_info, node, node_value)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.comprehension)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.iter" ], [ "COMPARE_OP", "node is node.parent.iter" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.GeneratorExp" ], [ "CALL_FUNCTION", "isinstance(node.parent.parent, ast.GeneratorExp)" ], [ "UNARY_NOT", "not isinstance(node.parent.parent, ast.GeneratorExp)" ], [ "LOAD_FAST", "is_special_comprehension_iter" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self._set_node_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOAD_METHOD", "NodeValue.covered" ], [ "CALL_METHOD", "NodeValue.covered()" ], [ "CALL_METHOD", "self._set_node_value(node.parent, frame, NodeValue.covered())" ], [ "LOAD_FAST", "exc_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "BINARY_ADD", "node._loops + (node.parent,)" ], [ "LOAD_GLOBAL", "ChangeValue" ], [ "LOAD_FAST", "comprehension_iter_proxy" ], [ "CALL_FUNCTION", "comprehension_iter_proxy()" ], [ "CALL_FUNCTION", "ChangeValue(comprehension_iter_proxy())" ], [ "LOAD_DEREF", "value" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self._add_iteration" ], [ "LOAD_DEREF", "loops" ], [ "LOAD_DEREF", "frame" ], [ "CALL_METHOD", "self._add_iteration(loops, frame)" ], [ "LOAD_FAST", "item" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.inner_calls" ], [ "LOAD_METHOD", "frame_info.inner_calls.pop" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "frame_info.inner_calls.pop(node, None)" ], [ "LOAD_FAST", "inner_calls" ], [ "LOAD_FAST", "node_value" ], [ "LOAD_METHOD", "node_value.set_meta" ], [ "LOAD_FAST", "inner_calls" ], [ "CALL_METHOD", "node_value.set_meta('inner_calls', inner_calls)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_ATTR", "self.stack[frame].iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.loops" ], [ "LOAD_FAST", "loop_node" ], [ "LOAD_ATTR", "loop_node._tree_index" ], [ "BINARY_SUBSCR", "iteration.loops[loop_node._tree_index]" ], [ "LOAD_FAST", "loop" ], [ "LOAD_METHOD", "loop.last" ], [ "CALL_METHOD", "loop.last()" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.index" ], [ "COMPARE_OP", "iteration.index > 0" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_ATTR", "self.stack[frame].iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.loops" ], [ "LOAD_FAST", "loop_node" ], [ "LOAD_ATTR", "loop_node._tree_index" ], [ "BINARY_SUBSCR", "iteration.loops[loop_node._tree_index]" ], [ "LOAD_FAST", "loop" ], [ "LOAD_METHOD", "loop.recorded_node" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "loop.recorded_node(node)" ], [ "LOAD_FAST", "loop" ], [ "LOAD_METHOD", "loop.last" ], [ "CALL_METHOD", "loop.last()" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.vals" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOAD_METHOD", "NodeValue.exception" ], [ "LOAD_FAST", "exc_value" ], [ "CALL_METHOD", "NodeValue.exception(exc_value)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._set_node_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "value" ], [ "CALL_METHOD", "self._set_node_value(node, frame, value)" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_GLOBAL", "_tracing_recursively" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "_tracing_recursively(frame)" ], [ "LOAD_FAST", "exc_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "exc_node" ], [ "COMPARE_OP", "node is exc_node" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._exception_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "exc_value" ], [ "CALL_METHOD", "self._exception_value(node, frame, exc_value)" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOAD_METHOD", "NodeValue.covered" ], [ "CALL_METHOD", "NodeValue.covered()" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._set_node_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "value" ], [ "CALL_METHOD", "self._set_node_value(node, frame, value)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._check_inner_call" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "value" ], [ "CALL_METHOD", "self._check_inner_call(self.stack[frame], node, value)" ], [ "LOAD_FAST", "enter_info" ], [ "LOAD_ATTR", "enter_info.current_frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_GLOBAL", "_tracing_recursively" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "_tracing_recursively(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_GLOBAL", "get_unfrozen_datetime" ], [ "CALL_FUNCTION", "get_unfrozen_datetime()" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_GLOBAL", "Iteration" ], [ "CALL_FUNCTION", "Iteration()" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "BINARY_SUBSCR", "self._code_infos[frame.f_code]" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "enter_info" ], [ "LOAD_ATTR", "enter_info.enter_node" ], [ "LOAD_ATTR", "enter_info.enter_node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Module" ], [ "CALL_FUNCTION", "isinstance(enter_info.enter_node.parent, ast.Module)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "LOAD_METHOD", "frame.f_locals.copy" ], [ "CALL_METHOD", "frame.f_locals.copy()" ], [ "LOAD_FAST", "code_info" ], [ "LOAD_ATTR", "code_info.arg_names" ], [ "LOAD_DEREF", "f_locals" ], [ "LOAD_METHOD", "f_locals.items" ], [ "CALL_METHOD", "f_locals.items()" ], [ "BINARY_ADD", "[(name, f_locals.pop(name))\n for name in code_info.arg_names\n if name] + [\n\n # Local variables other than actual arguments. These are variables from\n # the enclosing scope. It's handy to treat them like arguments in the UI\n it for it in f_locals.items()\n if it[0][0] != '.' # Appears when using nested tuple arguments\n ]" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_METHOD", "json.dumps" ], [ "LOAD_FAST", "arguments" ], [ "CALL_METHOD", "json.dumps([[k, cheap_repr(v)] for k, v in arguments])" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._call_id" ], [ "CALL_METHOD", "self._call_id()" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "defaultdict(list)" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_METHOD", "self.stack.get" ], [ "LOAD_FAST", "enter_info" ], [ "LOAD_ATTR", "enter_info.caller_frame" ], [ "CALL_METHOD", "self.stack.get(enter_info.caller_frame)" ], [ "LOAD_FAST", "prev" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "prev" ], [ "CALL_FUNCTION", "getattr(prev, 'inner_calls', None)" ], [ "LOAD_FAST", "inner_calls" ], [ "COMPARE_OP", "inner_calls is not None" ], [ "LOAD_FAST", "inner_calls" ], [ "LOAD_FAST", "enter_info" ], [ "LOAD_ATTR", "enter_info.call_node" ], [ "BINARY_SUBSCR", "inner_calls[enter_info.call_node]" ], [ "LOAD_METHOD", "inner_calls[enter_info.call_node].append" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.call_id" ], [ "CALL_METHOD", "inner_calls[enter_info.call_node].append(frame_info.call_id)" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "name" ], [ "LOAD_DEREF", "f_locals" ], [ "LOAD_METHOD", "f_locals.pop" ], [ "LOAD_FAST", "name" ], [ "CALL_METHOD", "f_locals.pop(name)" ], [ "LOAD_FAST", "it" ], [ "BINARY_SUBSCR", "it[0]" ], [ "BINARY_SUBSCR", "it[0][0]" ], [ "COMPARE_OP", "it[0][0] != '.'" ], [ "LOAD_FAST", "it" ], [ "LOAD_FAST", "k" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "cheap_repr(v)" ], [ "LOAD_GLOBAL", "uuid4" ], [ "CALL_FUNCTION", "uuid4()" ], [ "LOAD_ATTR", "uuid4().hex" ], [ "LOAD_DEREF", "exit_info" ], [ "LOAD_ATTR", "exit_info.current_frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_GLOBAL", "_tracing_recursively" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "_tracing_recursively(frame)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.iteration" ], [ "LOAD_GLOBAL", "_deep_dict" ], [ "CALL_FUNCTION", "_deep_dict()" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self._extract_node_values" ], [ "LOAD_DEREF", "top_iteration" ], [ "LOAD_DEREF", "node_values" ], [ "CALL_METHOD", "self._extract_node_values(top_iteration, (), node_values)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "BINARY_SUBSCR", "self._code_infos[frame.f_code]" ], [ "LOAD_ATTR", "self._code_infos[frame.f_code].db_func" ], [ "LOAD_DEREF", "exit_info" ], [ "LOAD_ATTR", "exit_info.exc_value" ], [ "LOAD_FAST", "exc" ], [ "LOAD_METHOD", "''.join" ], [ "LOAD_GLOBAL", "traceback" ], [ "LOAD_METHOD", "traceback.format_exception" ], [ "LOAD_GLOBAL", "type" ], [ "LOAD_FAST", "exc" ], [ "CALL_FUNCTION", "type(exc)" ], [ "LOAD_FAST", "exc" ], [ "LOAD_DEREF", "exit_info" ], [ "LOAD_ATTR", "exit_info.exc_tb" ], [ "CALL_METHOD", "traceback.format_exception(type(exc), exc, exit_info.exc_tb)" ], [ "CALL_METHOD", "''.join(traceback.format_exception(type(exc), exc, exit_info.exc_tb))" ], [ "LOAD_GLOBAL", "exception_string" ], [ "LOAD_FAST", "exc" ], [ "CALL_FUNCTION", "exception_string(exc)" ], [ "LOAD_GLOBAL", "retry_db" ], [ "CALL_FUNCTION", "retry_db" ], [ "LOAD_FAST", "add_call" ], [ "CALL_FUNCTION", "add_call()" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.call_id" ], [ "LOAD_DEREF", "self" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.db" ], [ "LOAD_ATTR", "self.db.Call" ], [ "LOAD_FAST", "Call" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.call_id" ], [ "LOAD_DEREF", "db_func" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.arguments" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_DEREF", "exit_info" ], [ "LOAD_ATTR", "exit_info.return_value" ], [ "CALL_FUNCTION", "cheap_repr(exit_info.return_value)" ], [ "LOAD_DEREF", "exception" ], [ "LOAD_DEREF", "traceback_str" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_ATTR", "json.dumps" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_DEREF", "node_values" ], [ "LOAD_DEREF", "top_iteration" ], [ "LOAD_METHOD", "top_iteration.extract_iterations" ], [ "CALL_METHOD", "top_iteration.extract_iterations()" ], [ "BINARY_SUBSCR", "top_iteration.extract_iterations()['loops']" ], [ "LOAD_GLOBAL", "type_registry" ], [ "LOAD_METHOD", "type_registry.names" ], [ "CALL_METHOD", "type_registry.names()" ], [ "LOAD_GLOBAL", "type_registry" ], [ "LOAD_ATTR", "type_registry.num_special_types" ], [ "CALL_FUNCTION_KW", "dict(\n node_values=node_values,\n loop_iterations=top_iteration.extract_iterations()['loops'],\n type_names=type_registry.names(),\n num_special_types=type_registry.num_special_types,\n )" ], [ "LOAD_GLOBAL", "ProtocolEncoder" ], [ "CALL_FUNCTION_KW", "json.dumps(\n dict(\n node_values=node_values,\n loop_iterations=top_iteration.extract_iterations()['loops'],\n type_names=type_registry.names(),\n num_special_types=type_registry.num_special_types,\n ),\n cls=ProtocolEncoder,\n separators=(',', ':')\n )" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.start_time" ], [ "CALL_FUNCTION_KW", "Call(id=frame_info.call_id,\n function_id=db_func,\n arguments=frame_info.arguments,\n return_value=cheap_repr(exit_info.return_value),\n exception=exception,\n traceback=traceback_str,\n data=json.dumps(\n dict(\n node_values=node_values,\n loop_iterations=top_iteration.extract_iterations()['loops'],\n type_names=type_registry.names(),\n num_special_types=type_registry.num_special_types,\n ),\n cls=ProtocolEncoder,\n separators=(',', ':')\n ),\n start_time=frame_info.start_time)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.db" ], [ "LOAD_METHOD", "self.db.session_scope" ], [ "CALL_METHOD", "self.db.session_scope()" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.add" ], [ "LOAD_FAST", "call" ], [ "CALL_METHOD", "session.add(call)" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.vals" ], [ "LOAD_METHOD", "iteration.vals.items" ], [ "CALL_METHOD", "iteration.vals.items()" ], [ "LOAD_FAST", "tree_index" ], [ "LOAD_FAST", "path" ], [ "BINARY_ADD", "(tree_index,) + path" ], [ "LOAD_FAST", "node_values" ], [ "LOAD_FAST", "full_path" ], [ "BINARY_SUBSCR", "full_path[:-1]" ], [ "LOAD_FAST", "d" ], [ "LOAD_FAST", "path_k" ], [ "BINARY_SUBSCR", "d[path_k]" ], [ "LOAD_FAST", "node_value" ], [ "LOAD_FAST", "d" ], [ "LOAD_FAST", "full_path" ], [ "BINARY_SUBSCR", "full_path[-1]" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.loops" ], [ "LOAD_METHOD", "iteration.loops.values" ], [ "CALL_METHOD", "iteration.loops.values()" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "loop" ], [ "CALL_FUNCTION", "enumerate(loop)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._extract_node_values" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "path + (i,)" ], [ "LOAD_FAST", "node_values" ], [ "CALL_METHOD", "self._extract_node_values(iteration, path + (i,), node_values)" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "BirdsEye" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(BirdsEye, self)" ], [ "LOAD_METHOD", "super(BirdsEye, self).trace_function" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "super(BirdsEye, self).trace_function(func)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_METHOD", "self._code_infos.get" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_ATTR", "new_func.__code__" ], [ "CALL_METHOD", "self._code_infos.get(new_func.__code__)" ], [ "LOAD_FAST", "code_info" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.getsourcelines" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "inspect.getsourcelines(func)" ], [ "LOAD_FAST", "start_lineno" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "lines" ], [ "CALL_FUNCTION", "len(lines)" ], [ "BINARY_ADD", "start_lineno + len(lines)" ], [ "LOAD_GLOBAL", "safe_qualname" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "safe_qualname(func)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.getsourcefile" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "inspect.getsourcefile(func)" ], [ "LOAD_FAST", "source_file" ], [ "LOAD_METHOD", "source_file.startswith" ], [ "CALL_METHOD", "source_file.startswith('= 0" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.getsourcefile" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "inspect.getsourcefile(frame)" ], [ "LOAD_FAST", "filename" ], [ "COMPARE_OP", "filename is not None" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_METHOD", "os.path.abspath" ], [ "LOAD_FAST", "filename" ], [ "CALL_METHOD", "os.path.abspath(filename)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "LOAD_METHOD", "frame.f_globals.get" ], [ "CALL_METHOD", "frame.f_globals.get('__name__')" ], [ "COMPARE_OP", "frame.f_globals.get('__name__') != '__main__'" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._treetrace_hidden_with_stmt" ], [ "LOAD_ATTR", "self._treetrace_hidden_with_stmt.__name__" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "COMPARE_OP", "self._treetrace_hidden_with_stmt.__name__ not in frame.f_globals" ], [ "LOAD_GLOBAL", "RuntimeError" ], [ "CALL_FUNCTION", "RuntimeError(\n 'To trace an imported module, you must import birdseye before '\n 'importing that module.')" ], [ "LOAD_GLOBAL", "read_source_file" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "read_source_file(filename)" ], [ "LOAD_METHOD", "read_source_file(filename).splitlines" ], [ "CALL_METHOD", "read_source_file(filename).splitlines()" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lineno" ], [ "BINARY_MULTIPLY", "[''] * frame.f_lineno" ], [ "LOAD_FAST", "lines" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lineno" ], [ "LOAD_METHOD", "'\\n'.join" ], [ "LOAD_FAST", "lines" ], [ "CALL_METHOD", "'\\n'.join(lines)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.exec_string" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "LOAD_FAST", "deep" ], [ "CALL_METHOD", "self.exec_string(source, filename, frame.f_globals, frame.f_locals, deep)" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_METHOD", "sys.exit" ], [ "CALL_METHOD", "sys.exit(0)" ], [ "LOAD_FAST", "globs" ], [ "LOAD_FAST", "locs" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self.compile" ], [ "LOAD_DEREF", "source" ], [ "LOAD_DEREF", "filename" ], [ "CALL_METHOD", "self.compile(source, filename)" ], [ "LOAD_FAST", "globs" ], [ "LOAD_METHOD", "globs.update" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self._trace_methods_dict" ], [ "LOAD_DEREF", "traced_file" ], [ "CALL_METHOD", "self._trace_methods_dict(traced_file)" ], [ "CALL_METHOD", "globs.update(self._trace_methods_dict(traced_file))" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self._trace" ], [ "LOAD_GLOBAL", "FILE_SENTINEL_NAME" ], [ "LOAD_DEREF", "filename" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.code" ], [ "LOAD_DEREF", "source" ], [ "CALL_METHOD", "self._trace(FILE_SENTINEL_NAME, filename, traced_file, traced_file.code, 'module', source)" ], [ "LOAD_FAST", "deep" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.nodes" ], [ "LOAD_DEREF", "find_code" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.code" ], [ "CALL_FUNCTION", "find_code(traced_file.code)" ], [ "LOAD_GLOBAL", "exec" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.code" ], [ "LOAD_FAST", "globs" ], [ "LOAD_FAST", "locs" ], [ "CALL_FUNCTION", "exec(traced_file.code, globs, locs)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(node, ast.FunctionDef)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.lineno" ], [ "LOAD_FAST", "root_code" ], [ "LOAD_ATTR", "root_code.co_consts" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.iscode" ], [ "LOAD_FAST", "code" ], [ "CALL_METHOD", "inspect.iscode(code)" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "LOAD_METHOD", "code.co_name.startswith" ], [ "CALL_METHOD", "code.co_name.startswith('<')" ], [ "LOAD_DEREF", "find_code" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "find_code(code)" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_firstlineno" ], [ "LOAD_DEREF", "nodes_by_lineno" ], [ "LOAD_METHOD", "nodes_by_lineno.get" ], [ "LOAD_FAST", "lineno" ], [ "CALL_METHOD", "nodes_by_lineno.get(lineno)" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._trace" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "LOAD_DEREF", "filename" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_FAST", "code" ], [ "LOAD_DEREF", "source" ], [ "LOAD_FAST", "lineno" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.last_token" ], [ "LOAD_ATTR", "node.last_token.end" ], [ "BINARY_SUBSCR", "node.last_token.end[0]" ], [ "BINARY_ADD", "node.last_token.end[0] + 1" ], [ "CALL_FUNCTION_KW", "self._trace(\n code.co_name, filename, traced_file, code,\n typ='function',\n source=source,\n start_lineno=lineno,\n end_lineno=node.last_token.end[0] + 1,\n )" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_DEREF", "start_lineno" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "source" ], [ "LOAD_METHOD", "source.splitlines" ], [ "CALL_METHOD", "source.splitlines()" ], [ "CALL_FUNCTION", "len(source.splitlines())" ], [ "BINARY_ADD", "start_lineno + len(source.splitlines())" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._nodes_of_interest" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_DEREF", "start_lineno" ], [ "LOAD_FAST", "end_lineno" ], [ "CALL_METHOD", "self._nodes_of_interest(traced_file, start_lineno, end_lineno)" ], [ "CALL_FUNCTION", "list(self._nodes_of_interest(traced_file, start_lineno, end_lineno))" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._nodes_html" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_DEREF", "start_lineno" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_FAST", "traced_file" ], [ "CALL_METHOD", "self._nodes_html(nodes, start_lineno, end_lineno, traced_file)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "nodes" ], [ "CALL_FUNCTION_KW", "dict(\n # This maps each node to the loops enclosing that node\n node_loops={\n node._tree_index: [n._tree_index for n in node._loops]\n for node, _ in nodes\n if node._loops\n },\n )" ], [ "LOAD_FAST", "typ" ], [ "COMPARE_OP", "typ == 'function'" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.tokens" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_FAST", "nodes" ], [ "CALL_FUNCTION", "only(node\n for node, _ in nodes\n if isinstance(node, ast.FunctionDef)\n and node.first_token.start[0] == start_lineno)" ], [ "LOAD_GLOBAL", "source_without_decorators" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_FAST", "func_node" ], [ "CALL_FUNCTION", "source_without_decorators(tokens, func_node)" ], [ "LOAD_FAST", "data_dict" ], [ "LOAD_ATTR", "data_dict.update" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._node_ranges" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_FAST", "func_startpos" ], [ "CALL_METHOD", "self._node_ranges(nodes, tokens, func_startpos)" ], [ "CALL_FUNCTION", "list(self._node_ranges(nodes, tokens, func_startpos))" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._loop_ranges" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_FAST", "func_startpos" ], [ "CALL_METHOD", "self._loop_ranges(nodes, tokens, func_startpos)" ], [ "CALL_FUNCTION", "list(self._loop_ranges(nodes, tokens, func_startpos))" ], [ "CALL_FUNCTION_KW", "data_dict.update(\n node_ranges=list(self._node_ranges(nodes, tokens, func_startpos)),\n loop_ranges=list(self._loop_ranges(nodes, tokens, func_startpos)),\n )" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_ATTR", "json.dumps" ], [ "LOAD_FAST", "data_dict" ], [ "CALL_FUNCTION_KW", "json.dumps(data_dict, sort_keys=True)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._db_func" ], [ "LOAD_FAST", "data" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "html_body" ], [ "LOAD_FAST", "name" ], [ "LOAD_DEREF", "start_lineno" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "typ" ], [ "CALL_METHOD", "self._db_func(data, filename, html_body, name, start_lineno, source, typ)" ], [ "LOAD_GLOBAL", "CodeInfo" ], [ "LOAD_FAST", "db_func" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_FAST", "arg_names" ], [ "CALL_FUNCTION", "CodeInfo(db_func, traced_file, arg_names)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_FAST", "n" ], [ "LOAD_ATTR", "n._tree_index" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(node, ast.FunctionDef)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.first_token" ], [ "LOAD_ATTR", "node.first_token.start" ], [ "BINARY_SUBSCR", "node.first_token.start[0]" ], [ "LOAD_DEREF", "start_lineno" ], [ "COMPARE_OP", "node.first_token.start[0] == start_lineno" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "classes" ], [ "COMPARE_OP", "'loop' not in classes" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.target" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.test" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_METHOD", "tokens.get_text_range" ], [ "LOAD_FAST", "target" ], [ "CALL_METHOD", "tokens.get_text_range(target)" ], [ "LOAD_FAST", "func_start" ], [ "LOAD_FAST", "func_start" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "CALL_FUNCTION_KW", "dict(\n tree_index=node._tree_index,\n start=start,\n end=end\n )" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_METHOD", "tokens.get_text_range" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "tokens.get_text_range(node)" ], [ "LOAD_FAST", "func_start" ], [ "LOAD_FAST", "func_start" ], [ "LOAD_FAST", "start" ], [ "COMPARE_OP", "start < 0" ], [ "LOAD_FAST", "end" ], [ "COMPARE_OP", "end < 0" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(node, ast.FunctionDef)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._depth" ], [ "LOAD_FAST", "classes" ], [ "CALL_FUNCTION_KW", "dict(\n tree_index=node._tree_index,\n start=start,\n end=end,\n depth=node._depth,\n classes=classes,\n )" ], [ "LOAD_FAST", "h" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "name" ], [ "BINARY_ADD", "filename + name" ], [ "LOAD_FAST", "html_body" ], [ "BINARY_ADD", "filename + name + html_body" ], [ "LOAD_FAST", "data" ], [ "BINARY_ADD", "filename + name + html_body + data" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "start_lineno" ], [ "CALL_FUNCTION", "str(start_lineno)" ], [ "BINARY_ADD", "filename + name + html_body + data + str(start_lineno)" ], [ "CALL_FUNCTION", "h(filename + name + html_body + data + str(start_lineno))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.db" ], [ "LOAD_ATTR", "self.db.Function" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.db" ], [ "LOAD_METHOD", "self.db.session_scope" ], [ "CALL_METHOD", "self.db.session_scope()" ], [ "LOAD_GLOBAL", "one_or_none" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.query" ], [ "LOAD_FAST", "Function" ], [ "CALL_METHOD", "session.query(Function)" ], [ "LOAD_ATTR", "session.query(Function).filter_by" ], [ "LOAD_FAST", "function_hash" ], [ "CALL_FUNCTION_KW", "session.query(Function).filter_by(hash=function_hash)" ], [ "CALL_FUNCTION", "one_or_none(session.query(Function).filter_by(hash=function_hash))" ], [ "LOAD_FAST", "db_func" ], [ "LOAD_FAST", "Function" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "typ" ], [ "LOAD_FAST", "html_body" ], [ "LOAD_FAST", "start_lineno" ], [ "LOAD_FAST", "data" ], [ "LOAD_FAST", "h" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "h(source)" ], [ "LOAD_FAST", "function_hash" ], [ "CALL_FUNCTION_KW", "Function(file=filename,\n name=name,\n type=typ,\n html_body=html_body,\n lineno=start_lineno,\n data=data,\n body_hash=h(source),\n hash=function_hash)" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.add" ], [ "LOAD_FAST", "db_func" ], [ "CALL_METHOD", "session.add(db_func)" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.commit" ], [ "CALL_METHOD", "session.commit()" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "db_func" ], [ "LOAD_ATTR", "db_func.id" ], [ "LOAD_GLOBAL", "int" ], [ "CALL_FUNCTION", "isinstance(db_func.id, int)" ], [ "LOAD_FAST", "db_func" ], [ "LOAD_ATTR", "db_func.id" ], [ "LOAD_GLOBAL", "hashlib" ], [ "LOAD_METHOD", "hashlib.sha256" ], [ "LOAD_FAST", "s" ], [ "LOAD_METHOD", "s.encode" ], [ "CALL_METHOD", "s.encode('utf8')" ], [ "CALL_METHOD", "hashlib.sha256(s.encode('utf8'))" ], [ "LOAD_METHOD", "hashlib.sha256(s.encode('utf8')).hexdigest" ], [ "CALL_METHOD", "hashlib.sha256(s.encode('utf8')).hexdigest()" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.nodes" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "CALL_FUNCTION", "isinstance(node, (ast.While, ast.For, ast.comprehension))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.GeneratorExp" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.GeneratorExp)" ], [ "LOAD_FAST", "classes" ], [ "LOAD_METHOD", "classes.append" ], [ "CALL_METHOD", "classes.append('loop')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "CALL_FUNCTION", "isinstance(node, ast.stmt)" ], [ "LOAD_FAST", "classes" ], [ "LOAD_METHOD", "classes.append" ], [ "CALL_METHOD", "classes.append('stmt')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "CALL_FUNCTION", "isinstance(node, ast.expr)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._is_interesting_expression" ], [ "LOAD_FAST", "classes" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.AST" ], [ "CALL_FUNCTION", "isinstance(node, ast.AST)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "hasattr(node, 'first_token')" ], [ "LOAD_FAST", "start_lineno" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.first_token" ], [ "LOAD_ATTR", "node.first_token.start" ], [ "BINARY_SUBSCR", "node.first_token.start[0]" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.tokens" ], [ "LOAD_METHOD", "traced_file.tokens.get_text_range" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "traced_file.tokens.get_text_range(node)" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "classes" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.root" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.walk" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.root" ], [ "CALL_METHOD", "ast.walk(traced_file.root)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.iter_child_nodes" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.iter_child_nodes(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._depth" ], [ "BINARY_ADD", "node._depth + 1" ], [ "LOAD_FAST", "child" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "positions" ], [ "LOAD_METHOD", "positions.extend" ], [ "LOAD_GLOBAL", "map" ], [ "LOAD_GLOBAL", "HTMLPosition" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._depth" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._depth" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_METHOD", "' '.join" ], [ "LOAD_FAST", "classes" ], [ "CALL_METHOD", "' '.join(classes)" ], [ "BINARY_MODULO", "'' % (node._tree_index, ' '.join(classes))" ], [ "CALL_FUNCTION", "map(\n HTMLPosition,\n [start, end],\n [True, False], # is_start\n [node._depth, node._depth],\n ['' % (node._tree_index, ' '.join(classes)),\n ''])" ], [ "CALL_METHOD", "positions.extend(map(\n HTMLPosition,\n [start, end],\n [True, False], # is_start\n [node._depth, node._depth],\n ['' % (node._tree_index, ' '.join(classes)),\n '']))" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._separate_comprehensions" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_FAST", "positions" ], [ "LOAD_FAST", "traced_file" ], [ "CALL_METHOD", "self._separate_comprehensions(\n [n[0] for n in nodes],\n end_lineno, positions, traced_file)" ], [ "LOAD_FAST", "positions" ], [ "LOAD_METHOD", "positions.append" ], [ "LOAD_GLOBAL", "HTMLPosition" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.source" ], [ "CALL_FUNCTION", "len(traced_file.source)" ], [ "CALL_FUNCTION", "HTMLPosition(len(traced_file.source), False, 0, '')" ], [ "CALL_METHOD", "positions.append(HTMLPosition(len(traced_file.source), False, 0, ''))" ], [ "LOAD_FAST", "positions" ], [ "LOAD_METHOD", "positions.sort" ], [ "CALL_METHOD", "positions.sort()" ], [ "LOAD_FAST", "positions" ], [ "LOAD_FAST", "html_parts" ], [ "LOAD_METHOD", "html_parts.append" ], [ "LOAD_GLOBAL", "html" ], [ "LOAD_METHOD", "html.escape" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.source" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "position" ], [ "LOAD_ATTR", "position.index" ], [ "BINARY_SUBSCR", "traced_file.source[start:position.index]" ], [ "CALL_METHOD", "html.escape(traced_file.source[start:position.index])" ], [ "CALL_METHOD", "html_parts.append(html.escape(traced_file.source[start:position.index]))" ], [ "LOAD_FAST", "html_parts" ], [ "LOAD_METHOD", "html_parts.append" ], [ "LOAD_FAST", "position" ], [ "LOAD_ATTR", "position.html" ], [ "CALL_METHOD", "html_parts.append(position.html)" ], [ "LOAD_FAST", "position" ], [ "LOAD_ATTR", "position.index" ], [ "LOAD_METHOD", "''.join" ], [ "LOAD_FAST", "html_parts" ], [ "CALL_METHOD", "''.join(html_parts)" ], [ "LOAD_METHOD", "'\\n'.join" ], [ "LOAD_FAST", "html_body" ], [ "LOAD_METHOD", "html_body.split" ], [ "CALL_METHOD", "html_body.split('\\n')" ], [ "LOAD_FAST", "start_lineno" ], [ "BINARY_SUBTRACT", "start_lineno - 1" ], [ "LOAD_FAST", "end_lineno" ], [ "BINARY_SUBTRACT", "end_lineno - 1" ], [ "BINARY_SUBSCR", "html_body.split('\\n')[start_lineno - 1:end_lineno - 1]" ], [ "CALL_METHOD", "'\\n'.join(html_body.split('\\n')[start_lineno - 1:end_lineno - 1])" ], [ "LOAD_FAST", "html_body" ], [ "LOAD_METHOD", "html_body.strip" ], [ "CALL_METHOD", "html_body.strip('\\n')" ], [ "LOAD_FAST", "n" ], [ "BINARY_SUBSCR", "n[0]" ], [ "LOAD_GLOBAL", "group_by_key_func" ], [ "LOAD_GLOBAL", "of_type" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "LOAD_FAST", "nodes" ], [ "CALL_FUNCTION", "of_type((ast.comprehension, ast.While, ast.For), nodes)" ], [ "CALL_FUNCTION", "group_by_key_func(of_type((ast.comprehension, ast.While, ast.For), nodes),\n lambda c: c.first_token.start[0]\n )" ], [ "LOAD_FAST", "comprehensions" ], [ "LOAD_METHOD", "comprehensions.values" ], [ "CALL_METHOD", "comprehensions.values()" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_FAST", "comp_list" ], [ "CALL_FUNCTION_KW", "sorted(comp_list, key=lambda c: c.first_token.startpos)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "comp" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "CALL_FUNCTION", "isinstance(comp, ast.comprehension)" ], [ "LOAD_FAST", "comp" ], [ "LOAD_FAST", "comp" ], [ "LOAD_ATTR", "comp.parent" ], [ "LOAD_ATTR", "comp.parent.generators" ], [ "BINARY_SUBSCR", "comp.parent.generators[0]" ], [ "COMPARE_OP", "comp is comp.parent.generators[0]" ], [ "LOAD_FAST", "get_start" ], [ "LOAD_FAST", "comp" ], [ "LOAD_ATTR", "comp.parent" ], [ "CALL_FUNCTION", "get_start(comp.parent)" ], [ "LOAD_FAST", "prev_start" ], [ "COMPARE_OP", "prev_start is not None" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "prev_start" ], [ "COMPARE_OP", "start < prev_start" ], [ "LOAD_FAST", "get_start" ], [ "LOAD_FAST", "comp" ], [ "CALL_FUNCTION", "get_start(comp)" ], [ "LOAD_FAST", "get_start" ], [ "LOAD_FAST", "comp" ], [ "CALL_FUNCTION", "get_start(comp)" ], [ "LOAD_FAST", "prev_start" ], [ "COMPARE_OP", "prev_start is not None" ], [ "LOAD_FAST", "positions" ], [ "LOAD_METHOD", "positions.append" ], [ "LOAD_GLOBAL", "HTMLPosition" ], [ "LOAD_FAST", "start" ], [ "CALL_FUNCTION", "HTMLPosition(start, True, 0, '\\n ')" ], [ "CALL_METHOD", "positions.append(HTMLPosition(start, True, 0, '\\n '))" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.first_token" ], [ "LOAD_ATTR", "c.first_token.start" ], [ "BINARY_SUBSCR", "c.first_token.start[0]" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.tokens" ], [ "LOAD_METHOD", "traced_file.tokens.get_text_range" ], [ "LOAD_FAST", "n" ], [ "CALL_METHOD", "traced_file.tokens.get_text_range(n)" ], [ "BINARY_SUBSCR", "traced_file.tokens.get_text_range(n)[0]" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.first_token" ], [ "LOAD_ATTR", "c.first_token.startpos" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "_deep_dict" ], [ "CALL_FUNCTION", "defaultdict(_deep_dict)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_GLOBAL", "_bad_codes" ], [ "COMPARE_OP", "frame.f_code in _bad_codes" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "IterationList" ], [ "CALL_FUNCTION", "defaultdict(IterationList)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.index" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.loops" ], [ "LOAD_METHOD", "self.loops.items" ], [ "CALL_METHOD", "self.loops.items()" ], [ "LOAD_FAST", "iteration_list" ], [ "LOAD_FAST", "tree_index" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_METHOD", "iteration.extract_iterations" ], [ "CALL_METHOD", "iteration.extract_iterations()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "deque" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.side_len" ], [ "CALL_FUNCTION_KW", "deque(maxlen=self.side_len)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "Counter" ], [ "CALL_FUNCTION", "Counter()" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.length" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.side_len" ], [ "COMPARE_OP", "self.length < self.side_len" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start" ], [ "LOAD_METHOD", "self.start.append" ], [ "LOAD_FAST", "iteration" ], [ "CALL_METHOD", "self.start.append(iteration)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "CALL_FUNCTION", "len(self.end)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.side_len" ], [ "COMPARE_OP", "len(self.end) >= self.side_len" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "BINARY_SUBSCR", "self.end[0]" ], [ "LOAD_ATTR", "self.end[0].keep" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start" ], [ "LOAD_METHOD", "self.start.append" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "BINARY_SUBSCR", "self.end[0]" ], [ "CALL_METHOD", "self.start.append(self.end[0])" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "LOAD_METHOD", "self.end.append" ], [ "LOAD_FAST", "iteration" ], [ "CALL_METHOD", "self.end.append(iteration)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.length" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "chain" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "CALL_FUNCTION", "chain(self.start, self.end)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "BINARY_SUBSCR", "self.end[-1]" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start" ], [ "BINARY_SUBSCR", "self.start[-1]" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.recorded" ], [ "LOAD_FAST", "node" ], [ "BINARY_SUBSCR", "self.recorded[node]" ], [ "COMPARE_OP", "self.recorded[node] >= 2" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.last" ], [ "CALL_METHOD", "self.last()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.recorded" ], [ "LOAD_FAST", "node" ], [ "LOAD_NAME", "type" ], [ "CALL_FUNCTION", "type(None)" ], [ "LOAD_NAME", "bool" ], [ "LOAD_NAME", "int" ], [ "LOAD_NAME", "float" ], [ "LOAD_NAME", "complex" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "long" ], [ "LOAD_NAME", "basic_types" ], [ "LOAD_NAME", "list" ], [ "LOAD_NAME", "dict" ], [ "LOAD_NAME", "tuple" ], [ "LOAD_NAME", "set" ], [ "LOAD_NAME", "frozenset" ], [ "LOAD_NAME", "str" ], [ "BINARY_ADD", "basic_types + (list, dict, tuple, set, frozenset, str)" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "unicode" ], [ "LOAD_NAME", "bytes" ], [ "LOAD_NAME", "len" ], [ "LOAD_NAME", "special_types" ], [ "CALL_FUNCTION", "len(special_types)" ], [ "LOAD_GLOBAL", "Lock" ], [ "CALL_FUNCTION", "Lock()" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "CALL_FUNCTION", "defaultdict(lambda: len(self.data))" ], [ "LOAD_DEREF", "self" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.special_types" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.data" ], [ "LOAD_FAST", "t" ], [ "BINARY_SUBSCR", "self.data[t]" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.data" ], [ "CALL_FUNCTION", "len(self.data)" ], [ "LOAD_GLOBAL", "correct_type" ], [ "LOAD_FAST", "item" ], [ "CALL_FUNCTION", "correct_type(item)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.lock" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.data" ], [ "LOAD_FAST", "t" ], [ "BINARY_SUBSCR", "self.data[t]" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.data" ], [ "LOAD_METHOD", "self.data.items" ], [ "CALL_METHOD", "self.data.items()" ], [ "CALL_FUNCTION", "dict((v, k) for k, v in self.data.items())" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_DEREF", "rev" ], [ "CALL_FUNCTION", "len(rev)" ], [ "CALL_FUNCTION", "range(len(rev))" ], [ "LOAD_FAST", "v" ], [ "LOAD_FAST", "k" ], [ "LOAD_GLOBAL", "safe_qualname" ], [ "LOAD_DEREF", "rev" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "rev[i]" ], [ "CALL_FUNCTION", "safe_qualname(rev[i])" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_FAST", "val_repr" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "type_index" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.meta" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.meta" ], [ "LOAD_FAST", "key" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.children" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.children" ], [ "LOAD_METHOD", "self.children.append" ], [ "LOAD_FAST", "key" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOAD_METHOD", "NodeValue.expression" ], [ "LOAD_FAST", "samples" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "level" ], [ "CALL_METHOD", "NodeValue.expression(samples, value, level)" ], [ "CALL_METHOD", "self.children.append((key, NodeValue.expression(samples, value, level)))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.val_repr" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.type_index" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.meta" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.children" ], [ "LOAD_FAST", "result" ], [ "LOAD_METHOD", "result.extend" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.children" ], [ "CALL_METHOD", "result.extend(self.children)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "cls" ], [ "CALL_FUNCTION", "cls('', -2)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_GLOBAL", "exception_string" ], [ "LOAD_FAST", "exc_value" ], [ "CALL_FUNCTION", "exception_string(exc_value)" ], [ "CALL_FUNCTION", "cls(exception_string(exc_value), -1)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "cheap_repr(val)" ], [ "LOAD_GLOBAL", "type_registry" ], [ "LOAD_FAST", "val" ], [ "BINARY_SUBSCR", "type_registry[val]" ], [ "CALL_FUNCTION", "cls(cheap_repr(val), type_registry[val])" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "TypeRegistry" ], [ "LOAD_ATTR", "TypeRegistry.basic_types" ], [ "LOAD_GLOBAL", "BirdsEye" ], [ "CALL_FUNCTION", "isinstance(val, (TypeRegistry.basic_types, BirdsEye))" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "QuerySet" ], [ "CALL_FUNCTION", "isinstance(val, QuerySet)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "len(val)" ], [ "LOAD_FAST", "result" ], [ "LOAD_METHOD", "result.set_meta" ], [ "LOAD_FAST", "length" ], [ "CALL_METHOD", "result.set_meta('len', length)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "ModuleType" ], [ "CALL_FUNCTION", "isinstance(val, ModuleType)" ], [ "LOAD_GLOBAL", "min" ], [ "LOAD_FAST", "level" ], [ "CALL_FUNCTION", "min(level, 2)" ], [ "LOAD_GLOBAL", "partial" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.add_child" ], [ "LOAD_FAST", "samples" ], [ "LOAD_FAST", "level" ], [ "BINARY_SUBTRACT", "level - 1" ], [ "CALL_FUNCTION", "partial(result.add_child, samples, level - 1)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Series" ], [ "LOAD_GLOBAL", "ndarray" ], [ "CALL_FUNCTION", "isinstance(val, (Series, ndarray))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "ndarray" ], [ "CALL_FUNCTION", "isinstance(val, ndarray)" ], [ "LOAD_FAST", "attrs" ], [ "LOAD_METHOD", "attrs.append" ], [ "CALL_METHOD", "attrs.append('shape')" ], [ "LOAD_FAST", "attrs" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "val" ], [ "LOAD_FAST", "name" ], [ "CALL_FUNCTION", "getattr(val, name)" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "attr" ], [ "CALL_FUNCTION", "add_child(name, attr)" ], [ "LOAD_FAST", "level" ], [ "COMPARE_OP", "level >= 3" ], [ "LOAD_FAST", "level" ], [ "COMPARE_OP", "level >= 2" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Series" ], [ "CALL_FUNCTION", "isinstance(val, Series)" ], [ "LOAD_FAST", "samples" ], [ "LOAD_FAST", "sample_type" ], [ "BINARY_SUBSCR", "samples[sample_type]" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "DataFrame" ], [ "CALL_FUNCTION", "isinstance(val, DataFrame)" ], [ "LOAD_FAST", "result" ], [ "LOAD_METHOD", "result.set_meta" ], [ "LOAD_FAST", "meta" ], [ "CALL_METHOD", "result.set_meta('dataframe', meta)" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['pandas_rows']" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['pandas_cols']" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_rows" ], [ "BINARY_ADD", "max_rows + 2" ], [ "COMPARE_OP", "length > max_rows + 2" ], [ "LOAD_FAST", "max_rows" ], [ "BINARY_FLOOR_DIVIDE", "max_rows // 2" ], [ "LOAD_FAST", "meta" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.columns" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "columns" ], [ "CALL_FUNCTION", "len(columns)" ], [ "LOAD_FAST", "num_cols" ], [ "LOAD_FAST", "max_cols" ], [ "BINARY_ADD", "max_cols + 2" ], [ "COMPARE_OP", "num_cols > max_cols + 2" ], [ "LOAD_FAST", "max_cols" ], [ "BINARY_FLOOR_DIVIDE", "max_cols // 2" ], [ "LOAD_FAST", "meta" ], [ "LOAD_GLOBAL", "set" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "num_cols" ], [ "LOAD_FAST", "max_cols" ], [ "CALL_FUNCTION", "_sample_indices(num_cols, max_cols)" ], [ "CALL_FUNCTION", "set(_sample_indices(num_cols, max_cols))" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_GLOBAL", "zip" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.columns" ], [ "LOAD_ATTR", "val.columns.format" ], [ "CALL_FUNCTION_KW", "val.columns.format(sparsify=False)" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.columns" ], [ "CALL_FUNCTION", "zip(val.columns.format(sparsify=False),\n val.columns)" ], [ "CALL_FUNCTION", "enumerate(zip(val.columns.format(sparsify=False),\n val.columns))" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "indices" ], [ "COMPARE_OP", "i in indices" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_FAST", "formatted_name" ], [ "LOAD_FAST", "val" ], [ "LOAD_FAST", "label" ], [ "BINARY_SUBSCR", "val[label]" ], [ "CALL_FUNCTION", "add_child(formatted_name, val[label])" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Series" ], [ "CALL_FUNCTION", "isinstance(val, Series)" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['pandas_rows']" ], [ "CALL_FUNCTION", "_sample_indices(length, samples['pandas_rows'])" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.index" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "val.index[i:i + 1]" ], [ "LOAD_ATTR", "val.index[i:i + 1].format" ], [ "CALL_FUNCTION_KW", "val.index[i:i + 1].format(sparsify=False)" ], [ "BINARY_SUBSCR", "val.index[i:i + 1].format(sparsify=False)[0]" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.iloc" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "val.iloc[i]" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_FAST", "k" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child(k, v)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "level" ], [ "COMPARE_OP", "level <= 0" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "bytes" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "unicode" ], [ "LOAD_GLOBAL", "xrange" ], [ "CALL_FUNCTION", "isinstance(val,\n (str, bytes, range)\n if PY3 else\n (str, unicode, xrange))" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Sequence" ], [ "LOAD_GLOBAL", "ndarray" ], [ "CALL_FUNCTION", "isinstance(val, (Sequence, ndarray))" ], [ "LOAD_FAST", "length" ], [ "COMPARE_OP", "length is not None" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['list']" ], [ "CALL_FUNCTION", "_sample_indices(length, samples['list'])" ], [ "LOAD_FAST", "val" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "val[i]" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "i" ], [ "CALL_FUNCTION", "str(i)" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child(str(i), v)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Mapping" ], [ "CALL_FUNCTION", "isinstance(val, Mapping)" ], [ "LOAD_GLOBAL", "islice" ], [ "LOAD_GLOBAL", "_safe_iter" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "iteritems" ], [ "CALL_FUNCTION", "_safe_iter(val, iteritems)" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['dict']" ], [ "CALL_FUNCTION", "islice(_safe_iter(val, iteritems), samples['dict'])" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "k" ], [ "CALL_FUNCTION", "cheap_repr(k)" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child(cheap_repr(k), v)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Set" ], [ "CALL_FUNCTION", "isinstance(val, Set)" ], [ "LOAD_GLOBAL", "_safe_iter" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "_safe_iter(val)" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['set']" ], [ "LOAD_FAST", "length" ], [ "COMPARE_OP", "length is None" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "num_items" ], [ "BINARY_ADD", "num_items + 2" ], [ "COMPARE_OP", "length > num_items + 2" ], [ "LOAD_GLOBAL", "islice" ], [ "LOAD_FAST", "vals" ], [ "LOAD_FAST", "num_items" ], [ "CALL_FUNCTION", "islice(vals, num_items)" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "vals" ], [ "CALL_FUNCTION", "enumerate(vals)" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_FAST", "i" ], [ "BINARY_MODULO", "'<%s>' % i" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child('<%s>' % i, v)" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "getattr(val, '__dict__', None)" ], [ "LOAD_FAST", "d" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_GLOBAL", "islice" ], [ "LOAD_GLOBAL", "_safe_iter" ], [ "LOAD_FAST", "d" ], [ "CALL_FUNCTION", "_safe_iter(d)" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['attributes']" ], [ "CALL_FUNCTION", "islice(_safe_iter(d),\n samples['attributes'])" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION_KW", "sorted(islice(_safe_iter(d),\n samples['attributes']),\n key=str)" ], [ "LOAD_FAST", "d" ], [ "LOAD_FAST", "k" ], [ "BINARY_SUBSCR", "d[k]" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "TracedFile" ], [ "CALL_FUNCTION", "isinstance(v, TracedFile)" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "k" ], [ "CALL_FUNCTION", "str(k)" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child(str(k), v)" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "type" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "type(val)" ], [ "CALL_FUNCTION", "getattr(type(val), '__slots__', None)" ], [ "CALL_FUNCTION", "sorted(getattr(type(val), '__slots__', None) or ())" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "val" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "getattr(val, s)" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "str(s)" ], [ "LOAD_FAST", "attr" ], [ "CALL_FUNCTION", "add_child(str(s), attr)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "x" ], [ "LOAD_FAST", "f" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "f(val)" ], [ "LOAD_FAST", "x" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_ADD", "max_length + 2" ], [ "COMPARE_OP", "length <= max_length + 2" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "range(length)" ], [ "LOAD_GLOBAL", "chain" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_FLOOR_DIVIDE", "max_length // 2" ], [ "CALL_FUNCTION", "range(max_length // 2)" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_FLOOR_DIVIDE", "max_length // 2" ], [ "BINARY_SUBTRACT", "length - max_length // 2" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "range(length - max_length // 2,\n length)" ], [ "CALL_FUNCTION", "chain(range(max_length // 2),\n range(length - max_length // 2,\n length))" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "len(x)" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "n == 0" ], [ "LOAD_GLOBAL", "repr" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "repr(x)" ], [ "LOAD_FAST", "helper" ], [ "LOAD_ATTR", "helper.level" ], [ "BINARY_SUBTRACT", "helper.level - 1" ], [ "LOAD_GLOBAL", "_repr_series_one_line" ], [ "LOAD_ATTR", "_repr_series_one_line.maxparts" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "n" ], [ "LOAD_FAST", "maxparts" ], [ "CALL_FUNCTION", "_sample_indices(n, maxparts)" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.index" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "x.index[i:i + 1]" ], [ "LOAD_ATTR", "x.index[i:i + 1].format" ], [ "CALL_FUNCTION_KW", "x.index[i:i + 1].format(sparsify=False)" ], [ "BINARY_SUBSCR", "x.index[i:i + 1].format(sparsify=False)[0]" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.iloc" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "x.iloc[i]" ], [ "LOAD_FAST", "pieces" ], [ "LOAD_METHOD", "pieces.append" ], [ "LOAD_FAST", "k" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "v" ], [ "LOAD_FAST", "newlevel" ], [ "CALL_FUNCTION", "cheap_repr(v, newlevel)" ], [ "BINARY_MODULO", "'%s = %s' % (k, cheap_repr(v, newlevel))" ], [ "CALL_METHOD", "pieces.append('%s = %s' % (k, cheap_repr(v, newlevel)))" ], [ "LOAD_FAST", "n" ], [ "LOAD_FAST", "maxparts" ], [ "BINARY_ADD", "maxparts + 2" ], [ "COMPARE_OP", "n > maxparts + 2" ], [ "LOAD_FAST", "pieces" ], [ "LOAD_METHOD", "pieces.insert" ], [ "LOAD_FAST", "maxparts" ], [ "BINARY_FLOOR_DIVIDE", "maxparts // 2" ], [ "CALL_METHOD", "pieces.insert(maxparts // 2, '...')" ], [ "LOAD_METHOD", "'; '.join" ], [ "LOAD_FAST", "pieces" ], [ "CALL_METHOD", "'; '.join(pieces)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "CALL_FUNCTION", "isinstance(node, ast.expr)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Num" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Str" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "ast" ], [ "CALL_FUNCTION", "getattr(ast, 'NameConstant', ())" ], [ "CALL_FUNCTION", "isinstance(node, (ast.Num, ast.Str, getattr(ast, 'NameConstant', ())))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "getattr(node, 'ctx', None)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Store" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Del" ], [ "CALL_FUNCTION", "isinstance(getattr(node, 'ctx', None),\n (ast.Store, ast.Del))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.UnaryOp" ], [ "CALL_FUNCTION", "isinstance(node, ast.UnaryOp)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.op" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.UAdd" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.USub" ], [ "CALL_FUNCTION", "isinstance(node.op, (ast.UAdd, ast.USub))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.operand" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Num" ], [ "CALL_FUNCTION", "isinstance(node.operand, ast.Num)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.List" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Tuple" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Dict" ], [ "CALL_FUNCTION", "isinstance(node, (ast.List, ast.Tuple, ast.Dict))" ], [ "LOAD_GLOBAL", "any" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.iter_child_nodes" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.iter_child_nodes(node)" ], [ "CALL_FUNCTION", "any(is_interesting_expression(n) for n in ast.iter_child_nodes(node))" ], [ "UNARY_NOT", "not any(is_interesting_expression(n) for n in ast.iter_child_nodes(node))" ], [ "UNARY_NOT", "not (isinstance(node, (ast.Num, ast.Str, getattr(ast, 'NameConstant', ()))) or\n isinstance(getattr(node, 'ctx', None),\n (ast.Store, ast.Del)) or\n (isinstance(node, ast.UnaryOp) and\n isinstance(node.op, (ast.UAdd, ast.USub)) and\n isinstance(node.operand, ast.Num)) or\n (isinstance(node, (ast.List, ast.Tuple, ast.Dict)) and\n not any(is_interesting_expression(n) for n in ast.iter_child_nodes(node))))" ], [ "LOAD_GLOBAL", "is_interesting_expression" ], [ "LOAD_FAST", "n" ], [ "CALL_FUNCTION", "is_interesting_expression(n)" ], [ "LOAD_GLOBAL", "cast" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "__builtins__" ], [ "CALL_FUNCTION", "cast(dict, __builtins__)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Name" ], [ "CALL_FUNCTION", "isinstance(node, ast.Name)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.id" ], [ "LOAD_FAST", "builtins" ], [ "COMPARE_OP", "node.id in builtins" ], [ "LOAD_FAST", "builtins" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.id" ], [ "BINARY_SUBSCR", "builtins[node.id]" ], [ "LOAD_FAST", "value" ], [ "COMPARE_OP", "builtins[node.id] is value" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "ast" ], [ "CALL_FUNCTION", "getattr(ast, 'NameConstant', ())" ], [ "CALL_FUNCTION", "isinstance(node, getattr(ast, 'NameConstant', ()))" ] ], "configuration.py": [ [ "LOAD_NAME", "ctypes" ], [ "LOAD_ATTR", "ctypes.windll" ], [ "LOAD_ATTR", "ctypes.windll.kernel32" ], [ "LOAD_NAME", "kernel32" ], [ "LOAD_METHOD", "kernel32.SetConsoleMode" ], [ "LOAD_NAME", "kernel32" ], [ "LOAD_METHOD", "kernel32.GetStdHandle" ], [ "CALL_METHOD", "kernel32.GetStdHandle(-11)" ], [ "CALL_METHOD", "kernel32.SetConsoleMode(kernel32.GetStdHandle(-11), 7)" ], [ "LOAD_NAME", "Exception" ], [ "LOAD_NAME", "os" ], [ "LOAD_ATTR", "os.name" ], [ "COMPARE_OP", "os.name != 'nt'" ], [ "LOAD_NAME", "DefaultFormatter" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "object" ], [ "LOAD_FAST", "builtins" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_GLOBAL", "builtins_module" ], [ "LOAD_FAST", "snoop" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.snoop" ], [ "CALL_FUNCTION", "setattr(builtins_module, snoop, package.snoop)" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_GLOBAL", "builtins_module" ], [ "LOAD_FAST", "pp" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.pp" ], [ "CALL_FUNCTION", "setattr(builtins_module, pp, package.pp)" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_GLOBAL", "builtins_module" ], [ "LOAD_FAST", "spy" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.spy" ], [ "CALL_FUNCTION", "setattr(builtins_module, spy, package.spy)" ], [ "LOAD_GLOBAL", "Config" ], [ "LOAD_FAST", "out" ], [ "LOAD_FAST", "prefix" ], [ "LOAD_FAST", "columns" ], [ "LOAD_FAST", "overwrite" ], [ "LOAD_FAST", "color" ], [ "LOAD_FAST", "enabled" ], [ "LOAD_FAST", "watch_extras" ], [ "LOAD_FAST", "replace_watch_extras" ], [ "LOAD_FAST", "formatter_class" ], [ "CALL_FUNCTION_KW", "Config(\n out=out,\n prefix=prefix,\n columns=columns,\n overwrite=overwrite,\n color=color,\n enabled=enabled,\n watch_extras=watch_extras,\n replace_watch_extras=replace_watch_extras,\n formatter_class=formatter_class,\n )" ], [ "LOAD_FAST", "config" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.snoop" ], [ "LOAD_FAST", "config" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.pp" ], [ "LOAD_FAST", "config" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.spy" ], [ "LOAD_NAME", "DefaultFormatter" ], [ "LOAD_GLOBAL", "can_color" ], [ "LOAD_FAST", "color" ], [ "COMPARE_OP", "color is None" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "out" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.stderr" ], [ "CALL_FUNCTION", "getattr(out or sys.stderr, 'isatty', lambda: False)" ], [ "LOAD_GLOBAL", "bool" ], [ "LOAD_FAST", "isatty" ], [ "CALL_FUNCTION", "isatty()" ], [ "CALL_FUNCTION", "bool(isatty())" ], [ "LOAD_GLOBAL", "get_write_function" ], [ "LOAD_FAST", "out" ], [ "LOAD_FAST", "overwrite" ], [ "CALL_FUNCTION", "get_write_function(out, overwrite)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "formatter_class" ], [ "LOAD_FAST", "prefix" ], [ "LOAD_FAST", "columns" ], [ "LOAD_FAST", "color" ], [ "CALL_FUNCTION", "formatter_class(prefix, columns, color)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "enabled" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "PP" ], [ "LOAD_DEREF", "self" ], [ "CALL_FUNCTION", "PP(self)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "Tracer" ], [ "LOAD_FAST", "ConfiguredTracer" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "Spy" ], [ "LOAD_DEREF", "self" ], [ "CALL_FUNCTION", "Spy(self)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "threading" ], [ "LOAD_METHOD", "threading.local" ], [ "CALL_METHOD", "threading.local()" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "replace_watch_extras" ], [ "COMPARE_OP", "replace_watch_extras is not None" ], [ "LOAD_GLOBAL", "ensure_tuple" ], [ "LOAD_FAST", "replace_watch_extras" ], [ "CALL_FUNCTION", "ensure_tuple(replace_watch_extras)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "len_shape_watch" ], [ "LOAD_GLOBAL", "dtype_watch" ], [ "LOAD_GLOBAL", "ensure_tuple" ], [ "LOAD_FAST", "watch_extras" ], [ "CALL_FUNCTION", "ensure_tuple(watch_extras)" ], [ "BINARY_ADD", "(len_shape_watch, dtype_watch) + ensure_tuple(watch_extras)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_CLASSDEREF", "self" ], [ "LOAD_FAST", "value" ], [ "LOAD_ATTR", "value.shape" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.ismethod" ], [ "LOAD_FAST", "shape" ], [ "CALL_METHOD", "inspect.ismethod(shape)" ], [ "LOAD_METHOD", "'{}.shape'.format" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "'{}.shape'.format(source)" ], [ "LOAD_FAST", "shape" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "value" ], [ "LOAD_GLOBAL", "QuerySet" ], [ "CALL_FUNCTION", "isinstance(value, QuerySet)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "len(value)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "value" ], [ "LOAD_GLOBAL", "six" ], [ "LOAD_ATTR", "six.string_types" ], [ "CALL_FUNCTION", "isinstance(value, six.string_types)" ], [ "LOAD_FAST", "length" ], [ "COMPARE_OP", "length < 50" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "value" ], [ "LOAD_GLOBAL", "Mapping" ], [ "LOAD_GLOBAL", "Set" ], [ "LOAD_GLOBAL", "Sequence" ], [ "CALL_FUNCTION", "isinstance(value, (Mapping, Set, Sequence))" ], [ "LOAD_FAST", "length" ], [ "COMPARE_OP", "length == 0" ], [ "LOAD_METHOD", "'len({})'.format" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "'len({})'.format(source)" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "value" ], [ "LOAD_ATTR", "value.dtype" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.ismethod" ], [ "LOAD_FAST", "dtype" ], [ "CALL_METHOD", "inspect.ismethod(dtype)" ], [ "LOAD_METHOD", "'{}.dtype'.format" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "'{}.dtype'.format(source)" ], [ "LOAD_FAST", "dtype" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_DEREF", "output" ], [ "LOAD_GLOBAL", "six" ], [ "LOAD_ATTR", "six.string_types" ], [ "CALL_FUNCTION", "isinstance(output, six.string_types)" ], [ "LOAD_GLOBAL", "is_pathlike" ], [ "LOAD_DEREF", "output" ], [ "CALL_FUNCTION", "is_pathlike(output)" ], [ "LOAD_FAST", "is_path" ], [ "LOAD_GLOBAL", "FileWriter" ], [ "LOAD_DEREF", "output" ], [ "LOAD_FAST", "overwrite" ], [ "CALL_FUNCTION", "FileWriter(output, overwrite)" ], [ "LOAD_ATTR", "FileWriter(output, overwrite).write" ], [ "LOAD_GLOBAL", "callable" ], [ "LOAD_DEREF", "output" ], [ "CALL_FUNCTION", "callable(output)" ], [ "LOAD_DEREF", "output" ], [ "LOAD_FAST", "write" ], [ "LOAD_DEREF", "output" ], [ "LOAD_FAST", "stream" ], [ "COMPARE_OP", "stream is None" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.stderr" ], [ "LOAD_FAST", "stream" ], [ "LOAD_METHOD", "stream.write" ], [ "LOAD_FAST", "s" ], [ "CALL_METHOD", "stream.write(s)" ], [ "LOAD_GLOBAL", "UnicodeEncodeError" ], [ "LOAD_FAST", "stream" ], [ "LOAD_METHOD", "stream.write" ], [ "LOAD_GLOBAL", "shitcode" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "shitcode(s)" ], [ "CALL_METHOD", "stream.write(shitcode(s))" ], [ "LOAD_GLOBAL", "six" ], [ "LOAD_METHOD", "six.text_type" ], [ "LOAD_FAST", "path" ], [ "CALL_METHOD", "six.text_type(path)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "overwrite" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "open" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.path" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.overwrite" ], [ "CALL_FUNCTION_KW", "open(self.path, 'w' if self.overwrite else 'a', encoding='utf-8')" ], [ "LOAD_FAST", "f" ], [ "LOAD_METHOD", "f.write" ], [ "LOAD_FAST", "s" ], [ "CALL_METHOD", "f.write(s)" ], [ "LOAD_FAST", "self" ] ], "db.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOAD_METHOD", "standard_library.install_aliases" ], [ "CALL_METHOD", "standard_library.install_aliases()" ], [ "LOAD_NAME", "RESERVED_WORDS" ], [ "LOAD_METHOD", "RESERVED_WORDS.add" ], [ "CALL_METHOD", "RESERVED_WORDS.add('function')" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "retry" ], [ "LOAD_NAME", "InterfaceError" ], [ "LOAD_NAME", "OperationalError" ], [ "LOAD_NAME", "InternalError" ], [ "LOAD_NAME", "ProgrammingError" ], [ "CALL_FUNCTION", "retry(3, (InterfaceError, OperationalError, InternalError, ProgrammingError))" ], [ "LOAD_NAME", "contextmanager" ], [ "CALL_FUNCTION", "contextmanager" ], [ "LOAD_FAST", "db_uri" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.environ" ], [ "LOAD_METHOD", "os.environ.get" ], [ "CALL_METHOD", "os.environ.get('BIRDSEYE_DB')" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_METHOD", "os.path.join" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_METHOD", "os.path.expanduser" ], [ "CALL_METHOD", "os.path.expanduser('~')" ], [ "CALL_METHOD", "os.path.join(os.path.expanduser('~'),\n '.birdseye.db')" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "dict" ], [ "CALL_FUNCTION_KW", "dict(\n pool_recycle=280,\n echo=False, # for convenience when debugging\n )" ], [ "LOAD_GLOBAL", "create_engine" ], [ "LOAD_FAST", "db_uri" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "create_engine(db_uri, **kwargs)" ], [ "LOAD_GLOBAL", "ArgumentError" ], [ "LOAD_FAST", "db_uri" ], [ "BINARY_ADD", "'sqlite:///' + db_uri" ], [ "LOAD_GLOBAL", "create_engine" ], [ "LOAD_FAST", "db_uri" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "create_engine(db_uri, **kwargs)" ], [ "LOAD_FAST", "engine" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "sessionmaker" ], [ "LOAD_FAST", "engine" ], [ "CALL_FUNCTION_KW", "sessionmaker(bind=engine)" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "object" ], [ "LOAD_GLOBAL", "declarative_base" ], [ "LOAD_FAST", "Base" ], [ "CALL_FUNCTION_KW", "declarative_base(cls=Base)" ], [ "LOAD_FAST", "Base" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "object" ], [ "LOAD_FAST", "engine" ], [ "LOAD_ATTR", "engine.name" ], [ "COMPARE_OP", "engine.name == 'mysql'" ], [ "LOAD_GLOBAL", "LONGTEXT" ], [ "LOAD_GLOBAL", "Text" ], [ "LOAD_FAST", "Base" ], [ "LOAD_FAST", "Base" ], [ "LOAD_FAST", "Call" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "Function" ], [ "LOAD_FAST", "self" ], [ "LOAD_DEREF", "KeyValue" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "KeyValueStore" ], [ "CALL_FUNCTION", "KeyValueStore()" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "_skip_version_check" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.table_exists" ], [ "LOAD_FAST", "Function" ], [ "CALL_METHOD", "self.table_exists(Function)" ], [ "LOAD_FAST", "Base" ], [ "LOAD_ATTR", "Base.metadata" ], [ "LOAD_METHOD", "Base.metadata.create_all" ], [ "LOAD_FAST", "engine" ], [ "CALL_METHOD", "Base.metadata.create_all(engine)" ], [ "LOAD_GLOBAL", "DB_VERSION" ], [ "LOAD_FAST", "kv" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.table_exists" ], [ "LOAD_DEREF", "KeyValue" ], [ "CALL_METHOD", "self.table_exists(KeyValue)" ], [ "LOAD_GLOBAL", "int" ], [ "LOAD_FAST", "kv" ], [ "LOAD_ATTR", "kv.version" ], [ "CALL_FUNCTION", "int(kv.version)" ], [ "LOAD_GLOBAL", "DB_VERSION" ], [ "COMPARE_OP", "int(kv.version) < DB_VERSION" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_METHOD", "sys.exit" ], [ "CALL_METHOD", "sys.exit('The birdseye database schema is out of date. '\n 'Run \"python -m birdseye.clear_db\" to delete the existing tables.')" ], [ "LOAD_NAME", "declared_attr" ], [ "CALL_FUNCTION", "declared_attr" ], [ "LOAD_FAST", "cls" ], [ "LOAD_ATTR", "cls.__name__" ], [ "LOAD_METHOD", "cls.__name__.lower" ], [ "CALL_METHOD", "cls.__name__.lower()" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "String" ], [ "CALL_FUNCTION", "String(50)" ], [ "CALL_FUNCTION_KW", "Column(String(50), primary_key=True)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "__getitem__" ], [ "LOAD_NAME", "__setitem__" ], [ "LOAD_DEREF", "db_self" ], [ "LOAD_METHOD", "db_self.session_scope" ], [ "CALL_METHOD", "db_self.session_scope()" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session\n .query" ], [ "LOAD_DEREF", "KeyValue" ], [ "LOAD_ATTR", "KeyValue.value" ], [ "CALL_METHOD", "session\n .query(KeyValue.value)" ], [ "LOAD_ATTR", "session\n .query(KeyValue.value)\n .filter_by" ], [ "LOAD_FAST", "item" ], [ "CALL_FUNCTION_KW", "session\n .query(KeyValue.value)\n .filter_by(key=item)" ], [ "LOAD_METHOD", "session\n .query(KeyValue.value)\n .filter_by(key=item)\n .scalar" ], [ "CALL_METHOD", "session\n .query(KeyValue.value)\n .filter_by(key=item)\n .scalar()" ], [ "LOAD_DEREF", "db_self" ], [ "LOAD_METHOD", "db_self.session_scope" ], [ "CALL_METHOD", "db_self.session_scope()" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.query" ], [ "LOAD_DEREF", "KeyValue" ], [ "CALL_METHOD", "session.query(KeyValue)" ], [ "LOAD_ATTR", "session.query(KeyValue).filter_by" ], [ "LOAD_FAST", "key" ], [ "CALL_FUNCTION_KW", "session.query(KeyValue).filter_by(key=key)" ], [ "LOAD_METHOD", "session.query(KeyValue).filter_by(key=key).delete" ], [ "CALL_METHOD", "session.query(KeyValue).filter_by(key=key).delete()" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.add" ], [ "LOAD_DEREF", "KeyValue" ], [ "LOAD_FAST", "key" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "str(value)" ], [ "CALL_FUNCTION_KW", "KeyValue(key=key, value=str(value))" ], [ "CALL_METHOD", "session.add(KeyValue(key=key, value=str(value)))" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "String" ], [ "CALL_FUNCTION_KW", "String(length=32)" ], [ "CALL_FUNCTION_KW", "Column(String(length=32), primary_key=True)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Integer" ], [ "LOAD_NAME", "ForeignKey" ], [ "CALL_FUNCTION", "ForeignKey('function.id')" ], [ "CALL_FUNCTION_KW", "Column(Integer, ForeignKey('function.id'), index=True)" ], [ "LOAD_NAME", "relationship" ], [ "LOAD_NAME", "backref" ], [ "CALL_FUNCTION_KW", "backref('calls', lazy='dynamic')" ], [ "CALL_FUNCTION_KW", "relationship('Function', backref=backref('calls', lazy='dynamic'))" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_CLASSDEREF", "LongText" ], [ "CALL_FUNCTION", "Column(LongText)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "DateTime" ], [ "CALL_FUNCTION_KW", "Column(DateTime, index=True)" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "id" ], [ "LOAD_NAME", "function_id" ], [ "LOAD_NAME", "return_value" ], [ "LOAD_NAME", "traceback" ], [ "LOAD_NAME", "exception" ], [ "LOAD_NAME", "start_time" ], [ "LOAD_NAME", "arguments" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._pretty_time" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start_time" ], [ "CALL_METHOD", "self._pretty_time(self.start_time)" ], [ "LOAD_FAST", "dt" ], [ "LOAD_GLOBAL", "Markup" ], [ "LOAD_FAST", "dt" ], [ "LOAD_METHOD", "dt.strftime" ], [ "CALL_METHOD", "dt.strftime('%Y-%m-%d %H:%M:%S')" ], [ "LOAD_GLOBAL", "naturaltime" ], [ "LOAD_FAST", "dt" ], [ "CALL_FUNCTION", "naturaltime(dt)" ], [ "BINARY_MODULO", "'%s (%s)' % (\n dt.strftime('%Y-%m-%d %H:%M:%S'),\n naturaltime(dt))" ], [ "CALL_FUNCTION", "Markup('%s (%s)' % (\n dt.strftime('%Y-%m-%d %H:%M:%S'),\n naturaltime(dt)))" ], [ "LOAD_GLOBAL", "Markup" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.success" ], [ "BINARY_MODULO", "'' % (\n ('ok', 'green') if self.success else\n ('remove', 'red'))" ], [ "CALL_FUNCTION", "Markup('' % (\n ('ok', 'green') if self.success else\n ('remove', 'red')))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.exception" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.traceback" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.return_value" ], [ "COMPARE_OP", "self.return_value == 'None'" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.traceback" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.success" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.return_value" ], [ "CALL_FUNCTION", "str(self.return_value)" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.exception" ], [ "CALL_FUNCTION", "str(self.exception)" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_METHOD", "json.loads" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.arguments" ], [ "CALL_METHOD", "json.loads(self.arguments)" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_METHOD", "json.loads" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.data" ], [ "CALL_METHOD", "json.loads(self.data)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.arguments_list" ], [ "LOAD_GLOBAL", "select_attrs" ], [ "LOAD_FAST", "call" ], [ "CALL_FUNCTION", "select_attrs(call, 'id function_id return_value traceback '\n 'exception start_time')" ], [ "CALL_FUNCTION_EX", "dict(arguments=call.arguments_list,\n **select_attrs(call, 'id function_id return_value traceback '\n 'exception start_time'))" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Integer" ], [ "LOAD_NAME", "Sequence" ], [ "CALL_FUNCTION", "Sequence('function_id_seq')" ], [ "CALL_FUNCTION_KW", "Column(Integer, Sequence('function_id_seq'), primary_key=True)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_CLASSDEREF", "LongText" ], [ "CALL_FUNCTION", "Column(LongText)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Integer" ], [ "CALL_FUNCTION", "Column(Integer)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_CLASSDEREF", "LongText" ], [ "CALL_FUNCTION", "Column(LongText)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "String" ], [ "CALL_FUNCTION_KW", "String(length=64)" ], [ "CALL_FUNCTION_KW", "Column(String(length=64), index=True)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "String" ], [ "CALL_FUNCTION_KW", "String(length=64)" ], [ "CALL_FUNCTION_KW", "Column(String(length=64), index=True)" ], [ "LOAD_NAME", "UniqueConstraint" ], [ "CALL_FUNCTION_KW", "UniqueConstraint('hash',\n name='everything_unique')" ], [ "LOAD_NAME", "Index" ], [ "CALL_FUNCTION_KW", "Index('idx_file', 'file', mysql_length=256)" ], [ "LOAD_NAME", "Index" ], [ "CALL_FUNCTION_KW", "Index('idx_name', 'name', mysql_length=32)" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "file" ], [ "LOAD_NAME", "name" ], [ "LOAD_NAME", "lineno" ], [ "LOAD_NAME", "hash" ], [ "LOAD_NAME", "body_hash" ], [ "LOAD_NAME", "type" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_METHOD", "json.loads" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.data" ], [ "CALL_METHOD", "json.loads(self.data)" ], [ "LOAD_GLOBAL", "select_attrs" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "select_attrs(func, 'file name lineno hash body_hash type')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.engine" ], [ "LOAD_ATTR", "self.engine.dialect" ], [ "LOAD_METHOD", "self.engine.dialect.has_table" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.engine" ], [ "LOAD_FAST", "table" ], [ "LOAD_ATTR", "table.__name__" ], [ "CALL_METHOD", "self.engine.dialect.has_table(self.engine, table.__name__)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.session_scope" ], [ "CALL_METHOD", "self.session_scope()" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.query" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.Function" ], [ "LOAD_ATTR", "self.Function.file" ], [ "CALL_METHOD", "session.query(self.Function.file)" ], [ "LOAD_METHOD", "session.query(self.Function.file).distinct" ], [ "CALL_METHOD", "session.query(self.Function.file).distinct()" ], [ "LOAD_FAST", "paths" ], [ "LOAD_METHOD", "paths.sort" ], [ "CALL_METHOD", "paths.sort()" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "paths" ], [ "COMPARE_OP", "IPYTHON_FILE_PATH in paths" ], [ "LOAD_FAST", "paths" ], [ "LOAD_METHOD", "paths.remove" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "CALL_METHOD", "paths.remove(IPYTHON_FILE_PATH)" ], [ "LOAD_FAST", "paths" ], [ "LOAD_METHOD", "paths.insert" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "CALL_METHOD", "paths.insert(0, IPYTHON_FILE_PATH)" ], [ "LOAD_FAST", "paths" ], [ "LOAD_GLOBAL", "is_ipython_cell" ], [ "LOAD_FAST", "f" ], [ "BINARY_SUBSCR", "f[0]" ], [ "CALL_FUNCTION", "is_ipython_cell(f[0])" ], [ "LOAD_FAST", "f" ], [ "BINARY_SUBSCR", "f[0]" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.Call" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.Function" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._KeyValue" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.table_exists" ], [ "LOAD_FAST", "model" ], [ "CALL_METHOD", "self.table_exists(model)" ], [ "LOAD_FAST", "model" ], [ "LOAD_ATTR", "model.__table__" ], [ "LOAD_METHOD", "model.__table__.drop" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.engine" ], [ "CALL_METHOD", "model.__table__.drop(self.engine)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.Session" ], [ "CALL_METHOD", "self.Session()" ], [ "LOAD_FAST", "session" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.commit" ], [ "CALL_METHOD", "session.commit()" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.rollback" ], [ "CALL_METHOD", "session.rollback()" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.close" ], [ "CALL_METHOD", "session.close()" ], [ "LOAD_GLOBAL", "functools" ], [ "LOAD_METHOD", "functools.wraps" ], [ "LOAD_DEREF", "func" ], [ "CALL_METHOD", "functools.wraps(func)" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "LOAD_GLOBAL", "retry_db" ], [ "LOAD_FAST", "wrapper" ], [ "CALL_FUNCTION", "retry_db(wrapper)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self.session_scope" ], [ "CALL_METHOD", "self.session_scope()" ], [ "LOAD_DEREF", "func" ], [ "LOAD_FAST", "session" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "func(session, *args, **kwargs)" ] ], "executing.py": [ [ "LOAD_NAME", "sys" ], [ "LOAD_ATTR", "sys.version_info" ], [ "BINARY_SUBSCR", "sys.version_info[0]" ], [ "COMPARE_OP", "sys.version_info[0] == 3" ], [ "LOAD_NAME", "PY3" ], [ "LOAD_NAME", "lru_cache" ], [ "CALL_FUNCTION_KW", "lru_cache(maxsize=None)" ], [ "LOAD_NAME", "str" ], [ "LOAD_NAME", "unicode" ], [ "LOAD_NAME", "dis" ], [ "LOAD_ATTR", "dis.get_instructions" ], [ "LOAD_NAME", "AttributeError" ], [ "LOAD_NAME", "namedtuple" ], [ "CALL_FUNCTION", "namedtuple('Instruction', 'offset argval opname')" ], [ "LOAD_NAME", "Exception" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.NodeVisitor" ], [ "LOAD_NAME", "sum" ], [ "LOAD_NAME", "__future__" ], [ "LOAD_ATTR", "__future__.all_feature_names" ], [ "CALL_FUNCTION", "sum(\n getattr(__future__, fname).compiler_flag\n for fname in __future__.all_feature_names\n)" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "RLock" ], [ "CALL_FUNCTION", "RLock()" ], [ "LOAD_NAME", "cache" ], [ "CALL_FUNCTION", "cache" ], [ "LOAD_GLOBAL", "functools" ], [ "LOAD_METHOD", "functools.wraps" ], [ "LOAD_DEREF", "func" ], [ "CALL_METHOD", "functools.wraps(func)" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "LOAD_FAST", "wrapper" ], [ "LOAD_FAST", "args" ], [ "LOAD_DEREF", "d" ], [ "COMPARE_OP", "args in d" ], [ "LOAD_DEREF", "d" ], [ "LOAD_FAST", "args" ], [ "BINARY_SUBSCR", "d[args]" ], [ "LOAD_DEREF", "func" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION_EX", "func(*args)" ], [ "LOAD_DEREF", "d" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "co" ], [ "LOAD_ATTR", "co.co_code" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "len(code)" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "i < n" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "code[i]" ], [ "LOAD_GLOBAL", "ord" ], [ "LOAD_FAST", "c" ], [ "CALL_FUNCTION", "ord(c)" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "LOAD_FAST", "op" ], [ "LOAD_GLOBAL", "HAVE_ARGUMENT" ], [ "COMPARE_OP", "op >= HAVE_ARGUMENT" ], [ "LOAD_GLOBAL", "ord" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "code[i]" ], [ "CALL_FUNCTION", "ord(code[i])" ], [ "LOAD_GLOBAL", "ord" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "code[i + 1]" ], [ "CALL_FUNCTION", "ord(code[i + 1])" ], [ "BINARY_MULTIPLY", "ord(code[i + 1]) * 256" ], [ "BINARY_ADD", "ord(code[i]) + ord(code[i + 1]) * 256" ], [ "LOAD_FAST", "extended_arg" ], [ "BINARY_ADD", "ord(code[i]) + ord(code[i + 1]) * 256 + extended_arg" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 2" ], [ "LOAD_FAST", "op" ], [ "LOAD_GLOBAL", "EXTENDED_ARG" ], [ "COMPARE_OP", "op == EXTENDED_ARG" ], [ "LOAD_FAST", "oparg" ], [ "BINARY_MULTIPLY", "oparg * 65536" ], [ "LOAD_FAST", "op" ], [ "LOAD_GLOBAL", "hasconst" ], [ "COMPARE_OP", "op in hasconst" ], [ "LOAD_FAST", "co" ], [ "LOAD_ATTR", "co.co_consts" ], [ "LOAD_FAST", "oparg" ], [ "BINARY_SUBSCR", "co.co_consts[oparg]" ], [ "LOAD_GLOBAL", "Instruction" ], [ "LOAD_FAST", "offset" ], [ "LOAD_FAST", "argval" ], [ "LOAD_GLOBAL", "opname" ], [ "LOAD_FAST", "op" ], [ "BINARY_SUBSCR", "opname[op]" ], [ "CALL_FUNCTION", "Instruction(offset, argval, opname[op])" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "it" ], [ "LOAD_GLOBAL", "Sized" ], [ "CALL_FUNCTION", "isinstance(it, Sized)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "len(it)" ], [ "COMPARE_OP", "len(it) != 1" ], [ "LOAD_GLOBAL", "NotOneValueFound" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "len(it)" ], [ "BINARY_MODULO", "'Expected one value, found %s' % len(it)" ], [ "CALL_FUNCTION", "NotOneValueFound('Expected one value, found %s' % len(it))" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "list(it)" ], [ "BINARY_SUBSCR", "list(it)[0]" ], [ "LOAD_GLOBAL", "tuple" ], [ "LOAD_GLOBAL", "islice" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "islice(it, 2)" ], [ "CALL_FUNCTION", "tuple(islice(it, 2))" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "lst" ], [ "CALL_FUNCTION", "len(lst)" ], [ "COMPARE_OP", "len(lst) == 0" ], [ "LOAD_GLOBAL", "NotOneValueFound" ], [ "CALL_FUNCTION", "NotOneValueFound('Expected one value, found 0')" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "lst" ], [ "CALL_FUNCTION", "len(lst)" ], [ "COMPARE_OP", "len(lst) > 1" ], [ "LOAD_GLOBAL", "NotOneValueFound" ], [ "CALL_FUNCTION", "NotOneValueFound('Expected one value, found several')" ], [ "LOAD_FAST", "lst" ], [ "BINARY_SUBSCR", "lst[0]" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "cache" ], [ "CALL_FUNCTION", "cache" ], [ "LOAD_NAME", "cache" ], [ "CALL_FUNCTION", "cache" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "text" ], [ "LOAD_GLOBAL", "text_type" ], [ "CALL_FUNCTION", "isinstance(text, text_type)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.decode_source" ], [ "LOAD_FAST", "text" ], [ "CALL_METHOD", "self.decode_source(text)" ], [ "LOAD_FAST", "text" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_FAST", "text" ], [ "LOAD_METHOD", "''.join" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "text" ], [ "LOAD_METHOD", "text.splitlines" ], [ "CALL_METHOD", "text.splitlines(True)" ], [ "CALL_FUNCTION", "enumerate(text.splitlines(True))" ], [ "CALL_METHOD", "''.join([\n '\\n' if i < 2 and encoding_pattern.match(line)\n else line\n for i, line in enumerate(text.splitlines(True))\n ])" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "defaultdict(list)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "text" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.parse" ], [ "LOAD_FAST", "ast_text" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION_KW", "ast.parse(ast_text, filename=filename)" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "SyntaxError" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.walk" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tree" ], [ "CALL_METHOD", "ast.walk(self.tree)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.iter_child_nodes" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.iter_child_nodes(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "hasattr(node, 'lineno')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._nodes_by_line" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.lineno" ], [ "BINARY_SUBSCR", "self._nodes_by_line[node.lineno]" ], [ "LOAD_METHOD", "self._nodes_by_line[node.lineno].append" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self._nodes_by_line[node.lineno].append(node)" ], [ "LOAD_GLOBAL", "QualnameVisitor" ], [ "CALL_FUNCTION", "QualnameVisitor()" ], [ "LOAD_FAST", "visitor" ], [ "LOAD_METHOD", "visitor.visit" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tree" ], [ "CALL_METHOD", "visitor.visit(self.tree)" ], [ "LOAD_FAST", "visitor" ], [ "LOAD_ATTR", "visitor.qualnames" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "i" ], [ "COMPARE_OP", "i < 2" ], [ "LOAD_GLOBAL", "encoding_pattern" ], [ "LOAD_METHOD", "encoding_pattern.match" ], [ "LOAD_FAST", "line" ], [ "CALL_METHOD", "encoding_pattern.match(line)" ], [ "LOAD_FAST", "line" ], [ "LOAD_FAST", "cls" ], [ "LOAD_METHOD", "cls.for_filename" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_filename" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "CALL_METHOD", "cls.for_filename(frame.f_code.co_filename, frame.f_globals or {})" ], [ "LOAD_FAST", "cls" ], [ "LOAD_METHOD", "cls._class_local" ], [ "CALL_METHOD", "cls._class_local('__source_cache', {})" ], [ "LOAD_FAST", "source_cache" ], [ "LOAD_FAST", "filename" ], [ "BINARY_SUBSCR", "source_cache[filename]" ], [ "LOAD_GLOBAL", "KeyError" ], [ "LOAD_GLOBAL", "linecache" ], [ "LOAD_METHOD", "linecache.getlines" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "module_globals" ], [ "CALL_METHOD", "linecache.getlines(filename, module_globals)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_FAST", "filename" ], [ "LOAD_METHOD", "''.join" ], [ "LOAD_FAST", "lines" ], [ "CALL_METHOD", "''.join(lines)" ], [ "CALL_FUNCTION", "cls(filename, ''.join(lines))" ], [ "LOAD_FAST", "source_cache" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_GLOBAL", "linecache" ], [ "CALL_FUNCTION", "hasattr(linecache, 'lazycache')" ], [ "LOAD_GLOBAL", "linecache" ], [ "LOAD_METHOD", "linecache.lazycache" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_filename" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "CALL_METHOD", "linecache.lazycache(frame.f_code.co_filename, frame.f_globals)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lasti" ], [ "LOAD_FAST", "cls" ], [ "LOAD_METHOD", "cls._class_local" ], [ "CALL_METHOD", "cls._class_local('__executing_cache', {})" ], [ "LOAD_FAST", "executing_cache" ], [ "LOAD_FAST", "key" ], [ "BINARY_SUBSCR", "executing_cache[key]" ], [ "LOAD_GLOBAL", "KeyError" ], [ "LOAD_FAST", "cls" ], [ "LOAD_METHOD", "cls.for_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "cls.for_frame(frame)" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.tree" ], [ "LOAD_FAST", "source" ], [ "LOAD_METHOD", "source.statements_at_line" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lineno" ], [ "CALL_METHOD", "source.statements_at_line(frame.f_lineno)" ], [ "LOAD_GLOBAL", "NodeFinder" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "stmts" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.tree" ], [ "CALL_FUNCTION", "NodeFinder(frame, stmts, source.tree)" ], [ "LOAD_ATTR", "NodeFinder(frame, stmts, source.tree).result" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_GLOBAL", "statement_containing_node" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "statement_containing_node(node)" ], [ "LOAD_FAST", "new_stmts" ], [ "LOAD_FAST", "stmts" ], [ "COMPARE_OP", "new_stmts <= stmts" ], [ "LOAD_FAST", "new_stmts" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "stmts" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "executing_cache" ], [ "LOAD_FAST", "key" ], [ "LOAD_GLOBAL", "Executing" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION_EX", "Executing(frame, *args)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_ATTR", "cls.__dict__" ], [ "LOAD_METHOD", "cls.__dict__.get" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "default" ], [ "CALL_METHOD", "cls.__dict__.get(name, default)" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_FAST", "cls" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "setattr(cls, name, result)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._nodes_by_line" ], [ "LOAD_FAST", "lineno" ], [ "BINARY_SUBSCR", "self._nodes_by_line[lineno]" ], [ "LOAD_GLOBAL", "statement_containing_node" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "statement_containing_node(node)" ], [ "LOAD_FAST", "ASTTokens" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.text" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tree" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.filename" ], [ "CALL_FUNCTION_KW", "ASTTokens(\n self.text,\n tree=self.tree,\n filename=self.filename,\n )" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "source" ], [ "LOAD_GLOBAL", "bytes" ], [ "CALL_FUNCTION", "isinstance(source, bytes)" ], [ "LOAD_GLOBAL", "detect_encoding" ], [ "LOAD_GLOBAL", "io" ], [ "LOAD_METHOD", "io.BytesIO" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "io.BytesIO(source)" ], [ "LOAD_ATTR", "io.BytesIO(source).readline" ], [ "CALL_FUNCTION", "detect_encoding(io.BytesIO(source).readline)" ], [ "LOAD_FAST", "source" ], [ "LOAD_METHOD", "source.decode" ], [ "LOAD_FAST", "encoding" ], [ "CALL_METHOD", "source.decode(encoding)" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_filename" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.filename" ], [ "COMPARE_OP", "code.co_filename == self.filename" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._qualnames" ], [ "LOAD_METHOD", "self._qualnames.get" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_firstlineno" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "CALL_METHOD", "self._qualnames.get((code.co_name, code.co_firstlineno), code.co_name)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "stmts" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.source" ], [ "LOAD_METHOD", "self.source.code_qualname" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_code" ], [ "CALL_METHOD", "self.source.code_qualname(self.frame.f_code)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.source" ], [ "LOAD_METHOD", "self.source.asttokens" ], [ "CALL_METHOD", "self.source.asttokens()" ], [ "LOAD_METHOD", "self.source.asttokens().get_text" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.node" ], [ "CALL_METHOD", "self.source.asttokens().get_text(self.node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.source" ], [ "LOAD_METHOD", "self.source.asttokens" ], [ "CALL_METHOD", "self.source.asttokens()" ], [ "LOAD_METHOD", "self.source.asttokens().get_text_range" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.node" ], [ "CALL_METHOD", "self.source.asttokens().get_text_range(self.node)" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "QualnameVisitor" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(QualnameVisitor, self)" ], [ "LOAD_METHOD", "super(QualnameVisitor, self).__init__" ], [ "CALL_METHOD", "super(QualnameVisitor, self).__init__()" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.name" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_METHOD", "self.stack.append" ], [ "LOAD_FAST", "name" ], [ "CALL_METHOD", "self.stack.append(name)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.qualnames" ], [ "LOAD_METHOD", "self.qualnames.setdefault" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.lineno" ], [ "LOAD_METHOD", "\".\".join" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "CALL_METHOD", "\".\".join(self.stack)" ], [ "CALL_METHOD", "self.qualnames.setdefault((name, node.lineno), \".\".join(self.stack))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_METHOD", "self.stack.append" ], [ "CALL_METHOD", "self.stack.append('')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Lambda" ], [ "CALL_FUNCTION", "isinstance(node, ast.Lambda)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.body" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.body" ], [ "LOAD_FAST", "children" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.visit" ], [ "LOAD_FAST", "child" ], [ "CALL_METHOD", "self.visit(child)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_METHOD", "self.stack.pop" ], [ "CALL_METHOD", "self.stack.pop()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_METHOD", "self.stack.pop" ], [ "CALL_METHOD", "self.stack.pop()" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.iter_fields" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.iter_fields(node)" ], [ "LOAD_FAST", "field" ], [ "COMPARE_OP", "field == 'body'" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.AST" ], [ "CALL_FUNCTION", "isinstance(child, ast.AST)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.visit" ], [ "LOAD_FAST", "child" ], [ "CALL_METHOD", "self.visit(child)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "isinstance(child, list)" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "grandchild" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.AST" ], [ "CALL_FUNCTION", "isinstance(grandchild, ast.AST)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.visit" ], [ "LOAD_FAST", "grandchild" ], [ "CALL_METHOD", "self.visit(grandchild)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.visit_FunctionDef" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self.visit_FunctionDef(node, '')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_METHOD", "self.stack.append" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.name" ], [ "CALL_METHOD", "self.stack.append(node.name)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.generic_visit" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self.generic_visit(node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_METHOD", "self.stack.pop" ], [ "CALL_METHOD", "self.stack.pop()" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "__future__" ], [ "LOAD_FAST", "fname" ], [ "CALL_FUNCTION", "getattr(__future__, fname)" ], [ "LOAD_ATTR", "getattr(__future__, fname).compiler_flag" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "matching_code" ], [ "LOAD_ATTR", "matching_code.co_filename" ], [ "LOAD_GLOBAL", "future_flags" ], [ "LOAD_FAST", "matching_code" ], [ "LOAD_ATTR", "matching_code.co_flags" ], [ "BINARY_AND", "future_flags & matching_code.co_flags" ], [ "CALL_FUNCTION_KW", "compile(\n source,\n matching_code.co_filename,\n 'exec',\n flags=future_flags & matching_code.co_flags,\n dont_inherit=True,\n )" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "tree" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_code" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lasti" ], [ "BINARY_SUBSCR", "frame.f_code.co_code[frame.f_lasti]" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_GLOBAL", "ord" ], [ "LOAD_FAST", "b" ], [ "CALL_FUNCTION", "ord(b)" ], [ "LOAD_GLOBAL", "dis" ], [ "LOAD_ATTR", "dis.opname" ], [ "LOAD_FAST", "b" ], [ "BINARY_SUBSCR", "dis.opname[b]" ], [ "LOAD_FAST", "op_name" ], [ "LOAD_METHOD", "op_name.startswith" ], [ "CALL_METHOD", "op_name.startswith('CALL_')" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Call" ], [ "LOAD_FAST", "op_name" ], [ "COMPARE_OP", "op_name == 'BINARY_SUBSCR'" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Subscript" ], [ "LOAD_FAST", "op_name" ], [ "LOAD_METHOD", "op_name.startswith" ], [ "CALL_METHOD", "op_name.startswith('BINARY_')" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.BinOp" ], [ "LOAD_FAST", "op_name" ], [ "LOAD_METHOD", "op_name.startswith" ], [ "CALL_METHOD", "op_name.startswith('UNARY_')" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.UnaryOp" ], [ "LOAD_FAST", "op_name" ], [ "COMPARE_OP", "op_name in ('LOAD_ATTR', 'LOAD_METHOD', 'LOOKUP_METHOD')" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Attribute" ], [ "LOAD_FAST", "op_name" ], [ "COMPARE_OP", "op_name == 'COMPARE_OP'" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Compare" ], [ "LOAD_GLOBAL", "RuntimeError" ], [ "LOAD_FAST", "op_name" ], [ "CALL_FUNCTION", "RuntimeError(op_name)" ], [ "LOAD_GLOBAL", "lock" ], [ "LOAD_FAST", "stmts" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.matching_nodes" ], [ "LOAD_FAST", "exprs" ], [ "CALL_METHOD", "self.matching_nodes(exprs)" ], [ "CALL_FUNCTION", "list(self.matching_nodes(exprs))" ], [ "CALL_FUNCTION", "only(list(self.matching_nodes(exprs)))" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.walk" ], [ "LOAD_FAST", "stmt" ], [ "CALL_METHOD", "ast.walk(stmt)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "typ" ], [ "CALL_FUNCTION", "isinstance(node, typ)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "hasattr(node, \"ctx\")" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.ctx" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Load" ], [ "CALL_FUNCTION", "isinstance(node.ctx, ast.Load)" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "exprs" ], [ "CALL_FUNCTION", "enumerate(exprs)" ], [ "LOAD_GLOBAL", "get_setter" ], [ "LOAD_FAST", "expr" ], [ "CALL_FUNCTION", "get_setter(expr)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.BinOp" ], [ "LOAD_FAST", "expr" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.Pow" ], [ "CALL_METHOD", "ast.Pow()" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Str" ], [ "LOAD_GLOBAL", "sentinel" ], [ "CALL_FUNCTION_KW", "ast.Str(s=sentinel)" ], [ "CALL_FUNCTION_KW", "ast.BinOp(\n left=expr,\n op=ast.Pow(),\n right=ast.Str(s=sentinel),\n )" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.fix_missing_locations" ], [ "LOAD_FAST", "replacement" ], [ "CALL_METHOD", "ast.fix_missing_locations(replacement)" ], [ "LOAD_FAST", "setter" ], [ "LOAD_FAST", "replacement" ], [ "CALL_FUNCTION", "setter(replacement)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.compile_instructions" ], [ "CALL_METHOD", "self.compile_instructions()" ], [ "LOAD_GLOBAL", "SyntaxError" ], [ "LOAD_FAST", "setter" ], [ "LOAD_FAST", "expr" ], [ "CALL_FUNCTION", "setter(expr)" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "instructions" ], [ "CALL_FUNCTION", "enumerate(instructions)" ], [ "LOAD_FAST", "indices" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_FAST", "indices" ], [ "CALL_FUNCTION", "only(indices)" ], [ "BINARY_SUBTRACT", "only(indices) - 1" ], [ "LOAD_FAST", "instructions" ], [ "LOAD_FAST", "arg_index" ], [ "BINARY_SUBSCR", "instructions[arg_index]" ], [ "LOAD_ATTR", "instructions[arg_index].opname" ], [ "COMPARE_OP", "instructions[arg_index].opname == 'EXTENDED_ARG'" ], [ "LOAD_FAST", "instructions" ], [ "LOAD_FAST", "arg_index" ], [ "BINARY_SUBSCR", "instructions[arg_index]" ], [ "LOAD_ATTR", "instructions[arg_index].offset" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_lasti" ], [ "COMPARE_OP", "instructions[arg_index].offset == self.frame.f_lasti" ], [ "LOAD_FAST", "expr" ], [ "LOAD_FAST", "instruction" ], [ "LOAD_ATTR", "instruction.argval" ], [ "LOAD_GLOBAL", "sentinel" ], [ "COMPARE_OP", "instruction.argval == sentinel" ], [ "LOAD_FAST", "i" ], [ "LOAD_GLOBAL", "compile_similar_to" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tree" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_code" ], [ "CALL_FUNCTION", "compile_similar_to(self.tree, self.frame.f_code)" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_GLOBAL", "find_codes" ], [ "LOAD_FAST", "module_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_code" ], [ "CALL_FUNCTION", "find_codes(module_code, self.frame.f_code)" ], [ "CALL_FUNCTION", "only(find_codes(module_code, self.frame.f_code))" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "get_instructions" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "get_instructions(code)" ], [ "CALL_FUNCTION", "list(get_instructions(code))" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.iter_fields" ], [ "LOAD_DEREF", "parent" ], [ "CALL_METHOD", "ast.iter_fields(parent)" ], [ "LOAD_DEREF", "field" ], [ "LOAD_FAST", "node" ], [ "COMPARE_OP", "field is node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_DEREF", "field" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "isinstance(field, list)" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_DEREF", "field" ], [ "CALL_FUNCTION", "enumerate(field)" ], [ "LOAD_FAST", "item" ], [ "LOAD_FAST", "node" ], [ "COMPARE_OP", "item is node" ], [ "LOAD_FAST", "setter" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_DEREF", "parent" ], [ "LOAD_DEREF", "name" ], [ "LOAD_FAST", "new_node" ], [ "CALL_FUNCTION", "setattr(parent, name, new_node)" ], [ "LOAD_FAST", "new_node" ], [ "LOAD_DEREF", "field" ], [ "LOAD_DEREF", "i" ], [ "LOAD_DEREF", "matches" ], [ "LOAD_FAST", "root_code" ], [ "CALL_FUNCTION", "matches(root_code)" ], [ "LOAD_DEREF", "code_options" ], [ "LOAD_METHOD", "code_options.append" ], [ "LOAD_FAST", "root_code" ], [ "CALL_METHOD", "code_options.append(root_code)" ], [ "LOAD_DEREF", "finder" ], [ "LOAD_FAST", "root_code" ], [ "CALL_FUNCTION", "finder(root_code)" ], [ "LOAD_DEREF", "code_options" ], [ "LOAD_GLOBAL", "all" ], [ "LOAD_GLOBAL", "attrgetter" ], [ "CALL_FUNCTION", "attrgetter('co_firstlineno')" ], [ "LOAD_GLOBAL", "attrgetter" ], [ "CALL_FUNCTION", "attrgetter('co_name')" ], [ "LOAD_GLOBAL", "code_names" ], [ "CALL_FUNCTION", "all(\n f(c) == f(matching)\n for f in [\n attrgetter('co_firstlineno'),\n attrgetter('co_name'),\n code_names,\n ]\n )" ], [ "LOAD_FAST", "f" ], [ "LOAD_DEREF", "c" ], [ "CALL_FUNCTION", "f(c)" ], [ "LOAD_FAST", "f" ], [ "LOAD_DEREF", "matching" ], [ "CALL_FUNCTION", "f(matching)" ], [ "COMPARE_OP", "f(c) == f(matching)" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_consts" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.iscode" ], [ "LOAD_FAST", "const" ], [ "CALL_METHOD", "inspect.iscode(const)" ], [ "LOAD_DEREF", "matches" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "matches(const)" ], [ "LOAD_DEREF", "code_options" ], [ "LOAD_METHOD", "code_options.append" ], [ "LOAD_FAST", "const" ], [ "CALL_METHOD", "code_options.append(const)" ], [ "LOAD_DEREF", "finder" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "finder(const)" ], [ "LOAD_GLOBAL", "frozenset" ], [ "CALL_FUNCTION", "frozenset()" ], [ "LOAD_METHOD", "frozenset().union" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_names" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_varnames" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_freevars" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_cellvars" ], [ "CALL_METHOD", "frozenset().union(\n code.co_names,\n code.co_varnames,\n code.co_freevars,\n code.co_cellvars,\n )" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "CALL_FUNCTION", "isinstance(node, ast.stmt)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_FAST", "node" ] ], "import_hook.py": [ [ "LOAD_NAME", "object" ], [ "LOAD_FAST", "spec" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "deep" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "eye" ], [ "LOAD_ATTR", "eye.exec_string" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.source" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._spec" ], [ "LOAD_ATTR", "self._spec.origin" ], [ "LOAD_FAST", "module" ], [ "LOAD_ATTR", "module.__dict__" ], [ "LOAD_FAST", "module" ], [ "LOAD_ATTR", "module.__dict__" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.deep" ], [ "CALL_FUNCTION_KW", "eye.exec_string(\n source=self.source,\n filename=self._spec.origin,\n globs=module.__dict__,\n locs=module.__dict__,\n deep=self.deep,\n )" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._spec" ], [ "LOAD_ATTR", "self._spec.loader" ], [ "LOAD_METHOD", "self._spec.loader.get_filename" ], [ "LOAD_FAST", "fullname" ], [ "CALL_METHOD", "self._spec.loader.get_filename(fullname)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._spec" ], [ "LOAD_ATTR", "self._spec.loader" ], [ "LOAD_METHOD", "self._spec.loader.is_package" ], [ "LOAD_FAST", "fullname" ], [ "CALL_METHOD", "self._spec.loader.is_package(fullname)" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.meta_path" ], [ "LOAD_FAST", "finder" ], [ "LOAD_FAST", "self" ], [ "COMPARE_OP", "finder is self" ], [ "LOAD_FAST", "finder" ], [ "LOAD_ATTR", "finder.__module__" ], [ "COMPARE_OP", "'pytest' in finder.__module__" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "finder" ], [ "CALL_FUNCTION", "hasattr(finder, 'find_spec')" ], [ "LOAD_FAST", "finder" ], [ "LOAD_ATTR", "finder.find_spec" ], [ "LOAD_FAST", "fullname" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "target" ], [ "CALL_FUNCTION_KW", "finder.find_spec(fullname, path, target=target)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "finder" ], [ "CALL_FUNCTION", "hasattr(finder, 'load_module')" ], [ "LOAD_GLOBAL", "spec_from_loader" ], [ "LOAD_FAST", "fullname" ], [ "LOAD_FAST", "finder" ], [ "CALL_FUNCTION", "spec_from_loader(fullname, finder)" ], [ "LOAD_FAST", "spec" ], [ "COMPARE_OP", "spec is not None" ], [ "LOAD_FAST", "spec" ], [ "LOAD_ATTR", "spec.origin" ], [ "COMPARE_OP", "spec.origin != 'builtin'" ], [ "LOAD_FAST", "spec" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._find_plain_spec" ], [ "LOAD_FAST", "fullname" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "target" ], [ "CALL_METHOD", "self._find_plain_spec(fullname, path, target)" ], [ "LOAD_FAST", "spec" ], [ "COMPARE_OP", "spec is None" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "spec" ], [ "LOAD_ATTR", "spec.loader" ], [ "CALL_FUNCTION", "hasattr(spec.loader, 'get_source')" ], [ "LOAD_GLOBAL", "callable" ], [ "LOAD_FAST", "spec" ], [ "LOAD_ATTR", "spec.loader" ], [ "LOAD_ATTR", "spec.loader.get_source" ], [ "CALL_FUNCTION", "callable(spec.loader.get_source)" ], [ "LOAD_FAST", "fullname" ], [ "COMPARE_OP", "fullname != 'org'" ], [ "LOAD_GLOBAL", "logging" ], [ "LOAD_METHOD", "logging.debug" ], [ "LOAD_FAST", "fullname" ], [ "CALL_METHOD", "logging.debug('Failed finding spec for %s', fullname)" ], [ "LOAD_FAST", "spec" ], [ "LOAD_ATTR", "spec.loader" ], [ "LOAD_METHOD", "spec.loader.get_source" ], [ "LOAD_FAST", "fullname" ], [ "CALL_METHOD", "spec.loader.get_source(fullname)" ], [ "LOAD_GLOBAL", "ImportError" ], [ "LOAD_GLOBAL", "logging" ], [ "LOAD_METHOD", "logging.debug" ], [ "LOAD_FAST", "fullname" ], [ "CALL_METHOD", "logging.debug('Loader for %s was unable to find the sources',\n fullname)" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_GLOBAL", "logging" ], [ "LOAD_METHOD", "logging.exception" ], [ "LOAD_FAST", "fullname" ], [ "CALL_METHOD", "logging.exception('Loader for %s raised an error', fullname)" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "source" ], [ "COMPARE_OP", "'birdseye' not in source" ], [ "LOAD_GLOBAL", "should_trace" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "should_trace(source)" ], [ "LOAD_FAST", "trace_stmt" ], [ "LOAD_GLOBAL", "BirdsEyeLoader" ], [ "LOAD_FAST", "spec" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "deep" ], [ "CALL_FUNCTION", "BirdsEyeLoader(spec, source, deep)" ], [ "LOAD_GLOBAL", "spec_from_loader" ], [ "LOAD_FAST", "fullname" ], [ "LOAD_FAST", "loader" ], [ "CALL_FUNCTION", "spec_from_loader(fullname, loader)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.parse" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "ast.parse(source)" ], [ "LOAD_ATTR", "ast.parse(source).body" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Import" ], [ "CALL_FUNCTION", "isinstance(stmt, ast.Import)" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_ATTR", "stmt.names" ], [ "LOAD_FAST", "alias" ], [ "LOAD_ATTR", "alias.name" ], [ "LOAD_METHOD", "alias.name.startswith" ], [ "CALL_METHOD", "alias.name.startswith('birdseye.trace_module')" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_FAST", "alias" ], [ "LOAD_ATTR", "alias.name" ], [ "LOAD_METHOD", "alias.name.endswith" ], [ "CALL_METHOD", "alias.name.endswith('deep')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.ImportFrom" ], [ "CALL_FUNCTION", "isinstance(stmt, ast.ImportFrom)" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_ATTR", "stmt.module" ], [ "COMPARE_OP", "stmt.module == 'birdseye'" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_ATTR", "stmt.names" ], [ "LOAD_FAST", "alias" ], [ "LOAD_ATTR", "alias.name" ], [ "LOAD_METHOD", "alias.name.startswith" ], [ "CALL_METHOD", "alias.name.startswith('trace_module')" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_FAST", "alias" ], [ "LOAD_ATTR", "alias.name" ], [ "LOAD_METHOD", "alias.name.endswith" ], [ "CALL_METHOD", "alias.name.endswith('deep')" ], [ "LOAD_FAST", "deep" ], [ "LOAD_FAST", "trace_stmt" ] ], "ipython.py": [ [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "BytesIO" ], [ "LOAD_NAME", "StringIO" ], [ "LOAD_NAME", "stream_proxy" ], [ "LOAD_NAME", "sys" ], [ "LOAD_ATTR", "sys.stderr" ], [ "CALL_FUNCTION", "stream_proxy(sys.stderr)" ], [ "LOAD_NAME", "sys" ], [ "LOAD_NAME", "stream_proxy" ], [ "LOAD_NAME", "sys" ], [ "LOAD_ATTR", "sys.stdout" ], [ "CALL_FUNCTION", "stream_proxy(sys.stdout)" ], [ "LOAD_NAME", "sys" ], [ "LOAD_NAME", "Environment" ], [ "LOAD_NAME", "PackageLoader" ], [ "CALL_FUNCTION", "PackageLoader('birdseye', 'templates')" ], [ "LOAD_NAME", "select_autoescape" ], [ "CALL_FUNCTION", "select_autoescape(['html', 'xml'])" ], [ "CALL_FUNCTION_KW", "Environment(\n loader=PackageLoader('birdseye', 'templates'),\n autoescape=select_autoescape(['html', 'xml'])\n)" ], [ "LOAD_NAME", "magics_class" ], [ "LOAD_NAME", "Magics" ], [ "CALL_FUNCTION", "magics_class" ], [ "LOAD_GLOBAL", "LocalProxy" ], [ "LOAD_FAST", "p" ], [ "CALL_FUNCTION", "LocalProxy(p)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.currentframe" ], [ "CALL_METHOD", "inspect.currentframe()" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_GLOBAL", "ThreadingMixIn" ], [ "LOAD_ATTR", "ThreadingMixIn.process_request_thread" ], [ "LOAD_ATTR", "ThreadingMixIn.process_request_thread.__code__" ], [ "COMPARE_OP", "frame.f_code == ThreadingMixIn.process_request_thread.__code__" ], [ "LOAD_GLOBAL", "fake_stream" ], [ "CALL_FUNCTION", "fake_stream()" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_GLOBAL", "thread_proxies" ], [ "LOAD_METHOD", "thread_proxies.get" ], [ "LOAD_GLOBAL", "currentThread" ], [ "CALL_FUNCTION", "currentThread()" ], [ "LOAD_ATTR", "currentThread().ident" ], [ "LOAD_DEREF", "original" ], [ "CALL_METHOD", "thread_proxies.get(currentThread().ident,\n original)" ], [ "LOAD_FAST", "show_server_output" ], [ "LOAD_GLOBAL", "fake_stream" ], [ "CALL_FUNCTION", "fake_stream()" ], [ "LOAD_GLOBAL", "thread_proxies" ], [ "LOAD_GLOBAL", "currentThread" ], [ "CALL_FUNCTION", "currentThread()" ], [ "LOAD_ATTR", "currentThread().ident" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_ATTR", "server.app" ], [ "LOAD_ATTR", "server.app.run" ], [ "LOAD_FAST", "port" ], [ "LOAD_FAST", "bind_host" ], [ "CALL_FUNCTION_KW", "server.app.run(\n debug=True,\n port=port,\n host=bind_host,\n use_reloader=False,\n )" ], [ "LOAD_GLOBAL", "socket" ], [ "LOAD_ATTR", "socket.error" ], [ "LOAD_NAME", "Unicode" ], [ "CALL_FUNCTION_KW", "Unicode(\n u'', config=True,\n help='If set, a server will not be automatically started by %%eye. '\n 'The iframe containing birdseye output will use this value as the base '\n 'of its URL.'\n )" ], [ "LOAD_NAME", "Int" ], [ "CALL_FUNCTION_KW", "Int(\n 7777, config=True,\n help='Port number for the server started by %%eye.'\n )" ], [ "LOAD_NAME", "Unicode" ], [ "CALL_FUNCTION_KW", "Unicode(\n '127.0.0.1', config=True,\n help='Host that the server started by %%eye listens on. '\n 'Set to 0.0.0.0 to make it accessible anywhere.'\n )" ], [ "LOAD_NAME", "Bool" ], [ "CALL_FUNCTION_KW", "Bool(\n False, config=True,\n help='Set to True to show stdout and stderr from the server started by %%eye.'\n )" ], [ "LOAD_NAME", "Unicode" ], [ "CALL_FUNCTION_KW", "Unicode(\n u'', config=True,\n help='The database URL that the server started by %%eye reads from. '\n 'Equivalent to the environment variable BIRDSEYE_DB.'\n )" ], [ "LOAD_NAME", "cell_magic" ], [ "CALL_FUNCTION", "cell_magic" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.server_url" ], [ "LOAD_GLOBAL", "Database" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.db_url" ], [ "CALL_FUNCTION", "Database(self.db_url)" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_ATTR", "server.db" ], [ "LOAD_ATTR", "server.db.Function" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_ATTR", "server.db" ], [ "LOAD_ATTR", "server.db.Call" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_ATTR", "server.db" ], [ "LOAD_ATTR", "server.db.Session" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_GLOBAL", "Thread" ], [ "LOAD_GLOBAL", "run_server" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.port" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.bind_host" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.show_server_output" ], [ "CALL_FUNCTION_KW", "Thread(\n target=run_server,\n args=(\n self.port,\n self.bind_host,\n self.show_server_output,\n ),\n )" ], [ "LOAD_METHOD", "Thread(\n target=run_server,\n args=(\n self.port,\n self.bind_host,\n self.show_server_output,\n ),\n ).start" ], [ "CALL_METHOD", "Thread(\n target=run_server,\n args=(\n self.port,\n self.bind_host,\n self.show_server_output,\n ),\n ).start()" ], [ "LOAD_GLOBAL", "Database" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.db_url" ], [ "CALL_FUNCTION", "Database(self.db_url)" ], [ "LOAD_GLOBAL", "eye" ], [ "LOAD_GLOBAL", "eye" ], [ "LOAD_METHOD", "eye.exec_ipython_cell" ], [ "LOAD_FAST", "cell" ], [ "LOAD_FAST", "callback" ], [ "CALL_METHOD", "eye.exec_ipython_cell(cell, callback)" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "call_id" ], [ "COMPARE_OP", "call_id is None" ], [ "LOAD_GLOBAL", "HTML" ], [ "LOAD_GLOBAL", "templates_env" ], [ "LOAD_METHOD", "templates_env.get_template" ], [ "CALL_METHOD", "templates_env.get_template('ipython_iframe.html')" ], [ "LOAD_ATTR", "templates_env.get_template('ipython_iframe.html').render" ], [ "LOAD_FAST", "call_id" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.server_url" ], [ "LOAD_METHOD", "self.server_url.rstrip" ], [ "CALL_METHOD", "self.server_url.rstrip('/')" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.port" ], [ "LOAD_GLOBAL", "uuid4" ], [ "CALL_FUNCTION", "uuid4()" ], [ "LOAD_ATTR", "uuid4().hex" ], [ "CALL_FUNCTION_KW", "templates_env.get_template('ipython_iframe.html').render(\n call_id=call_id,\n url=self.server_url.rstrip('/'),\n port=self.port,\n container_id=uuid4().hex,\n )" ], [ "CALL_FUNCTION", "HTML(templates_env.get_template('ipython_iframe.html').render(\n call_id=call_id,\n url=self.server_url.rstrip('/'),\n port=self.port,\n container_id=uuid4().hex,\n ))" ], [ "LOAD_GLOBAL", "display" ], [ "LOAD_FAST", "html" ], [ "CALL_FUNCTION", "display(html)" ] ], "server.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOAD_METHOD", "standard_library.install_aliases" ], [ "CALL_METHOD", "standard_library.install_aliases()" ], [ "LOAD_NAME", "Flask" ], [ "CALL_FUNCTION", "Flask('birdseye')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.jinja_env" ], [ "LOAD_NAME", "Humanize" ], [ "LOAD_NAME", "app" ], [ "CALL_FUNCTION", "Humanize(app)" ], [ "LOAD_NAME", "PathConverter" ], [ "LOAD_NAME", "FileConverter" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.url_map" ], [ "LOAD_ATTR", "app.url_map.converters" ], [ "LOAD_NAME", "Database" ], [ "CALL_FUNCTION", "Database()" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.Session" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.Function" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.Call" ], [ "LOAD_NAME", "app" ], [ "LOAD_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/file/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/file/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/file//__function__/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/file//__function__/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/api/file//__function__//latest_call/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/api/file//__function__//latest_call/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "LOAD_NAME", "app" ], [ "LOAD_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/call/')" ], [ "CALL_FUNCTION", "app.route('/call/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/ipython_call/')" ], [ "CALL_FUNCTION", "app.route('/ipython_call/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/ipython_iframe/')" ], [ "CALL_FUNCTION", "app.route('/ipython_iframe/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION_KW", "app.route('/kill', methods=['POST'])" ], [ "CALL_FUNCTION", "app.route('/kill', methods=['POST'])" ], [ "LOAD_NAME", "app" ], [ "LOAD_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/api/call/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/api/call/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/api/calls_by_body_hash/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/api/calls_by_body_hash/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION_KW", "app.route('/api/body_hashes_present/', methods=['POST'])" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/api/body_hashes_present/', methods=['POST'])" ], [ "LOAD_NAME", "sys" ], [ "LOAD_ATTR", "sys.argv" ], [ "BINARY_SUBSCR", "sys.argv[1:]" ], [ "LOAD_NAME", "__name__" ], [ "COMPARE_OP", "__name__ == '__main__'" ], [ "LOAD_NAME", "main" ], [ "CALL_FUNCTION", "main()" ], [ "LOAD_GLOBAL", "db" ], [ "LOAD_METHOD", "db.all_file_paths" ], [ "CALL_METHOD", "db.all_file_paths()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_columns" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.basic_columns" ], [ "BINARY_ADD", "Call.basic_columns + Function.basic_columns" ], [ "CALL_FUNCTION_EX", "session.query(*(Call.basic_columns + Function.basic_columns))" ], [ "LOAD_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)" ], [ "LOAD_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .order_by" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.start_time" ], [ "LOAD_METHOD", "Call.start_time.desc" ], [ "CALL_METHOD", "Call.start_time.desc()" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .order_by(Call.start_time.desc())" ], [ "BINARY_SUBSCR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .order_by(Call.start_time.desc())[:100]" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "CALL_FUNCTION", "OrderedDict()" ], [ "LOAD_FAST", "recent_calls" ], [ "LOAD_GLOBAL", "is_ipython_cell" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.file" ], [ "CALL_FUNCTION", "is_ipython_cell(row.file)" ], [ "LOAD_FAST", "files" ], [ "LOAD_METHOD", "files.setdefault" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.file" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "CALL_FUNCTION", "OrderedDict()" ], [ "CALL_METHOD", "files.setdefault(\n row.file, OrderedDict()\n )" ], [ "LOAD_METHOD", "files.setdefault(\n row.file, OrderedDict()\n ).setdefault" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.name" ], [ "LOAD_FAST", "row" ], [ "CALL_METHOD", "files.setdefault(\n row.file, OrderedDict()\n ).setdefault(\n row.name, row\n )" ], [ "LOAD_FAST", "all_paths" ], [ "LOAD_FAST", "files" ], [ "LOAD_METHOD", "files.setdefault" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "CALL_FUNCTION", "OrderedDict()" ], [ "CALL_METHOD", "files.setdefault(\n path, OrderedDict()\n )" ], [ "LOAD_GLOBAL", "partial" ], [ "LOAD_GLOBAL", "short_path" ], [ "LOAD_FAST", "all_paths" ], [ "CALL_FUNCTION_KW", "partial(short_path, all_paths=all_paths)" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "short" ], [ "LOAD_FAST", "files" ], [ "CALL_FUNCTION_KW", "render_template('index.html',\n short=short,\n files=files)" ], [ "LOAD_GLOBAL", "fix_abs_path" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "fix_abs_path(path)" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_columns" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.basic_columns" ], [ "BINARY_ADD", "Call.basic_columns + Function.basic_columns" ], [ "CALL_FUNCTION_EX", "session.query(*(Call.basic_columns + Function.basic_columns))" ], [ "LOAD_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)" ], [ "LOAD_ATTR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION_KW", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path)" ], [ "LOAD_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path)\n .subquery" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path)\n .subquery('filtered_calls')" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.query" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.name" ], [ "LOAD_GLOBAL", "sqlalchemy" ], [ "LOAD_ATTR", "sqlalchemy.func" ], [ "LOAD_METHOD", "sqlalchemy.func.max" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.start_time" ], [ "CALL_METHOD", "sqlalchemy.func.max(filtered_calls.c.start_time)" ], [ "LOAD_METHOD", "sqlalchemy.func.max(filtered_calls.c.start_time).label" ], [ "CALL_METHOD", "sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')" ], [ "CALL_METHOD", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n )" ], [ "LOAD_METHOD", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n ).group_by" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.name" ], [ "CALL_METHOD", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n ).group_by(\n filtered_calls.c.name,\n )" ], [ "LOAD_METHOD", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n ).group_by(\n filtered_calls.c.name,\n ).subquery" ], [ "CALL_METHOD", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n ).group_by(\n filtered_calls.c.name,\n ).subquery('latest_calls')" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.query" ], [ "LOAD_FAST", "filtered_calls" ], [ "CALL_METHOD", "session.query(filtered_calls)" ], [ "LOAD_METHOD", "session.query(filtered_calls).join" ], [ "LOAD_FAST", "latest_calls" ], [ "LOAD_GLOBAL", "sqlalchemy" ], [ "LOAD_METHOD", "sqlalchemy.and_" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.name" ], [ "LOAD_FAST", "latest_calls" ], [ "LOAD_ATTR", "latest_calls.c" ], [ "LOAD_ATTR", "latest_calls.c.name" ], [ "COMPARE_OP", "filtered_calls.c.name == latest_calls.c.name" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.start_time" ], [ "LOAD_FAST", "latest_calls" ], [ "LOAD_ATTR", "latest_calls.c" ], [ "LOAD_ATTR", "latest_calls.c.maxtime" ], [ "COMPARE_OP", "filtered_calls.c.start_time == latest_calls.c.maxtime" ], [ "CALL_METHOD", "sqlalchemy.and_(\n filtered_calls.c.name == latest_calls.c.name,\n filtered_calls.c.start_time == latest_calls.c.maxtime,\n )" ], [ "CALL_METHOD", "session.query(filtered_calls).join(\n latest_calls,\n sqlalchemy.and_(\n filtered_calls.c.name == latest_calls.c.name,\n filtered_calls.c.start_time == latest_calls.c.maxtime,\n )\n )" ], [ "LOAD_METHOD", "session.query(filtered_calls).join(\n latest_calls,\n sqlalchemy.and_(\n filtered_calls.c.name == latest_calls.c.name,\n filtered_calls.c.start_time == latest_calls.c.maxtime,\n )\n ).order_by" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.start_time" ], [ "LOAD_METHOD", "filtered_calls.c.start_time.desc" ], [ "CALL_METHOD", "filtered_calls.c.start_time.desc()" ], [ "CALL_METHOD", "session.query(filtered_calls).join(\n latest_calls,\n sqlalchemy.and_(\n filtered_calls.c.name == latest_calls.c.name,\n filtered_calls.c.start_time == latest_calls.c.maxtime,\n )\n ).order_by(filtered_calls.c.start_time.desc())" ], [ "LOAD_GLOBAL", "group_by_attr" ], [ "LOAD_FAST", "query" ], [ "CALL_FUNCTION", "group_by_attr(query, 'type')" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.query" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.name" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.type" ], [ "CALL_METHOD", "session.query(Function.name, Function.type)" ], [ "LOAD_ATTR", "session.query(Function.name, Function.type)\n .filter_by" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION_KW", "session.query(Function.name, Function.type)\n .filter_by(file=path)" ], [ "LOAD_METHOD", "session.query(Function.name, Function.type)\n .filter_by(file=path)\n .distinct" ], [ "CALL_METHOD", "session.query(Function.name, Function.type)\n .filter_by(file=path)\n .distinct()" ], [ "CALL_FUNCTION", "sorted(session.query(Function.name, Function.type)\n .filter_by(file=path)\n .distinct())" ], [ "LOAD_FAST", "query" ], [ "LOAD_FAST", "all_funcs" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.name" ], [ "LOAD_FAST", "func_names" ], [ "COMPARE_OP", "func.name not in func_names" ], [ "LOAD_FAST", "funcs" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.type" ], [ "BINARY_SUBSCR", "funcs[func.type]" ], [ "LOAD_METHOD", "funcs[func.type].append" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "funcs[func.type].append(func)" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "funcs" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "COMPARE_OP", "path == IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "basename" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "basename(path)" ], [ "CALL_FUNCTION_KW", "render_template('file.html',\n funcs=funcs,\n is_ipython=path == IPYTHON_FILE_PATH,\n full_path=path,\n short_path=basename(path))" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.name" ], [ "LOAD_GLOBAL", "fix_abs_path" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "fix_abs_path(path)" ], [ "LOAD_GLOBAL", "get_calls" ], [ "LOAD_FAST", "session" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "func_name" ], [ "CALL_FUNCTION", "get_calls(session, path, func_name, 200)" ], [ "LOAD_FAST", "query" ], [ "LOAD_FAST", "query" ], [ "BINARY_SUBSCR", "query[0]" ], [ "LOAD_FAST", "query" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.query" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_METHOD", "session.query(Function)" ], [ "LOAD_ATTR", "session.query(Function).filter_by" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "func_name" ], [ "CALL_FUNCTION_KW", "session.query(Function).filter_by(file=path, name=func_name)" ], [ "BINARY_SUBSCR", "session.query(Function).filter_by(file=path, name=func_name)[0]" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "func" ], [ "LOAD_GLOBAL", "basename" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "basename(path)" ], [ "LOAD_FAST", "calls" ], [ "CALL_FUNCTION_KW", "render_template('function.html',\n func=func,\n short_path=basename(path),\n calls=calls)" ], [ "LOAD_GLOBAL", "withattrs" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_FUNCTION", "Call()" ], [ "LOAD_FAST", "row" ], [ "LOAD_METHOD", "row._asdict" ], [ "CALL_METHOD", "row._asdict()" ], [ "CALL_FUNCTION_EX", "withattrs(Call(), **row._asdict())" ], [ "LOAD_GLOBAL", "fix_abs_path" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "fix_abs_path(path)" ], [ "LOAD_GLOBAL", "get_calls" ], [ "LOAD_FAST", "session" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "func_name" ], [ "CALL_FUNCTION", "get_calls(session, path, func_name, 1)" ], [ "BINARY_SUBSCR", "get_calls(session, path, func_name, 1)[0]" ], [ "LOAD_GLOBAL", "jsonify" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.id" ], [ "LOAD_GLOBAL", "url_for" ], [ "LOAD_GLOBAL", "call_view" ], [ "LOAD_ATTR", "call_view.__name__" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.id" ], [ "CALL_FUNCTION_KW", "url_for(call_view.__name__,\n call_id=call.id)" ], [ "CALL_FUNCTION_KW", "dict(\n id=call.id,\n url=url_for(call_view.__name__,\n call_id=call.id),\n )" ], [ "CALL_FUNCTION", "jsonify(dict(\n id=call.id,\n url=url_for(call_view.__name__,\n call_id=call.id),\n ))" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_columns" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.basic_columns" ], [ "BINARY_ADD", "Call.basic_columns + Function.basic_columns" ], [ "CALL_FUNCTION_EX", "session.query(*(Call.basic_columns + Function.basic_columns))" ], [ "LOAD_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)" ], [ "LOAD_ATTR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "func_name" ], [ "CALL_FUNCTION_KW", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path, name=func_name)" ], [ "LOAD_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path, name=func_name)\n .order_by" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.start_time" ], [ "LOAD_METHOD", "Call.start_time.desc" ], [ "CALL_METHOD", "Call.start_time.desc()" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path, name=func_name)\n .order_by(Call.start_time.desc())" ], [ "LOAD_FAST", "limit" ], [ "BINARY_SUBSCR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path, name=func_name)\n .order_by(Call.start_time.desc())[:limit]" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_METHOD", "session.query(Call)" ], [ "LOAD_ATTR", "session.query(Call).filter_by" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION_KW", "session.query(Call).filter_by(id=call_id)" ], [ "LOAD_METHOD", "session.query(Call).filter_by(id=call_id).one" ], [ "CALL_METHOD", "session.query(Call).filter_by(id=call_id).one()" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.function" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "template" ], [ "LOAD_GLOBAL", "basename" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.file" ], [ "CALL_FUNCTION", "basename(func.file)" ], [ "LOAD_FAST", "call" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION_KW", "render_template(template,\n short_path=basename(func.file),\n call=call,\n func=func)" ], [ "LOAD_GLOBAL", "base_call_view" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION", "base_call_view(call_id, 'call.html')" ], [ "LOAD_GLOBAL", "base_call_view" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION", "base_call_view(call_id, 'ipython_call.html')" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION_KW", "render_template('ipython_iframe.html',\n container_id='1234',\n port=7777,\n call_id=call_id)" ], [ "LOAD_GLOBAL", "request" ], [ "LOAD_ATTR", "request.environ" ], [ "LOAD_METHOD", "request.environ.get" ], [ "CALL_METHOD", "request.environ.get('werkzeug.server.shutdown')" ], [ "LOAD_FAST", "func" ], [ "COMPARE_OP", "func is None" ], [ "LOAD_GLOBAL", "RuntimeError" ], [ "CALL_FUNCTION", "RuntimeError('Not running with the Werkzeug Server')" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "func()" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_METHOD", "session.query(Call)" ], [ "LOAD_ATTR", "session.query(Call).filter_by" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION_KW", "session.query(Call).filter_by(id=call_id)" ], [ "LOAD_METHOD", "session.query(Call).filter_by(id=call_id).one" ], [ "CALL_METHOD", "session.query(Call).filter_by(id=call_id).one()" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.function" ], [ "LOAD_GLOBAL", "DecentJSONEncoder" ], [ "CALL_FUNCTION", "DecentJSONEncoder()" ], [ "LOAD_METHOD", "DecentJSONEncoder().encode" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.parsed_data" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_METHOD", "Call.basic_dict" ], [ "LOAD_FAST", "call" ], [ "CALL_METHOD", "Call.basic_dict(call)" ], [ "CALL_FUNCTION_EX", "dict(data=call.parsed_data, **Call.basic_dict(call))" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.parsed_data" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_METHOD", "Function.basic_dict" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "Function.basic_dict(func)" ], [ "CALL_FUNCTION_EX", "dict(data=func.parsed_data, **Function.basic_dict(func))" ], [ "CALL_FUNCTION_KW", "dict(\n call=dict(data=call.parsed_data, **Call.basic_dict(call)),\n function=dict(data=func.parsed_data, **Function.basic_dict(func)))" ], [ "CALL_METHOD", "DecentJSONEncoder().encode(dict(\n call=dict(data=call.parsed_data, **Call.basic_dict(call)),\n function=dict(data=func.parsed_data, **Function.basic_dict(func))))" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_columns" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.data" ], [ "BINARY_ADD", "Call.basic_columns + (Function.data,)" ], [ "CALL_FUNCTION_EX", "session.query(*Call.basic_columns + (Function.data,))" ], [ "LOAD_METHOD", "session.query(*Call.basic_columns + (Function.data,))\n .join" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_METHOD", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)" ], [ "LOAD_ATTR", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by" ], [ "LOAD_FAST", "body_hash" ], [ "CALL_FUNCTION_KW", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by(body_hash=body_hash)" ], [ "LOAD_METHOD", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by(body_hash=body_hash)\n .order_by" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.start_time" ], [ "LOAD_METHOD", "Call.start_time.desc" ], [ "CALL_METHOD", "Call.start_time.desc()" ], [ "CALL_METHOD", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by(body_hash=body_hash)\n .order_by(Call.start_time.desc())" ], [ "BINARY_SUBSCR", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by(body_hash=body_hash)\n .order_by(Call.start_time.desc())[:200]" ], [ "LOAD_FAST", "query" ], [ "LOAD_FAST", "query" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "function_data_set" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_METHOD", "json.loads" ], [ "LOAD_DEREF", "function_data" ], [ "CALL_METHOD", "json.loads(function_data)" ], [ "LOAD_FAST", "add" ], [ "LOAD_FAST", "ranges" ], [ "CALL_FUNCTION", "add('node_ranges', ranges)" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "add" ], [ "LOAD_FAST", "current_loop_ranges" ], [ "CALL_FUNCTION", "add('loop_ranges', current_loop_ranges)" ], [ "LOAD_FAST", "loop_ranges" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "current_loop_ranges" ], [ "COMPARE_OP", "loop_ranges in (set(), current_loop_ranges)" ], [ "LOAD_FAST", "current_loop_ranges" ], [ "LOAD_FAST", "ranges" ], [ "LOAD_FAST", "loop_ranges" ], [ "LOAD_GLOBAL", "DecentJSONEncoder" ], [ "CALL_FUNCTION", "DecentJSONEncoder()" ], [ "LOAD_METHOD", "DecentJSONEncoder().encode" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "calls" ], [ "LOAD_FAST", "ranges" ], [ "LOAD_FAST", "loop_ranges" ], [ "CALL_FUNCTION_KW", "dict(\n calls=calls, ranges=ranges, loop_ranges=loop_ranges)" ], [ "CALL_METHOD", "DecentJSONEncoder().encode(dict(\n calls=calls, ranges=ranges, loop_ranges=loop_ranges))" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_METHOD", "Call.basic_dict" ], [ "LOAD_GLOBAL", "withattrs" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_FUNCTION", "Call()" ], [ "LOAD_FAST", "row" ], [ "LOAD_METHOD", "row._asdict" ], [ "CALL_METHOD", "row._asdict()" ], [ "CALL_FUNCTION_EX", "withattrs(Call(), **row._asdict())" ], [ "CALL_METHOD", "Call.basic_dict(withattrs(Call(), **row._asdict()))" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.data" ], [ "LOAD_DEREF", "function_data" ], [ "LOAD_FAST", "key" ], [ "BINARY_SUBSCR", "function_data[key]" ], [ "LOAD_FAST", "ranges_set" ], [ "LOAD_METHOD", "ranges_set.add" ], [ "LOAD_FAST", "node" ], [ "BINARY_SUBSCR", "node['start']" ], [ "LOAD_FAST", "node" ], [ "BINARY_SUBSCR", "node['end']" ], [ "CALL_METHOD", "ranges_set.add((node['start'], node['end']))" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "CALL_FUNCTION_KW", "dict(start=start, end=end)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "CALL_FUNCTION_KW", "dict(start=start, end=end)" ], [ "LOAD_GLOBAL", "request" ], [ "LOAD_METHOD", "request.get_json" ], [ "CALL_METHOD", "request.get_json()" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.query" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.body_hash" ], [ "LOAD_GLOBAL", "sqlalchemy" ], [ "LOAD_ATTR", "sqlalchemy.func" ], [ "LOAD_METHOD", "sqlalchemy.func.count" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.id" ], [ "CALL_METHOD", "sqlalchemy.func.count(Call.id)" ], [ "CALL_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))" ], [ "LOAD_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)" ], [ "LOAD_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)\n .filter" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.body_hash" ], [ "LOAD_METHOD", "Function.body_hash.in_" ], [ "LOAD_FAST", "hashes" ], [ "CALL_METHOD", "Function.body_hash.in_(hashes)" ], [ "CALL_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)\n .filter(Function.body_hash.in_(hashes))" ], [ "LOAD_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)\n .filter(Function.body_hash.in_(hashes))\n .group_by" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.body_hash" ], [ "CALL_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)\n .filter(Function.body_hash.in_(hashes))\n .group_by(Function.body_hash)" ], [ "LOAD_GLOBAL", "DecentJSONEncoder" ], [ "CALL_FUNCTION", "DecentJSONEncoder()" ], [ "LOAD_METHOD", "DecentJSONEncoder().encode" ], [ "LOAD_FAST", "query" ], [ "CALL_METHOD", "DecentJSONEncoder().encode([\n dict(hash=h, count=count)\n for h, count in query\n ])" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "h" ], [ "LOAD_FAST", "count" ], [ "CALL_FUNCTION_KW", "dict(hash=h, count=count)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "argv" ], [ "CALL_FUNCTION", "len(argv)" ], [ "COMPARE_OP", "len(argv) == 1" ], [ "LOAD_FAST", "argv" ], [ "BINARY_SUBSCR", "argv[0]" ], [ "LOAD_METHOD", "argv[0].isdigit" ], [ "CALL_METHOD", "argv[0].isdigit()" ], [ "LOAD_FAST", "argv" ], [ "LOAD_METHOD", "argv.insert" ], [ "CALL_METHOD", "argv.insert(0, '--port')" ], [ "LOAD_GLOBAL", "argparse" ], [ "LOAD_ATTR", "argparse.ArgumentParser" ], [ "CALL_FUNCTION_KW", "argparse.ArgumentParser(description=\"Bird's Eye: A graphical Python debugger\")" ], [ "LOAD_FAST", "parser" ], [ "LOAD_ATTR", "parser.add_argument" ], [ "LOAD_GLOBAL", "int" ], [ "CALL_FUNCTION_KW", "parser.add_argument('-p', '--port', help='HTTP port, default is 7777', default=7777, type=int)" ], [ "LOAD_FAST", "parser" ], [ "LOAD_ATTR", "parser.add_argument" ], [ "CALL_FUNCTION_KW", "parser.add_argument('--host', help=\"HTTP host, default is 'localhost'\", default='localhost')" ], [ "LOAD_FAST", "parser" ], [ "LOAD_METHOD", "parser.parse_args" ], [ "LOAD_FAST", "argv" ], [ "CALL_METHOD", "parser.parse_args(argv)" ], [ "LOAD_GLOBAL", "app" ], [ "LOAD_ATTR", "app.run" ], [ "LOAD_FAST", "args" ], [ "LOAD_ATTR", "args.port" ], [ "LOAD_FAST", "args" ], [ "LOAD_ATTR", "args.host" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.environ" ], [ "LOAD_METHOD", "os.environ.get" ], [ "CALL_METHOD", "os.environ.get('BIRDSEYE_RELOADER')" ], [ "COMPARE_OP", "os.environ.get('BIRDSEYE_RELOADER') == '1'" ], [ "CALL_FUNCTION_KW", "app.run(\n port=args.port,\n host=args.host,\n use_reloader=os.environ.get('BIRDSEYE_RELOADER') == '1',\n )" ] ], "tests.py": [ [ "LOAD_NAME", "unittest" ], [ "LOAD_ATTR", "unittest.TestCase" ], [ "LOAD_NAME", "unittest" ], [ "LOAD_ATTR", "unittest.TestCase" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "TestFile" ], [ "CALL_FUNCTION", "TestFile()" ], [ "LOAD_METHOD", "TestFile().test_file" ], [ "CALL_METHOD", "TestFile().test_file()" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "Tester" ], [ "CALL_FUNCTION", "Tester()" ], [ "LOAD_NAME", "tester" ], [ "CALL_FUNCTION", "tester([1, 2, 3])" ], [ "COMPARE_OP", "tester([1, 2, 3]) == [1, 2, 3]" ], [ "LOAD_NAME", "tester" ], [ "LOAD_ATTR", "tester.asd" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester.asd is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_SUBSCR", "tester[19]" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester[19] is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_POWER", "tester ** 4" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester ** 4 is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_MULTIPLY", "tester * 3" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester * 3 is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_SUBTRACT", "tester - 2" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester - 2 is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_ADD", "tester + 1" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester + 1 is tester" ], [ "LOAD_NAME", "tester" ], [ "UNARY_NEGATIVE", "-tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "-tester is tester" ], [ "LOAD_NAME", "tester" ], [ "UNARY_POSITIVE", "+tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "+tester is tester" ], [ "LOAD_NAME", "tester" ], [ "UNARY_INVERT", "~tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "~tester is tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester < 7" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "(tester < 7) is tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester >= 78" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "(tester >= 78) is tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester != 79" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "(tester != 79) is tester" ], [ "LOAD_NAME", "tester" ], [ "LOAD_METHOD", "tester.foo" ], [ "CALL_METHOD", "tester.foo(45, False)" ], [ "COMPARE_OP", "tester.foo(45, False) == 45" ], [ "LOAD_NAME", "__name__" ], [ "COMPARE_OP", "__name__ == '__main__'" ], [ "LOAD_NAME", "unittest" ], [ "LOAD_METHOD", "unittest.main" ], [ "CALL_METHOD", "unittest.main()" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(1)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(2)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(3)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(9\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n 8)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n 99\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(33)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([4,\n 5, 6, [\n 7]])" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "LOAD_GLOBAL", "decorator_with_args" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('123')" ], [ "LOAD_GLOBAL", "int" ], [ "CALL_FUNCTION", "int()" ], [ "CALL_FUNCTION_KW", "decorator_with_args(tester('123'), x=int())" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "tuple([1, 2])" ], [ "CALL_FUNCTION", "list(tuple([1, 2]))" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "CALL_FUNCTION_KW", "tester(list(tuple([1, 2])), returns=empty_decorator)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "tuple(\n [3, 4])" ], [ "CALL_FUNCTION", "list(\n tuple(\n [3, 4]))" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "CALL_FUNCTION_KW", "tester(\n list(\n tuple(\n [3, 4])),\n returns=empty_decorator)" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "LOAD_GLOBAL", "decorator_with_args" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "str()" ], [ "LOAD_GLOBAL", "int" ], [ "CALL_FUNCTION", "int()" ], [ "CALL_FUNCTION_KW", "decorator_with_args(\n str(),\n x=int())" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "tuple([5, 6])" ], [ "CALL_FUNCTION", "list(tuple([5, 6]))" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "CALL_FUNCTION_KW", "tester(list(tuple([5, 6])), returns=empty_decorator)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "tuple([7, 8])" ], [ "CALL_FUNCTION", "list(tuple([7, 8]))" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "CALL_FUNCTION_KW", "tester(list(tuple([7, 8])), returns=empty_decorator)" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "LOAD_GLOBAL", "decorator_with_args" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('sdf')" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('123234')" ], [ "CALL_FUNCTION_KW", "decorator_with_args(tester('sdf'), x=tester('123234'))" ], [ "CALL_FUNCTION", "decorator_with_args(tester('sdf'), x=tester('123234'))" ], [ "CALL_FUNCTION", "empty_decorator" ], [ "CALL_FUNCTION", "tester(list(tuple([7, 8])), returns=empty_decorator)" ], [ "CALL_FUNCTION", "tester(list(tuple([5, 6])), returns=empty_decorator)" ], [ "CALL_FUNCTION", "decorator_with_args(\n str(),\n x=int())" ], [ "CALL_FUNCTION", "empty_decorator" ], [ "CALL_FUNCTION", "tester(\n list(\n tuple(\n [3, 4])),\n returns=empty_decorator)" ], [ "CALL_FUNCTION", "tester(list(tuple([1, 2])), returns=empty_decorator)" ], [ "CALL_FUNCTION", "decorator_with_args(tester('123'), x=int())" ], [ "CALL_FUNCTION", "empty_decorator" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "str([{tester(x) for x in [1]}, {tester(y) for y in [1]}])" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "str([{tester(x) for x in [1]},\n {tester(x) for x in [1]}])" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "list(tester(x) for x in [1])" ], [ "CALL_FUNCTION", "str([{tester(x) for x in [1]}, list(tester(x) for x in [1])])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "y" ], [ "CALL_FUNCTION", "tester(y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertEqual" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(3)" ], [ "CALL_FUNCTION", "(lambda x: (tester(x), tester(x)))(tester(3))" ], [ "CALL_METHOD", "self.assertEqual(\n (lambda x: (tester(x), tester(x)))(tester(3)),\n (3, 3),\n )" ], [ "CALL_FUNCTION", "(lambda: (lambda: tester(1))())()" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertEqual" ], [ "CALL_FUNCTION", "(lambda: [tester(x) for x in tester([1, 2])])()" ], [ "CALL_METHOD", "self.assertEqual(\n (lambda: [tester(x) for x in tester([1, 2])])(),\n [1, 2],\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "CALL_FUNCTION", "(lambda: tester(1))()" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(1)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x): {tester(b+x): {tester(c+x) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_FAST", "foo" ], [ "CALL_FUNCTION", "foo()" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "CALL_FUNCTION", "tester(a+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "CALL_FUNCTION", "tester(b+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "CALL_FUNCTION", "tester(c+x)" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x): {tester(b+x): {tester(c+x) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+y): {tester(b+y): {tester(c+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x+y): {tester(b+x+y): {tester(c+x+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_FAST", "bar" ], [ "CALL_FUNCTION", "bar()" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "CALL_FUNCTION", "tester(a+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "CALL_FUNCTION", "tester(b+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "CALL_FUNCTION", "tester(c+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+y" ], [ "CALL_FUNCTION", "tester(a+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+y" ], [ "CALL_FUNCTION", "tester(b+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+y" ], [ "CALL_FUNCTION", "tester(c+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+x+y" ], [ "CALL_FUNCTION", "tester(a+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+x+y" ], [ "CALL_FUNCTION", "tester(b+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+x+y" ], [ "CALL_FUNCTION", "tester(c+x+y)" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x): {tester(b+x): {tester(c+x) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+y): {tester(b+y): {tester(c+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x+y): {tester(b+x+y): {tester(c+x+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x+y+z): {tester(b+x+y+z): {tester(c+x+y+z) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "CALL_FUNCTION", "tester(a+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "CALL_FUNCTION", "tester(b+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "CALL_FUNCTION", "tester(c+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+y" ], [ "CALL_FUNCTION", "tester(a+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+y" ], [ "CALL_FUNCTION", "tester(b+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+y" ], [ "CALL_FUNCTION", "tester(c+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+x+y" ], [ "CALL_FUNCTION", "tester(a+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+x+y" ], [ "CALL_FUNCTION", "tester(b+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+x+y" ], [ "CALL_FUNCTION", "tester(c+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+x+y" ], [ "LOAD_DEREF", "z" ], [ "BINARY_ADD", "a+x+y+z" ], [ "CALL_FUNCTION", "tester(a+x+y+z)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+x+y" ], [ "LOAD_DEREF", "z" ], [ "BINARY_ADD", "b+x+y+z" ], [ "CALL_FUNCTION", "tester(b+x+y+z)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+x+y" ], [ "LOAD_DEREF", "z" ], [ "BINARY_ADD", "c+x+y+z" ], [ "CALL_FUNCTION", "tester(c+x+y+z)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION_KW", "dict(x=tester)" ], [ "BINARY_SUBSCR", "dict(x=tester)['x']" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "dict(x=tester)['x'](tester)" ], [ "CALL_FUNCTION_KW", "dict(x=tester)['x'](tester)(3, check_func=False)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertRaises" ], [ "LOAD_GLOBAL", "TypeError" ], [ "CALL_METHOD", "self.assertRaises(TypeError)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2, 3])" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(0)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(4)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(5)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "tester(ValueError)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(9)" ], [ "LOAD_GLOBAL", "TypeError" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(10)" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "str()" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertRaises" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "Exception" ], [ "CALL_FUNCTION", "tester(Exception)" ], [ "CALL_METHOD", "self.assertRaises(tester(Exception))" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(0)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(0)" ], [ "LOAD_GLOBAL", "tester" ], [ "BINARY_TRUE_DIVIDE", "1 / 0" ], [ "CALL_FUNCTION", "tester(1 / 0)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "gen" ], [ "CALL_FUNCTION", "gen()" ], [ "CALL_FUNCTION", "list(gen())" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "gen2" ], [ "CALL_FUNCTION", "list(gen2)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(4)" ], [ "LOAD_GLOBAL", "time" ], [ "LOAD_METHOD", "time.time" ], [ "CALL_METHOD", "time.time()" ], [ "LOAD_GLOBAL", "range" ], [ "CALL_FUNCTION", "range(10000)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_METHOD", "Source.executing" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.currentframe" ], [ "CALL_METHOD", "inspect.currentframe()" ], [ "CALL_METHOD", "Source.executing(inspect.currentframe())" ], [ "LOAD_ATTR", "Source.executing(inspect.currentframe()).node" ], [ "LOAD_FAST", "node" ], [ "COMPARE_OP", "node is None" ], [ "LOAD_FAST", "new_node" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertIs" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "new_node" ], [ "CALL_METHOD", "self.assertIs(node, new_node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertLess" ], [ "LOAD_GLOBAL", "time" ], [ "LOAD_METHOD", "time.time" ], [ "CALL_METHOD", "time.time()" ], [ "LOAD_FAST", "start" ], [ "BINARY_SUBTRACT", "time.time() - start" ], [ "CALL_METHOD", "self.assertLess(time.time() - start, 1)" ], [ "LOAD_FAST", "check" ], [ "CALL_FUNCTION", "check(u'# coding=utf8\\n\u00e9', 'utf8')" ], [ "LOAD_FAST", "check" ], [ "CALL_FUNCTION", "check(u'# coding=gbk\\n\u00e9', 'gbk')" ], [ "LOAD_FAST", "check" ], [ "LOAD_GLOBAL", "UnicodeDecodeError" ], [ "CALL_FUNCTION_KW", "check(u'# coding=utf8\\n\u00e9', 'gbk', exception=UnicodeDecodeError)" ], [ "LOAD_FAST", "check" ], [ "CALL_FUNCTION_KW", "check(u'# coding=gbk\\n\u00e9', 'utf8', matches=False)" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_FAST", "check" ], [ "CALL_FUNCTION", "check(u'\u00e9', 'utf8')" ], [ "LOAD_FAST", "check" ], [ "LOAD_GLOBAL", "SyntaxError" ], [ "CALL_FUNCTION_KW", "check(u'\u00e9', 'gbk', exception=SyntaxError)" ], [ "LOAD_FAST", "source" ], [ "LOAD_METHOD", "source.encode" ], [ "LOAD_FAST", "encoding" ], [ "CALL_METHOD", "source.encode(encoding)" ], [ "LOAD_FAST", "exception" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self.assertRaises" ], [ "LOAD_FAST", "exception" ], [ "CALL_METHOD", "self.assertRaises(exception)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_METHOD", "Source.decode_source" ], [ "LOAD_FAST", "encoded" ], [ "CALL_METHOD", "Source.decode_source(encoded)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_METHOD", "Source.decode_source" ], [ "LOAD_FAST", "encoded" ], [ "CALL_METHOD", "Source.decode_source(encoded)" ], [ "LOAD_FAST", "matches" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self.assertEqual" ], [ "LOAD_FAST", "decoded" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "self.assertEqual(decoded, source)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self.assertNotEqual" ], [ "LOAD_FAST", "decoded" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "self.assertNotEqual(decoded, source)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('a')" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('''\n ab''')" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('''\n abc\n def\n '''\n )" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n '''\n 123\n 456\n '''\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n '''\n 345\n 456786\n '''\n )" ], [ "CALL_FUNCTION", "str([\n tester(\n '''\n 123\n 456\n '''\n ),\n tester(\n '''\n 345\n 456786\n '''\n ),\n ])" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n [\n '''\n 123\n 456\n '''\n '''\n 345\n 456786\n '''\n ,\n '''\n 123\n 456\n ''',\n '''\n 345\n 456786\n '''\n ]\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(1)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(2)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(3)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_METHOD", "Source.for_filename" ], [ "LOAD_GLOBAL", "__file__" ], [ "CALL_METHOD", "Source.for_filename(__file__)" ], [ "LOAD_METHOD", "Source.for_filename(__file__).code_qualname" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.__code__" ], [ "CALL_METHOD", "Source.for_filename(__file__).code_qualname(func.__code__)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertEqual" ], [ "LOAD_FAST", "qn" ], [ "LOAD_FAST", "qualname" ], [ "CALL_METHOD", "self.assertEqual(qn, qualname)" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_FAST", "check_actual_qualname" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertEqual" ], [ "LOAD_FAST", "qn" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.__qualname__" ], [ "CALL_METHOD", "self.assertEqual(qn, func.__qualname__)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertTrue" ], [ "LOAD_FAST", "qn" ], [ "LOAD_METHOD", "qn.endswith" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.__name__" ], [ "CALL_METHOD", "qn.endswith(func.__name__)" ], [ "CALL_METHOD", "self.assertTrue(qn.endswith(func.__name__))" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assert_qualname" ], [ "LOAD_GLOBAL", "C" ], [ "LOAD_ATTR", "C.f" ], [ "CALL_METHOD", "self.assert_qualname(C.f, 'C.f')" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assert_qualname" ], [ "LOAD_GLOBAL", "C" ], [ "LOAD_ATTR", "C.D" ], [ "LOAD_ATTR", "C.D.g" ], [ "CALL_METHOD", "self.assert_qualname(C.D.g, 'C.D.g')" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assert_qualname" ], [ "LOAD_GLOBAL", "f" ], [ "CALL_METHOD", "self.assert_qualname(f, 'f')" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assert_qualname" ], [ "LOAD_GLOBAL", "f" ], [ "CALL_FUNCTION", "f()" ], [ "CALL_METHOD", "self.assert_qualname(f(), 'f..g')" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assert_qualname" ], [ "LOAD_GLOBAL", "C" ], [ "LOAD_ATTR", "C.D" ], [ "LOAD_METHOD", "C.D.h" ], [ "CALL_METHOD", "C.D.h()" ], [ "CALL_METHOD", "self.assert_qualname(C.D.h(), 'C.D.h..i..j')" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assert_qualname" ], [ "LOAD_GLOBAL", "lamb" ], [ "CALL_METHOD", "self.assert_qualname(lamb, '')" ], [ "LOAD_GLOBAL", "lambda_maker" ], [ "CALL_FUNCTION", "lambda_maker()" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assert_qualname" ], [ "LOAD_FAST", "foo" ], [ "CALL_METHOD", "self.assert_qualname(foo, 'lambda_maker..foo')" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assert_qualname" ], [ "LOAD_FAST", "foo" ], [ "LOAD_ATTR", "foo.x" ], [ "CALL_METHOD", "self.assert_qualname(foo.x, 'lambda_maker..')" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assert_qualname" ], [ "LOAD_FAST", "foo" ], [ "CALL_FUNCTION", "foo()" ], [ "CALL_METHOD", "self.assert_qualname(foo(), 'lambda_maker..foo..')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assert_qualname" ], [ "LOAD_FAST", "foo" ], [ "CALL_FUNCTION", "foo()" ], [ "CALL_FUNCTION", "foo()()" ], [ "CALL_FUNCTION_KW", "self.assert_qualname(foo()(), 'lambda_maker..foo..', check_actual_qualname=False)" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "range" ], [ "CALL_FUNCTION", "range(66000)" ], [ "CALL_FUNCTION", "list(range(66000))" ], [ "BINARY_MODULO", "'tester(6)\\n%s\\ntester(9)' % list(range(66000))" ], [ "LOAD_GLOBAL", "tempfile" ], [ "LOAD_METHOD", "tempfile.mkstemp" ], [ "CALL_METHOD", "tempfile.mkstemp()" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "compile(source, filename, 'exec')" ], [ "LOAD_GLOBAL", "open" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "open(filename, 'w')" ], [ "LOAD_FAST", "outfile" ], [ "LOAD_METHOD", "outfile.write" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "outfile.write(source)" ], [ "LOAD_GLOBAL", "exec" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "exec(code)" ], [ "LOAD_GLOBAL", "range" ], [ "CALL_FUNCTION", "range(5)" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "n" ], [ "CALL_FUNCTION", "range(n)" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "n == 1" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertEqual" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_FAST", "gen" ], [ "CALL_FUNCTION", "only(gen)" ], [ "CALL_METHOD", "self.assertEqual(only(gen), 0)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertRaises" ], [ "LOAD_GLOBAL", "NotOneValueFound" ], [ "CALL_METHOD", "self.assertRaises(NotOneValueFound)" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_FAST", "gen" ], [ "CALL_FUNCTION", "only(gen)" ], [ "LOAD_FAST", "i" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_METHOD", "os.path.join" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_METHOD", "os.path.dirname" ], [ "LOAD_GLOBAL", "__file__" ], [ "CALL_METHOD", "os.path.dirname(__file__)" ], [ "CALL_METHOD", "os.path.join(os.path.dirname(__file__), 'not_code.txt', )" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_METHOD", "Source.for_filename" ], [ "LOAD_FAST", "path" ], [ "CALL_METHOD", "Source.for_filename(path)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertIsNone" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.tree" ], [ "CALL_METHOD", "self.assertIsNone(source.tree)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.currentframe" ], [ "CALL_METHOD", "inspect.currentframe()" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_METHOD", "Source.executing" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "Source.executing(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertEqual" ], [ "LOAD_FAST", "executing" ], [ "LOAD_METHOD", "executing.code_qualname" ], [ "CALL_METHOD", "executing.code_qualname()" ], [ "CALL_METHOD", "self.assertEqual(executing.code_qualname(), 'TestStuff.test_executing_methods')" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.version" ], [ "LOAD_METHOD", "sys.version.lower" ], [ "CALL_METHOD", "sys.version.lower()" ], [ "COMPARE_OP", "'pypy' not in sys.version.lower()" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertEqual" ], [ "LOAD_FAST", "executing" ], [ "LOAD_METHOD", "executing.text" ], [ "CALL_METHOD", "executing.text()" ], [ "LOAD_FAST", "text" ], [ "CALL_METHOD", "self.assertEqual(executing.text(), text)" ], [ "LOAD_FAST", "executing" ], [ "LOAD_METHOD", "executing.text_range" ], [ "CALL_METHOD", "executing.text_range()" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertEqual" ], [ "LOAD_FAST", "executing" ], [ "LOAD_ATTR", "executing.source" ], [ "LOAD_ATTR", "executing.source.text" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "BINARY_SUBSCR", "executing.source.text[start:end]" ], [ "LOAD_FAST", "text" ], [ "CALL_METHOD", "self.assertEqual(executing.source.text[start:end], text)" ], [ "LOAD_GLOBAL", "C" ], [ "CALL_FUNCTION", "C()" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_FAST", "c" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.x" ], [ "LOAD_ATTR", "c.x.x" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.x" ], [ "LOAD_ATTR", "c.x.y" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.y" ], [ "LOAD_ATTR", "c.y.x" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.y" ], [ "LOAD_ATTR", "c.y.y" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.x" ], [ "LOAD_ATTR", "c.x.asd" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.y" ], [ "LOAD_ATTR", "c.y.qwe" ], [ "CALL_FUNCTION", "str((c.x.x, c.x.y, c.y.x, c.y.y, c.x.asd, c.y.qwe))" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_METHOD", "Source.for_frame" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.currentframe" ], [ "CALL_METHOD", "inspect.currentframe()" ], [ "CALL_METHOD", "Source.for_frame(inspect.currentframe())" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.text" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.filename" ], [ "CALL_FUNCTION", "compile(source.text, source.filename, 'exec')" ], [ "LOAD_GLOBAL", "get_instructions" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "get_instructions(code)" ], [ "LOAD_FAST", "instructions" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.starts_line" ], [ "COMPARE_OP", "inst.starts_line is not None" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.starts_line" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.opname" ], [ "LOAD_METHOD", "inst.opname.startswith" ], [ "CALL_METHOD", "inst.opname.startswith(\n ('BINARY_', 'UNARY_', 'LOAD_ATTR', 'LOAD_METHOD', 'LOOKUP_METHOD', 'COMPARE_OP'))" ], [ "LOAD_GLOBAL", "C" ], [ "CALL_FUNCTION", "C()" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.offset" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "frame" ], [ "LOAD_GLOBAL", "globals" ], [ "CALL_FUNCTION", "globals()" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "lineno" ], [ "LOAD_FAST", "frame" ], [ "LOAD_GLOBAL", "print" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.opname" ], [ "CALL_FUNCTION", "print(inst.opname)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_METHOD", "Source.executing" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "Source.executing(frame)" ], [ "LOAD_ATTR", "Source.executing(frame).node" ], [ "COMPARE_OP", "Source.executing(frame).node is not None" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_FAST", "i" ], [ "CALL_FUNCTION", "i()" ], [ "LOAD_FAST", "j" ], [ "LOAD_FAST", "g" ], [ "LOAD_FAST", "assign" ], [ "CALL_FUNCTION", "assign(lambda: 1)" ], [ "CALL_FUNCTION", "assign(lambda: 1)" ], [ "LOAD_FAST", "foo" ], [ "LOAD_FAST", "decorator" ], [ "LOAD_DEREF", "x" ], [ "LOAD_FAST", "func" ], [ "LOAD_FAST", "func" ], [ "LOAD_NAME", "__add__" ], [ "LOAD_NAME", "__invert__" ], [ "LOAD_NAME", "__lt__" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.currentframe" ], [ "CALL_METHOD", "inspect.currentframe()" ], [ "LOAD_ATTR", "inspect.currentframe().f_back" ], [ "LOAD_ATTR", "inspect.currentframe().f_back.f_back" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_METHOD", "Source.lazycache" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "Source.lazycache(frame)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_METHOD", "Source.executing" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "Source.executing(frame)" ], [ "LOAD_ATTR", "Source.executing(frame).node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "typ" ], [ "CALL_FUNCTION", "isinstance(node, typ)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "typ" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.currentframe" ], [ "CALL_METHOD", "inspect.currentframe()" ], [ "LOAD_ATTR", "inspect.currentframe().f_back" ], [ "LOAD_ATTR", "inspect.currentframe().f_back.f_back" ], [ "LOAD_GLOBAL", "eval" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.Expression" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.Expression(node)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_filename" ], [ "CALL_FUNCTION", "compile(ast.Expression(node), frame.f_code.co_filename, 'eval')" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "CALL_FUNCTION", "eval(\n compile(ast.Expression(node), frame.f_code.co_filename, 'eval'),\n frame.f_globals,\n frame.f_locals,\n )" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "value" ], [ "COMPARE_OP", "result == value" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Call" ], [ "CALL_METHOD", "self.get_node(ast.Call)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.check" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.args" ], [ "BINARY_SUBSCR", "call.args[0]" ], [ "LOAD_FAST", "arg" ], [ "CALL_METHOD", "self.check(call.args[0], arg)" ], [ "LOAD_FAST", "check_func" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.check" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.func" ], [ "LOAD_FAST", "self" ], [ "CALL_METHOD", "self.check(call.func, self)" ], [ "LOAD_FAST", "returns" ], [ "COMPARE_OP", "returns is None" ], [ "LOAD_FAST", "arg" ], [ "LOAD_FAST", "returns" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Attribute" ], [ "CALL_METHOD", "self.get_node(ast.Attribute)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.value" ], [ "LOAD_FAST", "self" ], [ "CALL_METHOD", "self.check(node.value, self)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.attr" ], [ "LOAD_FAST", "item" ], [ "COMPARE_OP", "node.attr == item" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Subscript" ], [ "CALL_METHOD", "self.get_node(ast.Subscript)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.value" ], [ "LOAD_FAST", "self" ], [ "CALL_METHOD", "self.check(node.value, self)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.slice" ], [ "LOAD_ATTR", "node.slice.value" ], [ "LOAD_FAST", "item" ], [ "CALL_METHOD", "self.check(node.slice.value, item)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.BinOp" ], [ "CALL_METHOD", "self.get_node(ast.BinOp)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.left" ], [ "LOAD_FAST", "self" ], [ "CALL_METHOD", "self.check(node.left, self)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.right" ], [ "LOAD_FAST", "other" ], [ "CALL_METHOD", "self.check(node.right, other)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.UnaryOp" ], [ "CALL_METHOD", "self.get_node(ast.UnaryOp)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.operand" ], [ "LOAD_FAST", "self" ], [ "CALL_METHOD", "self.check(node.operand, self)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Compare" ], [ "CALL_METHOD", "self.get_node(ast.Compare)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.left" ], [ "LOAD_FAST", "self" ], [ "CALL_METHOD", "self.check(node.left, self)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.comparators" ], [ "BINARY_SUBSCR", "node.comparators[0]" ], [ "LOAD_FAST", "other" ], [ "CALL_METHOD", "self.check(node.comparators[0], other)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "func" ], [ "LOAD_GLOBAL", "empty_decorator" ] ], "tracer.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOAD_METHOD", "standard_library.install_aliases" ], [ "CALL_METHOD", "standard_library.install_aliases()" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "NamedTuple" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "Union" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "BINARY_SUBSCR", "Union[ast.expr, ast.stmt]" ], [ "BINARY_SUBSCR", "Optional[Union[ast.expr, ast.stmt]]" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.AST" ], [ "LOAD_NAME", "FrameType" ], [ "LOAD_NAME", "FrameType" ], [ "CALL_FUNCTION", "NamedTuple('EnterCallInfo', [\n\n # Node from where the call was made\n ('call_node', Optional[Union[ast.expr, ast.stmt]]),\n\n # Node where the call begins\n ('enter_node', ast.AST),\n\n # Frame from which the call was made\n ('caller_frame', FrameType),\n\n # Frame of the call\n ('current_frame', FrameType)])" ], [ "LOAD_NAME", "NamedTuple" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "Union" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "BINARY_SUBSCR", "Union[ast.expr, ast.stmt]" ], [ "BINARY_SUBSCR", "Optional[Union[ast.expr, ast.stmt]]" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.Return" ], [ "BINARY_SUBSCR", "Optional[ast.Return]" ], [ "LOAD_NAME", "FrameType" ], [ "LOAD_NAME", "FrameType" ], [ "LOAD_NAME", "Any" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "Exception" ], [ "BINARY_SUBSCR", "Optional[Exception]" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "TracebackType" ], [ "BINARY_SUBSCR", "Optional[TracebackType]" ], [ "CALL_FUNCTION", "NamedTuple('ExitCallInfo', [\n\n # Node from where the call was made\n ('call_node', Optional[Union[ast.expr, ast.stmt]]),\n\n # Node where the call explicitly returned\n ('return_node', Optional[ast.Return]),\n\n # Frame from which the call was made\n ('caller_frame', FrameType),\n\n # Frame of the call\n ('current_frame', FrameType),\n\n # Node where the call explicitly returned\n ('return_value', Any),\n\n # Exception raised in the call causing it to end,\n # will propagate to the caller\n ('exc_value', Optional[Exception]),\n\n # Traceback corresponding to exc_value\n ('exc_tb', Optional[TracebackType])])" ], [ "LOAD_NAME", "namedtuple" ], [ "CALL_FUNCTION", "namedtuple('ChangeValue', 'value')" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.NodeTransformer" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "Union" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "BINARY_SUBSCR", "Union[ast.For, ast.While, ast.comprehension]" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.PyCF_ONLY_AST" ], [ "LOAD_FAST", "flags" ], [ "BINARY_OR", "ast.PyCF_ONLY_AST | flags" ], [ "CALL_FUNCTION_KW", "compile(source, filename, 'exec', ast.PyCF_ONLY_AST | flags, dont_inherit=True)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.set_basic_node_attributes" ], [ "CALL_METHOD", "self.set_basic_node_attributes()" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_METHOD", "tracer.parse_extra" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "CALL_METHOD", "tracer.parse_extra(self.root, source, filename)" ], [ "LOAD_FAST", "new_root" ], [ "COMPARE_OP", "new_root is not None" ], [ "LOAD_FAST", "new_root" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.set_basic_node_attributes" ], [ "CALL_METHOD", "self.set_basic_node_attributes()" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.set_enter_call_nodes" ], [ "CALL_METHOD", "self.set_enter_call_nodes()" ], [ "LOAD_GLOBAL", "deepcopy" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "CALL_FUNCTION", "deepcopy(self.root)" ], [ "LOAD_GLOBAL", "_NodeVisitor" ], [ "CALL_FUNCTION", "_NodeVisitor()" ], [ "LOAD_METHOD", "_NodeVisitor().visit" ], [ "LOAD_FAST", "new_root" ], [ "CALL_METHOD", "_NodeVisitor().visit(new_root)" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "new_root" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "flags" ], [ "CALL_FUNCTION_KW", "compile(new_root, filename, \"exec\", dont_inherit=True, flags=flags)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.walk" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "CALL_METHOD", "ast.walk(self.root)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.iter_child_nodes" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.iter_child_nodes(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.nodes" ], [ "CALL_FUNCTION", "len(self.nodes)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.nodes" ], [ "LOAD_METHOD", "self.nodes.append" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self.nodes.append(node)" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "LOAD_ATTR", "self.root.body" ], [ "CALL_FUNCTION", "enumerate(self.root.body)" ], [ "LOAD_GLOBAL", "is_future_import" ], [ "LOAD_FAST", "stmt" ], [ "CALL_FUNCTION", "is_future_import(stmt)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "LOAD_ATTR", "self.root.body" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "self.root.body[:i + 1]" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.walk" ], [ "LOAD_FAST", "s" ], [ "CALL_METHOD", "ast.walk(s)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.nodes" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Module" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(node, (ast.Module, ast.FunctionDef))" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.body" ], [ "LOAD_GLOBAL", "is_future_import" ], [ "LOAD_FAST", "stmt" ], [ "CALL_FUNCTION", "is_future_import(stmt)" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_NAME", "lru_cache" ], [ "CALL_FUNCTION", "lru_cache()" ], [ "CALL_FUNCTION", "lru_cache()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "defaultdict(list)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "TracedFile" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "flags" ], [ "CALL_FUNCTION", "TracedFile(self, source, filename, flags)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._treetrace_hidden_with_stmt" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._treetrace_hidden_before_expr" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._treetrace_hidden_after_expr" ], [ "LOAD_GLOBAL", "partial" ], [ "LOAD_FAST", "f" ], [ "LOAD_DEREF", "traced_file" ], [ "CALL_FUNCTION", "partial(f, traced_file)" ], [ "LOAD_FAST", "f" ], [ "LOAD_ATTR", "f.__name__" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_DEREF", "func" ], [ "LOAD_GLOBAL", "FunctionType" ], [ "CALL_FUNCTION", "isinstance(func, FunctionType)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError('You can only trace user-defined functions. '\n 'The birdseye decorator must be applied first, '\n 'at the bottom of the list.')" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.iscoroutinefunction" ], [ "LOAD_DEREF", "func" ], [ "CALL_METHOD", "inspect.iscoroutinefunction(func)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.isasyncgenfunction" ], [ "LOAD_DEREF", "func" ], [ "CALL_METHOD", "inspect.isasyncgenfunction(func)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError('You cannot trace async functions')" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_GLOBAL", "is_lambda" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "is_lambda(func)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError('You cannot trace lambdas')" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.getsourcefile" ], [ "LOAD_DEREF", "func" ], [ "CALL_METHOD", "inspect.getsourcefile(func)" ], [ "LOAD_GLOBAL", "is_ipython_cell" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "is_ipython_cell(filename)" ], [ "LOAD_FAST", "get_ipython" ], [ "CALL_FUNCTION", "get_ipython()" ], [ "LOAD_ATTR", "get_ipython().compile" ], [ "LOAD_ATTR", "get_ipython().compile.flags" ], [ "LOAD_METHOD", "''.join" ], [ "LOAD_FAST", "linecache" ], [ "LOAD_ATTR", "linecache.cache" ], [ "LOAD_FAST", "filename" ], [ "BINARY_SUBSCR", "linecache.cache[filename]" ], [ "BINARY_SUBSCR", "linecache.cache[filename][2]" ], [ "CALL_METHOD", "''.join(linecache.cache[filename][2])" ], [ "LOAD_GLOBAL", "read_source_file" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "read_source_file(filename)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "flags" ], [ "CALL_METHOD", "self.compile(source, filename, flags)" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__dict__" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError('The birdseye decorator must be applied first, '\n 'at the bottom of the list.')" ], [ "LOAD_DEREF", "find_code" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.code" ], [ "CALL_FUNCTION", "find_code(traced_file.code)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_DEREF", "code_options" ], [ "CALL_FUNCTION", "len(code_options)" ], [ "COMPARE_OP", "len(code_options) > 1" ], [ "LOAD_GLOBAL", "is_lambda" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "is_lambda(func)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError(\"Failed to trace lambda. Convert the function to a def.\")" ], [ "LOAD_DEREF", "code_options" ], [ "BINARY_SUBSCR", "code_options[0]" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__globals__" ], [ "LOAD_METHOD", "func.__globals__.update" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._trace_methods_dict" ], [ "LOAD_FAST", "traced_file" ], [ "CALL_METHOD", "self._trace_methods_dict(traced_file)" ], [ "CALL_METHOD", "func.__globals__.update(self._trace_methods_dict(traced_file))" ], [ "LOAD_GLOBAL", "FunctionType" ], [ "LOAD_FAST", "new_func_code" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__globals__" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__name__" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__defaults__" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__closure__" ], [ "CALL_FUNCTION", "FunctionType(new_func_code, func.__globals__, func.__name__, func.__defaults__, func.__closure__)" ], [ "LOAD_GLOBAL", "update_wrapper" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "update_wrapper(new_func, func)" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "getattr(func, '__kwdefaults__', None)" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_FAST", "root_code" ], [ "LOAD_ATTR", "root_code.co_consts" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.iscode" ], [ "LOAD_FAST", "const" ], [ "CALL_METHOD", "inspect.iscode(const)" ], [ "LOAD_FAST", "const" ], [ "LOAD_ATTR", "const.co_firstlineno" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__code__" ], [ "LOAD_ATTR", "func.__code__.co_firstlineno" ], [ "COMPARE_OP", "const.co_firstlineno == func.__code__.co_firstlineno" ], [ "LOAD_FAST", "const" ], [ "LOAD_ATTR", "const.co_name" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__code__" ], [ "LOAD_ATTR", "func.__code__.co_name" ], [ "COMPARE_OP", "const.co_name == func.__code__.co_name" ], [ "LOAD_FAST", "matches" ], [ "LOAD_DEREF", "code_options" ], [ "LOAD_METHOD", "code_options.append" ], [ "LOAD_FAST", "const" ], [ "CALL_METHOD", "code_options.append(const)" ], [ "LOAD_DEREF", "find_code" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "find_code(const)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.isclass" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "inspect.isclass(func)" ], [ "LOAD_GLOBAL", "TypeError" ], [ "CALL_FUNCTION", "TypeError('Decorating classes is no longer supported')" ], [ "LOAD_FAST", "func" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self.trace_function" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "self.trace_function(func)" ], [ "LOAD_FAST", "optional" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.trace_function" ], [ "LOAD_FAST", "decorator" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self.trace_function" ], [ "LOAD_DEREF", "actual_func" ], [ "CALL_METHOD", "self.trace_function(actual_func)" ], [ "LOAD_GLOBAL", "wraps" ], [ "LOAD_DEREF", "actual_func" ], [ "CALL_FUNCTION", "wraps(actual_func)" ], [ "CALL_FUNCTION", "wraps(actual_func)" ], [ "LOAD_FAST", "wrapper" ], [ "LOAD_FAST", "kwargs" ], [ "LOAD_METHOD", "kwargs.pop" ], [ "CALL_METHOD", "kwargs.pop('trace_call', False)" ], [ "LOAD_FAST", "trace_call" ], [ "LOAD_DEREF", "traced" ], [ "LOAD_DEREF", "actual_func" ], [ "LOAD_FAST", "f" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "f(*args, **kwargs)" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_METHOD", "sys._getframe" ], [ "CALL_METHOD", "sys._getframe(2)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.secondary_to_main_frames" ], [ "LOAD_METHOD", "self.secondary_to_main_frames.get" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self.secondary_to_main_frames.get(frame)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "COMPARE_OP", "frame.f_code.co_name in ('', '', '')" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_GLOBAL", "ancestors" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ancestors(node)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Lambda" ], [ "CALL_FUNCTION", "isinstance(node, (ast.FunctionDef, ast.Lambda))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.ClassDef" ], [ "CALL_FUNCTION", "isinstance(node, ast.ClassDef)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "COMPARE_OP", "frame.f_code.co_name in ('', '')" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.secondary_to_main_frames" ], [ "LOAD_FAST", "original_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.main_to_secondary_frames" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.main_to_secondary_frames[frame]" ], [ "LOAD_METHOD", "self.main_to_secondary_frames[frame].append" ], [ "LOAD_FAST", "original_frame" ], [ "CALL_METHOD", "self.main_to_secondary_frames[frame].append(original_frame)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.nodes" ], [ "LOAD_FAST", "_tree_index" ], [ "BINARY_SUBSCR", "traced_file.nodes[_tree_index]" ], [ "LOAD_GLOBAL", "cast" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "cast(ast.stmt, node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._main_frame" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self._main_frame(node)" ], [ "LOAD_GLOBAL", "_StmtContext" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "_StmtContext(self, node, frame)" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.nodes" ], [ "LOAD_FAST", "_tree_index" ], [ "BINARY_SUBSCR", "traced_file.nodes[_tree_index]" ], [ "LOAD_GLOBAL", "cast" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "cast(ast.expr, node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._main_frame" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self._main_frame(node)" ], [ "LOAD_FAST", "frame" ], [ "COMPARE_OP", "frame is None" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_stack" ], [ "LOAD_METHOD", "frame_info.expression_stack.append" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "frame_info.expression_stack.append(node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.before_expr" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self.before_expr(node, frame)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._main_frame" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self._main_frame(node)" ], [ "LOAD_FAST", "frame" ], [ "COMPARE_OP", "frame is None" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._after_expr" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "value" ], [ "CALL_METHOD", "self._after_expr(node, frame, value, None, None)" ], [ "LOAD_FAST", "result" ], [ "COMPARE_OP", "result is not None" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "ChangeValue" ], [ "CALL_FUNCTION", "isinstance(result, ChangeValue)" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.value" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_stack" ], [ "LOAD_METHOD", "frame_info.expression_stack.pop" ], [ "CALL_METHOD", "frame_info.expression_stack.pop()" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_values" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.after_expr" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "exc_value" ], [ "LOAD_FAST", "exc_tb" ], [ "CALL_METHOD", "self.after_expr(node, frame, value, exc_value, exc_tb)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._get_caller_stuff" ], [ "LOAD_FAST", "current_frame" ], [ "CALL_METHOD", "self._get_caller_stuff(current_frame)" ], [ "LOAD_GLOBAL", "FrameInfo" ], [ "CALL_FUNCTION", "FrameInfo()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "current_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.enter_call" ], [ "LOAD_GLOBAL", "EnterCallInfo" ], [ "LOAD_FAST", "call_node" ], [ "LOAD_FAST", "enter_node" ], [ "LOAD_FAST", "caller_frame" ], [ "LOAD_FAST", "current_frame" ], [ "CALL_FUNCTION", "EnterCallInfo(call_node, enter_node, caller_frame, current_frame)" ], [ "CALL_METHOD", "self.enter_call(EnterCallInfo(call_node, enter_node, caller_frame, current_frame))" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.secondary_to_main_frames" ], [ "LOAD_METHOD", "self.secondary_to_main_frames.get" ], [ "LOAD_FAST", "caller_frame" ], [ "CALL_METHOD", "self.secondary_to_main_frames.get(caller_frame)" ], [ "LOAD_FAST", "main_frame" ], [ "LOAD_FAST", "main_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "caller_frame" ], [ "BINARY_SUBSCR", "self.stack[caller_frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_stack" ], [ "LOAD_FAST", "expression_stack" ], [ "LOAD_FAST", "expression_stack" ], [ "BINARY_SUBSCR", "expression_stack[-1]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.statement_stack" ], [ "BINARY_SUBSCR", "frame_info.statement_stack[-1]" ], [ "LOAD_FAST", "caller_frame" ], [ "LOAD_FAST", "call_node" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "getattr(node, '_visit_ignore', False)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "CALL_FUNCTION", "isinstance(node, ast.expr)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "hasattr(node, \"ctx\")" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.ctx" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Load" ], [ "CALL_FUNCTION", "isinstance(node.ctx, ast.Load)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "ast" ], [ "CALL_FUNCTION", "getattr(ast, 'Starred', ())" ], [ "CALL_FUNCTION", "isinstance(node, getattr(ast, 'Starred', ()))" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.visit_expr" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self.visit_expr(node)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "CALL_FUNCTION", "isinstance(node, ast.stmt)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.visit_stmt" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self.visit_stmt(node)" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "_NodeVisitor" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self)" ], [ "LOAD_METHOD", "super(_NodeVisitor, self).generic_visit" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "super(_NodeVisitor, self).generic_visit(node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._create_simple_marker_call" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "TreeTracerBase" ], [ "LOAD_ATTR", "TreeTracerBase._treetrace_hidden_before_expr" ], [ "CALL_METHOD", "self._create_simple_marker_call(node, TreeTracerBase._treetrace_hidden_before_expr)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.copy_location" ], [ "LOAD_FAST", "before_marker" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.copy_location(before_marker, node)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Call" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Name" ], [ "LOAD_GLOBAL", "TreeTracerBase" ], [ "LOAD_ATTR", "TreeTracerBase._treetrace_hidden_after_expr" ], [ "LOAD_ATTR", "TreeTracerBase._treetrace_hidden_after_expr.__name__" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.Load" ], [ "CALL_METHOD", "ast.Load()" ], [ "CALL_FUNCTION_KW", "ast.Name(id=TreeTracerBase._treetrace_hidden_after_expr.__name__,\n ctx=ast.Load())" ], [ "LOAD_FAST", "before_marker" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "_NodeVisitor" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self)" ], [ "LOAD_METHOD", "super(_NodeVisitor, self).generic_visit" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "super(_NodeVisitor, self).generic_visit(node)" ], [ "CALL_FUNCTION_KW", "ast.Call(\n func=ast.Name(id=TreeTracerBase._treetrace_hidden_after_expr.__name__,\n ctx=ast.Load()),\n args=[\n before_marker,\n super(_NodeVisitor, self).generic_visit(node),\n ],\n keywords=[],\n )" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.copy_location" ], [ "LOAD_FAST", "after_marker" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.copy_location(after_marker, node)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.fix_missing_locations" ], [ "LOAD_FAST", "after_marker" ], [ "CALL_METHOD", "ast.fix_missing_locations(after_marker)" ], [ "LOAD_FAST", "after_marker" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._create_simple_marker_call" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "_NodeVisitor" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self)" ], [ "LOAD_METHOD", "super(_NodeVisitor, self).generic_visit" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "super(_NodeVisitor, self).generic_visit(node)" ], [ "LOAD_GLOBAL", "TreeTracerBase" ], [ "LOAD_ATTR", "TreeTracerBase._treetrace_hidden_with_stmt" ], [ "CALL_METHOD", "self._create_simple_marker_call(\n super(_NodeVisitor, self).generic_visit(node),\n TreeTracerBase._treetrace_hidden_with_stmt)" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.With" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.withitem" ], [ "LOAD_FAST", "context_expr" ], [ "CALL_FUNCTION_KW", "ast.withitem(context_expr=context_expr)" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION_KW", "ast.With(\n items=[ast.withitem(context_expr=context_expr)],\n body=[node],\n )" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.With" ], [ "LOAD_FAST", "context_expr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION_KW", "ast.With(\n context_expr=context_expr,\n body=[node],\n )" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.copy_location" ], [ "LOAD_FAST", "wrapped" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.copy_location(wrapped, node)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.fix_missing_locations" ], [ "LOAD_FAST", "wrapped" ], [ "CALL_METHOD", "ast.fix_missing_locations(wrapped)" ], [ "LOAD_FAST", "wrapped" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Call" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Name" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.__name__" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.Load" ], [ "CALL_METHOD", "ast.Load()" ], [ "CALL_FUNCTION_KW", "ast.Name(id=func.__name__,\n ctx=ast.Load())" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.Num" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "CALL_METHOD", "ast.Num(node._tree_index)" ], [ "CALL_FUNCTION_KW", "ast.Call(\n func=ast.Name(id=func.__name__,\n ctx=ast.Load()),\n args=[ast.Num(node._tree_index)],\n keywords=[],\n )" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tracer" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "getattr(node, '_enter_call_node', False)" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_METHOD", "tracer._enter_call" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "tracer._enter_call(node, frame)" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "tracer.stack[frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.statement_stack" ], [ "LOAD_METHOD", "frame_info.statement_stack.append" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "frame_info.statement_stack.append(node)" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_METHOD", "tracer.before_stmt" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "tracer.before_stmt(node, frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tracer" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "tracer.stack[frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.statement_stack" ], [ "LOAD_METHOD", "frame_info.statement_stack.pop" ], [ "CALL_METHOD", "frame_info.statement_stack.pop()" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.exc_value" ], [ "COMPARE_OP", "exc_val is not frame_info.exc_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_stack" ], [ "LOAD_FAST", "expression_stack" ], [ "LOAD_FAST", "expression_stack" ], [ "BINARY_SUBSCR", "expression_stack[-1]" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_METHOD", "tracer._after_expr" ], [ "LOAD_FAST", "exc_node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "exc_tb" ], [ "CALL_METHOD", "tracer._after_expr(exc_node, frame, None, exc_val, exc_tb)" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_METHOD", "tracer.after_stmt" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "exc_tb" ], [ "LOAD_FAST", "exc_node" ], [ "CALL_METHOD", "tracer.after_stmt(node, frame, exc_val, exc_tb, exc_node)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Return" ], [ "CALL_FUNCTION", "isinstance(node, ast.Return)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.return_node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Module" ], [ "CALL_FUNCTION", "isinstance(parent, (ast.FunctionDef, ast.Module))" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.body" ], [ "BINARY_SUBSCR", "parent.body[-1]" ], [ "COMPARE_OP", "node is parent.body[-1]" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_FAST", "exiting" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_METHOD", "tracer._get_caller_stuff" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "tracer._get_caller_stuff(frame)" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_ATTR", "return_node.value" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_values" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_ATTR", "return_node.value" ], [ "BINARY_SUBSCR", "frame_info.expression_values[return_node.value]" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_METHOD", "tracer.exit_call" ], [ "LOAD_GLOBAL", "ExitCallInfo" ], [ "LOAD_FAST", "call_node" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_FAST", "caller_frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "return_value" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "exc_tb" ], [ "CALL_FUNCTION", "ExitCallInfo(call_node,\n return_node,\n caller_frame,\n frame,\n return_value,\n exc_val,\n exc_tb\n )" ], [ "CALL_METHOD", "tracer.exit_call(ExitCallInfo(call_node,\n return_node,\n caller_frame,\n frame,\n return_value,\n exc_val,\n exc_tb\n ))" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.stack" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tracer" ], [ "LOAD_ATTR", "self.tracer.main_to_secondary_frames" ], [ "LOAD_METHOD", "self.tracer.main_to_secondary_frames.pop" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self.tracer.main_to_secondary_frames.pop(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tracer" ], [ "LOAD_ATTR", "self.tracer.secondary_to_main_frames" ], [ "LOAD_FAST", "secondary_frame" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(parent, ast.FunctionDef)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "CALL_FUNCTION", "isinstance(parent, ast.For)" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.iter" ], [ "LOAD_DEREF", "node" ], [ "COMPARE_OP", "parent.iter is not node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "CALL_FUNCTION", "isinstance(parent, ast.While)" ], [ "LOAD_DEREF", "node" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.orelse" ], [ "COMPARE_OP", "node not in parent.orelse" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "CALL_FUNCTION", "isinstance(parent, ast.comprehension)" ], [ "LOAD_DEREF", "node" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.ifs" ], [ "COMPARE_OP", "node in parent.ifs" ], [ "LOAD_FAST", "is_containing_loop" ], [ "LOAD_FAST", "result" ], [ "LOAD_METHOD", "result.append" ], [ "LOAD_FAST", "parent" ], [ "CALL_METHOD", "result.append(parent)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.ListComp" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.GeneratorExp" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.DictComp" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.SetComp" ], [ "CALL_FUNCTION", "isinstance(parent, (ast.ListComp,\n ast.GeneratorExp,\n ast.DictComp,\n ast.SetComp))" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.generators" ], [ "LOAD_DEREF", "node" ], [ "LOAD_FAST", "generators" ], [ "COMPARE_OP", "node in generators" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "takewhile" ], [ "LOAD_FAST", "generators" ], [ "CALL_FUNCTION", "takewhile(lambda n: n != node, generators)" ], [ "CALL_FUNCTION", "list(takewhile(lambda n: n != node, generators))" ], [ "LOAD_FAST", "result" ], [ "LOAD_METHOD", "result.extend" ], [ "LOAD_GLOBAL", "reversed" ], [ "LOAD_FAST", "generators" ], [ "CALL_FUNCTION", "reversed(generators)" ], [ "CALL_METHOD", "result.extend(reversed(generators))" ], [ "LOAD_FAST", "parent" ], [ "LOAD_FAST", "result" ], [ "LOAD_METHOD", "result.reverse" ], [ "CALL_METHOD", "result.reverse()" ], [ "LOAD_GLOBAL", "tuple" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "tuple(result)" ], [ "LOAD_FAST", "n" ], [ "LOAD_DEREF", "node" ], [ "COMPARE_OP", "n != node" ] ], "tracer2.py": [ [ "LOAD_NAME", "find_repr_function" ], [ "LOAD_NAME", "six" ], [ "LOAD_ATTR", "six.text_type" ], [ "CALL_FUNCTION", "find_repr_function(six.text_type)" ], [ "LOAD_NAME", "find_repr_function" ], [ "LOAD_NAME", "six" ], [ "LOAD_ATTR", "six.binary_type" ], [ "CALL_FUNCTION", "find_repr_function(six.binary_type)" ], [ "LOAD_NAME", "find_repr_function" ], [ "LOAD_NAME", "object" ], [ "CALL_FUNCTION", "find_repr_function(object)" ], [ "LOAD_NAME", "find_repr_function" ], [ "LOAD_NAME", "int" ], [ "CALL_FUNCTION", "find_repr_function(int)" ], [ "LOAD_NAME", "cheap_repr" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "threading" ], [ "LOAD_METHOD", "threading.local" ], [ "CALL_METHOD", "threading.local()" ], [ "LOAD_NAME", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_METHOD", "os.path.dirname" ], [ "LOAD_ATTR", "(lambda: 0).__code__" ], [ "LOAD_ATTR", "(lambda: 0).__code__.co_filename" ], [ "CALL_METHOD", "os.path.dirname((lambda: 0).__code__.co_filename)" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_METHOD", "os.path.dirname" ], [ "LOAD_NAME", "birdseye" ], [ "LOAD_ATTR", "birdseye.__file__" ], [ "CALL_METHOD", "os.path.dirname(birdseye.__file__)" ], [ "LOAD_NAME", "type" ], [ "LOAD_NAME", "six" ], [ "LOAD_METHOD", "six.add_metaclass" ], [ "LOAD_NAME", "TracerMeta" ], [ "CALL_METHOD", "six.add_metaclass(TracerMeta)" ], [ "LOAD_NAME", "object" ], [ "CALL_FUNCTION", "six.add_metaclass(TracerMeta)" ], [ "LOAD_NAME", "object" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lineno" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "CALL_FUNCTION", "OrderedDict()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_METHOD", "Source.for_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "Source.for_frame(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_flags" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.CO_GENERATOR" ], [ "BINARY_AND", "frame.f_code.co_flags & inspect.CO_GENERATOR" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "is_comprehension_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "is_comprehension_frame(frame)" ], [ "LOAD_GLOBAL", "re" ], [ "LOAD_METHOD", "re.match" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "CALL_METHOD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name)" ], [ "LOAD_METHOD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group" ], [ "CALL_METHOD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group(1)" ], [ "LOAD_METHOD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group(1).title" ], [ "CALL_METHOD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group(1).title()" ], [ "BINARY_ADD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group(1).title()\n + u' comprehension'" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_lineno" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.local_reprs" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.get_local_reprs" ], [ "LOAD_FAST", "watch" ], [ "LOAD_FAST", "watch_extras" ], [ "CALL_METHOD", "self.get_local_reprs(watch, watch_extras)" ], [ "CALL_FUNCTION", "OrderedDict(\n (source, my_cheap_repr(value))\n for source, value in\n self.get_local_reprs(watch, watch_extras)\n )" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.comprehension_type" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.local_reprs" ], [ "LOAD_METHOD", "self.local_reprs.items" ], [ "CALL_METHOD", "self.local_reprs.items()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.comprehension_variables" ], [ "LOAD_METHOD", "self.comprehension_variables.setdefault" ], [ "LOAD_FAST", "name" ], [ "CALL_METHOD", "self.comprehension_variables.setdefault(name, [])" ], [ "LOAD_FAST", "values" ], [ "LOAD_FAST", "values" ], [ "BINARY_SUBSCR", "values[-1]" ], [ "LOAD_FAST", "value_repr" ], [ "COMPARE_OP", "values[-1] != value_repr" ], [ "LOAD_FAST", "values" ], [ "LOAD_METHOD", "values.append" ], [ "LOAD_FAST", "value_repr" ], [ "CALL_METHOD", "values.append(value_repr)" ], [ "LOAD_GLOBAL", "truncate_list" ], [ "LOAD_FAST", "values" ], [ "CALL_FUNCTION", "truncate_list(values, 11)" ], [ "LOAD_FAST", "values" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event in ('return', 'exception')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.comprehension_variables" ], [ "LOAD_METHOD", "self.comprehension_variables.items" ], [ "CALL_METHOD", "self.comprehension_variables.items()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.local_reprs" ], [ "LOAD_METHOD", "self.local_reprs.items" ], [ "CALL_METHOD", "self.local_reprs.items()" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "old_local_reprs" ], [ "COMPARE_OP", "name not in old_local_reprs" ], [ "LOAD_FAST", "old_local_reprs" ], [ "LOAD_FAST", "name" ], [ "BINARY_SUBSCR", "old_local_reprs[name]" ], [ "LOAD_FAST", "value_repr" ], [ "COMPARE_OP", "old_local_reprs[name] != value_repr" ], [ "LOAD_FAST", "variables" ], [ "LOAD_METHOD", "variables.append" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "value_repr" ], [ "CALL_METHOD", "variables.append((name, value_repr))" ], [ "LOAD_FAST", "variables" ], [ "LOAD_FAST", "source" ], [ "LOAD_GLOBAL", "my_cheap_repr" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "my_cheap_repr(value)" ], [ "LOAD_FAST", "name" ], [ "LOAD_METHOD", "', '.join" ], [ "LOAD_FAST", "values" ], [ "CALL_METHOD", "', '.join(values)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_varnames" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_cellvars" ], [ "BINARY_ADD", "code.co_varnames + code.co_cellvars" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_freevars" ], [ "BINARY_ADD", "code.co_varnames + code.co_cellvars + code.co_freevars" ], [ "LOAD_GLOBAL", "tuple" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "LOAD_METHOD", "frame.f_locals.keys" ], [ "CALL_METHOD", "frame.f_locals.keys()" ], [ "CALL_FUNCTION", "tuple(frame.f_locals.keys())" ], [ "BINARY_ADD", "code.co_varnames + code.co_cellvars + code.co_freevars + tuple(frame.f_locals.keys())" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "LOAD_METHOD", "frame.f_locals.items" ], [ "CALL_METHOD", "frame.f_locals.items()" ], [ "CALL_FUNCTION_KW", "sorted(\n frame.f_locals.items(),\n key=lambda key_value: vars_order.index(key_value[0])\n )" ], [ "LOAD_FAST", "watch" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_FAST", "variable" ], [ "LOAD_METHOD", "variable.items" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "variable.items(frame)" ], [ "CALL_FUNCTION", "sorted(variable.items(frame))" ], [ "LOAD_FAST", "result_items" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "watch_extras" ], [ "LOAD_FAST", "extra" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "extra(source, value)" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_FAST", "pair" ], [ "COMPARE_OP", "pair is not None" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "pair" ], [ "CALL_FUNCTION", "len(pair)" ], [ "COMPARE_OP", "len(pair) == 2" ], [ "LOAD_FAST", "pair" ], [ "LOAD_DEREF", "vars_order" ], [ "LOAD_METHOD", "vars_order.index" ], [ "LOAD_FAST", "key_value" ], [ "BINARY_SUBSCR", "key_value[0]" ], [ "CALL_METHOD", "vars_order.index(key_value[0])" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "TracerMeta" ], [ "LOAD_FAST", "mcs" ], [ "CALL_FUNCTION", "super(TracerMeta, mcs)" ], [ "LOAD_ATTR", "super(TracerMeta, mcs).__new__" ], [ "LOAD_FAST", "mcs" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "super(TracerMeta, mcs).__new__(mcs, *args, **kwargs)" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "result()" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "no_args_decorator" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION", "no_args_decorator(args, kwargs)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_METHOD", "cls.default" ], [ "LOAD_FAST", "args" ], [ "BINARY_SUBSCR", "args[0]" ], [ "CALL_METHOD", "cls.default(args[0])" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "TracerMeta" ], [ "LOAD_FAST", "cls" ], [ "CALL_FUNCTION", "super(TracerMeta, cls)" ], [ "LOAD_ATTR", "super(TracerMeta, cls).__call__" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "super(TracerMeta, cls).__call__(*args, **kwargs)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.default" ], [ "LOAD_ATTR", "self.default.__enter__" ], [ "CALL_FUNCTION_KW", "self.default.__enter__(context=1)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.default" ], [ "LOAD_ATTR", "self.default.__exit__" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION_EX", "self.default.__exit__(*args, context=1)" ], [ "LOAD_GLOBAL", "ensure_tuple" ], [ "LOAD_FAST", "watch" ], [ "CALL_FUNCTION", "ensure_tuple(watch)" ], [ "LOAD_GLOBAL", "ensure_tuple" ], [ "LOAD_FAST", "watch_explode" ], [ "CALL_FUNCTION", "ensure_tuple(watch_explode)" ], [ "BINARY_ADD", "[\n v if isinstance(v, BaseVariable) else CommonVariable(v)\n for v in ensure_tuple(watch)\n ] + [\n v if isinstance(v, BaseVariable) else Exploding(v)\n for v in ensure_tuple(watch_explode)\n ]" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "ArgDefaultDict" ], [ "LOAD_GLOBAL", "FrameInfo" ], [ "CALL_FUNCTION", "ArgDefaultDict(FrameInfo)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "depth" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.depth" ], [ "COMPARE_OP", "self.depth >= 1" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "BaseVariable" ], [ "CALL_FUNCTION", "isinstance(v, BaseVariable)" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "CommonVariable" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "CommonVariable(v)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "BaseVariable" ], [ "CALL_FUNCTION", "isinstance(v, BaseVariable)" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "Exploding" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "Exploding(v)" ], [ "LOAD_GLOBAL", "iscoroutinefunction" ], [ "LOAD_DEREF", "function" ], [ "CALL_FUNCTION", "iscoroutinefunction(function)" ], [ "LOAD_GLOBAL", "NotImplementedError" ], [ "CALL_FUNCTION", "NotImplementedError(\"coroutines are not supported, sorry!\")" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.target_codes" ], [ "LOAD_METHOD", "self.target_codes.add" ], [ "LOAD_DEREF", "function" ], [ "LOAD_ATTR", "function.__code__" ], [ "CALL_METHOD", "self.target_codes.add(function.__code__)" ], [ "LOAD_GLOBAL", "functools" ], [ "LOAD_METHOD", "functools.wraps" ], [ "LOAD_DEREF", "function" ], [ "CALL_METHOD", "functools.wraps(function)" ], [ "CALL_FUNCTION", "functools.wraps(function)" ], [ "LOAD_GLOBAL", "functools" ], [ "LOAD_METHOD", "functools.wraps" ], [ "LOAD_DEREF", "function" ], [ "CALL_METHOD", "functools.wraps(function)" ], [ "CALL_FUNCTION", "functools.wraps(function)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.isgeneratorfunction" ], [ "LOAD_DEREF", "function" ], [ "CALL_METHOD", "inspect.isgeneratorfunction(function)" ], [ "LOAD_FAST", "generator_wrapper" ], [ "LOAD_FAST", "simple_wrapper" ], [ "LOAD_DEREF", "self" ], [ "LOAD_DEREF", "function" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "function(*args, **kwargs)" ], [ "LOAD_DEREF", "function" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "function(*args, **kwargs)" ], [ "LOAD_FAST", "gen" ], [ "LOAD_ATTR", "gen.send" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "method" ], [ "LOAD_FAST", "incoming" ], [ "CALL_FUNCTION", "method(incoming)" ], [ "LOAD_GLOBAL", "StopIteration" ], [ "LOAD_FAST", "gen" ], [ "LOAD_ATTR", "gen.send" ], [ "LOAD_FAST", "outgoing" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_FAST", "gen" ], [ "LOAD_ATTR", "gen.throw" ], [ "LOAD_FAST", "e" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.enabled" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_METHOD", "sys._getframe" ], [ "LOAD_FAST", "context" ], [ "BINARY_ADD", "context + 1" ], [ "CALL_METHOD", "sys._getframe(context + 1)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._is_internal_frame" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_METHOD", "self._is_internal_frame(calling_frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.trace" ], [ "LOAD_FAST", "calling_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.target_frames" ], [ "LOAD_METHOD", "self.target_frames.add" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_METHOD", "self.target_frames.add(calling_frame)" ], [ "LOAD_FAST", "calling_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.trace" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_METHOD", "self.trace(calling_frame, 'enter', None)" ], [ "LOAD_GLOBAL", "thread_global" ], [ "LOAD_ATTR", "thread_global.__dict__" ], [ "LOAD_METHOD", "thread_global.__dict__.setdefault" ], [ "CALL_METHOD", "thread_global.__dict__.setdefault('original_trace_functions', [])" ], [ "LOAD_FAST", "stack" ], [ "LOAD_METHOD", "stack.append" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_METHOD", "sys.gettrace" ], [ "CALL_METHOD", "sys.gettrace()" ], [ "CALL_METHOD", "stack.append(sys.gettrace())" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_METHOD", "sys.settrace" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.trace" ], [ "CALL_METHOD", "sys.settrace(self.trace)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.enabled" ], [ "LOAD_GLOBAL", "thread_global" ], [ "LOAD_ATTR", "thread_global.original_trace_functions" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_METHOD", "sys.settrace" ], [ "LOAD_FAST", "stack" ], [ "LOAD_METHOD", "stack.pop" ], [ "CALL_METHOD", "stack.pop()" ], [ "CALL_METHOD", "sys.settrace(stack.pop())" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_METHOD", "sys._getframe" ], [ "LOAD_FAST", "context" ], [ "BINARY_ADD", "context + 1" ], [ "CALL_METHOD", "sys._getframe(context + 1)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.trace" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_METHOD", "self.trace(calling_frame, 'exit', None)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.target_frames" ], [ "LOAD_METHOD", "self.target_frames.discard" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_METHOD", "self.target_frames.discard(calling_frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame_infos" ], [ "LOAD_METHOD", "self.frame_infos.pop" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_METHOD", "self.frame_infos.pop(calling_frame, None)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_filename" ], [ "LOAD_METHOD", "frame.f_code.co_filename.startswith" ], [ "LOAD_GLOBAL", "internal_directories" ], [ "CALL_METHOD", "frame.f_code.co_filename.startswith(internal_directories)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.target_codes" ], [ "COMPARE_OP", "frame.f_code in self.target_codes" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.target_frames" ], [ "COMPARE_OP", "frame in self.target_frames" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._is_traced_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self._is_traced_frame(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.depth" ], [ "COMPARE_OP", "self.depth == 1" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._is_internal_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self._is_internal_frame(frame)" ], [ "LOAD_GLOBAL", "is_comprehension_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "is_comprehension_frame(frame)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_GLOBAL", "is_comprehension_frame" ], [ "LOAD_FAST", "candidate" ], [ "CALL_FUNCTION", "is_comprehension_frame(candidate)" ], [ "LOAD_FAST", "candidate" ], [ "LOAD_ATTR", "candidate.f_back" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._is_traced_frame" ], [ "LOAD_FAST", "candidate" ], [ "CALL_METHOD", "self._is_traced_frame(candidate)" ], [ "LOAD_FAST", "candidate" ], [ "LOAD_ATTR", "candidate.f_back" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.depth" ], [ "COMPARE_OP", "i >= self.depth" ], [ "LOAD_FAST", "candidate" ], [ "COMPARE_OP", "candidate is None" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._is_internal_frame" ], [ "LOAD_FAST", "candidate" ], [ "CALL_METHOD", "self._is_internal_frame(candidate)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.thread_local" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_ATTR", "thread_local.__dict__" ], [ "LOAD_METHOD", "thread_local.__dict__.setdefault" ], [ "CALL_METHOD", "thread_local.__dict__.setdefault('depth', -1)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame_infos" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.frame_infos[frame]" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event in ('call', 'enter')" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.last_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.last_frame" ], [ "LOAD_FAST", "frame" ], [ "COMPARE_OP", "self.config.last_frame is not frame" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.last_line_no" ], [ "LOAD_GLOBAL", "Event" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "event" ], [ "LOAD_FAST", "arg" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_ATTR", "thread_local.depth" ], [ "LOAD_FAST", "line_no" ], [ "CALL_FUNCTION_KW", "Event(frame_info, event, arg, thread_local.depth, line_no=line_no)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.formatter" ], [ "LOAD_METHOD", "self.config.formatter.format_line_only" ], [ "LOAD_FAST", "trace_event" ], [ "CALL_METHOD", "self.config.formatter.format_line_only(trace_event)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_METHOD", "self.config.write" ], [ "LOAD_FAST", "line" ], [ "CALL_METHOD", "self.config.write(line)" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event == 'exception'" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_GLOBAL", "Event" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "event" ], [ "LOAD_FAST", "arg" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_ATTR", "thread_local.depth" ], [ "CALL_FUNCTION", "Event(frame_info, event, arg, thread_local.depth)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "COMPARE_OP", "frame.f_code.co_name == ''" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event not in ('return', 'exception')" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_METHOD", "frame_info.update_variables" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.watch" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.watch_extras" ], [ "LOAD_FAST", "event" ], [ "CALL_METHOD", "frame_info.update_variables(\n self.watch,\n self.config.watch_extras,\n event,\n )" ], [ "LOAD_FAST", "trace_event" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event in ('return', 'exit')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame_infos" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.formatter" ], [ "LOAD_METHOD", "self.config.formatter.format" ], [ "LOAD_FAST", "trace_event" ], [ "CALL_METHOD", "self.config.formatter.format(trace_event)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_METHOD", "self.config.write" ], [ "LOAD_FAST", "formatted" ], [ "CALL_METHOD", "self.config.write(formatted)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.trace" ], [ "LOAD_FAST", "config" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "NO_ASTTOKENS" ], [ "LOAD_GLOBAL", "Exception" ], [ "CALL_FUNCTION", "Exception(\"birdseye doesn't support this version of Python\")" ], [ "LOAD_GLOBAL", "ImportError" ], [ "LOAD_GLOBAL", "Exception" ], [ "CALL_FUNCTION", "Exception(\"You must install birdseye separately to use spy: pip install birdseye\")" ], [ "LOAD_GLOBAL", "no_args_decorator" ], [ "LOAD_DEREF", "args" ], [ "LOAD_DEREF", "kwargs" ], [ "CALL_FUNCTION", "no_args_decorator(args, kwargs)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self._trace" ], [ "LOAD_DEREF", "args" ], [ "BINARY_SUBSCR", "args[0]" ], [ "CALL_METHOD", "self._trace(args[0])" ], [ "LOAD_FAST", "decorator" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._trace" ], [ "LOAD_FAST", "func" ], [ "LOAD_DEREF", "args" ], [ "LOAD_DEREF", "kwargs" ], [ "CALL_FUNCTION_EX", "self._trace(func, *args, **kwargs)" ], [ "LOAD_FAST", "eye" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "eye(func)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.snoop" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "self.config.snoop(*args, **kwargs)" ], [ "LOAD_DEREF", "traced" ], [ "CALL_FUNCTION", "self.config.snoop(*args, **kwargs)(traced)" ], [ "LOAD_GLOBAL", "functools" ], [ "LOAD_METHOD", "functools.wraps" ], [ "LOAD_DEREF", "func" ], [ "CALL_METHOD", "functools.wraps(func)" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "LOAD_FAST", "wrapper" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.enabled" ], [ "LOAD_DEREF", "traced" ], [ "LOAD_DEREF", "func" ], [ "LOAD_FAST", "final_func" ], [ "LOAD_FAST", "func_args" ], [ "LOAD_FAST", "func_kwargs" ], [ "CALL_FUNCTION_EX", "final_func(*func_args, **func_kwargs)" ] ], "utils.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOAD_METHOD", "standard_library.install_aliases" ], [ "CALL_METHOD", "standard_library.install_aliases()" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "type" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "version_info" ], [ "LOAD_ATTR", "version_info.major" ], [ "COMPARE_OP", "version_info.major == 2" ], [ "LOAD_NAME", "PY2" ], [ "UNARY_NOT", "not PY2" ], [ "LOAD_NAME", "TypeVar" ], [ "CALL_FUNCTION", "TypeVar('T')" ], [ "LOAD_NAME", "TypeVar" ], [ "CALL_FUNCTION", "TypeVar('RT')" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "unicode" ], [ "LOAD_NAME", "str" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "type" ], [ "LOAD_NAME", "json" ], [ "LOAD_ATTR", "json.JSONEncoder" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_GLOBAL", "ntpath" ], [ "LOAD_METHOD", "ntpath.split" ], [ "LOAD_FAST", "path" ], [ "CALL_METHOD", "ntpath.split(path)" ], [ "LOAD_FAST", "tail" ], [ "LOAD_GLOBAL", "ntpath" ], [ "LOAD_METHOD", "ntpath.basename" ], [ "LOAD_FAST", "head" ], [ "CALL_METHOD", "ntpath.basename(head)" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_METHOD", "os.path.commonprefix" ], [ "LOAD_FAST", "paths" ], [ "CALL_METHOD", "os.path.commonprefix(paths)" ], [ "LOAD_GLOBAL", "ntpath" ], [ "LOAD_METHOD", "ntpath.split" ], [ "LOAD_FAST", "prefix" ], [ "CALL_METHOD", "ntpath.split(prefix)" ], [ "BINARY_SUBSCR", "ntpath.split(prefix)[0]" ], [ "LOAD_FAST", "paths" ], [ "BINARY_SUBSCR", "paths[0]" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "prefix" ], [ "CALL_FUNCTION", "len(prefix)" ], [ "BINARY_SUBSCR", "paths[0][len(prefix)]" ], [ "LOAD_FAST", "first_char_after" ], [ "COMPARE_OP", "first_char_after in r'\\/'" ], [ "LOAD_FAST", "first_char_after" ], [ "LOAD_FAST", "prefix" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "COMPARE_OP", "path == IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "all_paths" ], [ "LOAD_GLOBAL", "common_ancestor" ], [ "LOAD_FAST", "all_paths" ], [ "CALL_FUNCTION", "common_ancestor(all_paths)" ], [ "LOAD_FAST", "prefix" ], [ "COMPARE_OP", "prefix in r'\\/'" ], [ "LOAD_GLOBAL", "strip_required_prefix" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "prefix" ], [ "CALL_FUNCTION", "strip_required_prefix(path, prefix)" ], [ "LOAD_GLOBAL", "path_leaf" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "path_leaf(path)" ], [ "LOAD_FAST", "f" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "COMPARE_OP", "f != IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "f" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "COMPARE_OP", "path == IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.sep" ], [ "COMPARE_OP", "os.path.sep == '/'" ], [ "LOAD_FAST", "path" ], [ "LOAD_METHOD", "path.startswith" ], [ "CALL_METHOD", "path.startswith('/')" ], [ "LOAD_FAST", "path" ], [ "BINARY_ADD", "'/' + path" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "type" ], [ "LOAD_FAST", "obj" ], [ "CALL_FUNCTION", "type(obj)" ], [ "LOAD_FAST", "t" ], [ "LOAD_GLOBAL", "types" ], [ "LOAD_ATTR", "types.InstanceType" ], [ "COMPARE_OP", "t is types.InstanceType" ], [ "LOAD_FAST", "obj" ], [ "LOAD_ATTR", "obj.__class__" ], [ "LOAD_FAST", "t" ], [ "LOAD_FAST", "iterable" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_DEREF", "type_or_tuple" ], [ "CALL_FUNCTION", "isinstance(x, type_or_tuple)" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "next" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "next(it)" ], [ "LOAD_GLOBAL", "StopIteration" ], [ "LOAD_GLOBAL", "raise_from" ], [ "LOAD_GLOBAL", "RuntimeError" ], [ "LOAD_FAST", "e" ], [ "CALL_FUNCTION", "raise_from(RuntimeError, e)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "expression" ], [ "CALL_FUNCTION", "hasattr(expression, 'one_or_none')" ], [ "LOAD_FAST", "expression" ], [ "LOAD_METHOD", "expression.one_or_none" ], [ "CALL_METHOD", "expression.one_or_none()" ], [ "LOAD_FAST", "expression" ], [ "LOAD_METHOD", "expression.all" ], [ "CALL_METHOD", "expression.all()" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "len(result)" ], [ "COMPARE_OP", "len(result) == 0" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "len(result)" ], [ "COMPARE_OP", "len(result) == 1" ], [ "LOAD_FAST", "result" ], [ "BINARY_SUBSCR", "result[0]" ], [ "LOAD_GLOBAL", "Exception" ], [ "CALL_FUNCTION", "Exception(\"There is more than one item returned for the supplied filter\")" ], [ "LOAD_FAST", "lst" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "isinstance(x, list)" ], [ "LOAD_FAST", "result" ], [ "LOAD_METHOD", "result.extend" ], [ "LOAD_GLOBAL", "flatten_list" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "flatten_list(x)" ], [ "CALL_METHOD", "result.extend(flatten_list(x))" ], [ "LOAD_FAST", "result" ], [ "LOAD_METHOD", "result.append" ], [ "LOAD_FAST", "x" ], [ "CALL_METHOD", "result.append(x)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "f" ], [ "LOAD_ATTR", "f.__code__" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "LOAD_ATTR", "(lambda: 0).__code__" ], [ "LOAD_ATTR", "(lambda: 0).__code__.co_name" ], [ "COMPARE_OP", "code.co_name == (lambda: 0).__code__.co_name" ], [ "LOAD_FAST", "o" ], [ "LOAD_ATTR", "o.as_json" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "ProtocolEncoder" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(ProtocolEncoder, self)" ], [ "LOAD_METHOD", "super(ProtocolEncoder, self).default" ], [ "LOAD_FAST", "o" ], [ "CALL_METHOD", "super(ProtocolEncoder, self).default(o)" ], [ "LOAD_FAST", "method" ], [ "CALL_FUNCTION", "method()" ], [ "LOAD_GLOBAL", "io" ], [ "LOAD_METHOD", "io.open" ], [ "LOAD_FAST", "filename" ], [ "CALL_METHOD", "io.open(filename, 'rb')" ], [ "LOAD_GLOBAL", "detect_encoding" ], [ "LOAD_FAST", "fp" ], [ "LOAD_ATTR", "fp.readline" ], [ "CALL_FUNCTION", "detect_encoding(fp.readline)" ], [ "LOAD_FAST", "fp" ], [ "LOAD_METHOD", "fp.seek" ], [ "CALL_METHOD", "fp.seek(0)" ], [ "LOAD_GLOBAL", "io" ], [ "LOAD_ATTR", "io.TextIOWrapper" ], [ "LOAD_FAST", "fp" ], [ "LOAD_FAST", "encoding" ], [ "CALL_FUNCTION_KW", "io.TextIOWrapper(fp, encoding, line_buffering=True)" ], [ "LOAD_FAST", "text" ], [ "LOAD_FAST", "text" ], [ "LOAD_FAST", "fp" ], [ "LOAD_METHOD", "fp.close" ], [ "CALL_METHOD", "fp.close()" ], [ "LOAD_FAST", "filename" ], [ "LOAD_METHOD", "filename.endswith" ], [ "CALL_METHOD", "filename.endswith('.pyc')" ], [ "LOAD_FAST", "filename" ], [ "BINARY_SUBSCR", "filename[:-1]" ], [ "LOAD_GLOBAL", "open_with_encoding_check" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "open_with_encoding_check(filename)" ], [ "LOAD_METHOD", "''.join" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "f" ], [ "CALL_FUNCTION", "enumerate(f)" ], [ "CALL_METHOD", "''.join([\n '\\n' if i < 2 and cookie_re.match(line)\n else line\n for i, line in enumerate(f)\n ])" ], [ "LOAD_FAST", "i" ], [ "COMPARE_OP", "i < 2" ], [ "LOAD_DEREF", "cookie_re" ], [ "LOAD_METHOD", "cookie_re.match" ], [ "LOAD_FAST", "line" ], [ "CALL_METHOD", "cookie_re.match(line)" ], [ "LOAD_FAST", "line" ], [ "LOAD_GLOBAL", "safe_next" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_METHOD", "tokens.get_tokens" ], [ "LOAD_FAST", "function_node" ], [ "CALL_METHOD", "tokens.get_tokens(function_node)" ], [ "CALL_FUNCTION", "safe_next(t for t in tokens.get_tokens(function_node)\n if t.string == 'def' and t.type == token.NAME)" ], [ "LOAD_FAST", "def_token" ], [ "LOAD_ATTR", "def_token.startpos" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_ATTR", "tokens.text" ], [ "LOAD_FAST", "startpos" ], [ "LOAD_FAST", "function_node" ], [ "LOAD_ATTR", "function_node.last_token" ], [ "LOAD_ATTR", "function_node.last_token.endpos" ], [ "BINARY_SUBSCR", "tokens.text[startpos:function_node.last_token.endpos]" ], [ "LOAD_METHOD", "tokens.text[startpos:function_node.last_token.endpos].rstrip" ], [ "CALL_METHOD", "tokens.text[startpos:function_node.last_token.endpos].rstrip()" ], [ "LOAD_FAST", "source" ], [ "LOAD_METHOD", "source.startswith" ], [ "CALL_METHOD", "source.startswith('def')" ], [ "LOAD_FAST", "startpos" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "t" ], [ "LOAD_ATTR", "t.string" ], [ "COMPARE_OP", "t.string == 'def'" ], [ "LOAD_FAST", "t" ], [ "LOAD_ATTR", "t.type" ], [ "LOAD_GLOBAL", "token" ], [ "LOAD_ATTR", "token.NAME" ], [ "COMPARE_OP", "t.type == token.NAME" ], [ "LOAD_FAST", "t" ], [ "LOAD_FAST", "args" ], [ "LOAD_GLOBAL", "print" ], [ "LOAD_FAST", "arg" ], [ "CALL_FUNCTION", "print(arg)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION", "len(args)" ], [ "COMPARE_OP", "len(args) == 1" ], [ "LOAD_FAST", "args" ], [ "BINARY_SUBSCR", "args[0]" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "filename" ], [ "LOAD_METHOD", "filename.startswith" ], [ "CALL_METHOD", "filename.startswith(' max_length" ], [ "LOAD_FAST", "max_length" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "middle" ], [ "CALL_FUNCTION", "len(middle)" ], [ "BINARY_SUBTRACT", "max_length - len(middle)" ], [ "BINARY_FLOOR_DIVIDE", "(max_length - len(middle)) // 2" ], [ "LOAD_FAST", "max_length" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "middle" ], [ "CALL_FUNCTION", "len(middle)" ], [ "BINARY_SUBTRACT", "max_length - len(middle)" ], [ "LOAD_FAST", "left" ], [ "BINARY_SUBTRACT", "max_length - len(middle) - left" ], [ "LOAD_FAST", "seq" ], [ "LOAD_FAST", "left" ], [ "BINARY_SUBSCR", "seq[:left]" ], [ "LOAD_FAST", "middle" ], [ "BINARY_ADD", "seq[:left] + middle" ], [ "LOAD_FAST", "seq" ], [ "LOAD_FAST", "right" ], [ "UNARY_NEGATIVE", "-right" ], [ "BINARY_SUBSCR", "seq[-right:]" ], [ "BINARY_ADD", "seq[:left] + middle + seq[-right:]" ], [ "LOAD_FAST", "seq" ], [ "LOAD_GLOBAL", "truncate" ], [ "LOAD_FAST", "string" ], [ "LOAD_FAST", "max_length" ], [ "CALL_FUNCTION", "truncate(string, max_length, '...')" ], [ "LOAD_GLOBAL", "truncate" ], [ "LOAD_FAST", "lst" ], [ "LOAD_FAST", "max_length" ], [ "CALL_FUNCTION", "truncate(lst, max_length, ['...'])" ], [ "LOAD_FAST", "split" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "six" ], [ "LOAD_ATTR", "six.string_types" ], [ "CALL_FUNCTION", "isinstance(x, six.string_types)" ], [ "LOAD_FAST", "x" ], [ "LOAD_METHOD", "x.replace" ], [ "CALL_METHOD", "x.replace(',', ' ')" ], [ "LOAD_METHOD", "x.replace(',', ' ').split" ], [ "CALL_METHOD", "x.replace(',', ' ').split()" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "set" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "isinstance(x, (list, set, tuple))" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "tuple" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tuple(x)" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_METHOD", "os.path.basename" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_filename" ], [ "CALL_METHOD", "os.path.basename(code.co_filename)" ], [ "LOAD_FAST", "result" ], [ "LOAD_METHOD", "result.endswith" ], [ "CALL_METHOD", "result.endswith('.pyc')" ], [ "LOAD_FAST", "result" ], [ "BINARY_SUBSCR", "result[:-1]" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "COMPARE_OP", "frame.f_code.co_name in ('', '', '')" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "code('{}.x')" ], [ "LOAD_GLOBAL", "SyntaxError" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "code('({})')" ], [ "LOAD_FAST", "without_parens" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "code('({}).x')" ], [ "COMPARE_OP", "without_parens != code('({}).x')" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "s" ], [ "LOAD_METHOD", "s.format" ], [ "LOAD_DEREF", "source" ], [ "CALL_METHOD", "s.format(source)" ], [ "CALL_FUNCTION", "compile(s.format(source), '', 'eval')" ], [ "LOAD_ATTR", "compile(s.format(source), '', 'eval').co_code" ], [ "LOAD_GLOBAL", "needs_parentheses" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "needs_parentheses(source)" ], [ "LOAD_METHOD", "'({})'.format" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "'({})'.format(source)" ], [ "LOAD_FAST", "source" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "REPR_TARGET_LENGTH" ], [ "CALL_FUNCTION_KW", "cheap_repr(x, target_length=REPR_TARGET_LENGTH)" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "ArgDefaultDict" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(ArgDefaultDict, self)" ], [ "LOAD_METHOD", "super(ArgDefaultDict, self).__init__" ], [ "CALL_METHOD", "super(ArgDefaultDict, self).__init__()" ], [ "LOAD_FAST", "factory" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.factory" ], [ "LOAD_FAST", "key" ], [ "CALL_METHOD", "self.factory(key)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "key" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "lst" ], [ "CALL_FUNCTION", "len(lst)" ], [ "COMPARE_OP", "len(lst) == 1" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "CALL_FUNCTION", "str(i + 1)" ], [ "BINARY_ADD", "' ' + str(i + 1)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_GLOBAL", "os" ], [ "CALL_FUNCTION", "hasattr(os, 'PathLike')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.PathLike" ], [ "CALL_FUNCTION", "isinstance(x, os.PathLike)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "hasattr(x, '__fspath__')" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "hasattr(x, 'open')" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.__class__" ], [ "LOAD_ATTR", "x.__class__.__name__" ], [ "LOAD_METHOD", "x.__class__.__name__.lower" ], [ "CALL_METHOD", "x.__class__.__name__.lower()" ], [ "COMPARE_OP", "'path' in x.__class__.__name__.lower()" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION", "len(args)" ], [ "COMPARE_OP", "len(args) == 1" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.isfunction" ], [ "LOAD_FAST", "args" ], [ "BINARY_SUBSCR", "args[0]" ], [ "CALL_METHOD", "inspect.isfunction(args[0])" ], [ "LOAD_FAST", "kwargs" ], [ "UNARY_NOT", "not kwargs" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_ADD", "max_length + 2" ], [ "COMPARE_OP", "length <= max_length + 2" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "range(length)" ], [ "LOAD_GLOBAL", "chain" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_FLOOR_DIVIDE", "max_length // 2" ], [ "CALL_FUNCTION", "range(max_length // 2)" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_FLOOR_DIVIDE", "max_length // 2" ], [ "BINARY_SUBTRACT", "length - max_length // 2" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "range(length - max_length // 2,\n length)" ], [ "CALL_FUNCTION", "chain(range(max_length // 2),\n range(length - max_length // 2,\n length))" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "len(x)" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "n == 0" ], [ "LOAD_GLOBAL", "repr" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "repr(x)" ], [ "LOAD_FAST", "helper" ], [ "LOAD_ATTR", "helper.level" ], [ "BINARY_SUBTRACT", "helper.level - 1" ], [ "LOAD_GLOBAL", "_repr_series_one_line" ], [ "LOAD_ATTR", "_repr_series_one_line.maxparts" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "n" ], [ "LOAD_FAST", "maxparts" ], [ "CALL_FUNCTION", "_sample_indices(n, maxparts)" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.index" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "x.index[i:i + 1]" ], [ "LOAD_ATTR", "x.index[i:i + 1].format" ], [ "CALL_FUNCTION_KW", "x.index[i:i + 1].format(sparsify=False)" ], [ "BINARY_SUBSCR", "x.index[i:i + 1].format(sparsify=False)[0]" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.iloc" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "x.iloc[i]" ], [ "LOAD_FAST", "pieces" ], [ "LOAD_METHOD", "pieces.append" ], [ "LOAD_FAST", "k" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "v" ], [ "LOAD_FAST", "newlevel" ], [ "CALL_FUNCTION", "cheap_repr(v, newlevel)" ], [ "BINARY_MODULO", "'%s = %s' % (k, cheap_repr(v, newlevel))" ], [ "CALL_METHOD", "pieces.append('%s = %s' % (k, cheap_repr(v, newlevel)))" ], [ "LOAD_FAST", "n" ], [ "LOAD_FAST", "maxparts" ], [ "BINARY_ADD", "maxparts + 2" ], [ "COMPARE_OP", "n > maxparts + 2" ], [ "LOAD_FAST", "pieces" ], [ "LOAD_METHOD", "pieces.insert" ], [ "LOAD_FAST", "maxparts" ], [ "BINARY_FLOOR_DIVIDE", "maxparts // 2" ], [ "CALL_METHOD", "pieces.insert(maxparts // 2, '...')" ], [ "LOAD_METHOD", "'; '.join" ], [ "LOAD_FAST", "pieces" ], [ "CALL_METHOD", "'; '.join(pieces)" ] ] }executing-0.8.0/tests/sample_results/3.8.json000066400000000000000000021416501410133640400211260ustar00rootroot00000000000000{ "bird.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOAD_METHOD", "standard_library.install_aliases" ], [ "CALL_METHOD", "standard_library.install_aliases()" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "warn_if_outdated" ], [ "LOAD_NAME", "__version__" ], [ "CALL_FUNCTION", "warn_if_outdated('birdseye', __version__)" ], [ "LOAD_NAME", "namedtuple" ], [ "CALL_FUNCTION", "namedtuple('CodeInfo', 'db_func traced_file arg_names')" ], [ "LOAD_NAME", "TreeTracerBase" ], [ "LOAD_NAME", "BirdsEye" ], [ "CALL_FUNCTION", "BirdsEye()" ], [ "LOAD_NAME", "NamedTuple" ], [ "LOAD_NAME", "int" ], [ "LOAD_NAME", "bool" ], [ "LOAD_NAME", "int" ], [ "LOAD_NAME", "str" ], [ "CALL_FUNCTION", "NamedTuple('HTMLPosition', [\n ('index', int),\n ('is_start', bool),\n ('depth', int),\n ('html', str),\n])" ], [ "LOAD_NAME", "eye" ], [ "LOAD_ATTR", "eye.enter_call" ], [ "LOAD_ATTR", "eye.enter_call.__code__" ], [ "LOAD_NAME", "eye" ], [ "LOAD_ATTR", "eye.exit_call" ], [ "LOAD_ATTR", "eye.exit_call.__code__" ], [ "LOAD_NAME", "eye" ], [ "LOAD_ATTR", "eye.after_expr" ], [ "LOAD_ATTR", "eye.after_expr.__code__" ], [ "LOAD_NAME", "eye" ], [ "LOAD_ATTR", "eye.after_stmt" ], [ "LOAD_ATTR", "eye.after_stmt.__code__" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "Iterable" ], [ "LOAD_NAME", "Iteration" ], [ "BINARY_SUBSCR", "Iterable[Iteration]" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "TypeRegistry" ], [ "CALL_FUNCTION", "TypeRegistry()" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "try_register_repr" ], [ "CALL_FUNCTION", "try_register_repr('pandas', 'Series')" ], [ "CALL_FUNCTION", "try_register_repr('pandas', 'Series')" ], [ "LOAD_NAME", "cached_property" ], [ "CALL_FUNCTION", "cached_property" ], [ "LOAD_NAME", "lru_cache" ], [ "CALL_FUNCTION", "lru_cache()" ], [ "CALL_FUNCTION", "lru_cache()" ], [ "LOAD_NAME", "retry_db" ], [ "CALL_FUNCTION", "retry_db" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "BirdsEye" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(BirdsEye, self)" ], [ "LOAD_METHOD", "super(BirdsEye, self).__init__" ], [ "CALL_METHOD", "super(BirdsEye, self).__init__()" ], [ "LOAD_FAST", "db_uri" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "num_samples" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "dict" ], [ "CALL_FUNCTION_KW", "dict(\n attributes=50,\n dict=50,\n list=30,\n set=30,\n pandas_rows=20,\n pandas_cols=100,\n )" ], [ "LOAD_GLOBAL", "dict" ], [ "CALL_FUNCTION_KW", "dict(\n attributes=50,\n dict=10,\n list=6,\n set=6,\n pandas_rows=6,\n pandas_cols=10,\n )" ], [ "CALL_FUNCTION_KW", "dict(\n big=dict(\n attributes=50,\n dict=50,\n list=30,\n set=30,\n pandas_rows=20,\n pandas_cols=100,\n ),\n small=dict(\n attributes=50,\n dict=10,\n list=6,\n set=6,\n pandas_rows=6,\n pandas_cols=10,\n ),\n )" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "Database" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._db_uri" ], [ "CALL_FUNCTION", "Database(self._db_uri)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.walk" ], [ "LOAD_FAST", "root" ], [ "CALL_METHOD", "ast.walk(root)" ], [ "LOAD_GLOBAL", "tracer" ], [ "LOAD_METHOD", "tracer.loops" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "tracer.loops(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "CALL_FUNCTION", "isinstance(node, ast.expr)" ], [ "LOAD_GLOBAL", "is_interesting_expression" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "is_interesting_expression(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "BirdsEye" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(BirdsEye, self)" ], [ "LOAD_METHOD", "super(BirdsEye, self).compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "flags" ], [ "CALL_METHOD", "super(BirdsEye, self).compile(source, filename, flags)" ], [ "LOAD_GLOBAL", "ASTTokens" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.root" ], [ "CALL_FUNCTION_KW", "ASTTokens(source, tree=traced_file.root)" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.For)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.body" ], [ "BINARY_SUBSCR", "node.parent.body[0]" ], [ "COMPARE_OP", "node is node.parent.body[0]" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._add_iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self._add_iteration(node._loops, frame)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.While)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.test" ], [ "COMPARE_OP", "node is node.parent.test" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._add_iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self._add_iteration(node._loops, frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_ATTR", "self.stack[frame].iteration" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "loops" ], [ "CALL_FUNCTION", "enumerate(loops)" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.loops" ], [ "LOAD_FAST", "loop_node" ], [ "LOAD_ATTR", "loop_node._tree_index" ], [ "BINARY_SUBSCR", "iteration.loops[loop_node._tree_index]" ], [ "LOAD_FAST", "i" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "loops" ], [ "CALL_FUNCTION", "len(loops)" ], [ "BINARY_SUBTRACT", "len(loops) - 1" ], [ "COMPARE_OP", "i == len(loops) - 1" ], [ "LOAD_FAST", "loop" ], [ "LOAD_METHOD", "loop.append" ], [ "LOAD_GLOBAL", "Iteration" ], [ "CALL_FUNCTION", "Iteration()" ], [ "CALL_METHOD", "loop.append(Iteration())" ], [ "LOAD_FAST", "loop" ], [ "LOAD_METHOD", "loop.last" ], [ "CALL_METHOD", "loop.last()" ], [ "LOAD_GLOBAL", "_tracing_recursively" ], [ "LOAD_DEREF", "frame" ], [ "CALL_FUNCTION", "_tracing_recursively(frame)" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._is_interesting_expression" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "BINARY_SUBSCR", "self._code_infos[frame.f_code]" ], [ "LOAD_ATTR", "self._code_infos[frame.f_code].traced_file" ], [ "LOAD_ATTR", "self._code_infos[frame.f_code].traced_file.is_ipython_cell" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Expr" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.Expr)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.parent" ], [ "LOAD_ATTR", "node.parent.parent.body" ], [ "BINARY_SUBSCR", "node.parent.parent.body[-1]" ], [ "COMPARE_OP", "node.parent is node.parent.parent.body[-1]" ], [ "LOAD_DEREF", "value" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "is_obvious_builtin" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_DEREF", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_ATTR", "self.stack[frame].expression_values" ], [ "LOAD_FAST", "node" ], [ "BINARY_SUBSCR", "self.stack[frame].expression_values[node]" ], [ "CALL_FUNCTION", "is_obvious_builtin(node, self.stack[frame].expression_values[node])" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_DEREF", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_FAST", "exc_value" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self._exception_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_FAST", "exc_value" ], [ "CALL_METHOD", "self._exception_value(node, frame, exc_value)" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOAD_ATTR", "NodeValue.expression" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.num_samples" ], [ "LOAD_DEREF", "value" ], [ "LOAD_GLOBAL", "max" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "CALL_FUNCTION", "len(node._loops)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self._is_first_loop_iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "frame" ], [ "CALL_METHOD", "self._is_first_loop_iteration(node, frame)" ], [ "UNARY_NOT", "not self._is_first_loop_iteration(node, frame)" ], [ "BINARY_MULTIPLY", "len(node._loops) * (not self._is_first_loop_iteration(node, frame))" ], [ "BINARY_SUBTRACT", "3 - len(node._loops) * (not self._is_first_loop_iteration(node, frame))" ], [ "CALL_FUNCTION", "max(1, 3 - len(node._loops) * (not self._is_first_loop_iteration(node, frame)))" ], [ "CALL_FUNCTION_KW", "NodeValue.expression(\n self.num_samples,\n value,\n level=max(1, 3 - len(node._loops) * (not self._is_first_loop_iteration(node, frame))),\n )" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self._set_node_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_FAST", "node_value" ], [ "CALL_METHOD", "self._set_node_value(node, frame, node_value)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self._check_inner_call" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node_value" ], [ "CALL_METHOD", "self._check_inner_call(frame_info, node, node_value)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.comprehension)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.iter" ], [ "COMPARE_OP", "node is node.parent.iter" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.GeneratorExp" ], [ "CALL_FUNCTION", "isinstance(node.parent.parent, ast.GeneratorExp)" ], [ "UNARY_NOT", "not isinstance(node.parent.parent, ast.GeneratorExp)" ], [ "LOAD_FAST", "is_special_comprehension_iter" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self._set_node_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOAD_METHOD", "NodeValue.covered" ], [ "CALL_METHOD", "NodeValue.covered()" ], [ "CALL_METHOD", "self._set_node_value(node.parent, frame, NodeValue.covered())" ], [ "LOAD_FAST", "exc_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "BINARY_ADD", "node._loops + (node.parent,)" ], [ "LOAD_GLOBAL", "ChangeValue" ], [ "LOAD_FAST", "comprehension_iter_proxy" ], [ "CALL_FUNCTION", "comprehension_iter_proxy()" ], [ "CALL_FUNCTION", "ChangeValue(comprehension_iter_proxy())" ], [ "LOAD_DEREF", "value" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self._add_iteration" ], [ "LOAD_DEREF", "loops" ], [ "LOAD_DEREF", "frame" ], [ "CALL_METHOD", "self._add_iteration(loops, frame)" ], [ "LOAD_FAST", "item" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.inner_calls" ], [ "LOAD_METHOD", "frame_info.inner_calls.pop" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "frame_info.inner_calls.pop(node, None)" ], [ "LOAD_FAST", "inner_calls" ], [ "LOAD_FAST", "node_value" ], [ "LOAD_METHOD", "node_value.set_meta" ], [ "LOAD_FAST", "inner_calls" ], [ "CALL_METHOD", "node_value.set_meta('inner_calls', inner_calls)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_ATTR", "self.stack[frame].iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.loops" ], [ "LOAD_FAST", "loop_node" ], [ "LOAD_ATTR", "loop_node._tree_index" ], [ "BINARY_SUBSCR", "iteration.loops[loop_node._tree_index]" ], [ "LOAD_FAST", "loop" ], [ "LOAD_METHOD", "loop.last" ], [ "CALL_METHOD", "loop.last()" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.index" ], [ "COMPARE_OP", "iteration.index > 0" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_ATTR", "self.stack[frame].iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.loops" ], [ "LOAD_FAST", "loop_node" ], [ "LOAD_ATTR", "loop_node._tree_index" ], [ "BINARY_SUBSCR", "iteration.loops[loop_node._tree_index]" ], [ "LOAD_FAST", "loop" ], [ "LOAD_METHOD", "loop.recorded_node" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "loop.recorded_node(node)" ], [ "LOAD_FAST", "loop" ], [ "LOAD_METHOD", "loop.last" ], [ "CALL_METHOD", "loop.last()" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.vals" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOAD_METHOD", "NodeValue.exception" ], [ "LOAD_FAST", "exc_value" ], [ "CALL_METHOD", "NodeValue.exception(exc_value)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._set_node_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "value" ], [ "CALL_METHOD", "self._set_node_value(node, frame, value)" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_GLOBAL", "_tracing_recursively" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "_tracing_recursively(frame)" ], [ "LOAD_FAST", "exc_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "exc_node" ], [ "COMPARE_OP", "node is exc_node" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._exception_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "exc_value" ], [ "CALL_METHOD", "self._exception_value(node, frame, exc_value)" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOAD_METHOD", "NodeValue.covered" ], [ "CALL_METHOD", "NodeValue.covered()" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._set_node_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "value" ], [ "CALL_METHOD", "self._set_node_value(node, frame, value)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._check_inner_call" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "value" ], [ "CALL_METHOD", "self._check_inner_call(self.stack[frame], node, value)" ], [ "LOAD_FAST", "enter_info" ], [ "LOAD_ATTR", "enter_info.current_frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_GLOBAL", "_tracing_recursively" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "_tracing_recursively(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_GLOBAL", "get_unfrozen_datetime" ], [ "CALL_FUNCTION", "get_unfrozen_datetime()" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_GLOBAL", "Iteration" ], [ "CALL_FUNCTION", "Iteration()" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "BINARY_SUBSCR", "self._code_infos[frame.f_code]" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "enter_info" ], [ "LOAD_ATTR", "enter_info.enter_node" ], [ "LOAD_ATTR", "enter_info.enter_node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Module" ], [ "CALL_FUNCTION", "isinstance(enter_info.enter_node.parent, ast.Module)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "LOAD_METHOD", "frame.f_locals.copy" ], [ "CALL_METHOD", "frame.f_locals.copy()" ], [ "LOAD_FAST", "code_info" ], [ "LOAD_ATTR", "code_info.arg_names" ], [ "LOAD_DEREF", "f_locals" ], [ "LOAD_METHOD", "f_locals.items" ], [ "CALL_METHOD", "f_locals.items()" ], [ "BINARY_ADD", "[(name, f_locals.pop(name))\n for name in code_info.arg_names\n if name] + [\n\n # Local variables other than actual arguments. These are variables from\n # the enclosing scope. It's handy to treat them like arguments in the UI\n it for it in f_locals.items()\n if it[0][0] != '.' # Appears when using nested tuple arguments\n ]" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_METHOD", "json.dumps" ], [ "LOAD_FAST", "arguments" ], [ "CALL_METHOD", "json.dumps([[k, cheap_repr(v)] for k, v in arguments])" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._call_id" ], [ "CALL_METHOD", "self._call_id()" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "defaultdict(list)" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_METHOD", "self.stack.get" ], [ "LOAD_FAST", "enter_info" ], [ "LOAD_ATTR", "enter_info.caller_frame" ], [ "CALL_METHOD", "self.stack.get(enter_info.caller_frame)" ], [ "LOAD_FAST", "prev" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "prev" ], [ "CALL_FUNCTION", "getattr(prev, 'inner_calls', None)" ], [ "LOAD_FAST", "inner_calls" ], [ "COMPARE_OP", "inner_calls is not None" ], [ "LOAD_FAST", "inner_calls" ], [ "LOAD_FAST", "enter_info" ], [ "LOAD_ATTR", "enter_info.call_node" ], [ "BINARY_SUBSCR", "inner_calls[enter_info.call_node]" ], [ "LOAD_METHOD", "inner_calls[enter_info.call_node].append" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.call_id" ], [ "CALL_METHOD", "inner_calls[enter_info.call_node].append(frame_info.call_id)" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "name" ], [ "LOAD_DEREF", "f_locals" ], [ "LOAD_METHOD", "f_locals.pop" ], [ "LOAD_FAST", "name" ], [ "CALL_METHOD", "f_locals.pop(name)" ], [ "LOAD_FAST", "it" ], [ "BINARY_SUBSCR", "it[0]" ], [ "BINARY_SUBSCR", "it[0][0]" ], [ "COMPARE_OP", "it[0][0] != '.'" ], [ "LOAD_FAST", "it" ], [ "LOAD_FAST", "k" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "cheap_repr(v)" ], [ "LOAD_GLOBAL", "uuid4" ], [ "CALL_FUNCTION", "uuid4()" ], [ "LOAD_ATTR", "uuid4().hex" ], [ "LOAD_DEREF", "exit_info" ], [ "LOAD_ATTR", "exit_info.current_frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_GLOBAL", "_tracing_recursively" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "_tracing_recursively(frame)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.iteration" ], [ "LOAD_GLOBAL", "_deep_dict" ], [ "CALL_FUNCTION", "_deep_dict()" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self._extract_node_values" ], [ "LOAD_DEREF", "top_iteration" ], [ "LOAD_DEREF", "node_values" ], [ "CALL_METHOD", "self._extract_node_values(top_iteration, (), node_values)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "BINARY_SUBSCR", "self._code_infos[frame.f_code]" ], [ "LOAD_ATTR", "self._code_infos[frame.f_code].db_func" ], [ "LOAD_DEREF", "exit_info" ], [ "LOAD_ATTR", "exit_info.exc_value" ], [ "LOAD_FAST", "exc" ], [ "LOAD_METHOD", "''.join" ], [ "LOAD_GLOBAL", "traceback" ], [ "LOAD_METHOD", "traceback.format_exception" ], [ "LOAD_GLOBAL", "type" ], [ "LOAD_FAST", "exc" ], [ "CALL_FUNCTION", "type(exc)" ], [ "LOAD_FAST", "exc" ], [ "LOAD_DEREF", "exit_info" ], [ "LOAD_ATTR", "exit_info.exc_tb" ], [ "CALL_METHOD", "traceback.format_exception(type(exc), exc, exit_info.exc_tb)" ], [ "CALL_METHOD", "''.join(traceback.format_exception(type(exc), exc, exit_info.exc_tb))" ], [ "LOAD_GLOBAL", "exception_string" ], [ "LOAD_FAST", "exc" ], [ "CALL_FUNCTION", "exception_string(exc)" ], [ "LOAD_GLOBAL", "retry_db" ], [ "CALL_FUNCTION", "retry_db" ], [ "LOAD_FAST", "add_call" ], [ "CALL_FUNCTION", "add_call()" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.call_id" ], [ "LOAD_DEREF", "self" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.db" ], [ "LOAD_ATTR", "self.db.Call" ], [ "LOAD_FAST", "Call" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.call_id" ], [ "LOAD_DEREF", "db_func" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.arguments" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_DEREF", "exit_info" ], [ "LOAD_ATTR", "exit_info.return_value" ], [ "CALL_FUNCTION", "cheap_repr(exit_info.return_value)" ], [ "LOAD_DEREF", "exception" ], [ "LOAD_DEREF", "traceback_str" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_ATTR", "json.dumps" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_DEREF", "node_values" ], [ "LOAD_DEREF", "top_iteration" ], [ "LOAD_METHOD", "top_iteration.extract_iterations" ], [ "CALL_METHOD", "top_iteration.extract_iterations()" ], [ "BINARY_SUBSCR", "top_iteration.extract_iterations()['loops']" ], [ "LOAD_GLOBAL", "type_registry" ], [ "LOAD_METHOD", "type_registry.names" ], [ "CALL_METHOD", "type_registry.names()" ], [ "LOAD_GLOBAL", "type_registry" ], [ "LOAD_ATTR", "type_registry.num_special_types" ], [ "CALL_FUNCTION_KW", "dict(\n node_values=node_values,\n loop_iterations=top_iteration.extract_iterations()['loops'],\n type_names=type_registry.names(),\n num_special_types=type_registry.num_special_types,\n )" ], [ "LOAD_GLOBAL", "ProtocolEncoder" ], [ "CALL_FUNCTION_KW", "json.dumps(\n dict(\n node_values=node_values,\n loop_iterations=top_iteration.extract_iterations()['loops'],\n type_names=type_registry.names(),\n num_special_types=type_registry.num_special_types,\n ),\n cls=ProtocolEncoder,\n separators=(',', ':')\n )" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.start_time" ], [ "CALL_FUNCTION_KW", "Call(id=frame_info.call_id,\n function_id=db_func,\n arguments=frame_info.arguments,\n return_value=cheap_repr(exit_info.return_value),\n exception=exception,\n traceback=traceback_str,\n data=json.dumps(\n dict(\n node_values=node_values,\n loop_iterations=top_iteration.extract_iterations()['loops'],\n type_names=type_registry.names(),\n num_special_types=type_registry.num_special_types,\n ),\n cls=ProtocolEncoder,\n separators=(',', ':')\n ),\n start_time=frame_info.start_time)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.db" ], [ "LOAD_METHOD", "self.db.session_scope" ], [ "CALL_METHOD", "self.db.session_scope()" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.add" ], [ "LOAD_FAST", "call" ], [ "CALL_METHOD", "session.add(call)" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.vals" ], [ "LOAD_METHOD", "iteration.vals.items" ], [ "CALL_METHOD", "iteration.vals.items()" ], [ "LOAD_FAST", "tree_index" ], [ "LOAD_FAST", "path" ], [ "BINARY_ADD", "(tree_index,) + path" ], [ "LOAD_FAST", "node_values" ], [ "LOAD_FAST", "full_path" ], [ "BINARY_SUBSCR", "full_path[:-1]" ], [ "LOAD_FAST", "d" ], [ "LOAD_FAST", "path_k" ], [ "BINARY_SUBSCR", "d[path_k]" ], [ "LOAD_FAST", "node_value" ], [ "LOAD_FAST", "d" ], [ "LOAD_FAST", "full_path" ], [ "BINARY_SUBSCR", "full_path[-1]" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.loops" ], [ "LOAD_METHOD", "iteration.loops.values" ], [ "CALL_METHOD", "iteration.loops.values()" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "loop" ], [ "CALL_FUNCTION", "enumerate(loop)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._extract_node_values" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "path + (i,)" ], [ "LOAD_FAST", "node_values" ], [ "CALL_METHOD", "self._extract_node_values(iteration, path + (i,), node_values)" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "BirdsEye" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(BirdsEye, self)" ], [ "LOAD_METHOD", "super(BirdsEye, self).trace_function" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "super(BirdsEye, self).trace_function(func)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_METHOD", "self._code_infos.get" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_ATTR", "new_func.__code__" ], [ "CALL_METHOD", "self._code_infos.get(new_func.__code__)" ], [ "LOAD_FAST", "code_info" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.getsourcelines" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "inspect.getsourcelines(func)" ], [ "LOAD_FAST", "start_lineno" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "lines" ], [ "CALL_FUNCTION", "len(lines)" ], [ "BINARY_ADD", "start_lineno + len(lines)" ], [ "LOAD_GLOBAL", "safe_qualname" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "safe_qualname(func)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.getsourcefile" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "inspect.getsourcefile(func)" ], [ "LOAD_FAST", "source_file" ], [ "LOAD_METHOD", "source_file.startswith" ], [ "CALL_METHOD", "source_file.startswith('= 0" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.getsourcefile" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "inspect.getsourcefile(frame)" ], [ "LOAD_FAST", "filename" ], [ "COMPARE_OP", "filename is not None" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_METHOD", "os.path.abspath" ], [ "LOAD_FAST", "filename" ], [ "CALL_METHOD", "os.path.abspath(filename)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "LOAD_METHOD", "frame.f_globals.get" ], [ "CALL_METHOD", "frame.f_globals.get('__name__')" ], [ "COMPARE_OP", "frame.f_globals.get('__name__') != '__main__'" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._treetrace_hidden_with_stmt" ], [ "LOAD_ATTR", "self._treetrace_hidden_with_stmt.__name__" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "COMPARE_OP", "self._treetrace_hidden_with_stmt.__name__ not in frame.f_globals" ], [ "LOAD_GLOBAL", "RuntimeError" ], [ "CALL_FUNCTION", "RuntimeError(\n 'To trace an imported module, you must import birdseye before '\n 'importing that module.')" ], [ "LOAD_GLOBAL", "read_source_file" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "read_source_file(filename)" ], [ "LOAD_METHOD", "read_source_file(filename).splitlines" ], [ "CALL_METHOD", "read_source_file(filename).splitlines()" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lineno" ], [ "BINARY_MULTIPLY", "[''] * frame.f_lineno" ], [ "LOAD_FAST", "lines" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lineno" ], [ "LOAD_METHOD", "'\\n'.join" ], [ "LOAD_FAST", "lines" ], [ "CALL_METHOD", "'\\n'.join(lines)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.exec_string" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "LOAD_FAST", "deep" ], [ "CALL_METHOD", "self.exec_string(source, filename, frame.f_globals, frame.f_locals, deep)" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_METHOD", "sys.exit" ], [ "CALL_METHOD", "sys.exit(0)" ], [ "LOAD_FAST", "globs" ], [ "LOAD_FAST", "locs" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self.compile" ], [ "LOAD_DEREF", "source" ], [ "LOAD_DEREF", "filename" ], [ "CALL_METHOD", "self.compile(source, filename)" ], [ "LOAD_FAST", "globs" ], [ "LOAD_METHOD", "globs.update" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self._trace_methods_dict" ], [ "LOAD_DEREF", "traced_file" ], [ "CALL_METHOD", "self._trace_methods_dict(traced_file)" ], [ "CALL_METHOD", "globs.update(self._trace_methods_dict(traced_file))" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self._trace" ], [ "LOAD_GLOBAL", "FILE_SENTINEL_NAME" ], [ "LOAD_DEREF", "filename" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.code" ], [ "LOAD_DEREF", "source" ], [ "CALL_METHOD", "self._trace(FILE_SENTINEL_NAME, filename, traced_file, traced_file.code, 'module', source)" ], [ "LOAD_FAST", "deep" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.nodes" ], [ "LOAD_DEREF", "find_code" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.code" ], [ "CALL_FUNCTION", "find_code(traced_file.code)" ], [ "LOAD_GLOBAL", "exec" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.code" ], [ "LOAD_FAST", "globs" ], [ "LOAD_FAST", "locs" ], [ "CALL_FUNCTION", "exec(traced_file.code, globs, locs)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(node, ast.FunctionDef)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.lineno" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "root_code" ], [ "LOAD_ATTR", "root_code.co_consts" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.iscode" ], [ "LOAD_FAST", "code" ], [ "CALL_METHOD", "inspect.iscode(code)" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "LOAD_METHOD", "code.co_name.startswith" ], [ "CALL_METHOD", "code.co_name.startswith('<')" ], [ "LOAD_DEREF", "find_code" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "find_code(code)" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_firstlineno" ], [ "LOAD_DEREF", "nodes_by_lineno" ], [ "LOAD_METHOD", "nodes_by_lineno.get" ], [ "LOAD_FAST", "lineno" ], [ "CALL_METHOD", "nodes_by_lineno.get(lineno)" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._trace" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "LOAD_DEREF", "filename" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_FAST", "code" ], [ "LOAD_DEREF", "source" ], [ "LOAD_FAST", "lineno" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.last_token" ], [ "LOAD_ATTR", "node.last_token.end" ], [ "BINARY_SUBSCR", "node.last_token.end[0]" ], [ "BINARY_ADD", "node.last_token.end[0] + 1" ], [ "CALL_FUNCTION_KW", "self._trace(\n code.co_name, filename, traced_file, code,\n typ='function',\n source=source,\n start_lineno=lineno,\n end_lineno=node.last_token.end[0] + 1,\n )" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_DEREF", "start_lineno" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "source" ], [ "LOAD_METHOD", "source.splitlines" ], [ "CALL_METHOD", "source.splitlines()" ], [ "CALL_FUNCTION", "len(source.splitlines())" ], [ "BINARY_ADD", "start_lineno + len(source.splitlines())" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._nodes_of_interest" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_DEREF", "start_lineno" ], [ "LOAD_FAST", "end_lineno" ], [ "CALL_METHOD", "self._nodes_of_interest(traced_file, start_lineno, end_lineno)" ], [ "CALL_FUNCTION", "list(self._nodes_of_interest(traced_file, start_lineno, end_lineno))" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._nodes_html" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_DEREF", "start_lineno" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_FAST", "traced_file" ], [ "CALL_METHOD", "self._nodes_html(nodes, start_lineno, end_lineno, traced_file)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "nodes" ], [ "CALL_FUNCTION_KW", "dict(\n # This maps each node to the loops enclosing that node\n node_loops={\n node._tree_index: [n._tree_index for n in node._loops]\n for node, _ in nodes\n if node._loops\n },\n )" ], [ "LOAD_FAST", "typ" ], [ "COMPARE_OP", "typ == 'function'" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.tokens" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_FAST", "nodes" ], [ "CALL_FUNCTION", "only(node\n for node, _ in nodes\n if isinstance(node, ast.FunctionDef)\n and node.first_token.start[0] == start_lineno)" ], [ "LOAD_GLOBAL", "source_without_decorators" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_FAST", "func_node" ], [ "CALL_FUNCTION", "source_without_decorators(tokens, func_node)" ], [ "LOAD_FAST", "data_dict" ], [ "LOAD_ATTR", "data_dict.update" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._node_ranges" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_FAST", "func_startpos" ], [ "CALL_METHOD", "self._node_ranges(nodes, tokens, func_startpos)" ], [ "CALL_FUNCTION", "list(self._node_ranges(nodes, tokens, func_startpos))" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._loop_ranges" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_FAST", "func_startpos" ], [ "CALL_METHOD", "self._loop_ranges(nodes, tokens, func_startpos)" ], [ "CALL_FUNCTION", "list(self._loop_ranges(nodes, tokens, func_startpos))" ], [ "CALL_FUNCTION_KW", "data_dict.update(\n node_ranges=list(self._node_ranges(nodes, tokens, func_startpos)),\n loop_ranges=list(self._loop_ranges(nodes, tokens, func_startpos)),\n )" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_ATTR", "json.dumps" ], [ "LOAD_FAST", "data_dict" ], [ "CALL_FUNCTION_KW", "json.dumps(data_dict, sort_keys=True)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._db_func" ], [ "LOAD_FAST", "data" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "html_body" ], [ "LOAD_FAST", "name" ], [ "LOAD_DEREF", "start_lineno" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "typ" ], [ "CALL_METHOD", "self._db_func(data, filename, html_body, name, start_lineno, source, typ)" ], [ "LOAD_GLOBAL", "CodeInfo" ], [ "LOAD_FAST", "db_func" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_FAST", "arg_names" ], [ "CALL_FUNCTION", "CodeInfo(db_func, traced_file, arg_names)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "n" ], [ "LOAD_ATTR", "n._tree_index" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(node, ast.FunctionDef)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.first_token" ], [ "LOAD_ATTR", "node.first_token.start" ], [ "BINARY_SUBSCR", "node.first_token.start[0]" ], [ "LOAD_DEREF", "start_lineno" ], [ "COMPARE_OP", "node.first_token.start[0] == start_lineno" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "classes" ], [ "COMPARE_OP", "'loop' not in classes" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.target" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.test" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_METHOD", "tokens.get_text_range" ], [ "LOAD_FAST", "target" ], [ "CALL_METHOD", "tokens.get_text_range(target)" ], [ "LOAD_FAST", "func_start" ], [ "LOAD_FAST", "func_start" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "CALL_FUNCTION_KW", "dict(\n tree_index=node._tree_index,\n start=start,\n end=end\n )" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_METHOD", "tokens.get_text_range" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "tokens.get_text_range(node)" ], [ "LOAD_FAST", "func_start" ], [ "LOAD_FAST", "func_start" ], [ "LOAD_FAST", "start" ], [ "COMPARE_OP", "start < 0" ], [ "LOAD_FAST", "end" ], [ "COMPARE_OP", "end < 0" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(node, ast.FunctionDef)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._depth" ], [ "LOAD_FAST", "classes" ], [ "CALL_FUNCTION_KW", "dict(\n tree_index=node._tree_index,\n start=start,\n end=end,\n depth=node._depth,\n classes=classes,\n )" ], [ "LOAD_FAST", "h" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "name" ], [ "BINARY_ADD", "filename + name" ], [ "LOAD_FAST", "html_body" ], [ "BINARY_ADD", "filename + name + html_body" ], [ "LOAD_FAST", "data" ], [ "BINARY_ADD", "filename + name + html_body + data" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "start_lineno" ], [ "CALL_FUNCTION", "str(start_lineno)" ], [ "BINARY_ADD", "filename + name + html_body + data + str(start_lineno)" ], [ "CALL_FUNCTION", "h(filename + name + html_body + data + str(start_lineno))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.db" ], [ "LOAD_ATTR", "self.db.Function" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.db" ], [ "LOAD_METHOD", "self.db.session_scope" ], [ "CALL_METHOD", "self.db.session_scope()" ], [ "LOAD_GLOBAL", "one_or_none" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.query" ], [ "LOAD_FAST", "Function" ], [ "CALL_METHOD", "session.query(Function)" ], [ "LOAD_ATTR", "session.query(Function).filter_by" ], [ "LOAD_FAST", "function_hash" ], [ "CALL_FUNCTION_KW", "session.query(Function).filter_by(hash=function_hash)" ], [ "CALL_FUNCTION", "one_or_none(session.query(Function).filter_by(hash=function_hash))" ], [ "LOAD_FAST", "db_func" ], [ "LOAD_FAST", "Function" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "typ" ], [ "LOAD_FAST", "html_body" ], [ "LOAD_FAST", "start_lineno" ], [ "LOAD_FAST", "data" ], [ "LOAD_FAST", "h" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "h(source)" ], [ "LOAD_FAST", "function_hash" ], [ "CALL_FUNCTION_KW", "Function(file=filename,\n name=name,\n type=typ,\n html_body=html_body,\n lineno=start_lineno,\n data=data,\n body_hash=h(source),\n hash=function_hash)" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.add" ], [ "LOAD_FAST", "db_func" ], [ "CALL_METHOD", "session.add(db_func)" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.commit" ], [ "CALL_METHOD", "session.commit()" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "db_func" ], [ "LOAD_ATTR", "db_func.id" ], [ "LOAD_GLOBAL", "int" ], [ "CALL_FUNCTION", "isinstance(db_func.id, int)" ], [ "LOAD_FAST", "db_func" ], [ "LOAD_ATTR", "db_func.id" ], [ "LOAD_GLOBAL", "hashlib" ], [ "LOAD_METHOD", "hashlib.sha256" ], [ "LOAD_FAST", "s" ], [ "LOAD_METHOD", "s.encode" ], [ "CALL_METHOD", "s.encode('utf8')" ], [ "CALL_METHOD", "hashlib.sha256(s.encode('utf8'))" ], [ "LOAD_METHOD", "hashlib.sha256(s.encode('utf8')).hexdigest" ], [ "CALL_METHOD", "hashlib.sha256(s.encode('utf8')).hexdigest()" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.nodes" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "CALL_FUNCTION", "isinstance(node, (ast.While, ast.For, ast.comprehension))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.GeneratorExp" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.GeneratorExp)" ], [ "LOAD_FAST", "classes" ], [ "LOAD_METHOD", "classes.append" ], [ "CALL_METHOD", "classes.append('loop')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "CALL_FUNCTION", "isinstance(node, ast.stmt)" ], [ "LOAD_FAST", "classes" ], [ "LOAD_METHOD", "classes.append" ], [ "CALL_METHOD", "classes.append('stmt')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "CALL_FUNCTION", "isinstance(node, ast.expr)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._is_interesting_expression" ], [ "LOAD_FAST", "classes" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.AST" ], [ "CALL_FUNCTION", "isinstance(node, ast.AST)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "hasattr(node, 'first_token')" ], [ "LOAD_FAST", "start_lineno" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.first_token" ], [ "LOAD_ATTR", "node.first_token.start" ], [ "BINARY_SUBSCR", "node.first_token.start[0]" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.tokens" ], [ "LOAD_METHOD", "traced_file.tokens.get_text_range" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "traced_file.tokens.get_text_range(node)" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "classes" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.root" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.walk" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.root" ], [ "CALL_METHOD", "ast.walk(traced_file.root)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.iter_child_nodes" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.iter_child_nodes(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._depth" ], [ "BINARY_ADD", "node._depth + 1" ], [ "LOAD_FAST", "child" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "positions" ], [ "LOAD_METHOD", "positions.extend" ], [ "LOAD_GLOBAL", "map" ], [ "LOAD_GLOBAL", "HTMLPosition" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._depth" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._depth" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_METHOD", "' '.join" ], [ "LOAD_FAST", "classes" ], [ "CALL_METHOD", "' '.join(classes)" ], [ "BINARY_MODULO", "'' % (node._tree_index, ' '.join(classes))" ], [ "CALL_FUNCTION", "map(\n HTMLPosition,\n [start, end],\n [True, False], # is_start\n [node._depth, node._depth],\n ['' % (node._tree_index, ' '.join(classes)),\n ''])" ], [ "CALL_METHOD", "positions.extend(map(\n HTMLPosition,\n [start, end],\n [True, False], # is_start\n [node._depth, node._depth],\n ['' % (node._tree_index, ' '.join(classes)),\n '']))" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._separate_comprehensions" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_FAST", "positions" ], [ "LOAD_FAST", "traced_file" ], [ "CALL_METHOD", "self._separate_comprehensions(\n [n[0] for n in nodes],\n end_lineno, positions, traced_file)" ], [ "LOAD_FAST", "positions" ], [ "LOAD_METHOD", "positions.append" ], [ "LOAD_GLOBAL", "HTMLPosition" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.source" ], [ "CALL_FUNCTION", "len(traced_file.source)" ], [ "CALL_FUNCTION", "HTMLPosition(len(traced_file.source), False, 0, '')" ], [ "CALL_METHOD", "positions.append(HTMLPosition(len(traced_file.source), False, 0, ''))" ], [ "LOAD_FAST", "positions" ], [ "LOAD_METHOD", "positions.sort" ], [ "CALL_METHOD", "positions.sort()" ], [ "LOAD_FAST", "positions" ], [ "LOAD_FAST", "html_parts" ], [ "LOAD_METHOD", "html_parts.append" ], [ "LOAD_GLOBAL", "html" ], [ "LOAD_METHOD", "html.escape" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.source" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "position" ], [ "LOAD_ATTR", "position.index" ], [ "BINARY_SUBSCR", "traced_file.source[start:position.index]" ], [ "CALL_METHOD", "html.escape(traced_file.source[start:position.index])" ], [ "CALL_METHOD", "html_parts.append(html.escape(traced_file.source[start:position.index]))" ], [ "LOAD_FAST", "html_parts" ], [ "LOAD_METHOD", "html_parts.append" ], [ "LOAD_FAST", "position" ], [ "LOAD_ATTR", "position.html" ], [ "CALL_METHOD", "html_parts.append(position.html)" ], [ "LOAD_FAST", "position" ], [ "LOAD_ATTR", "position.index" ], [ "LOAD_METHOD", "''.join" ], [ "LOAD_FAST", "html_parts" ], [ "CALL_METHOD", "''.join(html_parts)" ], [ "LOAD_METHOD", "'\\n'.join" ], [ "LOAD_FAST", "html_body" ], [ "LOAD_METHOD", "html_body.split" ], [ "CALL_METHOD", "html_body.split('\\n')" ], [ "LOAD_FAST", "start_lineno" ], [ "BINARY_SUBTRACT", "start_lineno - 1" ], [ "LOAD_FAST", "end_lineno" ], [ "BINARY_SUBTRACT", "end_lineno - 1" ], [ "BINARY_SUBSCR", "html_body.split('\\n')[start_lineno - 1:end_lineno - 1]" ], [ "CALL_METHOD", "'\\n'.join(html_body.split('\\n')[start_lineno - 1:end_lineno - 1])" ], [ "LOAD_FAST", "html_body" ], [ "LOAD_METHOD", "html_body.strip" ], [ "CALL_METHOD", "html_body.strip('\\n')" ], [ "LOAD_FAST", "n" ], [ "BINARY_SUBSCR", "n[0]" ], [ "LOAD_GLOBAL", "group_by_key_func" ], [ "LOAD_GLOBAL", "of_type" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "LOAD_FAST", "nodes" ], [ "CALL_FUNCTION", "of_type((ast.comprehension, ast.While, ast.For), nodes)" ], [ "CALL_FUNCTION", "group_by_key_func(of_type((ast.comprehension, ast.While, ast.For), nodes),\n lambda c: c.first_token.start[0]\n )" ], [ "LOAD_FAST", "comprehensions" ], [ "LOAD_METHOD", "comprehensions.values" ], [ "CALL_METHOD", "comprehensions.values()" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_FAST", "comp_list" ], [ "CALL_FUNCTION_KW", "sorted(comp_list, key=lambda c: c.first_token.startpos)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "comp" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "CALL_FUNCTION", "isinstance(comp, ast.comprehension)" ], [ "LOAD_FAST", "comp" ], [ "LOAD_FAST", "comp" ], [ "LOAD_ATTR", "comp.parent" ], [ "LOAD_ATTR", "comp.parent.generators" ], [ "BINARY_SUBSCR", "comp.parent.generators[0]" ], [ "COMPARE_OP", "comp is comp.parent.generators[0]" ], [ "LOAD_FAST", "get_start" ], [ "LOAD_FAST", "comp" ], [ "LOAD_ATTR", "comp.parent" ], [ "CALL_FUNCTION", "get_start(comp.parent)" ], [ "LOAD_FAST", "prev_start" ], [ "COMPARE_OP", "prev_start is not None" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "prev_start" ], [ "COMPARE_OP", "start < prev_start" ], [ "LOAD_FAST", "get_start" ], [ "LOAD_FAST", "comp" ], [ "CALL_FUNCTION", "get_start(comp)" ], [ "LOAD_FAST", "get_start" ], [ "LOAD_FAST", "comp" ], [ "CALL_FUNCTION", "get_start(comp)" ], [ "LOAD_FAST", "prev_start" ], [ "COMPARE_OP", "prev_start is not None" ], [ "LOAD_FAST", "positions" ], [ "LOAD_METHOD", "positions.append" ], [ "LOAD_GLOBAL", "HTMLPosition" ], [ "LOAD_FAST", "start" ], [ "CALL_FUNCTION", "HTMLPosition(start, True, 0, '\\n ')" ], [ "CALL_METHOD", "positions.append(HTMLPosition(start, True, 0, '\\n '))" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.first_token" ], [ "LOAD_ATTR", "c.first_token.start" ], [ "BINARY_SUBSCR", "c.first_token.start[0]" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.tokens" ], [ "LOAD_METHOD", "traced_file.tokens.get_text_range" ], [ "LOAD_FAST", "n" ], [ "CALL_METHOD", "traced_file.tokens.get_text_range(n)" ], [ "BINARY_SUBSCR", "traced_file.tokens.get_text_range(n)[0]" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.first_token" ], [ "LOAD_ATTR", "c.first_token.startpos" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "_deep_dict" ], [ "CALL_FUNCTION", "defaultdict(_deep_dict)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_GLOBAL", "_bad_codes" ], [ "COMPARE_OP", "frame.f_code in _bad_codes" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "IterationList" ], [ "CALL_FUNCTION", "defaultdict(IterationList)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.index" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.loops" ], [ "LOAD_METHOD", "self.loops.items" ], [ "CALL_METHOD", "self.loops.items()" ], [ "LOAD_FAST", "tree_index" ], [ "LOAD_FAST", "iteration_list" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_METHOD", "iteration.extract_iterations" ], [ "CALL_METHOD", "iteration.extract_iterations()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "deque" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.side_len" ], [ "CALL_FUNCTION_KW", "deque(maxlen=self.side_len)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "Counter" ], [ "CALL_FUNCTION", "Counter()" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.length" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.side_len" ], [ "COMPARE_OP", "self.length < self.side_len" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start" ], [ "LOAD_METHOD", "self.start.append" ], [ "LOAD_FAST", "iteration" ], [ "CALL_METHOD", "self.start.append(iteration)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "CALL_FUNCTION", "len(self.end)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.side_len" ], [ "COMPARE_OP", "len(self.end) >= self.side_len" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "BINARY_SUBSCR", "self.end[0]" ], [ "LOAD_ATTR", "self.end[0].keep" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start" ], [ "LOAD_METHOD", "self.start.append" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "BINARY_SUBSCR", "self.end[0]" ], [ "CALL_METHOD", "self.start.append(self.end[0])" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "LOAD_METHOD", "self.end.append" ], [ "LOAD_FAST", "iteration" ], [ "CALL_METHOD", "self.end.append(iteration)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.length" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "chain" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "CALL_FUNCTION", "chain(self.start, self.end)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "BINARY_SUBSCR", "self.end[-1]" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start" ], [ "BINARY_SUBSCR", "self.start[-1]" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.recorded" ], [ "LOAD_FAST", "node" ], [ "BINARY_SUBSCR", "self.recorded[node]" ], [ "COMPARE_OP", "self.recorded[node] >= 2" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.last" ], [ "CALL_METHOD", "self.last()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.recorded" ], [ "LOAD_FAST", "node" ], [ "LOAD_NAME", "type" ], [ "CALL_FUNCTION", "type(None)" ], [ "LOAD_NAME", "bool" ], [ "LOAD_NAME", "int" ], [ "LOAD_NAME", "float" ], [ "LOAD_NAME", "complex" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "long" ], [ "LOAD_NAME", "basic_types" ], [ "LOAD_NAME", "list" ], [ "LOAD_NAME", "dict" ], [ "LOAD_NAME", "tuple" ], [ "LOAD_NAME", "set" ], [ "LOAD_NAME", "frozenset" ], [ "LOAD_NAME", "str" ], [ "BINARY_ADD", "basic_types + (list, dict, tuple, set, frozenset, str)" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "unicode" ], [ "LOAD_NAME", "bytes" ], [ "LOAD_NAME", "len" ], [ "LOAD_NAME", "special_types" ], [ "CALL_FUNCTION", "len(special_types)" ], [ "LOAD_GLOBAL", "Lock" ], [ "CALL_FUNCTION", "Lock()" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "CALL_FUNCTION", "defaultdict(lambda: len(self.data))" ], [ "LOAD_DEREF", "self" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.special_types" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.data" ], [ "LOAD_FAST", "t" ], [ "BINARY_SUBSCR", "self.data[t]" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.data" ], [ "CALL_FUNCTION", "len(self.data)" ], [ "LOAD_GLOBAL", "correct_type" ], [ "LOAD_FAST", "item" ], [ "CALL_FUNCTION", "correct_type(item)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.lock" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.data" ], [ "LOAD_FAST", "t" ], [ "BINARY_SUBSCR", "self.data[t]" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.data" ], [ "LOAD_METHOD", "self.data.items" ], [ "CALL_METHOD", "self.data.items()" ], [ "CALL_FUNCTION", "dict((v, k) for k, v in self.data.items())" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_DEREF", "rev" ], [ "CALL_FUNCTION", "len(rev)" ], [ "CALL_FUNCTION", "range(len(rev))" ], [ "LOAD_FAST", "v" ], [ "LOAD_FAST", "k" ], [ "LOAD_GLOBAL", "safe_qualname" ], [ "LOAD_DEREF", "rev" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "rev[i]" ], [ "CALL_FUNCTION", "safe_qualname(rev[i])" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_FAST", "val_repr" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "type_index" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.meta" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.meta" ], [ "LOAD_FAST", "key" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.children" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.children" ], [ "LOAD_METHOD", "self.children.append" ], [ "LOAD_FAST", "key" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOAD_METHOD", "NodeValue.expression" ], [ "LOAD_FAST", "samples" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "level" ], [ "CALL_METHOD", "NodeValue.expression(samples, value, level)" ], [ "CALL_METHOD", "self.children.append((key, NodeValue.expression(samples, value, level)))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.val_repr" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.type_index" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.meta" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.children" ], [ "LOAD_FAST", "result" ], [ "LOAD_METHOD", "result.extend" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.children" ], [ "CALL_METHOD", "result.extend(self.children)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "cls" ], [ "CALL_FUNCTION", "cls('', -2)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_GLOBAL", "exception_string" ], [ "LOAD_FAST", "exc_value" ], [ "CALL_FUNCTION", "exception_string(exc_value)" ], [ "CALL_FUNCTION", "cls(exception_string(exc_value), -1)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "cheap_repr(val)" ], [ "LOAD_GLOBAL", "type_registry" ], [ "LOAD_FAST", "val" ], [ "BINARY_SUBSCR", "type_registry[val]" ], [ "CALL_FUNCTION", "cls(cheap_repr(val), type_registry[val])" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "TypeRegistry" ], [ "LOAD_ATTR", "TypeRegistry.basic_types" ], [ "LOAD_GLOBAL", "BirdsEye" ], [ "CALL_FUNCTION", "isinstance(val, (TypeRegistry.basic_types, BirdsEye))" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "QuerySet" ], [ "CALL_FUNCTION", "isinstance(val, QuerySet)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "len(val)" ], [ "LOAD_FAST", "result" ], [ "LOAD_METHOD", "result.set_meta" ], [ "LOAD_FAST", "length" ], [ "CALL_METHOD", "result.set_meta('len', length)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "ModuleType" ], [ "CALL_FUNCTION", "isinstance(val, ModuleType)" ], [ "LOAD_GLOBAL", "min" ], [ "LOAD_FAST", "level" ], [ "CALL_FUNCTION", "min(level, 2)" ], [ "LOAD_GLOBAL", "partial" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.add_child" ], [ "LOAD_FAST", "samples" ], [ "LOAD_FAST", "level" ], [ "BINARY_SUBTRACT", "level - 1" ], [ "CALL_FUNCTION", "partial(result.add_child, samples, level - 1)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Series" ], [ "LOAD_GLOBAL", "ndarray" ], [ "CALL_FUNCTION", "isinstance(val, (Series, ndarray))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "ndarray" ], [ "CALL_FUNCTION", "isinstance(val, ndarray)" ], [ "LOAD_FAST", "attrs" ], [ "LOAD_METHOD", "attrs.append" ], [ "CALL_METHOD", "attrs.append('shape')" ], [ "LOAD_FAST", "attrs" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "val" ], [ "LOAD_FAST", "name" ], [ "CALL_FUNCTION", "getattr(val, name)" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "attr" ], [ "CALL_FUNCTION", "add_child(name, attr)" ], [ "LOAD_FAST", "level" ], [ "COMPARE_OP", "level >= 3" ], [ "LOAD_FAST", "level" ], [ "COMPARE_OP", "level >= 2" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Series" ], [ "CALL_FUNCTION", "isinstance(val, Series)" ], [ "LOAD_FAST", "samples" ], [ "LOAD_FAST", "sample_type" ], [ "BINARY_SUBSCR", "samples[sample_type]" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "DataFrame" ], [ "CALL_FUNCTION", "isinstance(val, DataFrame)" ], [ "LOAD_FAST", "result" ], [ "LOAD_METHOD", "result.set_meta" ], [ "LOAD_FAST", "meta" ], [ "CALL_METHOD", "result.set_meta('dataframe', meta)" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['pandas_rows']" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['pandas_cols']" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_rows" ], [ "BINARY_ADD", "max_rows + 2" ], [ "COMPARE_OP", "length > max_rows + 2" ], [ "LOAD_FAST", "max_rows" ], [ "BINARY_FLOOR_DIVIDE", "max_rows // 2" ], [ "LOAD_FAST", "meta" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.columns" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "columns" ], [ "CALL_FUNCTION", "len(columns)" ], [ "LOAD_FAST", "num_cols" ], [ "LOAD_FAST", "max_cols" ], [ "BINARY_ADD", "max_cols + 2" ], [ "COMPARE_OP", "num_cols > max_cols + 2" ], [ "LOAD_FAST", "max_cols" ], [ "BINARY_FLOOR_DIVIDE", "max_cols // 2" ], [ "LOAD_FAST", "meta" ], [ "LOAD_GLOBAL", "set" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "num_cols" ], [ "LOAD_FAST", "max_cols" ], [ "CALL_FUNCTION", "_sample_indices(num_cols, max_cols)" ], [ "CALL_FUNCTION", "set(_sample_indices(num_cols, max_cols))" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_GLOBAL", "zip" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.columns" ], [ "LOAD_ATTR", "val.columns.format" ], [ "CALL_FUNCTION_KW", "val.columns.format(sparsify=False)" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.columns" ], [ "CALL_FUNCTION", "zip(val.columns.format(sparsify=False),\n val.columns)" ], [ "CALL_FUNCTION", "enumerate(zip(val.columns.format(sparsify=False),\n val.columns))" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "indices" ], [ "COMPARE_OP", "i in indices" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_FAST", "formatted_name" ], [ "LOAD_FAST", "val" ], [ "LOAD_FAST", "label" ], [ "BINARY_SUBSCR", "val[label]" ], [ "CALL_FUNCTION", "add_child(formatted_name, val[label])" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Series" ], [ "CALL_FUNCTION", "isinstance(val, Series)" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['pandas_rows']" ], [ "CALL_FUNCTION", "_sample_indices(length, samples['pandas_rows'])" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.index" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "val.index[i:i + 1]" ], [ "LOAD_ATTR", "val.index[i:i + 1].format" ], [ "CALL_FUNCTION_KW", "val.index[i:i + 1].format(sparsify=False)" ], [ "BINARY_SUBSCR", "val.index[i:i + 1].format(sparsify=False)[0]" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.iloc" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "val.iloc[i]" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_FAST", "k" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child(k, v)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "level" ], [ "COMPARE_OP", "level <= 0" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "bytes" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "unicode" ], [ "LOAD_GLOBAL", "xrange" ], [ "CALL_FUNCTION", "isinstance(val,\n (str, bytes, range)\n if PY3 else\n (str, unicode, xrange))" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Sequence" ], [ "LOAD_GLOBAL", "ndarray" ], [ "CALL_FUNCTION", "isinstance(val, (Sequence, ndarray))" ], [ "LOAD_FAST", "length" ], [ "COMPARE_OP", "length is not None" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['list']" ], [ "CALL_FUNCTION", "_sample_indices(length, samples['list'])" ], [ "LOAD_FAST", "val" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "val[i]" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "i" ], [ "CALL_FUNCTION", "str(i)" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child(str(i), v)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Mapping" ], [ "CALL_FUNCTION", "isinstance(val, Mapping)" ], [ "LOAD_GLOBAL", "islice" ], [ "LOAD_GLOBAL", "_safe_iter" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "iteritems" ], [ "CALL_FUNCTION", "_safe_iter(val, iteritems)" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['dict']" ], [ "CALL_FUNCTION", "islice(_safe_iter(val, iteritems), samples['dict'])" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "k" ], [ "CALL_FUNCTION", "cheap_repr(k)" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child(cheap_repr(k), v)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Set" ], [ "CALL_FUNCTION", "isinstance(val, Set)" ], [ "LOAD_GLOBAL", "_safe_iter" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "_safe_iter(val)" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['set']" ], [ "LOAD_FAST", "length" ], [ "COMPARE_OP", "length is None" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "num_items" ], [ "BINARY_ADD", "num_items + 2" ], [ "COMPARE_OP", "length > num_items + 2" ], [ "LOAD_GLOBAL", "islice" ], [ "LOAD_FAST", "vals" ], [ "LOAD_FAST", "num_items" ], [ "CALL_FUNCTION", "islice(vals, num_items)" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "vals" ], [ "CALL_FUNCTION", "enumerate(vals)" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_FAST", "i" ], [ "BINARY_MODULO", "'<%s>' % i" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child('<%s>' % i, v)" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "getattr(val, '__dict__', None)" ], [ "LOAD_FAST", "d" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_GLOBAL", "islice" ], [ "LOAD_GLOBAL", "_safe_iter" ], [ "LOAD_FAST", "d" ], [ "CALL_FUNCTION", "_safe_iter(d)" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['attributes']" ], [ "CALL_FUNCTION", "islice(_safe_iter(d),\n samples['attributes'])" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION_KW", "sorted(islice(_safe_iter(d),\n samples['attributes']),\n key=str)" ], [ "LOAD_FAST", "d" ], [ "LOAD_FAST", "k" ], [ "BINARY_SUBSCR", "d[k]" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "TracedFile" ], [ "CALL_FUNCTION", "isinstance(v, TracedFile)" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "k" ], [ "CALL_FUNCTION", "str(k)" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child(str(k), v)" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "type" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "type(val)" ], [ "CALL_FUNCTION", "getattr(type(val), '__slots__', None)" ], [ "CALL_FUNCTION", "sorted(getattr(type(val), '__slots__', None) or ())" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "val" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "getattr(val, s)" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "str(s)" ], [ "LOAD_FAST", "attr" ], [ "CALL_FUNCTION", "add_child(str(s), attr)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "x" ], [ "LOAD_FAST", "f" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "f(val)" ], [ "LOAD_FAST", "x" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_ADD", "max_length + 2" ], [ "COMPARE_OP", "length <= max_length + 2" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "range(length)" ], [ "LOAD_GLOBAL", "chain" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_FLOOR_DIVIDE", "max_length // 2" ], [ "CALL_FUNCTION", "range(max_length // 2)" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_FLOOR_DIVIDE", "max_length // 2" ], [ "BINARY_SUBTRACT", "length - max_length // 2" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "range(length - max_length // 2,\n length)" ], [ "CALL_FUNCTION", "chain(range(max_length // 2),\n range(length - max_length // 2,\n length))" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "len(x)" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "n == 0" ], [ "LOAD_GLOBAL", "repr" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "repr(x)" ], [ "LOAD_FAST", "helper" ], [ "LOAD_ATTR", "helper.level" ], [ "BINARY_SUBTRACT", "helper.level - 1" ], [ "LOAD_GLOBAL", "_repr_series_one_line" ], [ "LOAD_ATTR", "_repr_series_one_line.maxparts" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "n" ], [ "LOAD_FAST", "maxparts" ], [ "CALL_FUNCTION", "_sample_indices(n, maxparts)" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.index" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "x.index[i:i + 1]" ], [ "LOAD_ATTR", "x.index[i:i + 1].format" ], [ "CALL_FUNCTION_KW", "x.index[i:i + 1].format(sparsify=False)" ], [ "BINARY_SUBSCR", "x.index[i:i + 1].format(sparsify=False)[0]" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.iloc" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "x.iloc[i]" ], [ "LOAD_FAST", "pieces" ], [ "LOAD_METHOD", "pieces.append" ], [ "LOAD_FAST", "k" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "v" ], [ "LOAD_FAST", "newlevel" ], [ "CALL_FUNCTION", "cheap_repr(v, newlevel)" ], [ "BINARY_MODULO", "'%s = %s' % (k, cheap_repr(v, newlevel))" ], [ "CALL_METHOD", "pieces.append('%s = %s' % (k, cheap_repr(v, newlevel)))" ], [ "LOAD_FAST", "n" ], [ "LOAD_FAST", "maxparts" ], [ "BINARY_ADD", "maxparts + 2" ], [ "COMPARE_OP", "n > maxparts + 2" ], [ "LOAD_FAST", "pieces" ], [ "LOAD_METHOD", "pieces.insert" ], [ "LOAD_FAST", "maxparts" ], [ "BINARY_FLOOR_DIVIDE", "maxparts // 2" ], [ "CALL_METHOD", "pieces.insert(maxparts // 2, '...')" ], [ "LOAD_METHOD", "'; '.join" ], [ "LOAD_FAST", "pieces" ], [ "CALL_METHOD", "'; '.join(pieces)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "CALL_FUNCTION", "isinstance(node, ast.expr)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Num" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Str" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "ast" ], [ "CALL_FUNCTION", "getattr(ast, 'NameConstant', ())" ], [ "CALL_FUNCTION", "isinstance(node, (ast.Num, ast.Str, getattr(ast, 'NameConstant', ())))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "getattr(node, 'ctx', None)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Store" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Del" ], [ "CALL_FUNCTION", "isinstance(getattr(node, 'ctx', None),\n (ast.Store, ast.Del))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.UnaryOp" ], [ "CALL_FUNCTION", "isinstance(node, ast.UnaryOp)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.op" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.UAdd" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.USub" ], [ "CALL_FUNCTION", "isinstance(node.op, (ast.UAdd, ast.USub))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.operand" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Num" ], [ "CALL_FUNCTION", "isinstance(node.operand, ast.Num)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.List" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Tuple" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Dict" ], [ "CALL_FUNCTION", "isinstance(node, (ast.List, ast.Tuple, ast.Dict))" ], [ "LOAD_GLOBAL", "any" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.iter_child_nodes" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.iter_child_nodes(node)" ], [ "CALL_FUNCTION", "any(is_interesting_expression(n) for n in ast.iter_child_nodes(node))" ], [ "UNARY_NOT", "not any(is_interesting_expression(n) for n in ast.iter_child_nodes(node))" ], [ "UNARY_NOT", "not (isinstance(node, (ast.Num, ast.Str, getattr(ast, 'NameConstant', ()))) or\n isinstance(getattr(node, 'ctx', None),\n (ast.Store, ast.Del)) or\n (isinstance(node, ast.UnaryOp) and\n isinstance(node.op, (ast.UAdd, ast.USub)) and\n isinstance(node.operand, ast.Num)) or\n (isinstance(node, (ast.List, ast.Tuple, ast.Dict)) and\n not any(is_interesting_expression(n) for n in ast.iter_child_nodes(node))))" ], [ "LOAD_GLOBAL", "is_interesting_expression" ], [ "LOAD_FAST", "n" ], [ "CALL_FUNCTION", "is_interesting_expression(n)" ], [ "LOAD_GLOBAL", "cast" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "__builtins__" ], [ "CALL_FUNCTION", "cast(dict, __builtins__)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Name" ], [ "CALL_FUNCTION", "isinstance(node, ast.Name)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.id" ], [ "LOAD_FAST", "builtins" ], [ "COMPARE_OP", "node.id in builtins" ], [ "LOAD_FAST", "builtins" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.id" ], [ "BINARY_SUBSCR", "builtins[node.id]" ], [ "LOAD_FAST", "value" ], [ "COMPARE_OP", "builtins[node.id] is value" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "ast" ], [ "CALL_FUNCTION", "getattr(ast, 'NameConstant', ())" ], [ "CALL_FUNCTION", "isinstance(node, getattr(ast, 'NameConstant', ()))" ] ], "configuration.py": [ [ "LOAD_NAME", "ctypes" ], [ "LOAD_ATTR", "ctypes.windll" ], [ "LOAD_ATTR", "ctypes.windll.kernel32" ], [ "LOAD_NAME", "kernel32" ], [ "LOAD_METHOD", "kernel32.SetConsoleMode" ], [ "LOAD_NAME", "kernel32" ], [ "LOAD_METHOD", "kernel32.GetStdHandle" ], [ "CALL_METHOD", "kernel32.GetStdHandle(-11)" ], [ "CALL_METHOD", "kernel32.SetConsoleMode(kernel32.GetStdHandle(-11), 7)" ], [ "LOAD_NAME", "Exception" ], [ "LOAD_NAME", "os" ], [ "LOAD_ATTR", "os.name" ], [ "COMPARE_OP", "os.name != 'nt'" ], [ "LOAD_NAME", "DefaultFormatter" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "object" ], [ "LOAD_FAST", "builtins" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_GLOBAL", "builtins_module" ], [ "LOAD_FAST", "snoop" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.snoop" ], [ "CALL_FUNCTION", "setattr(builtins_module, snoop, package.snoop)" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_GLOBAL", "builtins_module" ], [ "LOAD_FAST", "pp" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.pp" ], [ "CALL_FUNCTION", "setattr(builtins_module, pp, package.pp)" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_GLOBAL", "builtins_module" ], [ "LOAD_FAST", "spy" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.spy" ], [ "CALL_FUNCTION", "setattr(builtins_module, spy, package.spy)" ], [ "LOAD_GLOBAL", "Config" ], [ "LOAD_FAST", "out" ], [ "LOAD_FAST", "prefix" ], [ "LOAD_FAST", "columns" ], [ "LOAD_FAST", "overwrite" ], [ "LOAD_FAST", "color" ], [ "LOAD_FAST", "enabled" ], [ "LOAD_FAST", "watch_extras" ], [ "LOAD_FAST", "replace_watch_extras" ], [ "LOAD_FAST", "formatter_class" ], [ "CALL_FUNCTION_KW", "Config(\n out=out,\n prefix=prefix,\n columns=columns,\n overwrite=overwrite,\n color=color,\n enabled=enabled,\n watch_extras=watch_extras,\n replace_watch_extras=replace_watch_extras,\n formatter_class=formatter_class,\n )" ], [ "LOAD_FAST", "config" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.snoop" ], [ "LOAD_FAST", "config" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.pp" ], [ "LOAD_FAST", "config" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.spy" ], [ "LOAD_NAME", "DefaultFormatter" ], [ "LOAD_GLOBAL", "can_color" ], [ "LOAD_FAST", "color" ], [ "COMPARE_OP", "color is None" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "out" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.stderr" ], [ "CALL_FUNCTION", "getattr(out or sys.stderr, 'isatty', lambda: False)" ], [ "LOAD_GLOBAL", "bool" ], [ "LOAD_FAST", "isatty" ], [ "CALL_FUNCTION", "isatty()" ], [ "CALL_FUNCTION", "bool(isatty())" ], [ "LOAD_GLOBAL", "get_write_function" ], [ "LOAD_FAST", "out" ], [ "LOAD_FAST", "overwrite" ], [ "CALL_FUNCTION", "get_write_function(out, overwrite)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "formatter_class" ], [ "LOAD_FAST", "prefix" ], [ "LOAD_FAST", "columns" ], [ "LOAD_FAST", "color" ], [ "CALL_FUNCTION", "formatter_class(prefix, columns, color)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "enabled" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "PP" ], [ "LOAD_DEREF", "self" ], [ "CALL_FUNCTION", "PP(self)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "Tracer" ], [ "LOAD_FAST", "ConfiguredTracer" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "Spy" ], [ "LOAD_DEREF", "self" ], [ "CALL_FUNCTION", "Spy(self)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "threading" ], [ "LOAD_METHOD", "threading.local" ], [ "CALL_METHOD", "threading.local()" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "replace_watch_extras" ], [ "COMPARE_OP", "replace_watch_extras is not None" ], [ "LOAD_GLOBAL", "ensure_tuple" ], [ "LOAD_FAST", "replace_watch_extras" ], [ "CALL_FUNCTION", "ensure_tuple(replace_watch_extras)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "len_shape_watch" ], [ "LOAD_GLOBAL", "dtype_watch" ], [ "LOAD_GLOBAL", "ensure_tuple" ], [ "LOAD_FAST", "watch_extras" ], [ "CALL_FUNCTION", "ensure_tuple(watch_extras)" ], [ "BINARY_ADD", "(len_shape_watch, dtype_watch) + ensure_tuple(watch_extras)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_CLASSDEREF", "self" ], [ "LOAD_FAST", "value" ], [ "LOAD_ATTR", "value.shape" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.ismethod" ], [ "LOAD_FAST", "shape" ], [ "CALL_METHOD", "inspect.ismethod(shape)" ], [ "LOAD_METHOD", "'{}.shape'.format" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "'{}.shape'.format(source)" ], [ "LOAD_FAST", "shape" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "value" ], [ "LOAD_GLOBAL", "QuerySet" ], [ "CALL_FUNCTION", "isinstance(value, QuerySet)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "len(value)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "value" ], [ "LOAD_GLOBAL", "six" ], [ "LOAD_ATTR", "six.string_types" ], [ "CALL_FUNCTION", "isinstance(value, six.string_types)" ], [ "LOAD_FAST", "length" ], [ "COMPARE_OP", "length < 50" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "value" ], [ "LOAD_GLOBAL", "Mapping" ], [ "LOAD_GLOBAL", "Set" ], [ "LOAD_GLOBAL", "Sequence" ], [ "CALL_FUNCTION", "isinstance(value, (Mapping, Set, Sequence))" ], [ "LOAD_FAST", "length" ], [ "COMPARE_OP", "length == 0" ], [ "LOAD_METHOD", "'len({})'.format" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "'len({})'.format(source)" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "value" ], [ "LOAD_ATTR", "value.dtype" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.ismethod" ], [ "LOAD_FAST", "dtype" ], [ "CALL_METHOD", "inspect.ismethod(dtype)" ], [ "LOAD_METHOD", "'{}.dtype'.format" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "'{}.dtype'.format(source)" ], [ "LOAD_FAST", "dtype" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_DEREF", "output" ], [ "LOAD_GLOBAL", "six" ], [ "LOAD_ATTR", "six.string_types" ], [ "CALL_FUNCTION", "isinstance(output, six.string_types)" ], [ "LOAD_GLOBAL", "is_pathlike" ], [ "LOAD_DEREF", "output" ], [ "CALL_FUNCTION", "is_pathlike(output)" ], [ "LOAD_FAST", "is_path" ], [ "LOAD_GLOBAL", "FileWriter" ], [ "LOAD_DEREF", "output" ], [ "LOAD_FAST", "overwrite" ], [ "CALL_FUNCTION", "FileWriter(output, overwrite)" ], [ "LOAD_ATTR", "FileWriter(output, overwrite).write" ], [ "LOAD_GLOBAL", "callable" ], [ "LOAD_DEREF", "output" ], [ "CALL_FUNCTION", "callable(output)" ], [ "LOAD_DEREF", "output" ], [ "LOAD_FAST", "write" ], [ "LOAD_DEREF", "output" ], [ "LOAD_FAST", "stream" ], [ "COMPARE_OP", "stream is None" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.stderr" ], [ "LOAD_FAST", "stream" ], [ "LOAD_METHOD", "stream.write" ], [ "LOAD_FAST", "s" ], [ "CALL_METHOD", "stream.write(s)" ], [ "LOAD_GLOBAL", "UnicodeEncodeError" ], [ "LOAD_FAST", "stream" ], [ "LOAD_METHOD", "stream.write" ], [ "LOAD_GLOBAL", "shitcode" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "shitcode(s)" ], [ "CALL_METHOD", "stream.write(shitcode(s))" ], [ "LOAD_GLOBAL", "six" ], [ "LOAD_METHOD", "six.text_type" ], [ "LOAD_FAST", "path" ], [ "CALL_METHOD", "six.text_type(path)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "overwrite" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "open" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.path" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.overwrite" ], [ "CALL_FUNCTION_KW", "open(self.path, 'w' if self.overwrite else 'a', encoding='utf-8')" ], [ "LOAD_FAST", "f" ], [ "LOAD_METHOD", "f.write" ], [ "LOAD_FAST", "s" ], [ "CALL_METHOD", "f.write(s)" ], [ "LOAD_FAST", "self" ] ], "db.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOAD_METHOD", "standard_library.install_aliases" ], [ "CALL_METHOD", "standard_library.install_aliases()" ], [ "LOAD_NAME", "RESERVED_WORDS" ], [ "LOAD_METHOD", "RESERVED_WORDS.add" ], [ "CALL_METHOD", "RESERVED_WORDS.add('function')" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "retry" ], [ "LOAD_NAME", "InterfaceError" ], [ "LOAD_NAME", "OperationalError" ], [ "LOAD_NAME", "InternalError" ], [ "LOAD_NAME", "ProgrammingError" ], [ "CALL_FUNCTION", "retry(3, (InterfaceError, OperationalError, InternalError, ProgrammingError))" ], [ "LOAD_NAME", "contextmanager" ], [ "CALL_FUNCTION", "contextmanager" ], [ "LOAD_FAST", "db_uri" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.environ" ], [ "LOAD_METHOD", "os.environ.get" ], [ "CALL_METHOD", "os.environ.get('BIRDSEYE_DB')" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_METHOD", "os.path.join" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_METHOD", "os.path.expanduser" ], [ "CALL_METHOD", "os.path.expanduser('~')" ], [ "CALL_METHOD", "os.path.join(os.path.expanduser('~'),\n '.birdseye.db')" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "dict" ], [ "CALL_FUNCTION_KW", "dict(\n pool_recycle=280,\n echo=False, # for convenience when debugging\n )" ], [ "LOAD_GLOBAL", "create_engine" ], [ "LOAD_FAST", "db_uri" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "create_engine(db_uri, **kwargs)" ], [ "LOAD_GLOBAL", "ArgumentError" ], [ "LOAD_FAST", "db_uri" ], [ "BINARY_ADD", "'sqlite:///' + db_uri" ], [ "LOAD_GLOBAL", "create_engine" ], [ "LOAD_FAST", "db_uri" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "create_engine(db_uri, **kwargs)" ], [ "LOAD_FAST", "engine" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "sessionmaker" ], [ "LOAD_FAST", "engine" ], [ "CALL_FUNCTION_KW", "sessionmaker(bind=engine)" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "object" ], [ "LOAD_GLOBAL", "declarative_base" ], [ "LOAD_FAST", "Base" ], [ "CALL_FUNCTION_KW", "declarative_base(cls=Base)" ], [ "LOAD_FAST", "Base" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "object" ], [ "LOAD_FAST", "engine" ], [ "LOAD_ATTR", "engine.name" ], [ "COMPARE_OP", "engine.name == 'mysql'" ], [ "LOAD_GLOBAL", "LONGTEXT" ], [ "LOAD_GLOBAL", "Text" ], [ "LOAD_FAST", "Base" ], [ "LOAD_FAST", "Base" ], [ "LOAD_FAST", "Call" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "Function" ], [ "LOAD_FAST", "self" ], [ "LOAD_DEREF", "KeyValue" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "KeyValueStore" ], [ "CALL_FUNCTION", "KeyValueStore()" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "_skip_version_check" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.table_exists" ], [ "LOAD_FAST", "Function" ], [ "CALL_METHOD", "self.table_exists(Function)" ], [ "LOAD_FAST", "Base" ], [ "LOAD_ATTR", "Base.metadata" ], [ "LOAD_METHOD", "Base.metadata.create_all" ], [ "LOAD_FAST", "engine" ], [ "CALL_METHOD", "Base.metadata.create_all(engine)" ], [ "LOAD_GLOBAL", "DB_VERSION" ], [ "LOAD_FAST", "kv" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.table_exists" ], [ "LOAD_DEREF", "KeyValue" ], [ "CALL_METHOD", "self.table_exists(KeyValue)" ], [ "LOAD_GLOBAL", "int" ], [ "LOAD_FAST", "kv" ], [ "LOAD_ATTR", "kv.version" ], [ "CALL_FUNCTION", "int(kv.version)" ], [ "LOAD_GLOBAL", "DB_VERSION" ], [ "COMPARE_OP", "int(kv.version) < DB_VERSION" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_METHOD", "sys.exit" ], [ "CALL_METHOD", "sys.exit('The birdseye database schema is out of date. '\n 'Run \"python -m birdseye.clear_db\" to delete the existing tables.')" ], [ "LOAD_NAME", "declared_attr" ], [ "CALL_FUNCTION", "declared_attr" ], [ "LOAD_FAST", "cls" ], [ "LOAD_ATTR", "cls.__name__" ], [ "LOAD_METHOD", "cls.__name__.lower" ], [ "CALL_METHOD", "cls.__name__.lower()" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "String" ], [ "CALL_FUNCTION", "String(50)" ], [ "CALL_FUNCTION_KW", "Column(String(50), primary_key=True)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "__getitem__" ], [ "LOAD_NAME", "__setitem__" ], [ "LOAD_DEREF", "db_self" ], [ "LOAD_METHOD", "db_self.session_scope" ], [ "CALL_METHOD", "db_self.session_scope()" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session\n .query" ], [ "LOAD_DEREF", "KeyValue" ], [ "LOAD_ATTR", "KeyValue.value" ], [ "CALL_METHOD", "session\n .query(KeyValue.value)" ], [ "LOAD_ATTR", "session\n .query(KeyValue.value)\n .filter_by" ], [ "LOAD_FAST", "item" ], [ "CALL_FUNCTION_KW", "session\n .query(KeyValue.value)\n .filter_by(key=item)" ], [ "LOAD_METHOD", "session\n .query(KeyValue.value)\n .filter_by(key=item)\n .scalar" ], [ "CALL_METHOD", "session\n .query(KeyValue.value)\n .filter_by(key=item)\n .scalar()" ], [ "LOAD_DEREF", "db_self" ], [ "LOAD_METHOD", "db_self.session_scope" ], [ "CALL_METHOD", "db_self.session_scope()" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.query" ], [ "LOAD_DEREF", "KeyValue" ], [ "CALL_METHOD", "session.query(KeyValue)" ], [ "LOAD_ATTR", "session.query(KeyValue).filter_by" ], [ "LOAD_FAST", "key" ], [ "CALL_FUNCTION_KW", "session.query(KeyValue).filter_by(key=key)" ], [ "LOAD_METHOD", "session.query(KeyValue).filter_by(key=key).delete" ], [ "CALL_METHOD", "session.query(KeyValue).filter_by(key=key).delete()" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.add" ], [ "LOAD_DEREF", "KeyValue" ], [ "LOAD_FAST", "key" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "str(value)" ], [ "CALL_FUNCTION_KW", "KeyValue(key=key, value=str(value))" ], [ "CALL_METHOD", "session.add(KeyValue(key=key, value=str(value)))" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "String" ], [ "CALL_FUNCTION_KW", "String(length=32)" ], [ "CALL_FUNCTION_KW", "Column(String(length=32), primary_key=True)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Integer" ], [ "LOAD_NAME", "ForeignKey" ], [ "CALL_FUNCTION", "ForeignKey('function.id')" ], [ "CALL_FUNCTION_KW", "Column(Integer, ForeignKey('function.id'), index=True)" ], [ "LOAD_NAME", "relationship" ], [ "LOAD_NAME", "backref" ], [ "CALL_FUNCTION_KW", "backref('calls', lazy='dynamic')" ], [ "CALL_FUNCTION_KW", "relationship('Function', backref=backref('calls', lazy='dynamic'))" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_CLASSDEREF", "LongText" ], [ "CALL_FUNCTION", "Column(LongText)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "DateTime" ], [ "CALL_FUNCTION_KW", "Column(DateTime, index=True)" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "id" ], [ "LOAD_NAME", "function_id" ], [ "LOAD_NAME", "return_value" ], [ "LOAD_NAME", "traceback" ], [ "LOAD_NAME", "exception" ], [ "LOAD_NAME", "start_time" ], [ "LOAD_NAME", "arguments" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._pretty_time" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start_time" ], [ "CALL_METHOD", "self._pretty_time(self.start_time)" ], [ "LOAD_FAST", "dt" ], [ "LOAD_GLOBAL", "Markup" ], [ "LOAD_FAST", "dt" ], [ "LOAD_METHOD", "dt.strftime" ], [ "CALL_METHOD", "dt.strftime('%Y-%m-%d %H:%M:%S')" ], [ "LOAD_GLOBAL", "naturaltime" ], [ "LOAD_FAST", "dt" ], [ "CALL_FUNCTION", "naturaltime(dt)" ], [ "BINARY_MODULO", "'%s (%s)' % (\n dt.strftime('%Y-%m-%d %H:%M:%S'),\n naturaltime(dt))" ], [ "CALL_FUNCTION", "Markup('%s (%s)' % (\n dt.strftime('%Y-%m-%d %H:%M:%S'),\n naturaltime(dt)))" ], [ "LOAD_GLOBAL", "Markup" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.success" ], [ "BINARY_MODULO", "'' % (\n ('ok', 'green') if self.success else\n ('remove', 'red'))" ], [ "CALL_FUNCTION", "Markup('' % (\n ('ok', 'green') if self.success else\n ('remove', 'red')))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.exception" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.traceback" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.return_value" ], [ "COMPARE_OP", "self.return_value == 'None'" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.traceback" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.success" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.return_value" ], [ "CALL_FUNCTION", "str(self.return_value)" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.exception" ], [ "CALL_FUNCTION", "str(self.exception)" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_METHOD", "json.loads" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.arguments" ], [ "CALL_METHOD", "json.loads(self.arguments)" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_METHOD", "json.loads" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.data" ], [ "CALL_METHOD", "json.loads(self.data)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.arguments_list" ], [ "LOAD_GLOBAL", "select_attrs" ], [ "LOAD_FAST", "call" ], [ "CALL_FUNCTION", "select_attrs(call, 'id function_id return_value traceback '\n 'exception start_time')" ], [ "CALL_FUNCTION_EX", "dict(arguments=call.arguments_list,\n **select_attrs(call, 'id function_id return_value traceback '\n 'exception start_time'))" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Integer" ], [ "LOAD_NAME", "Sequence" ], [ "CALL_FUNCTION", "Sequence('function_id_seq')" ], [ "CALL_FUNCTION_KW", "Column(Integer, Sequence('function_id_seq'), primary_key=True)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_CLASSDEREF", "LongText" ], [ "CALL_FUNCTION", "Column(LongText)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Integer" ], [ "CALL_FUNCTION", "Column(Integer)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_CLASSDEREF", "LongText" ], [ "CALL_FUNCTION", "Column(LongText)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "String" ], [ "CALL_FUNCTION_KW", "String(length=64)" ], [ "CALL_FUNCTION_KW", "Column(String(length=64), index=True)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "String" ], [ "CALL_FUNCTION_KW", "String(length=64)" ], [ "CALL_FUNCTION_KW", "Column(String(length=64), index=True)" ], [ "LOAD_NAME", "UniqueConstraint" ], [ "CALL_FUNCTION_KW", "UniqueConstraint('hash',\n name='everything_unique')" ], [ "LOAD_NAME", "Index" ], [ "CALL_FUNCTION_KW", "Index('idx_file', 'file', mysql_length=256)" ], [ "LOAD_NAME", "Index" ], [ "CALL_FUNCTION_KW", "Index('idx_name', 'name', mysql_length=32)" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "file" ], [ "LOAD_NAME", "name" ], [ "LOAD_NAME", "lineno" ], [ "LOAD_NAME", "hash" ], [ "LOAD_NAME", "body_hash" ], [ "LOAD_NAME", "type" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_METHOD", "json.loads" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.data" ], [ "CALL_METHOD", "json.loads(self.data)" ], [ "LOAD_GLOBAL", "select_attrs" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "select_attrs(func, 'file name lineno hash body_hash type')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.engine" ], [ "LOAD_ATTR", "self.engine.dialect" ], [ "LOAD_METHOD", "self.engine.dialect.has_table" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.engine" ], [ "LOAD_FAST", "table" ], [ "LOAD_ATTR", "table.__name__" ], [ "CALL_METHOD", "self.engine.dialect.has_table(self.engine, table.__name__)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.session_scope" ], [ "CALL_METHOD", "self.session_scope()" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.query" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.Function" ], [ "LOAD_ATTR", "self.Function.file" ], [ "CALL_METHOD", "session.query(self.Function.file)" ], [ "LOAD_METHOD", "session.query(self.Function.file).distinct" ], [ "CALL_METHOD", "session.query(self.Function.file).distinct()" ], [ "LOAD_FAST", "paths" ], [ "LOAD_METHOD", "paths.sort" ], [ "CALL_METHOD", "paths.sort()" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "paths" ], [ "COMPARE_OP", "IPYTHON_FILE_PATH in paths" ], [ "LOAD_FAST", "paths" ], [ "LOAD_METHOD", "paths.remove" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "CALL_METHOD", "paths.remove(IPYTHON_FILE_PATH)" ], [ "LOAD_FAST", "paths" ], [ "LOAD_METHOD", "paths.insert" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "CALL_METHOD", "paths.insert(0, IPYTHON_FILE_PATH)" ], [ "LOAD_FAST", "paths" ], [ "LOAD_GLOBAL", "is_ipython_cell" ], [ "LOAD_FAST", "f" ], [ "BINARY_SUBSCR", "f[0]" ], [ "CALL_FUNCTION", "is_ipython_cell(f[0])" ], [ "LOAD_FAST", "f" ], [ "BINARY_SUBSCR", "f[0]" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.Call" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.Function" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._KeyValue" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.table_exists" ], [ "LOAD_FAST", "model" ], [ "CALL_METHOD", "self.table_exists(model)" ], [ "LOAD_FAST", "model" ], [ "LOAD_ATTR", "model.__table__" ], [ "LOAD_METHOD", "model.__table__.drop" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.engine" ], [ "CALL_METHOD", "model.__table__.drop(self.engine)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.Session" ], [ "CALL_METHOD", "self.Session()" ], [ "LOAD_FAST", "session" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.commit" ], [ "CALL_METHOD", "session.commit()" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.rollback" ], [ "CALL_METHOD", "session.rollback()" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.close" ], [ "CALL_METHOD", "session.close()" ], [ "LOAD_GLOBAL", "functools" ], [ "LOAD_METHOD", "functools.wraps" ], [ "LOAD_DEREF", "func" ], [ "CALL_METHOD", "functools.wraps(func)" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "LOAD_GLOBAL", "retry_db" ], [ "LOAD_FAST", "wrapper" ], [ "CALL_FUNCTION", "retry_db(wrapper)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self.session_scope" ], [ "CALL_METHOD", "self.session_scope()" ], [ "LOAD_DEREF", "func" ], [ "LOAD_FAST", "session" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "func(session, *args, **kwargs)" ] ], "executing.py": [ [ "LOAD_NAME", "sys" ], [ "LOAD_ATTR", "sys.version_info" ], [ "BINARY_SUBSCR", "sys.version_info[0]" ], [ "COMPARE_OP", "sys.version_info[0] == 3" ], [ "LOAD_NAME", "PY3" ], [ "LOAD_NAME", "lru_cache" ], [ "CALL_FUNCTION_KW", "lru_cache(maxsize=None)" ], [ "LOAD_NAME", "str" ], [ "LOAD_NAME", "unicode" ], [ "LOAD_NAME", "dis" ], [ "LOAD_ATTR", "dis.get_instructions" ], [ "LOAD_NAME", "AttributeError" ], [ "LOAD_NAME", "namedtuple" ], [ "CALL_FUNCTION", "namedtuple('Instruction', 'offset argval opname')" ], [ "LOAD_NAME", "Exception" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.NodeVisitor" ], [ "LOAD_NAME", "sum" ], [ "LOAD_NAME", "__future__" ], [ "LOAD_ATTR", "__future__.all_feature_names" ], [ "CALL_FUNCTION", "sum(\n getattr(__future__, fname).compiler_flag\n for fname in __future__.all_feature_names\n)" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "RLock" ], [ "CALL_FUNCTION", "RLock()" ], [ "LOAD_NAME", "cache" ], [ "CALL_FUNCTION", "cache" ], [ "LOAD_GLOBAL", "functools" ], [ "LOAD_METHOD", "functools.wraps" ], [ "LOAD_DEREF", "func" ], [ "CALL_METHOD", "functools.wraps(func)" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "LOAD_FAST", "wrapper" ], [ "LOAD_FAST", "args" ], [ "LOAD_DEREF", "d" ], [ "COMPARE_OP", "args in d" ], [ "LOAD_DEREF", "d" ], [ "LOAD_FAST", "args" ], [ "BINARY_SUBSCR", "d[args]" ], [ "LOAD_DEREF", "func" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION_EX", "func(*args)" ], [ "LOAD_DEREF", "d" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "co" ], [ "LOAD_ATTR", "co.co_code" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "len(code)" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "i < n" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "code[i]" ], [ "LOAD_GLOBAL", "ord" ], [ "LOAD_FAST", "c" ], [ "CALL_FUNCTION", "ord(c)" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "LOAD_FAST", "op" ], [ "LOAD_GLOBAL", "HAVE_ARGUMENT" ], [ "COMPARE_OP", "op >= HAVE_ARGUMENT" ], [ "LOAD_GLOBAL", "ord" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "code[i]" ], [ "CALL_FUNCTION", "ord(code[i])" ], [ "LOAD_GLOBAL", "ord" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "code[i + 1]" ], [ "CALL_FUNCTION", "ord(code[i + 1])" ], [ "BINARY_MULTIPLY", "ord(code[i + 1]) * 256" ], [ "BINARY_ADD", "ord(code[i]) + ord(code[i + 1]) * 256" ], [ "LOAD_FAST", "extended_arg" ], [ "BINARY_ADD", "ord(code[i]) + ord(code[i + 1]) * 256 + extended_arg" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 2" ], [ "LOAD_FAST", "op" ], [ "LOAD_GLOBAL", "EXTENDED_ARG" ], [ "COMPARE_OP", "op == EXTENDED_ARG" ], [ "LOAD_FAST", "oparg" ], [ "BINARY_MULTIPLY", "oparg * 65536" ], [ "LOAD_FAST", "op" ], [ "LOAD_GLOBAL", "hasconst" ], [ "COMPARE_OP", "op in hasconst" ], [ "LOAD_FAST", "co" ], [ "LOAD_ATTR", "co.co_consts" ], [ "LOAD_FAST", "oparg" ], [ "BINARY_SUBSCR", "co.co_consts[oparg]" ], [ "LOAD_GLOBAL", "Instruction" ], [ "LOAD_FAST", "offset" ], [ "LOAD_FAST", "argval" ], [ "LOAD_GLOBAL", "opname" ], [ "LOAD_FAST", "op" ], [ "BINARY_SUBSCR", "opname[op]" ], [ "CALL_FUNCTION", "Instruction(offset, argval, opname[op])" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "it" ], [ "LOAD_GLOBAL", "Sized" ], [ "CALL_FUNCTION", "isinstance(it, Sized)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "len(it)" ], [ "COMPARE_OP", "len(it) != 1" ], [ "LOAD_GLOBAL", "NotOneValueFound" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "len(it)" ], [ "BINARY_MODULO", "'Expected one value, found %s' % len(it)" ], [ "CALL_FUNCTION", "NotOneValueFound('Expected one value, found %s' % len(it))" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "list(it)" ], [ "BINARY_SUBSCR", "list(it)[0]" ], [ "LOAD_GLOBAL", "tuple" ], [ "LOAD_GLOBAL", "islice" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "islice(it, 2)" ], [ "CALL_FUNCTION", "tuple(islice(it, 2))" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "lst" ], [ "CALL_FUNCTION", "len(lst)" ], [ "COMPARE_OP", "len(lst) == 0" ], [ "LOAD_GLOBAL", "NotOneValueFound" ], [ "CALL_FUNCTION", "NotOneValueFound('Expected one value, found 0')" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "lst" ], [ "CALL_FUNCTION", "len(lst)" ], [ "COMPARE_OP", "len(lst) > 1" ], [ "LOAD_GLOBAL", "NotOneValueFound" ], [ "CALL_FUNCTION", "NotOneValueFound('Expected one value, found several')" ], [ "LOAD_FAST", "lst" ], [ "BINARY_SUBSCR", "lst[0]" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "cache" ], [ "CALL_FUNCTION", "cache" ], [ "LOAD_NAME", "cache" ], [ "CALL_FUNCTION", "cache" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "text" ], [ "LOAD_GLOBAL", "text_type" ], [ "CALL_FUNCTION", "isinstance(text, text_type)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.decode_source" ], [ "LOAD_FAST", "text" ], [ "CALL_METHOD", "self.decode_source(text)" ], [ "LOAD_FAST", "text" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_FAST", "text" ], [ "LOAD_METHOD", "''.join" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "text" ], [ "LOAD_METHOD", "text.splitlines" ], [ "CALL_METHOD", "text.splitlines(True)" ], [ "CALL_FUNCTION", "enumerate(text.splitlines(True))" ], [ "CALL_METHOD", "''.join([\n '\\n' if i < 2 and encoding_pattern.match(line)\n else line\n for i, line in enumerate(text.splitlines(True))\n ])" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "defaultdict(list)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "text" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.parse" ], [ "LOAD_FAST", "ast_text" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION_KW", "ast.parse(ast_text, filename=filename)" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "SyntaxError" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.walk" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tree" ], [ "CALL_METHOD", "ast.walk(self.tree)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.iter_child_nodes" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.iter_child_nodes(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "hasattr(node, 'lineno')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._nodes_by_line" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.lineno" ], [ "BINARY_SUBSCR", "self._nodes_by_line[node.lineno]" ], [ "LOAD_METHOD", "self._nodes_by_line[node.lineno].append" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self._nodes_by_line[node.lineno].append(node)" ], [ "LOAD_GLOBAL", "QualnameVisitor" ], [ "CALL_FUNCTION", "QualnameVisitor()" ], [ "LOAD_FAST", "visitor" ], [ "LOAD_METHOD", "visitor.visit" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tree" ], [ "CALL_METHOD", "visitor.visit(self.tree)" ], [ "LOAD_FAST", "visitor" ], [ "LOAD_ATTR", "visitor.qualnames" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "i" ], [ "COMPARE_OP", "i < 2" ], [ "LOAD_GLOBAL", "encoding_pattern" ], [ "LOAD_METHOD", "encoding_pattern.match" ], [ "LOAD_FAST", "line" ], [ "CALL_METHOD", "encoding_pattern.match(line)" ], [ "LOAD_FAST", "line" ], [ "LOAD_FAST", "cls" ], [ "LOAD_METHOD", "cls.for_filename" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_filename" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "CALL_METHOD", "cls.for_filename(frame.f_code.co_filename, frame.f_globals or {})" ], [ "LOAD_FAST", "cls" ], [ "LOAD_METHOD", "cls._class_local" ], [ "CALL_METHOD", "cls._class_local('__source_cache', {})" ], [ "LOAD_FAST", "source_cache" ], [ "LOAD_FAST", "filename" ], [ "BINARY_SUBSCR", "source_cache[filename]" ], [ "LOAD_GLOBAL", "KeyError" ], [ "LOAD_GLOBAL", "linecache" ], [ "LOAD_METHOD", "linecache.getlines" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "module_globals" ], [ "CALL_METHOD", "linecache.getlines(filename, module_globals)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_FAST", "filename" ], [ "LOAD_METHOD", "''.join" ], [ "LOAD_FAST", "lines" ], [ "CALL_METHOD", "''.join(lines)" ], [ "CALL_FUNCTION", "cls(filename, ''.join(lines))" ], [ "LOAD_FAST", "source_cache" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_GLOBAL", "linecache" ], [ "CALL_FUNCTION", "hasattr(linecache, 'lazycache')" ], [ "LOAD_GLOBAL", "linecache" ], [ "LOAD_METHOD", "linecache.lazycache" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_filename" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "CALL_METHOD", "linecache.lazycache(frame.f_code.co_filename, frame.f_globals)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lasti" ], [ "LOAD_FAST", "cls" ], [ "LOAD_METHOD", "cls._class_local" ], [ "CALL_METHOD", "cls._class_local('__executing_cache', {})" ], [ "LOAD_FAST", "executing_cache" ], [ "LOAD_FAST", "key" ], [ "BINARY_SUBSCR", "executing_cache[key]" ], [ "LOAD_GLOBAL", "KeyError" ], [ "LOAD_FAST", "cls" ], [ "LOAD_METHOD", "cls.for_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "cls.for_frame(frame)" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.tree" ], [ "LOAD_FAST", "source" ], [ "LOAD_METHOD", "source.statements_at_line" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lineno" ], [ "CALL_METHOD", "source.statements_at_line(frame.f_lineno)" ], [ "LOAD_GLOBAL", "NodeFinder" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "stmts" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.tree" ], [ "CALL_FUNCTION", "NodeFinder(frame, stmts, source.tree)" ], [ "LOAD_ATTR", "NodeFinder(frame, stmts, source.tree).result" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_GLOBAL", "statement_containing_node" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "statement_containing_node(node)" ], [ "LOAD_FAST", "new_stmts" ], [ "LOAD_FAST", "stmts" ], [ "COMPARE_OP", "new_stmts <= stmts" ], [ "LOAD_FAST", "new_stmts" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "stmts" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "executing_cache" ], [ "LOAD_FAST", "key" ], [ "LOAD_GLOBAL", "Executing" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION_EX", "Executing(frame, *args)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_ATTR", "cls.__dict__" ], [ "LOAD_METHOD", "cls.__dict__.get" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "default" ], [ "CALL_METHOD", "cls.__dict__.get(name, default)" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_FAST", "cls" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "setattr(cls, name, result)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._nodes_by_line" ], [ "LOAD_FAST", "lineno" ], [ "BINARY_SUBSCR", "self._nodes_by_line[lineno]" ], [ "LOAD_GLOBAL", "statement_containing_node" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "statement_containing_node(node)" ], [ "LOAD_FAST", "ASTTokens" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.text" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tree" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.filename" ], [ "CALL_FUNCTION_KW", "ASTTokens(\n self.text,\n tree=self.tree,\n filename=self.filename,\n )" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "source" ], [ "LOAD_GLOBAL", "bytes" ], [ "CALL_FUNCTION", "isinstance(source, bytes)" ], [ "LOAD_GLOBAL", "detect_encoding" ], [ "LOAD_GLOBAL", "io" ], [ "LOAD_METHOD", "io.BytesIO" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "io.BytesIO(source)" ], [ "LOAD_ATTR", "io.BytesIO(source).readline" ], [ "CALL_FUNCTION", "detect_encoding(io.BytesIO(source).readline)" ], [ "LOAD_FAST", "source" ], [ "LOAD_METHOD", "source.decode" ], [ "LOAD_FAST", "encoding" ], [ "CALL_METHOD", "source.decode(encoding)" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_filename" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.filename" ], [ "COMPARE_OP", "code.co_filename == self.filename" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._qualnames" ], [ "LOAD_METHOD", "self._qualnames.get" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_firstlineno" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "CALL_METHOD", "self._qualnames.get((code.co_name, code.co_firstlineno), code.co_name)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "stmts" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.source" ], [ "LOAD_METHOD", "self.source.code_qualname" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_code" ], [ "CALL_METHOD", "self.source.code_qualname(self.frame.f_code)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.source" ], [ "LOAD_METHOD", "self.source.asttokens" ], [ "CALL_METHOD", "self.source.asttokens()" ], [ "LOAD_METHOD", "self.source.asttokens().get_text" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.node" ], [ "CALL_METHOD", "self.source.asttokens().get_text(self.node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.source" ], [ "LOAD_METHOD", "self.source.asttokens" ], [ "CALL_METHOD", "self.source.asttokens()" ], [ "LOAD_METHOD", "self.source.asttokens().get_text_range" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.node" ], [ "CALL_METHOD", "self.source.asttokens().get_text_range(self.node)" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "QualnameVisitor" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(QualnameVisitor, self)" ], [ "LOAD_METHOD", "super(QualnameVisitor, self).__init__" ], [ "CALL_METHOD", "super(QualnameVisitor, self).__init__()" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.name" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_METHOD", "self.stack.append" ], [ "LOAD_FAST", "name" ], [ "CALL_METHOD", "self.stack.append(name)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.qualnames" ], [ "LOAD_METHOD", "self.qualnames.setdefault" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.lineno" ], [ "LOAD_METHOD", "\".\".join" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "CALL_METHOD", "\".\".join(self.stack)" ], [ "CALL_METHOD", "self.qualnames.setdefault((name, node.lineno), \".\".join(self.stack))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_METHOD", "self.stack.append" ], [ "CALL_METHOD", "self.stack.append('')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Lambda" ], [ "CALL_FUNCTION", "isinstance(node, ast.Lambda)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.body" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.body" ], [ "LOAD_FAST", "children" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.visit" ], [ "LOAD_FAST", "child" ], [ "CALL_METHOD", "self.visit(child)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_METHOD", "self.stack.pop" ], [ "CALL_METHOD", "self.stack.pop()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_METHOD", "self.stack.pop" ], [ "CALL_METHOD", "self.stack.pop()" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.iter_fields" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.iter_fields(node)" ], [ "LOAD_FAST", "field" ], [ "COMPARE_OP", "field == 'body'" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.AST" ], [ "CALL_FUNCTION", "isinstance(child, ast.AST)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.visit" ], [ "LOAD_FAST", "child" ], [ "CALL_METHOD", "self.visit(child)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "isinstance(child, list)" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "grandchild" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.AST" ], [ "CALL_FUNCTION", "isinstance(grandchild, ast.AST)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.visit" ], [ "LOAD_FAST", "grandchild" ], [ "CALL_METHOD", "self.visit(grandchild)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.visit_FunctionDef" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self.visit_FunctionDef(node, '')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_METHOD", "self.stack.append" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.name" ], [ "CALL_METHOD", "self.stack.append(node.name)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.generic_visit" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self.generic_visit(node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_METHOD", "self.stack.pop" ], [ "CALL_METHOD", "self.stack.pop()" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "__future__" ], [ "LOAD_FAST", "fname" ], [ "CALL_FUNCTION", "getattr(__future__, fname)" ], [ "LOAD_ATTR", "getattr(__future__, fname).compiler_flag" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "matching_code" ], [ "LOAD_ATTR", "matching_code.co_filename" ], [ "LOAD_GLOBAL", "future_flags" ], [ "LOAD_FAST", "matching_code" ], [ "LOAD_ATTR", "matching_code.co_flags" ], [ "BINARY_AND", "future_flags & matching_code.co_flags" ], [ "CALL_FUNCTION_KW", "compile(\n source,\n matching_code.co_filename,\n 'exec',\n flags=future_flags & matching_code.co_flags,\n dont_inherit=True,\n )" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "tree" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_code" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lasti" ], [ "BINARY_SUBSCR", "frame.f_code.co_code[frame.f_lasti]" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_GLOBAL", "ord" ], [ "LOAD_FAST", "b" ], [ "CALL_FUNCTION", "ord(b)" ], [ "LOAD_GLOBAL", "dis" ], [ "LOAD_ATTR", "dis.opname" ], [ "LOAD_FAST", "b" ], [ "BINARY_SUBSCR", "dis.opname[b]" ], [ "LOAD_FAST", "op_name" ], [ "LOAD_METHOD", "op_name.startswith" ], [ "CALL_METHOD", "op_name.startswith('CALL_')" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Call" ], [ "LOAD_FAST", "op_name" ], [ "COMPARE_OP", "op_name == 'BINARY_SUBSCR'" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Subscript" ], [ "LOAD_FAST", "op_name" ], [ "LOAD_METHOD", "op_name.startswith" ], [ "CALL_METHOD", "op_name.startswith('BINARY_')" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.BinOp" ], [ "LOAD_FAST", "op_name" ], [ "LOAD_METHOD", "op_name.startswith" ], [ "CALL_METHOD", "op_name.startswith('UNARY_')" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.UnaryOp" ], [ "LOAD_FAST", "op_name" ], [ "COMPARE_OP", "op_name in ('LOAD_ATTR', 'LOAD_METHOD', 'LOOKUP_METHOD')" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Attribute" ], [ "LOAD_FAST", "op_name" ], [ "COMPARE_OP", "op_name == 'COMPARE_OP'" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Compare" ], [ "LOAD_GLOBAL", "RuntimeError" ], [ "LOAD_FAST", "op_name" ], [ "CALL_FUNCTION", "RuntimeError(op_name)" ], [ "LOAD_GLOBAL", "lock" ], [ "LOAD_FAST", "stmts" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.matching_nodes" ], [ "LOAD_FAST", "exprs" ], [ "CALL_METHOD", "self.matching_nodes(exprs)" ], [ "CALL_FUNCTION", "list(self.matching_nodes(exprs))" ], [ "CALL_FUNCTION", "only(list(self.matching_nodes(exprs)))" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.walk" ], [ "LOAD_FAST", "stmt" ], [ "CALL_METHOD", "ast.walk(stmt)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "typ" ], [ "CALL_FUNCTION", "isinstance(node, typ)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "hasattr(node, \"ctx\")" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.ctx" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Load" ], [ "CALL_FUNCTION", "isinstance(node.ctx, ast.Load)" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "exprs" ], [ "CALL_FUNCTION", "enumerate(exprs)" ], [ "LOAD_GLOBAL", "get_setter" ], [ "LOAD_FAST", "expr" ], [ "CALL_FUNCTION", "get_setter(expr)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.BinOp" ], [ "LOAD_FAST", "expr" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.Pow" ], [ "CALL_METHOD", "ast.Pow()" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Str" ], [ "LOAD_GLOBAL", "sentinel" ], [ "CALL_FUNCTION_KW", "ast.Str(s=sentinel)" ], [ "CALL_FUNCTION_KW", "ast.BinOp(\n left=expr,\n op=ast.Pow(),\n right=ast.Str(s=sentinel),\n )" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.fix_missing_locations" ], [ "LOAD_FAST", "replacement" ], [ "CALL_METHOD", "ast.fix_missing_locations(replacement)" ], [ "LOAD_FAST", "setter" ], [ "LOAD_FAST", "replacement" ], [ "CALL_FUNCTION", "setter(replacement)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.compile_instructions" ], [ "CALL_METHOD", "self.compile_instructions()" ], [ "LOAD_GLOBAL", "SyntaxError" ], [ "LOAD_FAST", "setter" ], [ "LOAD_FAST", "expr" ], [ "CALL_FUNCTION", "setter(expr)" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "instructions" ], [ "CALL_FUNCTION", "enumerate(instructions)" ], [ "LOAD_FAST", "indices" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_FAST", "indices" ], [ "CALL_FUNCTION", "only(indices)" ], [ "BINARY_SUBTRACT", "only(indices) - 1" ], [ "LOAD_FAST", "instructions" ], [ "LOAD_FAST", "arg_index" ], [ "BINARY_SUBSCR", "instructions[arg_index]" ], [ "LOAD_ATTR", "instructions[arg_index].opname" ], [ "COMPARE_OP", "instructions[arg_index].opname == 'EXTENDED_ARG'" ], [ "LOAD_FAST", "instructions" ], [ "LOAD_FAST", "arg_index" ], [ "BINARY_SUBSCR", "instructions[arg_index]" ], [ "LOAD_ATTR", "instructions[arg_index].offset" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_lasti" ], [ "COMPARE_OP", "instructions[arg_index].offset == self.frame.f_lasti" ], [ "LOAD_FAST", "expr" ], [ "LOAD_FAST", "instruction" ], [ "LOAD_ATTR", "instruction.argval" ], [ "LOAD_GLOBAL", "sentinel" ], [ "COMPARE_OP", "instruction.argval == sentinel" ], [ "LOAD_FAST", "i" ], [ "LOAD_GLOBAL", "compile_similar_to" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tree" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_code" ], [ "CALL_FUNCTION", "compile_similar_to(self.tree, self.frame.f_code)" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_GLOBAL", "find_codes" ], [ "LOAD_FAST", "module_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_code" ], [ "CALL_FUNCTION", "find_codes(module_code, self.frame.f_code)" ], [ "CALL_FUNCTION", "only(find_codes(module_code, self.frame.f_code))" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "get_instructions" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "get_instructions(code)" ], [ "CALL_FUNCTION", "list(get_instructions(code))" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.iter_fields" ], [ "LOAD_DEREF", "parent" ], [ "CALL_METHOD", "ast.iter_fields(parent)" ], [ "LOAD_DEREF", "field" ], [ "LOAD_FAST", "node" ], [ "COMPARE_OP", "field is node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_DEREF", "field" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "isinstance(field, list)" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_DEREF", "field" ], [ "CALL_FUNCTION", "enumerate(field)" ], [ "LOAD_FAST", "item" ], [ "LOAD_FAST", "node" ], [ "COMPARE_OP", "item is node" ], [ "LOAD_FAST", "setter" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_DEREF", "parent" ], [ "LOAD_DEREF", "name" ], [ "LOAD_FAST", "new_node" ], [ "CALL_FUNCTION", "setattr(parent, name, new_node)" ], [ "LOAD_FAST", "new_node" ], [ "LOAD_DEREF", "field" ], [ "LOAD_DEREF", "i" ], [ "LOAD_DEREF", "matches" ], [ "LOAD_FAST", "root_code" ], [ "CALL_FUNCTION", "matches(root_code)" ], [ "LOAD_DEREF", "code_options" ], [ "LOAD_METHOD", "code_options.append" ], [ "LOAD_FAST", "root_code" ], [ "CALL_METHOD", "code_options.append(root_code)" ], [ "LOAD_DEREF", "finder" ], [ "LOAD_FAST", "root_code" ], [ "CALL_FUNCTION", "finder(root_code)" ], [ "LOAD_DEREF", "code_options" ], [ "LOAD_GLOBAL", "all" ], [ "LOAD_GLOBAL", "attrgetter" ], [ "CALL_FUNCTION", "attrgetter('co_firstlineno')" ], [ "LOAD_GLOBAL", "attrgetter" ], [ "CALL_FUNCTION", "attrgetter('co_name')" ], [ "LOAD_GLOBAL", "code_names" ], [ "CALL_FUNCTION", "all(\n f(c) == f(matching)\n for f in [\n attrgetter('co_firstlineno'),\n attrgetter('co_name'),\n code_names,\n ]\n )" ], [ "LOAD_FAST", "f" ], [ "LOAD_DEREF", "c" ], [ "CALL_FUNCTION", "f(c)" ], [ "LOAD_FAST", "f" ], [ "LOAD_DEREF", "matching" ], [ "CALL_FUNCTION", "f(matching)" ], [ "COMPARE_OP", "f(c) == f(matching)" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_consts" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.iscode" ], [ "LOAD_FAST", "const" ], [ "CALL_METHOD", "inspect.iscode(const)" ], [ "LOAD_DEREF", "matches" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "matches(const)" ], [ "LOAD_DEREF", "code_options" ], [ "LOAD_METHOD", "code_options.append" ], [ "LOAD_FAST", "const" ], [ "CALL_METHOD", "code_options.append(const)" ], [ "LOAD_DEREF", "finder" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "finder(const)" ], [ "LOAD_GLOBAL", "frozenset" ], [ "CALL_FUNCTION", "frozenset()" ], [ "LOAD_METHOD", "frozenset().union" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_names" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_varnames" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_freevars" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_cellvars" ], [ "CALL_METHOD", "frozenset().union(\n code.co_names,\n code.co_varnames,\n code.co_freevars,\n code.co_cellvars,\n )" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "CALL_FUNCTION", "isinstance(node, ast.stmt)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_FAST", "node" ] ], "import_hook.py": [ [ "LOAD_NAME", "object" ], [ "LOAD_FAST", "spec" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "deep" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "eye" ], [ "LOAD_ATTR", "eye.exec_string" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.source" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._spec" ], [ "LOAD_ATTR", "self._spec.origin" ], [ "LOAD_FAST", "module" ], [ "LOAD_ATTR", "module.__dict__" ], [ "LOAD_FAST", "module" ], [ "LOAD_ATTR", "module.__dict__" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.deep" ], [ "CALL_FUNCTION_KW", "eye.exec_string(\n source=self.source,\n filename=self._spec.origin,\n globs=module.__dict__,\n locs=module.__dict__,\n deep=self.deep,\n )" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._spec" ], [ "LOAD_ATTR", "self._spec.loader" ], [ "LOAD_METHOD", "self._spec.loader.get_filename" ], [ "LOAD_FAST", "fullname" ], [ "CALL_METHOD", "self._spec.loader.get_filename(fullname)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._spec" ], [ "LOAD_ATTR", "self._spec.loader" ], [ "LOAD_METHOD", "self._spec.loader.is_package" ], [ "LOAD_FAST", "fullname" ], [ "CALL_METHOD", "self._spec.loader.is_package(fullname)" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.meta_path" ], [ "LOAD_FAST", "finder" ], [ "LOAD_FAST", "self" ], [ "COMPARE_OP", "finder is self" ], [ "LOAD_FAST", "finder" ], [ "LOAD_ATTR", "finder.__module__" ], [ "COMPARE_OP", "'pytest' in finder.__module__" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "finder" ], [ "CALL_FUNCTION", "hasattr(finder, 'find_spec')" ], [ "LOAD_FAST", "finder" ], [ "LOAD_ATTR", "finder.find_spec" ], [ "LOAD_FAST", "fullname" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "target" ], [ "CALL_FUNCTION_KW", "finder.find_spec(fullname, path, target=target)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "finder" ], [ "CALL_FUNCTION", "hasattr(finder, 'load_module')" ], [ "LOAD_GLOBAL", "spec_from_loader" ], [ "LOAD_FAST", "fullname" ], [ "LOAD_FAST", "finder" ], [ "CALL_FUNCTION", "spec_from_loader(fullname, finder)" ], [ "LOAD_FAST", "spec" ], [ "COMPARE_OP", "spec is not None" ], [ "LOAD_FAST", "spec" ], [ "LOAD_ATTR", "spec.origin" ], [ "COMPARE_OP", "spec.origin != 'builtin'" ], [ "LOAD_FAST", "spec" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._find_plain_spec" ], [ "LOAD_FAST", "fullname" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "target" ], [ "CALL_METHOD", "self._find_plain_spec(fullname, path, target)" ], [ "LOAD_FAST", "spec" ], [ "COMPARE_OP", "spec is None" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "spec" ], [ "LOAD_ATTR", "spec.loader" ], [ "CALL_FUNCTION", "hasattr(spec.loader, 'get_source')" ], [ "LOAD_GLOBAL", "callable" ], [ "LOAD_FAST", "spec" ], [ "LOAD_ATTR", "spec.loader" ], [ "LOAD_ATTR", "spec.loader.get_source" ], [ "CALL_FUNCTION", "callable(spec.loader.get_source)" ], [ "LOAD_FAST", "fullname" ], [ "COMPARE_OP", "fullname != 'org'" ], [ "LOAD_GLOBAL", "logging" ], [ "LOAD_METHOD", "logging.debug" ], [ "LOAD_FAST", "fullname" ], [ "CALL_METHOD", "logging.debug('Failed finding spec for %s', fullname)" ], [ "LOAD_FAST", "spec" ], [ "LOAD_ATTR", "spec.loader" ], [ "LOAD_METHOD", "spec.loader.get_source" ], [ "LOAD_FAST", "fullname" ], [ "CALL_METHOD", "spec.loader.get_source(fullname)" ], [ "LOAD_GLOBAL", "ImportError" ], [ "LOAD_GLOBAL", "logging" ], [ "LOAD_METHOD", "logging.debug" ], [ "LOAD_FAST", "fullname" ], [ "CALL_METHOD", "logging.debug('Loader for %s was unable to find the sources',\n fullname)" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_GLOBAL", "logging" ], [ "LOAD_METHOD", "logging.exception" ], [ "LOAD_FAST", "fullname" ], [ "CALL_METHOD", "logging.exception('Loader for %s raised an error', fullname)" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "source" ], [ "COMPARE_OP", "'birdseye' not in source" ], [ "LOAD_GLOBAL", "should_trace" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "should_trace(source)" ], [ "LOAD_FAST", "trace_stmt" ], [ "LOAD_GLOBAL", "BirdsEyeLoader" ], [ "LOAD_FAST", "spec" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "deep" ], [ "CALL_FUNCTION", "BirdsEyeLoader(spec, source, deep)" ], [ "LOAD_GLOBAL", "spec_from_loader" ], [ "LOAD_FAST", "fullname" ], [ "LOAD_FAST", "loader" ], [ "CALL_FUNCTION", "spec_from_loader(fullname, loader)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.parse" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "ast.parse(source)" ], [ "LOAD_ATTR", "ast.parse(source).body" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Import" ], [ "CALL_FUNCTION", "isinstance(stmt, ast.Import)" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_ATTR", "stmt.names" ], [ "LOAD_FAST", "alias" ], [ "LOAD_ATTR", "alias.name" ], [ "LOAD_METHOD", "alias.name.startswith" ], [ "CALL_METHOD", "alias.name.startswith('birdseye.trace_module')" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_FAST", "alias" ], [ "LOAD_ATTR", "alias.name" ], [ "LOAD_METHOD", "alias.name.endswith" ], [ "CALL_METHOD", "alias.name.endswith('deep')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.ImportFrom" ], [ "CALL_FUNCTION", "isinstance(stmt, ast.ImportFrom)" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_ATTR", "stmt.module" ], [ "COMPARE_OP", "stmt.module == 'birdseye'" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_ATTR", "stmt.names" ], [ "LOAD_FAST", "alias" ], [ "LOAD_ATTR", "alias.name" ], [ "LOAD_METHOD", "alias.name.startswith" ], [ "CALL_METHOD", "alias.name.startswith('trace_module')" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_FAST", "alias" ], [ "LOAD_ATTR", "alias.name" ], [ "LOAD_METHOD", "alias.name.endswith" ], [ "CALL_METHOD", "alias.name.endswith('deep')" ], [ "LOAD_FAST", "deep" ], [ "LOAD_FAST", "trace_stmt" ] ], "ipython.py": [ [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "BytesIO" ], [ "LOAD_NAME", "StringIO" ], [ "LOAD_NAME", "stream_proxy" ], [ "LOAD_NAME", "sys" ], [ "LOAD_ATTR", "sys.stderr" ], [ "CALL_FUNCTION", "stream_proxy(sys.stderr)" ], [ "LOAD_NAME", "sys" ], [ "LOAD_NAME", "stream_proxy" ], [ "LOAD_NAME", "sys" ], [ "LOAD_ATTR", "sys.stdout" ], [ "CALL_FUNCTION", "stream_proxy(sys.stdout)" ], [ "LOAD_NAME", "sys" ], [ "LOAD_NAME", "Environment" ], [ "LOAD_NAME", "PackageLoader" ], [ "CALL_FUNCTION", "PackageLoader('birdseye', 'templates')" ], [ "LOAD_NAME", "select_autoescape" ], [ "CALL_FUNCTION", "select_autoescape(['html', 'xml'])" ], [ "CALL_FUNCTION_KW", "Environment(\n loader=PackageLoader('birdseye', 'templates'),\n autoescape=select_autoescape(['html', 'xml'])\n)" ], [ "LOAD_NAME", "magics_class" ], [ "LOAD_NAME", "Magics" ], [ "CALL_FUNCTION", "magics_class" ], [ "LOAD_GLOBAL", "LocalProxy" ], [ "LOAD_FAST", "p" ], [ "CALL_FUNCTION", "LocalProxy(p)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.currentframe" ], [ "CALL_METHOD", "inspect.currentframe()" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_GLOBAL", "ThreadingMixIn" ], [ "LOAD_ATTR", "ThreadingMixIn.process_request_thread" ], [ "LOAD_ATTR", "ThreadingMixIn.process_request_thread.__code__" ], [ "COMPARE_OP", "frame.f_code == ThreadingMixIn.process_request_thread.__code__" ], [ "LOAD_GLOBAL", "fake_stream" ], [ "CALL_FUNCTION", "fake_stream()" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_GLOBAL", "thread_proxies" ], [ "LOAD_METHOD", "thread_proxies.get" ], [ "LOAD_GLOBAL", "currentThread" ], [ "CALL_FUNCTION", "currentThread()" ], [ "LOAD_ATTR", "currentThread().ident" ], [ "LOAD_DEREF", "original" ], [ "CALL_METHOD", "thread_proxies.get(currentThread().ident,\n original)" ], [ "LOAD_FAST", "show_server_output" ], [ "LOAD_GLOBAL", "fake_stream" ], [ "CALL_FUNCTION", "fake_stream()" ], [ "LOAD_GLOBAL", "thread_proxies" ], [ "LOAD_GLOBAL", "currentThread" ], [ "CALL_FUNCTION", "currentThread()" ], [ "LOAD_ATTR", "currentThread().ident" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_ATTR", "server.app" ], [ "LOAD_ATTR", "server.app.run" ], [ "LOAD_FAST", "port" ], [ "LOAD_FAST", "bind_host" ], [ "CALL_FUNCTION_KW", "server.app.run(\n debug=True,\n port=port,\n host=bind_host,\n use_reloader=False,\n )" ], [ "LOAD_GLOBAL", "socket" ], [ "LOAD_ATTR", "socket.error" ], [ "LOAD_NAME", "Unicode" ], [ "CALL_FUNCTION_KW", "Unicode(\n u'', config=True,\n help='If set, a server will not be automatically started by %%eye. '\n 'The iframe containing birdseye output will use this value as the base '\n 'of its URL.'\n )" ], [ "LOAD_NAME", "Int" ], [ "CALL_FUNCTION_KW", "Int(\n 7777, config=True,\n help='Port number for the server started by %%eye.'\n )" ], [ "LOAD_NAME", "Unicode" ], [ "CALL_FUNCTION_KW", "Unicode(\n '127.0.0.1', config=True,\n help='Host that the server started by %%eye listens on. '\n 'Set to 0.0.0.0 to make it accessible anywhere.'\n )" ], [ "LOAD_NAME", "Bool" ], [ "CALL_FUNCTION_KW", "Bool(\n False, config=True,\n help='Set to True to show stdout and stderr from the server started by %%eye.'\n )" ], [ "LOAD_NAME", "Unicode" ], [ "CALL_FUNCTION_KW", "Unicode(\n u'', config=True,\n help='The database URL that the server started by %%eye reads from. '\n 'Equivalent to the environment variable BIRDSEYE_DB.'\n )" ], [ "LOAD_NAME", "cell_magic" ], [ "CALL_FUNCTION", "cell_magic" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.server_url" ], [ "LOAD_GLOBAL", "Database" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.db_url" ], [ "CALL_FUNCTION", "Database(self.db_url)" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_ATTR", "server.db" ], [ "LOAD_ATTR", "server.db.Function" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_ATTR", "server.db" ], [ "LOAD_ATTR", "server.db.Call" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_ATTR", "server.db" ], [ "LOAD_ATTR", "server.db.Session" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_GLOBAL", "Thread" ], [ "LOAD_GLOBAL", "run_server" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.port" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.bind_host" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.show_server_output" ], [ "CALL_FUNCTION_KW", "Thread(\n target=run_server,\n args=(\n self.port,\n self.bind_host,\n self.show_server_output,\n ),\n )" ], [ "LOAD_METHOD", "Thread(\n target=run_server,\n args=(\n self.port,\n self.bind_host,\n self.show_server_output,\n ),\n ).start" ], [ "CALL_METHOD", "Thread(\n target=run_server,\n args=(\n self.port,\n self.bind_host,\n self.show_server_output,\n ),\n ).start()" ], [ "LOAD_GLOBAL", "Database" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.db_url" ], [ "CALL_FUNCTION", "Database(self.db_url)" ], [ "LOAD_GLOBAL", "eye" ], [ "LOAD_GLOBAL", "eye" ], [ "LOAD_METHOD", "eye.exec_ipython_cell" ], [ "LOAD_FAST", "cell" ], [ "LOAD_FAST", "callback" ], [ "CALL_METHOD", "eye.exec_ipython_cell(cell, callback)" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "call_id" ], [ "COMPARE_OP", "call_id is None" ], [ "LOAD_GLOBAL", "HTML" ], [ "LOAD_GLOBAL", "templates_env" ], [ "LOAD_METHOD", "templates_env.get_template" ], [ "CALL_METHOD", "templates_env.get_template('ipython_iframe.html')" ], [ "LOAD_ATTR", "templates_env.get_template('ipython_iframe.html').render" ], [ "LOAD_FAST", "call_id" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.server_url" ], [ "LOAD_METHOD", "self.server_url.rstrip" ], [ "CALL_METHOD", "self.server_url.rstrip('/')" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.port" ], [ "LOAD_GLOBAL", "uuid4" ], [ "CALL_FUNCTION", "uuid4()" ], [ "LOAD_ATTR", "uuid4().hex" ], [ "CALL_FUNCTION_KW", "templates_env.get_template('ipython_iframe.html').render(\n call_id=call_id,\n url=self.server_url.rstrip('/'),\n port=self.port,\n container_id=uuid4().hex,\n )" ], [ "CALL_FUNCTION", "HTML(templates_env.get_template('ipython_iframe.html').render(\n call_id=call_id,\n url=self.server_url.rstrip('/'),\n port=self.port,\n container_id=uuid4().hex,\n ))" ], [ "LOAD_GLOBAL", "display" ], [ "LOAD_FAST", "html" ], [ "CALL_FUNCTION", "display(html)" ] ], "server.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOAD_METHOD", "standard_library.install_aliases" ], [ "CALL_METHOD", "standard_library.install_aliases()" ], [ "LOAD_NAME", "Flask" ], [ "CALL_FUNCTION", "Flask('birdseye')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.jinja_env" ], [ "LOAD_NAME", "Humanize" ], [ "LOAD_NAME", "app" ], [ "CALL_FUNCTION", "Humanize(app)" ], [ "LOAD_NAME", "PathConverter" ], [ "LOAD_NAME", "FileConverter" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.url_map" ], [ "LOAD_ATTR", "app.url_map.converters" ], [ "LOAD_NAME", "Database" ], [ "CALL_FUNCTION", "Database()" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.Session" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.Function" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.Call" ], [ "LOAD_NAME", "app" ], [ "LOAD_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/file/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/file/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/file//__function__/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/file//__function__/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/api/file//__function__//latest_call/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/api/file//__function__//latest_call/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "LOAD_NAME", "app" ], [ "LOAD_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/call/')" ], [ "CALL_FUNCTION", "app.route('/call/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/ipython_call/')" ], [ "CALL_FUNCTION", "app.route('/ipython_call/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/ipython_iframe/')" ], [ "CALL_FUNCTION", "app.route('/ipython_iframe/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION_KW", "app.route('/kill', methods=['POST'])" ], [ "CALL_FUNCTION", "app.route('/kill', methods=['POST'])" ], [ "LOAD_NAME", "app" ], [ "LOAD_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/api/call/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/api/call/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/api/calls_by_body_hash/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/api/calls_by_body_hash/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION_KW", "app.route('/api/body_hashes_present/', methods=['POST'])" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/api/body_hashes_present/', methods=['POST'])" ], [ "LOAD_NAME", "sys" ], [ "LOAD_ATTR", "sys.argv" ], [ "BINARY_SUBSCR", "sys.argv[1:]" ], [ "LOAD_NAME", "__name__" ], [ "COMPARE_OP", "__name__ == '__main__'" ], [ "LOAD_NAME", "main" ], [ "CALL_FUNCTION", "main()" ], [ "LOAD_GLOBAL", "db" ], [ "LOAD_METHOD", "db.all_file_paths" ], [ "CALL_METHOD", "db.all_file_paths()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_columns" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.basic_columns" ], [ "BINARY_ADD", "Call.basic_columns + Function.basic_columns" ], [ "CALL_FUNCTION_EX", "session.query(*(Call.basic_columns + Function.basic_columns))" ], [ "LOAD_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)" ], [ "LOAD_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .order_by" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.start_time" ], [ "LOAD_METHOD", "Call.start_time.desc" ], [ "CALL_METHOD", "Call.start_time.desc()" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .order_by(Call.start_time.desc())" ], [ "BINARY_SUBSCR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .order_by(Call.start_time.desc())[:100]" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "CALL_FUNCTION", "OrderedDict()" ], [ "LOAD_FAST", "recent_calls" ], [ "LOAD_GLOBAL", "is_ipython_cell" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.file" ], [ "CALL_FUNCTION", "is_ipython_cell(row.file)" ], [ "LOAD_FAST", "files" ], [ "LOAD_METHOD", "files.setdefault" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.file" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "CALL_FUNCTION", "OrderedDict()" ], [ "CALL_METHOD", "files.setdefault(\n row.file, OrderedDict()\n )" ], [ "LOAD_METHOD", "files.setdefault(\n row.file, OrderedDict()\n ).setdefault" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.name" ], [ "LOAD_FAST", "row" ], [ "CALL_METHOD", "files.setdefault(\n row.file, OrderedDict()\n ).setdefault(\n row.name, row\n )" ], [ "LOAD_FAST", "all_paths" ], [ "LOAD_FAST", "files" ], [ "LOAD_METHOD", "files.setdefault" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "CALL_FUNCTION", "OrderedDict()" ], [ "CALL_METHOD", "files.setdefault(\n path, OrderedDict()\n )" ], [ "LOAD_GLOBAL", "partial" ], [ "LOAD_GLOBAL", "short_path" ], [ "LOAD_FAST", "all_paths" ], [ "CALL_FUNCTION_KW", "partial(short_path, all_paths=all_paths)" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "short" ], [ "LOAD_FAST", "files" ], [ "CALL_FUNCTION_KW", "render_template('index.html',\n short=short,\n files=files)" ], [ "LOAD_GLOBAL", "fix_abs_path" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "fix_abs_path(path)" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_columns" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.basic_columns" ], [ "BINARY_ADD", "Call.basic_columns + Function.basic_columns" ], [ "CALL_FUNCTION_EX", "session.query(*(Call.basic_columns + Function.basic_columns))" ], [ "LOAD_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)" ], [ "LOAD_ATTR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION_KW", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path)" ], [ "LOAD_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path)\n .subquery" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path)\n .subquery('filtered_calls')" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.query" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.name" ], [ "LOAD_GLOBAL", "sqlalchemy" ], [ "LOAD_ATTR", "sqlalchemy.func" ], [ "LOAD_METHOD", "sqlalchemy.func.max" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.start_time" ], [ "CALL_METHOD", "sqlalchemy.func.max(filtered_calls.c.start_time)" ], [ "LOAD_METHOD", "sqlalchemy.func.max(filtered_calls.c.start_time).label" ], [ "CALL_METHOD", "sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')" ], [ "CALL_METHOD", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n )" ], [ "LOAD_METHOD", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n ).group_by" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.name" ], [ "CALL_METHOD", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n ).group_by(\n filtered_calls.c.name,\n )" ], [ "LOAD_METHOD", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n ).group_by(\n filtered_calls.c.name,\n ).subquery" ], [ "CALL_METHOD", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n ).group_by(\n filtered_calls.c.name,\n ).subquery('latest_calls')" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.query" ], [ "LOAD_FAST", "filtered_calls" ], [ "CALL_METHOD", "session.query(filtered_calls)" ], [ "LOAD_METHOD", "session.query(filtered_calls).join" ], [ "LOAD_FAST", "latest_calls" ], [ "LOAD_GLOBAL", "sqlalchemy" ], [ "LOAD_METHOD", "sqlalchemy.and_" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.name" ], [ "LOAD_FAST", "latest_calls" ], [ "LOAD_ATTR", "latest_calls.c" ], [ "LOAD_ATTR", "latest_calls.c.name" ], [ "COMPARE_OP", "filtered_calls.c.name == latest_calls.c.name" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.start_time" ], [ "LOAD_FAST", "latest_calls" ], [ "LOAD_ATTR", "latest_calls.c" ], [ "LOAD_ATTR", "latest_calls.c.maxtime" ], [ "COMPARE_OP", "filtered_calls.c.start_time == latest_calls.c.maxtime" ], [ "CALL_METHOD", "sqlalchemy.and_(\n filtered_calls.c.name == latest_calls.c.name,\n filtered_calls.c.start_time == latest_calls.c.maxtime,\n )" ], [ "CALL_METHOD", "session.query(filtered_calls).join(\n latest_calls,\n sqlalchemy.and_(\n filtered_calls.c.name == latest_calls.c.name,\n filtered_calls.c.start_time == latest_calls.c.maxtime,\n )\n )" ], [ "LOAD_METHOD", "session.query(filtered_calls).join(\n latest_calls,\n sqlalchemy.and_(\n filtered_calls.c.name == latest_calls.c.name,\n filtered_calls.c.start_time == latest_calls.c.maxtime,\n )\n ).order_by" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.start_time" ], [ "LOAD_METHOD", "filtered_calls.c.start_time.desc" ], [ "CALL_METHOD", "filtered_calls.c.start_time.desc()" ], [ "CALL_METHOD", "session.query(filtered_calls).join(\n latest_calls,\n sqlalchemy.and_(\n filtered_calls.c.name == latest_calls.c.name,\n filtered_calls.c.start_time == latest_calls.c.maxtime,\n )\n ).order_by(filtered_calls.c.start_time.desc())" ], [ "LOAD_GLOBAL", "group_by_attr" ], [ "LOAD_FAST", "query" ], [ "CALL_FUNCTION", "group_by_attr(query, 'type')" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.query" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.name" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.type" ], [ "CALL_METHOD", "session.query(Function.name, Function.type)" ], [ "LOAD_ATTR", "session.query(Function.name, Function.type)\n .filter_by" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION_KW", "session.query(Function.name, Function.type)\n .filter_by(file=path)" ], [ "LOAD_METHOD", "session.query(Function.name, Function.type)\n .filter_by(file=path)\n .distinct" ], [ "CALL_METHOD", "session.query(Function.name, Function.type)\n .filter_by(file=path)\n .distinct()" ], [ "CALL_FUNCTION", "sorted(session.query(Function.name, Function.type)\n .filter_by(file=path)\n .distinct())" ], [ "LOAD_FAST", "query" ], [ "LOAD_FAST", "all_funcs" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.name" ], [ "LOAD_FAST", "func_names" ], [ "COMPARE_OP", "func.name not in func_names" ], [ "LOAD_FAST", "funcs" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.type" ], [ "BINARY_SUBSCR", "funcs[func.type]" ], [ "LOAD_METHOD", "funcs[func.type].append" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "funcs[func.type].append(func)" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "funcs" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "COMPARE_OP", "path == IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "basename" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "basename(path)" ], [ "CALL_FUNCTION_KW", "render_template('file.html',\n funcs=funcs,\n is_ipython=path == IPYTHON_FILE_PATH,\n full_path=path,\n short_path=basename(path))" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.name" ], [ "LOAD_GLOBAL", "fix_abs_path" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "fix_abs_path(path)" ], [ "LOAD_GLOBAL", "get_calls" ], [ "LOAD_FAST", "session" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "func_name" ], [ "CALL_FUNCTION", "get_calls(session, path, func_name, 200)" ], [ "LOAD_FAST", "query" ], [ "LOAD_FAST", "query" ], [ "BINARY_SUBSCR", "query[0]" ], [ "LOAD_FAST", "query" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.query" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_METHOD", "session.query(Function)" ], [ "LOAD_ATTR", "session.query(Function).filter_by" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "func_name" ], [ "CALL_FUNCTION_KW", "session.query(Function).filter_by(file=path, name=func_name)" ], [ "BINARY_SUBSCR", "session.query(Function).filter_by(file=path, name=func_name)[0]" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "func" ], [ "LOAD_GLOBAL", "basename" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "basename(path)" ], [ "LOAD_FAST", "calls" ], [ "CALL_FUNCTION_KW", "render_template('function.html',\n func=func,\n short_path=basename(path),\n calls=calls)" ], [ "LOAD_GLOBAL", "withattrs" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_FUNCTION", "Call()" ], [ "LOAD_FAST", "row" ], [ "LOAD_METHOD", "row._asdict" ], [ "CALL_METHOD", "row._asdict()" ], [ "CALL_FUNCTION_EX", "withattrs(Call(), **row._asdict())" ], [ "LOAD_GLOBAL", "fix_abs_path" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "fix_abs_path(path)" ], [ "LOAD_GLOBAL", "get_calls" ], [ "LOAD_FAST", "session" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "func_name" ], [ "CALL_FUNCTION", "get_calls(session, path, func_name, 1)" ], [ "BINARY_SUBSCR", "get_calls(session, path, func_name, 1)[0]" ], [ "LOAD_GLOBAL", "jsonify" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.id" ], [ "LOAD_GLOBAL", "url_for" ], [ "LOAD_GLOBAL", "call_view" ], [ "LOAD_ATTR", "call_view.__name__" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.id" ], [ "CALL_FUNCTION_KW", "url_for(call_view.__name__,\n call_id=call.id)" ], [ "CALL_FUNCTION_KW", "dict(\n id=call.id,\n url=url_for(call_view.__name__,\n call_id=call.id),\n )" ], [ "CALL_FUNCTION", "jsonify(dict(\n id=call.id,\n url=url_for(call_view.__name__,\n call_id=call.id),\n ))" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_columns" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.basic_columns" ], [ "BINARY_ADD", "Call.basic_columns + Function.basic_columns" ], [ "CALL_FUNCTION_EX", "session.query(*(Call.basic_columns + Function.basic_columns))" ], [ "LOAD_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)" ], [ "LOAD_ATTR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "func_name" ], [ "CALL_FUNCTION_KW", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path, name=func_name)" ], [ "LOAD_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path, name=func_name)\n .order_by" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.start_time" ], [ "LOAD_METHOD", "Call.start_time.desc" ], [ "CALL_METHOD", "Call.start_time.desc()" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path, name=func_name)\n .order_by(Call.start_time.desc())" ], [ "LOAD_FAST", "limit" ], [ "BINARY_SUBSCR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path, name=func_name)\n .order_by(Call.start_time.desc())[:limit]" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_METHOD", "session.query(Call)" ], [ "LOAD_ATTR", "session.query(Call).filter_by" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION_KW", "session.query(Call).filter_by(id=call_id)" ], [ "LOAD_METHOD", "session.query(Call).filter_by(id=call_id).one" ], [ "CALL_METHOD", "session.query(Call).filter_by(id=call_id).one()" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.function" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "template" ], [ "LOAD_GLOBAL", "basename" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.file" ], [ "CALL_FUNCTION", "basename(func.file)" ], [ "LOAD_FAST", "call" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION_KW", "render_template(template,\n short_path=basename(func.file),\n call=call,\n func=func)" ], [ "LOAD_GLOBAL", "base_call_view" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION", "base_call_view(call_id, 'call.html')" ], [ "LOAD_GLOBAL", "base_call_view" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION", "base_call_view(call_id, 'ipython_call.html')" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION_KW", "render_template('ipython_iframe.html',\n container_id='1234',\n port=7777,\n call_id=call_id)" ], [ "LOAD_GLOBAL", "request" ], [ "LOAD_ATTR", "request.environ" ], [ "LOAD_METHOD", "request.environ.get" ], [ "CALL_METHOD", "request.environ.get('werkzeug.server.shutdown')" ], [ "LOAD_FAST", "func" ], [ "COMPARE_OP", "func is None" ], [ "LOAD_GLOBAL", "RuntimeError" ], [ "CALL_FUNCTION", "RuntimeError('Not running with the Werkzeug Server')" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "func()" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_METHOD", "session.query(Call)" ], [ "LOAD_ATTR", "session.query(Call).filter_by" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION_KW", "session.query(Call).filter_by(id=call_id)" ], [ "LOAD_METHOD", "session.query(Call).filter_by(id=call_id).one" ], [ "CALL_METHOD", "session.query(Call).filter_by(id=call_id).one()" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.function" ], [ "LOAD_GLOBAL", "DecentJSONEncoder" ], [ "CALL_FUNCTION", "DecentJSONEncoder()" ], [ "LOAD_METHOD", "DecentJSONEncoder().encode" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.parsed_data" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_METHOD", "Call.basic_dict" ], [ "LOAD_FAST", "call" ], [ "CALL_METHOD", "Call.basic_dict(call)" ], [ "CALL_FUNCTION_EX", "dict(data=call.parsed_data, **Call.basic_dict(call))" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.parsed_data" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_METHOD", "Function.basic_dict" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "Function.basic_dict(func)" ], [ "CALL_FUNCTION_EX", "dict(data=func.parsed_data, **Function.basic_dict(func))" ], [ "CALL_FUNCTION_KW", "dict(\n call=dict(data=call.parsed_data, **Call.basic_dict(call)),\n function=dict(data=func.parsed_data, **Function.basic_dict(func)))" ], [ "CALL_METHOD", "DecentJSONEncoder().encode(dict(\n call=dict(data=call.parsed_data, **Call.basic_dict(call)),\n function=dict(data=func.parsed_data, **Function.basic_dict(func))))" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_columns" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.data" ], [ "BINARY_ADD", "Call.basic_columns + (Function.data,)" ], [ "CALL_FUNCTION_EX", "session.query(*Call.basic_columns + (Function.data,))" ], [ "LOAD_METHOD", "session.query(*Call.basic_columns + (Function.data,))\n .join" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_METHOD", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)" ], [ "LOAD_ATTR", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by" ], [ "LOAD_FAST", "body_hash" ], [ "CALL_FUNCTION_KW", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by(body_hash=body_hash)" ], [ "LOAD_METHOD", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by(body_hash=body_hash)\n .order_by" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.start_time" ], [ "LOAD_METHOD", "Call.start_time.desc" ], [ "CALL_METHOD", "Call.start_time.desc()" ], [ "CALL_METHOD", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by(body_hash=body_hash)\n .order_by(Call.start_time.desc())" ], [ "BINARY_SUBSCR", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by(body_hash=body_hash)\n .order_by(Call.start_time.desc())[:200]" ], [ "LOAD_FAST", "query" ], [ "LOAD_FAST", "query" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "function_data_set" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_METHOD", "json.loads" ], [ "LOAD_DEREF", "function_data" ], [ "CALL_METHOD", "json.loads(function_data)" ], [ "LOAD_FAST", "add" ], [ "LOAD_FAST", "ranges" ], [ "CALL_FUNCTION", "add('node_ranges', ranges)" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "add" ], [ "LOAD_FAST", "current_loop_ranges" ], [ "CALL_FUNCTION", "add('loop_ranges', current_loop_ranges)" ], [ "LOAD_FAST", "loop_ranges" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "current_loop_ranges" ], [ "COMPARE_OP", "loop_ranges in (set(), current_loop_ranges)" ], [ "LOAD_FAST", "current_loop_ranges" ], [ "LOAD_FAST", "ranges" ], [ "LOAD_FAST", "loop_ranges" ], [ "LOAD_GLOBAL", "DecentJSONEncoder" ], [ "CALL_FUNCTION", "DecentJSONEncoder()" ], [ "LOAD_METHOD", "DecentJSONEncoder().encode" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "calls" ], [ "LOAD_FAST", "ranges" ], [ "LOAD_FAST", "loop_ranges" ], [ "CALL_FUNCTION_KW", "dict(\n calls=calls, ranges=ranges, loop_ranges=loop_ranges)" ], [ "CALL_METHOD", "DecentJSONEncoder().encode(dict(\n calls=calls, ranges=ranges, loop_ranges=loop_ranges))" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_METHOD", "Call.basic_dict" ], [ "LOAD_GLOBAL", "withattrs" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_FUNCTION", "Call()" ], [ "LOAD_FAST", "row" ], [ "LOAD_METHOD", "row._asdict" ], [ "CALL_METHOD", "row._asdict()" ], [ "CALL_FUNCTION_EX", "withattrs(Call(), **row._asdict())" ], [ "CALL_METHOD", "Call.basic_dict(withattrs(Call(), **row._asdict()))" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.data" ], [ "LOAD_DEREF", "function_data" ], [ "LOAD_FAST", "key" ], [ "BINARY_SUBSCR", "function_data[key]" ], [ "LOAD_FAST", "ranges_set" ], [ "LOAD_METHOD", "ranges_set.add" ], [ "LOAD_FAST", "node" ], [ "BINARY_SUBSCR", "node['start']" ], [ "LOAD_FAST", "node" ], [ "BINARY_SUBSCR", "node['end']" ], [ "CALL_METHOD", "ranges_set.add((node['start'], node['end']))" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "CALL_FUNCTION_KW", "dict(start=start, end=end)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "CALL_FUNCTION_KW", "dict(start=start, end=end)" ], [ "LOAD_GLOBAL", "request" ], [ "LOAD_METHOD", "request.get_json" ], [ "CALL_METHOD", "request.get_json()" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.query" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.body_hash" ], [ "LOAD_GLOBAL", "sqlalchemy" ], [ "LOAD_ATTR", "sqlalchemy.func" ], [ "LOAD_METHOD", "sqlalchemy.func.count" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.id" ], [ "CALL_METHOD", "sqlalchemy.func.count(Call.id)" ], [ "CALL_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))" ], [ "LOAD_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)" ], [ "LOAD_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)\n .filter" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.body_hash" ], [ "LOAD_METHOD", "Function.body_hash.in_" ], [ "LOAD_FAST", "hashes" ], [ "CALL_METHOD", "Function.body_hash.in_(hashes)" ], [ "CALL_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)\n .filter(Function.body_hash.in_(hashes))" ], [ "LOAD_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)\n .filter(Function.body_hash.in_(hashes))\n .group_by" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.body_hash" ], [ "CALL_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)\n .filter(Function.body_hash.in_(hashes))\n .group_by(Function.body_hash)" ], [ "LOAD_GLOBAL", "DecentJSONEncoder" ], [ "CALL_FUNCTION", "DecentJSONEncoder()" ], [ "LOAD_METHOD", "DecentJSONEncoder().encode" ], [ "LOAD_FAST", "query" ], [ "CALL_METHOD", "DecentJSONEncoder().encode([\n dict(hash=h, count=count)\n for h, count in query\n ])" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "h" ], [ "LOAD_FAST", "count" ], [ "CALL_FUNCTION_KW", "dict(hash=h, count=count)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "argv" ], [ "CALL_FUNCTION", "len(argv)" ], [ "COMPARE_OP", "len(argv) == 1" ], [ "LOAD_FAST", "argv" ], [ "BINARY_SUBSCR", "argv[0]" ], [ "LOAD_METHOD", "argv[0].isdigit" ], [ "CALL_METHOD", "argv[0].isdigit()" ], [ "LOAD_FAST", "argv" ], [ "LOAD_METHOD", "argv.insert" ], [ "CALL_METHOD", "argv.insert(0, '--port')" ], [ "LOAD_GLOBAL", "argparse" ], [ "LOAD_ATTR", "argparse.ArgumentParser" ], [ "CALL_FUNCTION_KW", "argparse.ArgumentParser(description=\"Bird's Eye: A graphical Python debugger\")" ], [ "LOAD_FAST", "parser" ], [ "LOAD_ATTR", "parser.add_argument" ], [ "LOAD_GLOBAL", "int" ], [ "CALL_FUNCTION_KW", "parser.add_argument('-p', '--port', help='HTTP port, default is 7777', default=7777, type=int)" ], [ "LOAD_FAST", "parser" ], [ "LOAD_ATTR", "parser.add_argument" ], [ "CALL_FUNCTION_KW", "parser.add_argument('--host', help=\"HTTP host, default is 'localhost'\", default='localhost')" ], [ "LOAD_FAST", "parser" ], [ "LOAD_METHOD", "parser.parse_args" ], [ "LOAD_FAST", "argv" ], [ "CALL_METHOD", "parser.parse_args(argv)" ], [ "LOAD_GLOBAL", "app" ], [ "LOAD_ATTR", "app.run" ], [ "LOAD_FAST", "args" ], [ "LOAD_ATTR", "args.port" ], [ "LOAD_FAST", "args" ], [ "LOAD_ATTR", "args.host" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.environ" ], [ "LOAD_METHOD", "os.environ.get" ], [ "CALL_METHOD", "os.environ.get('BIRDSEYE_RELOADER')" ], [ "COMPARE_OP", "os.environ.get('BIRDSEYE_RELOADER') == '1'" ], [ "CALL_FUNCTION_KW", "app.run(\n port=args.port,\n host=args.host,\n use_reloader=os.environ.get('BIRDSEYE_RELOADER') == '1',\n )" ] ], "tests.py": [ [ "LOAD_NAME", "unittest" ], [ "LOAD_ATTR", "unittest.TestCase" ], [ "LOAD_NAME", "unittest" ], [ "LOAD_ATTR", "unittest.TestCase" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "TestFile" ], [ "CALL_FUNCTION", "TestFile()" ], [ "LOAD_METHOD", "TestFile().test_file" ], [ "CALL_METHOD", "TestFile().test_file()" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "Tester" ], [ "CALL_FUNCTION", "Tester()" ], [ "LOAD_NAME", "tester" ], [ "CALL_FUNCTION", "tester([1, 2, 3])" ], [ "COMPARE_OP", "tester([1, 2, 3]) == [1, 2, 3]" ], [ "LOAD_NAME", "tester" ], [ "LOAD_ATTR", "tester.asd" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester.asd is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_SUBSCR", "tester[19]" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester[19] is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_POWER", "tester ** 4" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester ** 4 is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_MULTIPLY", "tester * 3" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester * 3 is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_SUBTRACT", "tester - 2" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester - 2 is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_ADD", "tester + 1" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester + 1 is tester" ], [ "LOAD_NAME", "tester" ], [ "UNARY_NEGATIVE", "-tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "-tester is tester" ], [ "LOAD_NAME", "tester" ], [ "UNARY_POSITIVE", "+tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "+tester is tester" ], [ "LOAD_NAME", "tester" ], [ "UNARY_INVERT", "~tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "~tester is tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester < 7" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "(tester < 7) is tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester >= 78" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "(tester >= 78) is tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester != 79" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "(tester != 79) is tester" ], [ "LOAD_NAME", "tester" ], [ "LOAD_METHOD", "tester.foo" ], [ "CALL_METHOD", "tester.foo(45, False)" ], [ "COMPARE_OP", "tester.foo(45, False) == 45" ], [ "LOAD_NAME", "__name__" ], [ "COMPARE_OP", "__name__ == '__main__'" ], [ "LOAD_NAME", "unittest" ], [ "LOAD_METHOD", "unittest.main" ], [ "CALL_METHOD", "unittest.main()" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(1)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(2)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(3)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(9\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n 8)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n 99\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(33)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([4,\n 5, 6, [\n 7]])" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "LOAD_GLOBAL", "decorator_with_args" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('123')" ], [ "LOAD_GLOBAL", "int" ], [ "CALL_FUNCTION", "int()" ], [ "CALL_FUNCTION_KW", "decorator_with_args(tester('123'), x=int())" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "tuple([1, 2])" ], [ "CALL_FUNCTION", "list(tuple([1, 2]))" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "CALL_FUNCTION_KW", "tester(list(tuple([1, 2])), returns=empty_decorator)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "tuple(\n [3, 4])" ], [ "CALL_FUNCTION", "list(\n tuple(\n [3, 4]))" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "CALL_FUNCTION_KW", "tester(\n list(\n tuple(\n [3, 4])),\n returns=empty_decorator)" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "LOAD_GLOBAL", "decorator_with_args" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "str()" ], [ "LOAD_GLOBAL", "int" ], [ "CALL_FUNCTION", "int()" ], [ "CALL_FUNCTION_KW", "decorator_with_args(\n str(),\n x=int())" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "tuple([5, 6])" ], [ "CALL_FUNCTION", "list(tuple([5, 6]))" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "CALL_FUNCTION_KW", "tester(list(tuple([5, 6])), returns=empty_decorator)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "tuple([7, 8])" ], [ "CALL_FUNCTION", "list(tuple([7, 8]))" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "CALL_FUNCTION_KW", "tester(list(tuple([7, 8])), returns=empty_decorator)" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "LOAD_GLOBAL", "decorator_with_args" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('sdf')" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('123234')" ], [ "CALL_FUNCTION_KW", "decorator_with_args(tester('sdf'), x=tester('123234'))" ], [ "CALL_FUNCTION", "decorator_with_args(tester('sdf'), x=tester('123234'))" ], [ "CALL_FUNCTION", "empty_decorator" ], [ "CALL_FUNCTION", "tester(list(tuple([7, 8])), returns=empty_decorator)" ], [ "CALL_FUNCTION", "tester(list(tuple([5, 6])), returns=empty_decorator)" ], [ "CALL_FUNCTION", "decorator_with_args(\n str(),\n x=int())" ], [ "CALL_FUNCTION", "empty_decorator" ], [ "CALL_FUNCTION", "tester(\n list(\n tuple(\n [3, 4])),\n returns=empty_decorator)" ], [ "CALL_FUNCTION", "tester(list(tuple([1, 2])), returns=empty_decorator)" ], [ "CALL_FUNCTION", "decorator_with_args(tester('123'), x=int())" ], [ "CALL_FUNCTION", "empty_decorator" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "str([{tester(x) for x in [1]}, {tester(y) for y in [1]}])" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "str([{tester(x) for x in [1]},\n {tester(x) for x in [1]}])" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "list(tester(x) for x in [1])" ], [ "CALL_FUNCTION", "str([{tester(x) for x in [1]}, list(tester(x) for x in [1])])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "y" ], [ "CALL_FUNCTION", "tester(y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertEqual" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(3)" ], [ "CALL_FUNCTION", "(lambda x: (tester(x), tester(x)))(tester(3))" ], [ "CALL_METHOD", "self.assertEqual(\n (lambda x: (tester(x), tester(x)))(tester(3)),\n (3, 3),\n )" ], [ "CALL_FUNCTION", "(lambda: (lambda: tester(1))())()" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertEqual" ], [ "CALL_FUNCTION", "(lambda: [tester(x) for x in tester([1, 2])])()" ], [ "CALL_METHOD", "self.assertEqual(\n (lambda: [tester(x) for x in tester([1, 2])])(),\n [1, 2],\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "CALL_FUNCTION", "(lambda: tester(1))()" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(1)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x): {tester(b+x): {tester(c+x) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_FAST", "foo" ], [ "CALL_FUNCTION", "foo()" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "CALL_FUNCTION", "tester(a+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "CALL_FUNCTION", "tester(b+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "CALL_FUNCTION", "tester(c+x)" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x): {tester(b+x): {tester(c+x) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+y): {tester(b+y): {tester(c+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x+y): {tester(b+x+y): {tester(c+x+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_FAST", "bar" ], [ "CALL_FUNCTION", "bar()" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "CALL_FUNCTION", "tester(a+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "CALL_FUNCTION", "tester(b+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "CALL_FUNCTION", "tester(c+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+y" ], [ "CALL_FUNCTION", "tester(a+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+y" ], [ "CALL_FUNCTION", "tester(b+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+y" ], [ "CALL_FUNCTION", "tester(c+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+x+y" ], [ "CALL_FUNCTION", "tester(a+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+x+y" ], [ "CALL_FUNCTION", "tester(b+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+x+y" ], [ "CALL_FUNCTION", "tester(c+x+y)" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x): {tester(b+x): {tester(c+x) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+y): {tester(b+y): {tester(c+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x+y): {tester(b+x+y): {tester(c+x+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x+y+z): {tester(b+x+y+z): {tester(c+x+y+z) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "CALL_FUNCTION", "tester(a+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "CALL_FUNCTION", "tester(b+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "CALL_FUNCTION", "tester(c+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+y" ], [ "CALL_FUNCTION", "tester(a+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+y" ], [ "CALL_FUNCTION", "tester(b+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+y" ], [ "CALL_FUNCTION", "tester(c+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+x+y" ], [ "CALL_FUNCTION", "tester(a+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+x+y" ], [ "CALL_FUNCTION", "tester(b+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+x+y" ], [ "CALL_FUNCTION", "tester(c+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+x+y" ], [ "LOAD_DEREF", "z" ], [ "BINARY_ADD", "a+x+y+z" ], [ "CALL_FUNCTION", "tester(a+x+y+z)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+x+y" ], [ "LOAD_DEREF", "z" ], [ "BINARY_ADD", "b+x+y+z" ], [ "CALL_FUNCTION", "tester(b+x+y+z)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+x+y" ], [ "LOAD_DEREF", "z" ], [ "BINARY_ADD", "c+x+y+z" ], [ "CALL_FUNCTION", "tester(c+x+y+z)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION_KW", "dict(x=tester)" ], [ "BINARY_SUBSCR", "dict(x=tester)['x']" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "dict(x=tester)['x'](tester)" ], [ "CALL_FUNCTION_KW", "dict(x=tester)['x'](tester)(3, check_func=False)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertRaises" ], [ "LOAD_GLOBAL", "TypeError" ], [ "CALL_METHOD", "self.assertRaises(TypeError)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2, 3])" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(0)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(4)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(5)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "tester(ValueError)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(9)" ], [ "LOAD_GLOBAL", "TypeError" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(10)" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "str()" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertRaises" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "Exception" ], [ "CALL_FUNCTION", "tester(Exception)" ], [ "CALL_METHOD", "self.assertRaises(tester(Exception))" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(0)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(0)" ], [ "LOAD_GLOBAL", "tester" ], [ "BINARY_TRUE_DIVIDE", "1 / 0" ], [ "CALL_FUNCTION", "tester(1 / 0)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "gen" ], [ "CALL_FUNCTION", "gen()" ], [ "CALL_FUNCTION", "list(gen())" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "gen2" ], [ "CALL_FUNCTION", "list(gen2)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(4)" ], [ "LOAD_GLOBAL", "time" ], [ "LOAD_METHOD", "time.time" ], [ "CALL_METHOD", "time.time()" ], [ "LOAD_GLOBAL", "range" ], [ "CALL_FUNCTION", "range(10000)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_METHOD", "Source.executing" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.currentframe" ], [ "CALL_METHOD", "inspect.currentframe()" ], [ "CALL_METHOD", "Source.executing(inspect.currentframe())" ], [ "LOAD_ATTR", "Source.executing(inspect.currentframe()).node" ], [ "LOAD_FAST", "node" ], [ "COMPARE_OP", "node is None" ], [ "LOAD_FAST", "new_node" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertIs" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "new_node" ], [ "CALL_METHOD", "self.assertIs(node, new_node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertLess" ], [ "LOAD_GLOBAL", "time" ], [ "LOAD_METHOD", "time.time" ], [ "CALL_METHOD", "time.time()" ], [ "LOAD_FAST", "start" ], [ "BINARY_SUBTRACT", "time.time() - start" ], [ "CALL_METHOD", "self.assertLess(time.time() - start, 1)" ], [ "LOAD_FAST", "check" ], [ "CALL_FUNCTION", "check(u'# coding=utf8\\n\u00e9', 'utf8')" ], [ "LOAD_FAST", "check" ], [ "CALL_FUNCTION", "check(u'# coding=gbk\\n\u00e9', 'gbk')" ], [ "LOAD_FAST", "check" ], [ "LOAD_GLOBAL", "UnicodeDecodeError" ], [ "CALL_FUNCTION_KW", "check(u'# coding=utf8\\n\u00e9', 'gbk', exception=UnicodeDecodeError)" ], [ "LOAD_FAST", "check" ], [ "CALL_FUNCTION_KW", "check(u'# coding=gbk\\n\u00e9', 'utf8', matches=False)" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_FAST", "check" ], [ "CALL_FUNCTION", "check(u'\u00e9', 'utf8')" ], [ "LOAD_FAST", "check" ], [ "LOAD_GLOBAL", "SyntaxError" ], [ "CALL_FUNCTION_KW", "check(u'\u00e9', 'gbk', exception=SyntaxError)" ], [ "LOAD_FAST", "source" ], [ "LOAD_METHOD", "source.encode" ], [ "LOAD_FAST", "encoding" ], [ "CALL_METHOD", "source.encode(encoding)" ], [ "LOAD_FAST", "exception" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self.assertRaises" ], [ "LOAD_FAST", "exception" ], [ "CALL_METHOD", "self.assertRaises(exception)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_METHOD", "Source.decode_source" ], [ "LOAD_FAST", "encoded" ], [ "CALL_METHOD", "Source.decode_source(encoded)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_METHOD", "Source.decode_source" ], [ "LOAD_FAST", "encoded" ], [ "CALL_METHOD", "Source.decode_source(encoded)" ], [ "LOAD_FAST", "matches" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self.assertEqual" ], [ "LOAD_FAST", "decoded" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "self.assertEqual(decoded, source)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self.assertNotEqual" ], [ "LOAD_FAST", "decoded" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "self.assertNotEqual(decoded, source)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('a')" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('''\n ab''')" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('''\n abc\n def\n '''\n )" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n '''\n 123\n 456\n '''\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n '''\n 345\n 456786\n '''\n )" ], [ "CALL_FUNCTION", "str([\n tester(\n '''\n 123\n 456\n '''\n ),\n tester(\n '''\n 345\n 456786\n '''\n ),\n ])" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n [\n '''\n 123\n 456\n '''\n '''\n 345\n 456786\n '''\n ,\n '''\n 123\n 456\n ''',\n '''\n 345\n 456786\n '''\n ]\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(1)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(2)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(3)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_METHOD", "Source.for_filename" ], [ "LOAD_GLOBAL", "__file__" ], [ "CALL_METHOD", "Source.for_filename(__file__)" ], [ "LOAD_METHOD", "Source.for_filename(__file__).code_qualname" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.__code__" ], [ "CALL_METHOD", "Source.for_filename(__file__).code_qualname(func.__code__)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertEqual" ], [ "LOAD_FAST", "qn" ], [ "LOAD_FAST", "qualname" ], [ "CALL_METHOD", "self.assertEqual(qn, qualname)" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_FAST", "check_actual_qualname" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertEqual" ], [ "LOAD_FAST", "qn" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.__qualname__" ], [ "CALL_METHOD", "self.assertEqual(qn, func.__qualname__)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertTrue" ], [ "LOAD_FAST", "qn" ], [ "LOAD_METHOD", "qn.endswith" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.__name__" ], [ "CALL_METHOD", "qn.endswith(func.__name__)" ], [ "CALL_METHOD", "self.assertTrue(qn.endswith(func.__name__))" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assert_qualname" ], [ "LOAD_GLOBAL", "C" ], [ "LOAD_ATTR", "C.f" ], [ "CALL_METHOD", "self.assert_qualname(C.f, 'C.f')" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assert_qualname" ], [ "LOAD_GLOBAL", "C" ], [ "LOAD_ATTR", "C.D" ], [ "LOAD_ATTR", "C.D.g" ], [ "CALL_METHOD", "self.assert_qualname(C.D.g, 'C.D.g')" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assert_qualname" ], [ "LOAD_GLOBAL", "f" ], [ "CALL_METHOD", "self.assert_qualname(f, 'f')" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assert_qualname" ], [ "LOAD_GLOBAL", "f" ], [ "CALL_FUNCTION", "f()" ], [ "CALL_METHOD", "self.assert_qualname(f(), 'f..g')" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assert_qualname" ], [ "LOAD_GLOBAL", "C" ], [ "LOAD_ATTR", "C.D" ], [ "LOAD_METHOD", "C.D.h" ], [ "CALL_METHOD", "C.D.h()" ], [ "CALL_METHOD", "self.assert_qualname(C.D.h(), 'C.D.h..i..j')" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assert_qualname" ], [ "LOAD_GLOBAL", "lamb" ], [ "CALL_METHOD", "self.assert_qualname(lamb, '')" ], [ "LOAD_GLOBAL", "lambda_maker" ], [ "CALL_FUNCTION", "lambda_maker()" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assert_qualname" ], [ "LOAD_FAST", "foo" ], [ "CALL_METHOD", "self.assert_qualname(foo, 'lambda_maker..foo')" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assert_qualname" ], [ "LOAD_FAST", "foo" ], [ "LOAD_ATTR", "foo.x" ], [ "CALL_METHOD", "self.assert_qualname(foo.x, 'lambda_maker..')" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assert_qualname" ], [ "LOAD_FAST", "foo" ], [ "CALL_FUNCTION", "foo()" ], [ "CALL_METHOD", "self.assert_qualname(foo(), 'lambda_maker..foo..')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assert_qualname" ], [ "LOAD_FAST", "foo" ], [ "CALL_FUNCTION", "foo()" ], [ "CALL_FUNCTION", "foo()()" ], [ "CALL_FUNCTION_KW", "self.assert_qualname(foo()(), 'lambda_maker..foo..', check_actual_qualname=False)" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "range" ], [ "CALL_FUNCTION", "range(66000)" ], [ "CALL_FUNCTION", "list(range(66000))" ], [ "BINARY_MODULO", "'tester(6)\\n%s\\ntester(9)' % list(range(66000))" ], [ "LOAD_GLOBAL", "tempfile" ], [ "LOAD_METHOD", "tempfile.mkstemp" ], [ "CALL_METHOD", "tempfile.mkstemp()" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "compile(source, filename, 'exec')" ], [ "LOAD_GLOBAL", "open" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "open(filename, 'w')" ], [ "LOAD_FAST", "outfile" ], [ "LOAD_METHOD", "outfile.write" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "outfile.write(source)" ], [ "LOAD_GLOBAL", "exec" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "exec(code)" ], [ "LOAD_GLOBAL", "range" ], [ "CALL_FUNCTION", "range(5)" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "n" ], [ "CALL_FUNCTION", "range(n)" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "n == 1" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertEqual" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_FAST", "gen" ], [ "CALL_FUNCTION", "only(gen)" ], [ "CALL_METHOD", "self.assertEqual(only(gen), 0)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertRaises" ], [ "LOAD_GLOBAL", "NotOneValueFound" ], [ "CALL_METHOD", "self.assertRaises(NotOneValueFound)" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_FAST", "gen" ], [ "CALL_FUNCTION", "only(gen)" ], [ "LOAD_FAST", "i" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_METHOD", "os.path.join" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_METHOD", "os.path.dirname" ], [ "LOAD_GLOBAL", "__file__" ], [ "CALL_METHOD", "os.path.dirname(__file__)" ], [ "CALL_METHOD", "os.path.join(os.path.dirname(__file__), 'not_code.txt', )" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_METHOD", "Source.for_filename" ], [ "LOAD_FAST", "path" ], [ "CALL_METHOD", "Source.for_filename(path)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertIsNone" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.tree" ], [ "CALL_METHOD", "self.assertIsNone(source.tree)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.currentframe" ], [ "CALL_METHOD", "inspect.currentframe()" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_METHOD", "Source.executing" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "Source.executing(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertEqual" ], [ "LOAD_FAST", "executing" ], [ "LOAD_METHOD", "executing.code_qualname" ], [ "CALL_METHOD", "executing.code_qualname()" ], [ "CALL_METHOD", "self.assertEqual(executing.code_qualname(), 'TestStuff.test_executing_methods')" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.version" ], [ "LOAD_METHOD", "sys.version.lower" ], [ "CALL_METHOD", "sys.version.lower()" ], [ "COMPARE_OP", "'pypy' not in sys.version.lower()" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertEqual" ], [ "LOAD_FAST", "executing" ], [ "LOAD_METHOD", "executing.text" ], [ "CALL_METHOD", "executing.text()" ], [ "LOAD_FAST", "text" ], [ "CALL_METHOD", "self.assertEqual(executing.text(), text)" ], [ "LOAD_FAST", "executing" ], [ "LOAD_METHOD", "executing.text_range" ], [ "CALL_METHOD", "executing.text_range()" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertEqual" ], [ "LOAD_FAST", "executing" ], [ "LOAD_ATTR", "executing.source" ], [ "LOAD_ATTR", "executing.source.text" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "BINARY_SUBSCR", "executing.source.text[start:end]" ], [ "LOAD_FAST", "text" ], [ "CALL_METHOD", "self.assertEqual(executing.source.text[start:end], text)" ], [ "LOAD_GLOBAL", "C" ], [ "CALL_FUNCTION", "C()" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_FAST", "c" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.x" ], [ "LOAD_ATTR", "c.x.x" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.x" ], [ "LOAD_ATTR", "c.x.y" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.y" ], [ "LOAD_ATTR", "c.y.x" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.y" ], [ "LOAD_ATTR", "c.y.y" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.x" ], [ "LOAD_ATTR", "c.x.asd" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.y" ], [ "LOAD_ATTR", "c.y.qwe" ], [ "CALL_FUNCTION", "str((c.x.x, c.x.y, c.y.x, c.y.y, c.x.asd, c.y.qwe))" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_METHOD", "Source.for_frame" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.currentframe" ], [ "CALL_METHOD", "inspect.currentframe()" ], [ "CALL_METHOD", "Source.for_frame(inspect.currentframe())" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.text" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.filename" ], [ "CALL_FUNCTION", "compile(source.text, source.filename, 'exec')" ], [ "LOAD_GLOBAL", "get_instructions" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "get_instructions(code)" ], [ "LOAD_FAST", "instructions" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.starts_line" ], [ "COMPARE_OP", "inst.starts_line is not None" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.starts_line" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.opname" ], [ "LOAD_METHOD", "inst.opname.startswith" ], [ "CALL_METHOD", "inst.opname.startswith(\n ('BINARY_', 'UNARY_', 'LOAD_ATTR', 'LOAD_METHOD', 'LOOKUP_METHOD', 'COMPARE_OP'))" ], [ "LOAD_GLOBAL", "C" ], [ "CALL_FUNCTION", "C()" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.offset" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "frame" ], [ "LOAD_GLOBAL", "globals" ], [ "CALL_FUNCTION", "globals()" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "lineno" ], [ "LOAD_FAST", "frame" ], [ "LOAD_GLOBAL", "print" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.opname" ], [ "CALL_FUNCTION", "print(inst.opname)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_METHOD", "Source.executing" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "Source.executing(frame)" ], [ "LOAD_ATTR", "Source.executing(frame).node" ], [ "COMPARE_OP", "Source.executing(frame).node is not None" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_FAST", "i" ], [ "CALL_FUNCTION", "i()" ], [ "LOAD_FAST", "j" ], [ "LOAD_FAST", "g" ], [ "LOAD_FAST", "assign" ], [ "CALL_FUNCTION", "assign(lambda: 1)" ], [ "CALL_FUNCTION", "assign(lambda: 1)" ], [ "LOAD_FAST", "foo" ], [ "LOAD_FAST", "decorator" ], [ "LOAD_DEREF", "x" ], [ "LOAD_FAST", "func" ], [ "LOAD_FAST", "func" ], [ "LOAD_NAME", "__add__" ], [ "LOAD_NAME", "__invert__" ], [ "LOAD_NAME", "__lt__" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.currentframe" ], [ "CALL_METHOD", "inspect.currentframe()" ], [ "LOAD_ATTR", "inspect.currentframe().f_back" ], [ "LOAD_ATTR", "inspect.currentframe().f_back.f_back" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_METHOD", "Source.lazycache" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "Source.lazycache(frame)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_METHOD", "Source.executing" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "Source.executing(frame)" ], [ "LOAD_ATTR", "Source.executing(frame).node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "typ" ], [ "CALL_FUNCTION", "isinstance(node, typ)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "typ" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.currentframe" ], [ "CALL_METHOD", "inspect.currentframe()" ], [ "LOAD_ATTR", "inspect.currentframe().f_back" ], [ "LOAD_ATTR", "inspect.currentframe().f_back.f_back" ], [ "LOAD_GLOBAL", "eval" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.Expression" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.Expression(node)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_filename" ], [ "CALL_FUNCTION", "compile(ast.Expression(node), frame.f_code.co_filename, 'eval')" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "CALL_FUNCTION", "eval(\n compile(ast.Expression(node), frame.f_code.co_filename, 'eval'),\n frame.f_globals,\n frame.f_locals,\n )" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "value" ], [ "COMPARE_OP", "result == value" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Call" ], [ "CALL_METHOD", "self.get_node(ast.Call)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.check" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.args" ], [ "BINARY_SUBSCR", "call.args[0]" ], [ "LOAD_FAST", "arg" ], [ "CALL_METHOD", "self.check(call.args[0], arg)" ], [ "LOAD_FAST", "check_func" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.check" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.func" ], [ "LOAD_FAST", "self" ], [ "CALL_METHOD", "self.check(call.func, self)" ], [ "LOAD_FAST", "returns" ], [ "COMPARE_OP", "returns is None" ], [ "LOAD_FAST", "arg" ], [ "LOAD_FAST", "returns" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Attribute" ], [ "CALL_METHOD", "self.get_node(ast.Attribute)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.value" ], [ "LOAD_FAST", "self" ], [ "CALL_METHOD", "self.check(node.value, self)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.attr" ], [ "LOAD_FAST", "item" ], [ "COMPARE_OP", "node.attr == item" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Subscript" ], [ "CALL_METHOD", "self.get_node(ast.Subscript)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.value" ], [ "LOAD_FAST", "self" ], [ "CALL_METHOD", "self.check(node.value, self)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.slice" ], [ "LOAD_ATTR", "node.slice.value" ], [ "LOAD_FAST", "item" ], [ "CALL_METHOD", "self.check(node.slice.value, item)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.BinOp" ], [ "CALL_METHOD", "self.get_node(ast.BinOp)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.left" ], [ "LOAD_FAST", "self" ], [ "CALL_METHOD", "self.check(node.left, self)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.right" ], [ "LOAD_FAST", "other" ], [ "CALL_METHOD", "self.check(node.right, other)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.UnaryOp" ], [ "CALL_METHOD", "self.get_node(ast.UnaryOp)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.operand" ], [ "LOAD_FAST", "self" ], [ "CALL_METHOD", "self.check(node.operand, self)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Compare" ], [ "CALL_METHOD", "self.get_node(ast.Compare)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.left" ], [ "LOAD_FAST", "self" ], [ "CALL_METHOD", "self.check(node.left, self)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.comparators" ], [ "BINARY_SUBSCR", "node.comparators[0]" ], [ "LOAD_FAST", "other" ], [ "CALL_METHOD", "self.check(node.comparators[0], other)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "func" ], [ "LOAD_GLOBAL", "empty_decorator" ] ], "tracer.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOAD_METHOD", "standard_library.install_aliases" ], [ "CALL_METHOD", "standard_library.install_aliases()" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "NamedTuple" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "Union" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "BINARY_SUBSCR", "Union[ast.expr, ast.stmt]" ], [ "BINARY_SUBSCR", "Optional[Union[ast.expr, ast.stmt]]" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.AST" ], [ "LOAD_NAME", "FrameType" ], [ "LOAD_NAME", "FrameType" ], [ "CALL_FUNCTION", "NamedTuple('EnterCallInfo', [\n\n # Node from where the call was made\n ('call_node', Optional[Union[ast.expr, ast.stmt]]),\n\n # Node where the call begins\n ('enter_node', ast.AST),\n\n # Frame from which the call was made\n ('caller_frame', FrameType),\n\n # Frame of the call\n ('current_frame', FrameType)])" ], [ "LOAD_NAME", "NamedTuple" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "Union" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "BINARY_SUBSCR", "Union[ast.expr, ast.stmt]" ], [ "BINARY_SUBSCR", "Optional[Union[ast.expr, ast.stmt]]" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.Return" ], [ "BINARY_SUBSCR", "Optional[ast.Return]" ], [ "LOAD_NAME", "FrameType" ], [ "LOAD_NAME", "FrameType" ], [ "LOAD_NAME", "Any" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "Exception" ], [ "BINARY_SUBSCR", "Optional[Exception]" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "TracebackType" ], [ "BINARY_SUBSCR", "Optional[TracebackType]" ], [ "CALL_FUNCTION", "NamedTuple('ExitCallInfo', [\n\n # Node from where the call was made\n ('call_node', Optional[Union[ast.expr, ast.stmt]]),\n\n # Node where the call explicitly returned\n ('return_node', Optional[ast.Return]),\n\n # Frame from which the call was made\n ('caller_frame', FrameType),\n\n # Frame of the call\n ('current_frame', FrameType),\n\n # Node where the call explicitly returned\n ('return_value', Any),\n\n # Exception raised in the call causing it to end,\n # will propagate to the caller\n ('exc_value', Optional[Exception]),\n\n # Traceback corresponding to exc_value\n ('exc_tb', Optional[TracebackType])])" ], [ "LOAD_NAME", "namedtuple" ], [ "CALL_FUNCTION", "namedtuple('ChangeValue', 'value')" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.NodeTransformer" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "Union" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "BINARY_SUBSCR", "Union[ast.For, ast.While, ast.comprehension]" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.PyCF_ONLY_AST" ], [ "LOAD_FAST", "flags" ], [ "BINARY_OR", "ast.PyCF_ONLY_AST | flags" ], [ "CALL_FUNCTION_KW", "compile(source, filename, 'exec', ast.PyCF_ONLY_AST | flags, dont_inherit=True)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.set_basic_node_attributes" ], [ "CALL_METHOD", "self.set_basic_node_attributes()" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_METHOD", "tracer.parse_extra" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "CALL_METHOD", "tracer.parse_extra(self.root, source, filename)" ], [ "LOAD_FAST", "new_root" ], [ "COMPARE_OP", "new_root is not None" ], [ "LOAD_FAST", "new_root" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.set_basic_node_attributes" ], [ "CALL_METHOD", "self.set_basic_node_attributes()" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.set_enter_call_nodes" ], [ "CALL_METHOD", "self.set_enter_call_nodes()" ], [ "LOAD_GLOBAL", "deepcopy" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "CALL_FUNCTION", "deepcopy(self.root)" ], [ "LOAD_GLOBAL", "_NodeVisitor" ], [ "CALL_FUNCTION", "_NodeVisitor()" ], [ "LOAD_METHOD", "_NodeVisitor().visit" ], [ "LOAD_FAST", "new_root" ], [ "CALL_METHOD", "_NodeVisitor().visit(new_root)" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "new_root" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "flags" ], [ "CALL_FUNCTION_KW", "compile(new_root, filename, \"exec\", dont_inherit=True, flags=flags)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.walk" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "CALL_METHOD", "ast.walk(self.root)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.iter_child_nodes" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.iter_child_nodes(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.nodes" ], [ "CALL_FUNCTION", "len(self.nodes)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.nodes" ], [ "LOAD_METHOD", "self.nodes.append" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self.nodes.append(node)" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "LOAD_ATTR", "self.root.body" ], [ "CALL_FUNCTION", "enumerate(self.root.body)" ], [ "LOAD_GLOBAL", "is_future_import" ], [ "LOAD_FAST", "stmt" ], [ "CALL_FUNCTION", "is_future_import(stmt)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "LOAD_ATTR", "self.root.body" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "self.root.body[:i + 1]" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.walk" ], [ "LOAD_FAST", "s" ], [ "CALL_METHOD", "ast.walk(s)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.nodes" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Module" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(node, (ast.Module, ast.FunctionDef))" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.body" ], [ "LOAD_GLOBAL", "is_future_import" ], [ "LOAD_FAST", "stmt" ], [ "CALL_FUNCTION", "is_future_import(stmt)" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_NAME", "lru_cache" ], [ "CALL_FUNCTION", "lru_cache()" ], [ "CALL_FUNCTION", "lru_cache()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "defaultdict(list)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "TracedFile" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "flags" ], [ "CALL_FUNCTION", "TracedFile(self, source, filename, flags)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._treetrace_hidden_with_stmt" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._treetrace_hidden_before_expr" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._treetrace_hidden_after_expr" ], [ "LOAD_FAST", "f" ], [ "LOAD_ATTR", "f.__name__" ], [ "LOAD_GLOBAL", "partial" ], [ "LOAD_FAST", "f" ], [ "LOAD_DEREF", "traced_file" ], [ "CALL_FUNCTION", "partial(f, traced_file)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_DEREF", "func" ], [ "LOAD_GLOBAL", "FunctionType" ], [ "CALL_FUNCTION", "isinstance(func, FunctionType)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError('You can only trace user-defined functions. '\n 'The birdseye decorator must be applied first, '\n 'at the bottom of the list.')" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.iscoroutinefunction" ], [ "LOAD_DEREF", "func" ], [ "CALL_METHOD", "inspect.iscoroutinefunction(func)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.isasyncgenfunction" ], [ "LOAD_DEREF", "func" ], [ "CALL_METHOD", "inspect.isasyncgenfunction(func)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError('You cannot trace async functions')" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_GLOBAL", "is_lambda" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "is_lambda(func)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError('You cannot trace lambdas')" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.getsourcefile" ], [ "LOAD_DEREF", "func" ], [ "CALL_METHOD", "inspect.getsourcefile(func)" ], [ "LOAD_GLOBAL", "is_ipython_cell" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "is_ipython_cell(filename)" ], [ "LOAD_FAST", "get_ipython" ], [ "CALL_FUNCTION", "get_ipython()" ], [ "LOAD_ATTR", "get_ipython().compile" ], [ "LOAD_ATTR", "get_ipython().compile.flags" ], [ "LOAD_METHOD", "''.join" ], [ "LOAD_FAST", "linecache" ], [ "LOAD_ATTR", "linecache.cache" ], [ "LOAD_FAST", "filename" ], [ "BINARY_SUBSCR", "linecache.cache[filename]" ], [ "BINARY_SUBSCR", "linecache.cache[filename][2]" ], [ "CALL_METHOD", "''.join(linecache.cache[filename][2])" ], [ "LOAD_GLOBAL", "read_source_file" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "read_source_file(filename)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "flags" ], [ "CALL_METHOD", "self.compile(source, filename, flags)" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__dict__" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError('The birdseye decorator must be applied first, '\n 'at the bottom of the list.')" ], [ "LOAD_DEREF", "find_code" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.code" ], [ "CALL_FUNCTION", "find_code(traced_file.code)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_DEREF", "code_options" ], [ "CALL_FUNCTION", "len(code_options)" ], [ "COMPARE_OP", "len(code_options) > 1" ], [ "LOAD_GLOBAL", "is_lambda" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "is_lambda(func)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError(\"Failed to trace lambda. Convert the function to a def.\")" ], [ "LOAD_DEREF", "code_options" ], [ "BINARY_SUBSCR", "code_options[0]" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__globals__" ], [ "LOAD_METHOD", "func.__globals__.update" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._trace_methods_dict" ], [ "LOAD_FAST", "traced_file" ], [ "CALL_METHOD", "self._trace_methods_dict(traced_file)" ], [ "CALL_METHOD", "func.__globals__.update(self._trace_methods_dict(traced_file))" ], [ "LOAD_GLOBAL", "FunctionType" ], [ "LOAD_FAST", "new_func_code" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__globals__" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__name__" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__defaults__" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__closure__" ], [ "CALL_FUNCTION", "FunctionType(new_func_code, func.__globals__, func.__name__, func.__defaults__, func.__closure__)" ], [ "LOAD_GLOBAL", "update_wrapper" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "update_wrapper(new_func, func)" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "getattr(func, '__kwdefaults__', None)" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_FAST", "root_code" ], [ "LOAD_ATTR", "root_code.co_consts" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.iscode" ], [ "LOAD_FAST", "const" ], [ "CALL_METHOD", "inspect.iscode(const)" ], [ "LOAD_FAST", "const" ], [ "LOAD_ATTR", "const.co_firstlineno" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__code__" ], [ "LOAD_ATTR", "func.__code__.co_firstlineno" ], [ "COMPARE_OP", "const.co_firstlineno == func.__code__.co_firstlineno" ], [ "LOAD_FAST", "const" ], [ "LOAD_ATTR", "const.co_name" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__code__" ], [ "LOAD_ATTR", "func.__code__.co_name" ], [ "COMPARE_OP", "const.co_name == func.__code__.co_name" ], [ "LOAD_FAST", "matches" ], [ "LOAD_DEREF", "code_options" ], [ "LOAD_METHOD", "code_options.append" ], [ "LOAD_FAST", "const" ], [ "CALL_METHOD", "code_options.append(const)" ], [ "LOAD_DEREF", "find_code" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "find_code(const)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.isclass" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "inspect.isclass(func)" ], [ "LOAD_GLOBAL", "TypeError" ], [ "CALL_FUNCTION", "TypeError('Decorating classes is no longer supported')" ], [ "LOAD_FAST", "func" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self.trace_function" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "self.trace_function(func)" ], [ "LOAD_FAST", "optional" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.trace_function" ], [ "LOAD_FAST", "decorator" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self.trace_function" ], [ "LOAD_DEREF", "actual_func" ], [ "CALL_METHOD", "self.trace_function(actual_func)" ], [ "LOAD_GLOBAL", "wraps" ], [ "LOAD_DEREF", "actual_func" ], [ "CALL_FUNCTION", "wraps(actual_func)" ], [ "CALL_FUNCTION", "wraps(actual_func)" ], [ "LOAD_FAST", "wrapper" ], [ "LOAD_FAST", "kwargs" ], [ "LOAD_METHOD", "kwargs.pop" ], [ "CALL_METHOD", "kwargs.pop('trace_call', False)" ], [ "LOAD_FAST", "trace_call" ], [ "LOAD_DEREF", "traced" ], [ "LOAD_DEREF", "actual_func" ], [ "LOAD_FAST", "f" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "f(*args, **kwargs)" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_METHOD", "sys._getframe" ], [ "CALL_METHOD", "sys._getframe(2)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.secondary_to_main_frames" ], [ "LOAD_METHOD", "self.secondary_to_main_frames.get" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self.secondary_to_main_frames.get(frame)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "COMPARE_OP", "frame.f_code.co_name in ('', '', '')" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_GLOBAL", "ancestors" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ancestors(node)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Lambda" ], [ "CALL_FUNCTION", "isinstance(node, (ast.FunctionDef, ast.Lambda))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.ClassDef" ], [ "CALL_FUNCTION", "isinstance(node, ast.ClassDef)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "COMPARE_OP", "frame.f_code.co_name in ('', '')" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.secondary_to_main_frames" ], [ "LOAD_FAST", "original_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.main_to_secondary_frames" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.main_to_secondary_frames[frame]" ], [ "LOAD_METHOD", "self.main_to_secondary_frames[frame].append" ], [ "LOAD_FAST", "original_frame" ], [ "CALL_METHOD", "self.main_to_secondary_frames[frame].append(original_frame)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.nodes" ], [ "LOAD_FAST", "_tree_index" ], [ "BINARY_SUBSCR", "traced_file.nodes[_tree_index]" ], [ "LOAD_GLOBAL", "cast" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "cast(ast.stmt, node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._main_frame" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self._main_frame(node)" ], [ "LOAD_GLOBAL", "_StmtContext" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "_StmtContext(self, node, frame)" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.nodes" ], [ "LOAD_FAST", "_tree_index" ], [ "BINARY_SUBSCR", "traced_file.nodes[_tree_index]" ], [ "LOAD_GLOBAL", "cast" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "cast(ast.expr, node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._main_frame" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self._main_frame(node)" ], [ "LOAD_FAST", "frame" ], [ "COMPARE_OP", "frame is None" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_stack" ], [ "LOAD_METHOD", "frame_info.expression_stack.append" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "frame_info.expression_stack.append(node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.before_expr" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self.before_expr(node, frame)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._main_frame" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self._main_frame(node)" ], [ "LOAD_FAST", "frame" ], [ "COMPARE_OP", "frame is None" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._after_expr" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "value" ], [ "CALL_METHOD", "self._after_expr(node, frame, value, None, None)" ], [ "LOAD_FAST", "result" ], [ "COMPARE_OP", "result is not None" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "ChangeValue" ], [ "CALL_FUNCTION", "isinstance(result, ChangeValue)" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.value" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_stack" ], [ "LOAD_METHOD", "frame_info.expression_stack.pop" ], [ "CALL_METHOD", "frame_info.expression_stack.pop()" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_values" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.after_expr" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "exc_value" ], [ "LOAD_FAST", "exc_tb" ], [ "CALL_METHOD", "self.after_expr(node, frame, value, exc_value, exc_tb)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._get_caller_stuff" ], [ "LOAD_FAST", "current_frame" ], [ "CALL_METHOD", "self._get_caller_stuff(current_frame)" ], [ "LOAD_GLOBAL", "FrameInfo" ], [ "CALL_FUNCTION", "FrameInfo()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "current_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.enter_call" ], [ "LOAD_GLOBAL", "EnterCallInfo" ], [ "LOAD_FAST", "call_node" ], [ "LOAD_FAST", "enter_node" ], [ "LOAD_FAST", "caller_frame" ], [ "LOAD_FAST", "current_frame" ], [ "CALL_FUNCTION", "EnterCallInfo(call_node, enter_node, caller_frame, current_frame)" ], [ "CALL_METHOD", "self.enter_call(EnterCallInfo(call_node, enter_node, caller_frame, current_frame))" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.secondary_to_main_frames" ], [ "LOAD_METHOD", "self.secondary_to_main_frames.get" ], [ "LOAD_FAST", "caller_frame" ], [ "CALL_METHOD", "self.secondary_to_main_frames.get(caller_frame)" ], [ "LOAD_FAST", "main_frame" ], [ "LOAD_FAST", "main_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "caller_frame" ], [ "BINARY_SUBSCR", "self.stack[caller_frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_stack" ], [ "LOAD_FAST", "expression_stack" ], [ "LOAD_FAST", "expression_stack" ], [ "BINARY_SUBSCR", "expression_stack[-1]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.statement_stack" ], [ "BINARY_SUBSCR", "frame_info.statement_stack[-1]" ], [ "LOAD_FAST", "caller_frame" ], [ "LOAD_FAST", "call_node" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "getattr(node, '_visit_ignore', False)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "CALL_FUNCTION", "isinstance(node, ast.expr)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "hasattr(node, \"ctx\")" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.ctx" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Load" ], [ "CALL_FUNCTION", "isinstance(node.ctx, ast.Load)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "ast" ], [ "CALL_FUNCTION", "getattr(ast, 'Starred', ())" ], [ "CALL_FUNCTION", "isinstance(node, getattr(ast, 'Starred', ()))" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.visit_expr" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self.visit_expr(node)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "CALL_FUNCTION", "isinstance(node, ast.stmt)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.visit_stmt" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self.visit_stmt(node)" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "_NodeVisitor" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self)" ], [ "LOAD_METHOD", "super(_NodeVisitor, self).generic_visit" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "super(_NodeVisitor, self).generic_visit(node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._create_simple_marker_call" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "TreeTracerBase" ], [ "LOAD_ATTR", "TreeTracerBase._treetrace_hidden_before_expr" ], [ "CALL_METHOD", "self._create_simple_marker_call(node, TreeTracerBase._treetrace_hidden_before_expr)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.copy_location" ], [ "LOAD_FAST", "before_marker" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.copy_location(before_marker, node)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Call" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Name" ], [ "LOAD_GLOBAL", "TreeTracerBase" ], [ "LOAD_ATTR", "TreeTracerBase._treetrace_hidden_after_expr" ], [ "LOAD_ATTR", "TreeTracerBase._treetrace_hidden_after_expr.__name__" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.Load" ], [ "CALL_METHOD", "ast.Load()" ], [ "CALL_FUNCTION_KW", "ast.Name(id=TreeTracerBase._treetrace_hidden_after_expr.__name__,\n ctx=ast.Load())" ], [ "LOAD_FAST", "before_marker" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "_NodeVisitor" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self)" ], [ "LOAD_METHOD", "super(_NodeVisitor, self).generic_visit" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "super(_NodeVisitor, self).generic_visit(node)" ], [ "CALL_FUNCTION_KW", "ast.Call(\n func=ast.Name(id=TreeTracerBase._treetrace_hidden_after_expr.__name__,\n ctx=ast.Load()),\n args=[\n before_marker,\n super(_NodeVisitor, self).generic_visit(node),\n ],\n keywords=[],\n )" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.copy_location" ], [ "LOAD_FAST", "after_marker" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.copy_location(after_marker, node)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.fix_missing_locations" ], [ "LOAD_FAST", "after_marker" ], [ "CALL_METHOD", "ast.fix_missing_locations(after_marker)" ], [ "LOAD_FAST", "after_marker" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._create_simple_marker_call" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "_NodeVisitor" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self)" ], [ "LOAD_METHOD", "super(_NodeVisitor, self).generic_visit" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "super(_NodeVisitor, self).generic_visit(node)" ], [ "LOAD_GLOBAL", "TreeTracerBase" ], [ "LOAD_ATTR", "TreeTracerBase._treetrace_hidden_with_stmt" ], [ "CALL_METHOD", "self._create_simple_marker_call(\n super(_NodeVisitor, self).generic_visit(node),\n TreeTracerBase._treetrace_hidden_with_stmt)" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.With" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.withitem" ], [ "LOAD_FAST", "context_expr" ], [ "CALL_FUNCTION_KW", "ast.withitem(context_expr=context_expr)" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION_KW", "ast.With(\n items=[ast.withitem(context_expr=context_expr)],\n body=[node],\n )" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.With" ], [ "LOAD_FAST", "context_expr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION_KW", "ast.With(\n context_expr=context_expr,\n body=[node],\n )" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.copy_location" ], [ "LOAD_FAST", "wrapped" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.copy_location(wrapped, node)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.fix_missing_locations" ], [ "LOAD_FAST", "wrapped" ], [ "CALL_METHOD", "ast.fix_missing_locations(wrapped)" ], [ "LOAD_FAST", "wrapped" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Call" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Name" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.__name__" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.Load" ], [ "CALL_METHOD", "ast.Load()" ], [ "CALL_FUNCTION_KW", "ast.Name(id=func.__name__,\n ctx=ast.Load())" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.Num" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "CALL_METHOD", "ast.Num(node._tree_index)" ], [ "CALL_FUNCTION_KW", "ast.Call(\n func=ast.Name(id=func.__name__,\n ctx=ast.Load()),\n args=[ast.Num(node._tree_index)],\n keywords=[],\n )" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tracer" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "getattr(node, '_enter_call_node', False)" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_METHOD", "tracer._enter_call" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "tracer._enter_call(node, frame)" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "tracer.stack[frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.statement_stack" ], [ "LOAD_METHOD", "frame_info.statement_stack.append" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "frame_info.statement_stack.append(node)" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_METHOD", "tracer.before_stmt" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "tracer.before_stmt(node, frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tracer" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "tracer.stack[frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.statement_stack" ], [ "LOAD_METHOD", "frame_info.statement_stack.pop" ], [ "CALL_METHOD", "frame_info.statement_stack.pop()" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.exc_value" ], [ "COMPARE_OP", "exc_val is not frame_info.exc_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_stack" ], [ "LOAD_FAST", "expression_stack" ], [ "LOAD_FAST", "expression_stack" ], [ "BINARY_SUBSCR", "expression_stack[-1]" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_METHOD", "tracer._after_expr" ], [ "LOAD_FAST", "exc_node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "exc_tb" ], [ "CALL_METHOD", "tracer._after_expr(exc_node, frame, None, exc_val, exc_tb)" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_METHOD", "tracer.after_stmt" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "exc_tb" ], [ "LOAD_FAST", "exc_node" ], [ "CALL_METHOD", "tracer.after_stmt(node, frame, exc_val, exc_tb, exc_node)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Return" ], [ "CALL_FUNCTION", "isinstance(node, ast.Return)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.return_node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Module" ], [ "CALL_FUNCTION", "isinstance(parent, (ast.FunctionDef, ast.Module))" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.body" ], [ "BINARY_SUBSCR", "parent.body[-1]" ], [ "COMPARE_OP", "node is parent.body[-1]" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_FAST", "exiting" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_METHOD", "tracer._get_caller_stuff" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "tracer._get_caller_stuff(frame)" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_ATTR", "return_node.value" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_values" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_ATTR", "return_node.value" ], [ "BINARY_SUBSCR", "frame_info.expression_values[return_node.value]" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_METHOD", "tracer.exit_call" ], [ "LOAD_GLOBAL", "ExitCallInfo" ], [ "LOAD_FAST", "call_node" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_FAST", "caller_frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "return_value" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "exc_tb" ], [ "CALL_FUNCTION", "ExitCallInfo(call_node,\n return_node,\n caller_frame,\n frame,\n return_value,\n exc_val,\n exc_tb\n )" ], [ "CALL_METHOD", "tracer.exit_call(ExitCallInfo(call_node,\n return_node,\n caller_frame,\n frame,\n return_value,\n exc_val,\n exc_tb\n ))" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.stack" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tracer" ], [ "LOAD_ATTR", "self.tracer.main_to_secondary_frames" ], [ "LOAD_METHOD", "self.tracer.main_to_secondary_frames.pop" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self.tracer.main_to_secondary_frames.pop(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tracer" ], [ "LOAD_ATTR", "self.tracer.secondary_to_main_frames" ], [ "LOAD_FAST", "secondary_frame" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(parent, ast.FunctionDef)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "CALL_FUNCTION", "isinstance(parent, ast.For)" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.iter" ], [ "LOAD_DEREF", "node" ], [ "COMPARE_OP", "parent.iter is not node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "CALL_FUNCTION", "isinstance(parent, ast.While)" ], [ "LOAD_DEREF", "node" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.orelse" ], [ "COMPARE_OP", "node not in parent.orelse" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "CALL_FUNCTION", "isinstance(parent, ast.comprehension)" ], [ "LOAD_DEREF", "node" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.ifs" ], [ "COMPARE_OP", "node in parent.ifs" ], [ "LOAD_FAST", "is_containing_loop" ], [ "LOAD_FAST", "result" ], [ "LOAD_METHOD", "result.append" ], [ "LOAD_FAST", "parent" ], [ "CALL_METHOD", "result.append(parent)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.ListComp" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.GeneratorExp" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.DictComp" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.SetComp" ], [ "CALL_FUNCTION", "isinstance(parent, (ast.ListComp,\n ast.GeneratorExp,\n ast.DictComp,\n ast.SetComp))" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.generators" ], [ "LOAD_DEREF", "node" ], [ "LOAD_FAST", "generators" ], [ "COMPARE_OP", "node in generators" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "takewhile" ], [ "LOAD_FAST", "generators" ], [ "CALL_FUNCTION", "takewhile(lambda n: n != node, generators)" ], [ "CALL_FUNCTION", "list(takewhile(lambda n: n != node, generators))" ], [ "LOAD_FAST", "result" ], [ "LOAD_METHOD", "result.extend" ], [ "LOAD_GLOBAL", "reversed" ], [ "LOAD_FAST", "generators" ], [ "CALL_FUNCTION", "reversed(generators)" ], [ "CALL_METHOD", "result.extend(reversed(generators))" ], [ "LOAD_FAST", "parent" ], [ "LOAD_FAST", "result" ], [ "LOAD_METHOD", "result.reverse" ], [ "CALL_METHOD", "result.reverse()" ], [ "LOAD_GLOBAL", "tuple" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "tuple(result)" ], [ "LOAD_FAST", "n" ], [ "LOAD_DEREF", "node" ], [ "COMPARE_OP", "n != node" ] ], "tracer2.py": [ [ "LOAD_NAME", "find_repr_function" ], [ "LOAD_NAME", "six" ], [ "LOAD_ATTR", "six.text_type" ], [ "CALL_FUNCTION", "find_repr_function(six.text_type)" ], [ "LOAD_NAME", "find_repr_function" ], [ "LOAD_NAME", "six" ], [ "LOAD_ATTR", "six.binary_type" ], [ "CALL_FUNCTION", "find_repr_function(six.binary_type)" ], [ "LOAD_NAME", "find_repr_function" ], [ "LOAD_NAME", "object" ], [ "CALL_FUNCTION", "find_repr_function(object)" ], [ "LOAD_NAME", "find_repr_function" ], [ "LOAD_NAME", "int" ], [ "CALL_FUNCTION", "find_repr_function(int)" ], [ "LOAD_NAME", "cheap_repr" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "threading" ], [ "LOAD_METHOD", "threading.local" ], [ "CALL_METHOD", "threading.local()" ], [ "LOAD_NAME", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_METHOD", "os.path.dirname" ], [ "LOAD_ATTR", "(lambda: 0).__code__" ], [ "LOAD_ATTR", "(lambda: 0).__code__.co_filename" ], [ "CALL_METHOD", "os.path.dirname((lambda: 0).__code__.co_filename)" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_METHOD", "os.path.dirname" ], [ "LOAD_NAME", "birdseye" ], [ "LOAD_ATTR", "birdseye.__file__" ], [ "CALL_METHOD", "os.path.dirname(birdseye.__file__)" ], [ "LOAD_NAME", "type" ], [ "LOAD_NAME", "six" ], [ "LOAD_METHOD", "six.add_metaclass" ], [ "LOAD_NAME", "TracerMeta" ], [ "CALL_METHOD", "six.add_metaclass(TracerMeta)" ], [ "LOAD_NAME", "object" ], [ "CALL_FUNCTION", "six.add_metaclass(TracerMeta)" ], [ "LOAD_NAME", "object" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lineno" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "CALL_FUNCTION", "OrderedDict()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_METHOD", "Source.for_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "Source.for_frame(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_flags" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.CO_GENERATOR" ], [ "BINARY_AND", "frame.f_code.co_flags & inspect.CO_GENERATOR" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "is_comprehension_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "is_comprehension_frame(frame)" ], [ "LOAD_GLOBAL", "re" ], [ "LOAD_METHOD", "re.match" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "CALL_METHOD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name)" ], [ "LOAD_METHOD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group" ], [ "CALL_METHOD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group(1)" ], [ "LOAD_METHOD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group(1).title" ], [ "CALL_METHOD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group(1).title()" ], [ "BINARY_ADD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group(1).title()\n + u' comprehension'" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_lineno" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.local_reprs" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.get_local_reprs" ], [ "LOAD_FAST", "watch" ], [ "LOAD_FAST", "watch_extras" ], [ "CALL_METHOD", "self.get_local_reprs(watch, watch_extras)" ], [ "CALL_FUNCTION", "OrderedDict(\n (source, my_cheap_repr(value))\n for source, value in\n self.get_local_reprs(watch, watch_extras)\n )" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.comprehension_type" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.local_reprs" ], [ "LOAD_METHOD", "self.local_reprs.items" ], [ "CALL_METHOD", "self.local_reprs.items()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.comprehension_variables" ], [ "LOAD_METHOD", "self.comprehension_variables.setdefault" ], [ "LOAD_FAST", "name" ], [ "CALL_METHOD", "self.comprehension_variables.setdefault(name, [])" ], [ "LOAD_FAST", "values" ], [ "LOAD_FAST", "values" ], [ "BINARY_SUBSCR", "values[-1]" ], [ "LOAD_FAST", "value_repr" ], [ "COMPARE_OP", "values[-1] != value_repr" ], [ "LOAD_FAST", "values" ], [ "LOAD_METHOD", "values.append" ], [ "LOAD_FAST", "value_repr" ], [ "CALL_METHOD", "values.append(value_repr)" ], [ "LOAD_GLOBAL", "truncate_list" ], [ "LOAD_FAST", "values" ], [ "CALL_FUNCTION", "truncate_list(values, 11)" ], [ "LOAD_FAST", "values" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event in ('return', 'exception')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.comprehension_variables" ], [ "LOAD_METHOD", "self.comprehension_variables.items" ], [ "CALL_METHOD", "self.comprehension_variables.items()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.local_reprs" ], [ "LOAD_METHOD", "self.local_reprs.items" ], [ "CALL_METHOD", "self.local_reprs.items()" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "old_local_reprs" ], [ "COMPARE_OP", "name not in old_local_reprs" ], [ "LOAD_FAST", "old_local_reprs" ], [ "LOAD_FAST", "name" ], [ "BINARY_SUBSCR", "old_local_reprs[name]" ], [ "LOAD_FAST", "value_repr" ], [ "COMPARE_OP", "old_local_reprs[name] != value_repr" ], [ "LOAD_FAST", "variables" ], [ "LOAD_METHOD", "variables.append" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "value_repr" ], [ "CALL_METHOD", "variables.append((name, value_repr))" ], [ "LOAD_FAST", "variables" ], [ "LOAD_FAST", "source" ], [ "LOAD_GLOBAL", "my_cheap_repr" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "my_cheap_repr(value)" ], [ "LOAD_FAST", "name" ], [ "LOAD_METHOD", "', '.join" ], [ "LOAD_FAST", "values" ], [ "CALL_METHOD", "', '.join(values)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_varnames" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_cellvars" ], [ "BINARY_ADD", "code.co_varnames + code.co_cellvars" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_freevars" ], [ "BINARY_ADD", "code.co_varnames + code.co_cellvars + code.co_freevars" ], [ "LOAD_GLOBAL", "tuple" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "LOAD_METHOD", "frame.f_locals.keys" ], [ "CALL_METHOD", "frame.f_locals.keys()" ], [ "CALL_FUNCTION", "tuple(frame.f_locals.keys())" ], [ "BINARY_ADD", "code.co_varnames + code.co_cellvars + code.co_freevars + tuple(frame.f_locals.keys())" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "LOAD_METHOD", "frame.f_locals.items" ], [ "CALL_METHOD", "frame.f_locals.items()" ], [ "CALL_FUNCTION_KW", "sorted(\n frame.f_locals.items(),\n key=lambda key_value: vars_order.index(key_value[0])\n )" ], [ "LOAD_FAST", "watch" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_FAST", "variable" ], [ "LOAD_METHOD", "variable.items" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "variable.items(frame)" ], [ "CALL_FUNCTION", "sorted(variable.items(frame))" ], [ "LOAD_FAST", "result_items" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "watch_extras" ], [ "LOAD_FAST", "extra" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "extra(source, value)" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_FAST", "pair" ], [ "COMPARE_OP", "pair is not None" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "pair" ], [ "CALL_FUNCTION", "len(pair)" ], [ "COMPARE_OP", "len(pair) == 2" ], [ "LOAD_FAST", "pair" ], [ "LOAD_DEREF", "vars_order" ], [ "LOAD_METHOD", "vars_order.index" ], [ "LOAD_FAST", "key_value" ], [ "BINARY_SUBSCR", "key_value[0]" ], [ "CALL_METHOD", "vars_order.index(key_value[0])" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "TracerMeta" ], [ "LOAD_FAST", "mcs" ], [ "CALL_FUNCTION", "super(TracerMeta, mcs)" ], [ "LOAD_ATTR", "super(TracerMeta, mcs).__new__" ], [ "LOAD_FAST", "mcs" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "super(TracerMeta, mcs).__new__(mcs, *args, **kwargs)" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "result()" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "no_args_decorator" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION", "no_args_decorator(args, kwargs)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_METHOD", "cls.default" ], [ "LOAD_FAST", "args" ], [ "BINARY_SUBSCR", "args[0]" ], [ "CALL_METHOD", "cls.default(args[0])" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "TracerMeta" ], [ "LOAD_FAST", "cls" ], [ "CALL_FUNCTION", "super(TracerMeta, cls)" ], [ "LOAD_ATTR", "super(TracerMeta, cls).__call__" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "super(TracerMeta, cls).__call__(*args, **kwargs)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.default" ], [ "LOAD_ATTR", "self.default.__enter__" ], [ "CALL_FUNCTION_KW", "self.default.__enter__(context=1)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.default" ], [ "LOAD_ATTR", "self.default.__exit__" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION_EX", "self.default.__exit__(*args, context=1)" ], [ "LOAD_GLOBAL", "ensure_tuple" ], [ "LOAD_FAST", "watch" ], [ "CALL_FUNCTION", "ensure_tuple(watch)" ], [ "LOAD_GLOBAL", "ensure_tuple" ], [ "LOAD_FAST", "watch_explode" ], [ "CALL_FUNCTION", "ensure_tuple(watch_explode)" ], [ "BINARY_ADD", "[\n v if isinstance(v, BaseVariable) else CommonVariable(v)\n for v in ensure_tuple(watch)\n ] + [\n v if isinstance(v, BaseVariable) else Exploding(v)\n for v in ensure_tuple(watch_explode)\n ]" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "ArgDefaultDict" ], [ "LOAD_GLOBAL", "FrameInfo" ], [ "CALL_FUNCTION", "ArgDefaultDict(FrameInfo)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "depth" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.depth" ], [ "COMPARE_OP", "self.depth >= 1" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "BaseVariable" ], [ "CALL_FUNCTION", "isinstance(v, BaseVariable)" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "CommonVariable" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "CommonVariable(v)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "BaseVariable" ], [ "CALL_FUNCTION", "isinstance(v, BaseVariable)" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "Exploding" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "Exploding(v)" ], [ "LOAD_GLOBAL", "iscoroutinefunction" ], [ "LOAD_DEREF", "function" ], [ "CALL_FUNCTION", "iscoroutinefunction(function)" ], [ "LOAD_GLOBAL", "NotImplementedError" ], [ "CALL_FUNCTION", "NotImplementedError(\"coroutines are not supported, sorry!\")" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.target_codes" ], [ "LOAD_METHOD", "self.target_codes.add" ], [ "LOAD_DEREF", "function" ], [ "LOAD_ATTR", "function.__code__" ], [ "CALL_METHOD", "self.target_codes.add(function.__code__)" ], [ "LOAD_GLOBAL", "functools" ], [ "LOAD_METHOD", "functools.wraps" ], [ "LOAD_DEREF", "function" ], [ "CALL_METHOD", "functools.wraps(function)" ], [ "CALL_FUNCTION", "functools.wraps(function)" ], [ "LOAD_GLOBAL", "functools" ], [ "LOAD_METHOD", "functools.wraps" ], [ "LOAD_DEREF", "function" ], [ "CALL_METHOD", "functools.wraps(function)" ], [ "CALL_FUNCTION", "functools.wraps(function)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.isgeneratorfunction" ], [ "LOAD_DEREF", "function" ], [ "CALL_METHOD", "inspect.isgeneratorfunction(function)" ], [ "LOAD_FAST", "generator_wrapper" ], [ "LOAD_FAST", "simple_wrapper" ], [ "LOAD_DEREF", "self" ], [ "LOAD_DEREF", "function" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "function(*args, **kwargs)" ], [ "LOAD_DEREF", "function" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "function(*args, **kwargs)" ], [ "LOAD_FAST", "gen" ], [ "LOAD_ATTR", "gen.send" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "method" ], [ "LOAD_FAST", "incoming" ], [ "CALL_FUNCTION", "method(incoming)" ], [ "LOAD_GLOBAL", "StopIteration" ], [ "LOAD_FAST", "gen" ], [ "LOAD_ATTR", "gen.send" ], [ "LOAD_FAST", "outgoing" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_FAST", "gen" ], [ "LOAD_ATTR", "gen.throw" ], [ "LOAD_FAST", "e" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.enabled" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_METHOD", "sys._getframe" ], [ "LOAD_FAST", "context" ], [ "BINARY_ADD", "context + 1" ], [ "CALL_METHOD", "sys._getframe(context + 1)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._is_internal_frame" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_METHOD", "self._is_internal_frame(calling_frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.trace" ], [ "LOAD_FAST", "calling_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.target_frames" ], [ "LOAD_METHOD", "self.target_frames.add" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_METHOD", "self.target_frames.add(calling_frame)" ], [ "LOAD_FAST", "calling_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.trace" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_METHOD", "self.trace(calling_frame, 'enter', None)" ], [ "LOAD_GLOBAL", "thread_global" ], [ "LOAD_ATTR", "thread_global.__dict__" ], [ "LOAD_METHOD", "thread_global.__dict__.setdefault" ], [ "CALL_METHOD", "thread_global.__dict__.setdefault('original_trace_functions', [])" ], [ "LOAD_FAST", "stack" ], [ "LOAD_METHOD", "stack.append" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_METHOD", "sys.gettrace" ], [ "CALL_METHOD", "sys.gettrace()" ], [ "CALL_METHOD", "stack.append(sys.gettrace())" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_METHOD", "sys.settrace" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.trace" ], [ "CALL_METHOD", "sys.settrace(self.trace)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.enabled" ], [ "LOAD_GLOBAL", "thread_global" ], [ "LOAD_ATTR", "thread_global.original_trace_functions" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_METHOD", "sys.settrace" ], [ "LOAD_FAST", "stack" ], [ "LOAD_METHOD", "stack.pop" ], [ "CALL_METHOD", "stack.pop()" ], [ "CALL_METHOD", "sys.settrace(stack.pop())" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_METHOD", "sys._getframe" ], [ "LOAD_FAST", "context" ], [ "BINARY_ADD", "context + 1" ], [ "CALL_METHOD", "sys._getframe(context + 1)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.trace" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_METHOD", "self.trace(calling_frame, 'exit', None)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.target_frames" ], [ "LOAD_METHOD", "self.target_frames.discard" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_METHOD", "self.target_frames.discard(calling_frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame_infos" ], [ "LOAD_METHOD", "self.frame_infos.pop" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_METHOD", "self.frame_infos.pop(calling_frame, None)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_filename" ], [ "LOAD_METHOD", "frame.f_code.co_filename.startswith" ], [ "LOAD_GLOBAL", "internal_directories" ], [ "CALL_METHOD", "frame.f_code.co_filename.startswith(internal_directories)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.target_codes" ], [ "COMPARE_OP", "frame.f_code in self.target_codes" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.target_frames" ], [ "COMPARE_OP", "frame in self.target_frames" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._is_traced_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self._is_traced_frame(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.depth" ], [ "COMPARE_OP", "self.depth == 1" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._is_internal_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self._is_internal_frame(frame)" ], [ "LOAD_GLOBAL", "is_comprehension_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "is_comprehension_frame(frame)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_GLOBAL", "is_comprehension_frame" ], [ "LOAD_FAST", "candidate" ], [ "CALL_FUNCTION", "is_comprehension_frame(candidate)" ], [ "LOAD_FAST", "candidate" ], [ "LOAD_ATTR", "candidate.f_back" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._is_traced_frame" ], [ "LOAD_FAST", "candidate" ], [ "CALL_METHOD", "self._is_traced_frame(candidate)" ], [ "LOAD_FAST", "candidate" ], [ "LOAD_ATTR", "candidate.f_back" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.depth" ], [ "COMPARE_OP", "i >= self.depth" ], [ "LOAD_FAST", "candidate" ], [ "COMPARE_OP", "candidate is None" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._is_internal_frame" ], [ "LOAD_FAST", "candidate" ], [ "CALL_METHOD", "self._is_internal_frame(candidate)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.thread_local" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_ATTR", "thread_local.__dict__" ], [ "LOAD_METHOD", "thread_local.__dict__.setdefault" ], [ "CALL_METHOD", "thread_local.__dict__.setdefault('depth', -1)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame_infos" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.frame_infos[frame]" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event in ('call', 'enter')" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.last_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.last_frame" ], [ "LOAD_FAST", "frame" ], [ "COMPARE_OP", "self.config.last_frame is not frame" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.last_line_no" ], [ "LOAD_GLOBAL", "Event" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "event" ], [ "LOAD_FAST", "arg" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_ATTR", "thread_local.depth" ], [ "LOAD_FAST", "line_no" ], [ "CALL_FUNCTION_KW", "Event(frame_info, event, arg, thread_local.depth, line_no=line_no)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.formatter" ], [ "LOAD_METHOD", "self.config.formatter.format_line_only" ], [ "LOAD_FAST", "trace_event" ], [ "CALL_METHOD", "self.config.formatter.format_line_only(trace_event)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_METHOD", "self.config.write" ], [ "LOAD_FAST", "line" ], [ "CALL_METHOD", "self.config.write(line)" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event == 'exception'" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_GLOBAL", "Event" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "event" ], [ "LOAD_FAST", "arg" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_ATTR", "thread_local.depth" ], [ "CALL_FUNCTION", "Event(frame_info, event, arg, thread_local.depth)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "COMPARE_OP", "frame.f_code.co_name == ''" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event not in ('return', 'exception')" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_METHOD", "frame_info.update_variables" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.watch" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.watch_extras" ], [ "LOAD_FAST", "event" ], [ "CALL_METHOD", "frame_info.update_variables(\n self.watch,\n self.config.watch_extras,\n event,\n )" ], [ "LOAD_FAST", "trace_event" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event in ('return', 'exit')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame_infos" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.formatter" ], [ "LOAD_METHOD", "self.config.formatter.format" ], [ "LOAD_FAST", "trace_event" ], [ "CALL_METHOD", "self.config.formatter.format(trace_event)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_METHOD", "self.config.write" ], [ "LOAD_FAST", "formatted" ], [ "CALL_METHOD", "self.config.write(formatted)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.trace" ], [ "LOAD_FAST", "config" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "NO_ASTTOKENS" ], [ "LOAD_GLOBAL", "Exception" ], [ "CALL_FUNCTION", "Exception(\"birdseye doesn't support this version of Python\")" ], [ "LOAD_GLOBAL", "ImportError" ], [ "LOAD_GLOBAL", "Exception" ], [ "CALL_FUNCTION", "Exception(\"You must install birdseye separately to use spy: pip install birdseye\")" ], [ "LOAD_GLOBAL", "no_args_decorator" ], [ "LOAD_DEREF", "args" ], [ "LOAD_DEREF", "kwargs" ], [ "CALL_FUNCTION", "no_args_decorator(args, kwargs)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self._trace" ], [ "LOAD_DEREF", "args" ], [ "BINARY_SUBSCR", "args[0]" ], [ "CALL_METHOD", "self._trace(args[0])" ], [ "LOAD_FAST", "decorator" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._trace" ], [ "LOAD_FAST", "func" ], [ "LOAD_DEREF", "args" ], [ "LOAD_DEREF", "kwargs" ], [ "CALL_FUNCTION_EX", "self._trace(func, *args, **kwargs)" ], [ "LOAD_FAST", "eye" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "eye(func)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.snoop" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "self.config.snoop(*args, **kwargs)" ], [ "LOAD_DEREF", "traced" ], [ "CALL_FUNCTION", "self.config.snoop(*args, **kwargs)(traced)" ], [ "LOAD_GLOBAL", "functools" ], [ "LOAD_METHOD", "functools.wraps" ], [ "LOAD_DEREF", "func" ], [ "CALL_METHOD", "functools.wraps(func)" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "LOAD_FAST", "wrapper" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.enabled" ], [ "LOAD_DEREF", "traced" ], [ "LOAD_DEREF", "func" ], [ "LOAD_FAST", "final_func" ], [ "LOAD_FAST", "func_args" ], [ "LOAD_FAST", "func_kwargs" ], [ "CALL_FUNCTION_EX", "final_func(*func_args, **func_kwargs)" ] ], "utils.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOAD_METHOD", "standard_library.install_aliases" ], [ "CALL_METHOD", "standard_library.install_aliases()" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "type" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "version_info" ], [ "LOAD_ATTR", "version_info.major" ], [ "COMPARE_OP", "version_info.major == 2" ], [ "LOAD_NAME", "PY2" ], [ "UNARY_NOT", "not PY2" ], [ "LOAD_NAME", "TypeVar" ], [ "CALL_FUNCTION", "TypeVar('T')" ], [ "LOAD_NAME", "TypeVar" ], [ "CALL_FUNCTION", "TypeVar('RT')" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "unicode" ], [ "LOAD_NAME", "str" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "type" ], [ "LOAD_NAME", "json" ], [ "LOAD_ATTR", "json.JSONEncoder" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_GLOBAL", "ntpath" ], [ "LOAD_METHOD", "ntpath.split" ], [ "LOAD_FAST", "path" ], [ "CALL_METHOD", "ntpath.split(path)" ], [ "LOAD_FAST", "tail" ], [ "LOAD_GLOBAL", "ntpath" ], [ "LOAD_METHOD", "ntpath.basename" ], [ "LOAD_FAST", "head" ], [ "CALL_METHOD", "ntpath.basename(head)" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_METHOD", "os.path.commonprefix" ], [ "LOAD_FAST", "paths" ], [ "CALL_METHOD", "os.path.commonprefix(paths)" ], [ "LOAD_GLOBAL", "ntpath" ], [ "LOAD_METHOD", "ntpath.split" ], [ "LOAD_FAST", "prefix" ], [ "CALL_METHOD", "ntpath.split(prefix)" ], [ "BINARY_SUBSCR", "ntpath.split(prefix)[0]" ], [ "LOAD_FAST", "paths" ], [ "BINARY_SUBSCR", "paths[0]" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "prefix" ], [ "CALL_FUNCTION", "len(prefix)" ], [ "BINARY_SUBSCR", "paths[0][len(prefix)]" ], [ "LOAD_FAST", "first_char_after" ], [ "COMPARE_OP", "first_char_after in r'\\/'" ], [ "LOAD_FAST", "first_char_after" ], [ "LOAD_FAST", "prefix" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "COMPARE_OP", "path == IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "all_paths" ], [ "LOAD_GLOBAL", "common_ancestor" ], [ "LOAD_FAST", "all_paths" ], [ "CALL_FUNCTION", "common_ancestor(all_paths)" ], [ "LOAD_FAST", "prefix" ], [ "COMPARE_OP", "prefix in r'\\/'" ], [ "LOAD_GLOBAL", "strip_required_prefix" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "prefix" ], [ "CALL_FUNCTION", "strip_required_prefix(path, prefix)" ], [ "LOAD_GLOBAL", "path_leaf" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "path_leaf(path)" ], [ "LOAD_FAST", "f" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "COMPARE_OP", "f != IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "f" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "COMPARE_OP", "path == IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.sep" ], [ "COMPARE_OP", "os.path.sep == '/'" ], [ "LOAD_FAST", "path" ], [ "LOAD_METHOD", "path.startswith" ], [ "CALL_METHOD", "path.startswith('/')" ], [ "LOAD_FAST", "path" ], [ "BINARY_ADD", "'/' + path" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "type" ], [ "LOAD_FAST", "obj" ], [ "CALL_FUNCTION", "type(obj)" ], [ "LOAD_FAST", "t" ], [ "LOAD_GLOBAL", "types" ], [ "LOAD_ATTR", "types.InstanceType" ], [ "COMPARE_OP", "t is types.InstanceType" ], [ "LOAD_FAST", "obj" ], [ "LOAD_ATTR", "obj.__class__" ], [ "LOAD_FAST", "t" ], [ "LOAD_FAST", "iterable" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_DEREF", "type_or_tuple" ], [ "CALL_FUNCTION", "isinstance(x, type_or_tuple)" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "next" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "next(it)" ], [ "LOAD_GLOBAL", "StopIteration" ], [ "LOAD_GLOBAL", "raise_from" ], [ "LOAD_GLOBAL", "RuntimeError" ], [ "LOAD_FAST", "e" ], [ "CALL_FUNCTION", "raise_from(RuntimeError, e)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "expression" ], [ "CALL_FUNCTION", "hasattr(expression, 'one_or_none')" ], [ "LOAD_FAST", "expression" ], [ "LOAD_METHOD", "expression.one_or_none" ], [ "CALL_METHOD", "expression.one_or_none()" ], [ "LOAD_FAST", "expression" ], [ "LOAD_METHOD", "expression.all" ], [ "CALL_METHOD", "expression.all()" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "len(result)" ], [ "COMPARE_OP", "len(result) == 0" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "len(result)" ], [ "COMPARE_OP", "len(result) == 1" ], [ "LOAD_FAST", "result" ], [ "BINARY_SUBSCR", "result[0]" ], [ "LOAD_GLOBAL", "Exception" ], [ "CALL_FUNCTION", "Exception(\"There is more than one item returned for the supplied filter\")" ], [ "LOAD_FAST", "lst" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "isinstance(x, list)" ], [ "LOAD_FAST", "result" ], [ "LOAD_METHOD", "result.extend" ], [ "LOAD_GLOBAL", "flatten_list" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "flatten_list(x)" ], [ "CALL_METHOD", "result.extend(flatten_list(x))" ], [ "LOAD_FAST", "result" ], [ "LOAD_METHOD", "result.append" ], [ "LOAD_FAST", "x" ], [ "CALL_METHOD", "result.append(x)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "f" ], [ "LOAD_ATTR", "f.__code__" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "LOAD_ATTR", "(lambda: 0).__code__" ], [ "LOAD_ATTR", "(lambda: 0).__code__.co_name" ], [ "COMPARE_OP", "code.co_name == (lambda: 0).__code__.co_name" ], [ "LOAD_FAST", "o" ], [ "LOAD_ATTR", "o.as_json" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "ProtocolEncoder" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(ProtocolEncoder, self)" ], [ "LOAD_METHOD", "super(ProtocolEncoder, self).default" ], [ "LOAD_FAST", "o" ], [ "CALL_METHOD", "super(ProtocolEncoder, self).default(o)" ], [ "LOAD_FAST", "method" ], [ "CALL_FUNCTION", "method()" ], [ "LOAD_GLOBAL", "io" ], [ "LOAD_METHOD", "io.open" ], [ "LOAD_FAST", "filename" ], [ "CALL_METHOD", "io.open(filename, 'rb')" ], [ "LOAD_GLOBAL", "detect_encoding" ], [ "LOAD_FAST", "fp" ], [ "LOAD_ATTR", "fp.readline" ], [ "CALL_FUNCTION", "detect_encoding(fp.readline)" ], [ "LOAD_FAST", "fp" ], [ "LOAD_METHOD", "fp.seek" ], [ "CALL_METHOD", "fp.seek(0)" ], [ "LOAD_GLOBAL", "io" ], [ "LOAD_ATTR", "io.TextIOWrapper" ], [ "LOAD_FAST", "fp" ], [ "LOAD_FAST", "encoding" ], [ "CALL_FUNCTION_KW", "io.TextIOWrapper(fp, encoding, line_buffering=True)" ], [ "LOAD_FAST", "text" ], [ "LOAD_FAST", "text" ], [ "LOAD_FAST", "fp" ], [ "LOAD_METHOD", "fp.close" ], [ "CALL_METHOD", "fp.close()" ], [ "LOAD_FAST", "filename" ], [ "LOAD_METHOD", "filename.endswith" ], [ "CALL_METHOD", "filename.endswith('.pyc')" ], [ "LOAD_FAST", "filename" ], [ "BINARY_SUBSCR", "filename[:-1]" ], [ "LOAD_GLOBAL", "open_with_encoding_check" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "open_with_encoding_check(filename)" ], [ "LOAD_METHOD", "''.join" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "f" ], [ "CALL_FUNCTION", "enumerate(f)" ], [ "CALL_METHOD", "''.join([\n '\\n' if i < 2 and cookie_re.match(line)\n else line\n for i, line in enumerate(f)\n ])" ], [ "LOAD_FAST", "i" ], [ "COMPARE_OP", "i < 2" ], [ "LOAD_DEREF", "cookie_re" ], [ "LOAD_METHOD", "cookie_re.match" ], [ "LOAD_FAST", "line" ], [ "CALL_METHOD", "cookie_re.match(line)" ], [ "LOAD_FAST", "line" ], [ "LOAD_GLOBAL", "safe_next" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_METHOD", "tokens.get_tokens" ], [ "LOAD_FAST", "function_node" ], [ "CALL_METHOD", "tokens.get_tokens(function_node)" ], [ "CALL_FUNCTION", "safe_next(t for t in tokens.get_tokens(function_node)\n if t.string == 'def' and t.type == token.NAME)" ], [ "LOAD_FAST", "def_token" ], [ "LOAD_ATTR", "def_token.startpos" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_ATTR", "tokens.text" ], [ "LOAD_FAST", "startpos" ], [ "LOAD_FAST", "function_node" ], [ "LOAD_ATTR", "function_node.last_token" ], [ "LOAD_ATTR", "function_node.last_token.endpos" ], [ "BINARY_SUBSCR", "tokens.text[startpos:function_node.last_token.endpos]" ], [ "LOAD_METHOD", "tokens.text[startpos:function_node.last_token.endpos].rstrip" ], [ "CALL_METHOD", "tokens.text[startpos:function_node.last_token.endpos].rstrip()" ], [ "LOAD_FAST", "source" ], [ "LOAD_METHOD", "source.startswith" ], [ "CALL_METHOD", "source.startswith('def')" ], [ "LOAD_FAST", "startpos" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "t" ], [ "LOAD_ATTR", "t.string" ], [ "COMPARE_OP", "t.string == 'def'" ], [ "LOAD_FAST", "t" ], [ "LOAD_ATTR", "t.type" ], [ "LOAD_GLOBAL", "token" ], [ "LOAD_ATTR", "token.NAME" ], [ "COMPARE_OP", "t.type == token.NAME" ], [ "LOAD_FAST", "t" ], [ "LOAD_FAST", "args" ], [ "LOAD_GLOBAL", "print" ], [ "LOAD_FAST", "arg" ], [ "CALL_FUNCTION", "print(arg)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION", "len(args)" ], [ "COMPARE_OP", "len(args) == 1" ], [ "LOAD_FAST", "args" ], [ "BINARY_SUBSCR", "args[0]" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "filename" ], [ "LOAD_METHOD", "filename.startswith" ], [ "CALL_METHOD", "filename.startswith(' max_length" ], [ "LOAD_FAST", "max_length" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "middle" ], [ "CALL_FUNCTION", "len(middle)" ], [ "BINARY_SUBTRACT", "max_length - len(middle)" ], [ "BINARY_FLOOR_DIVIDE", "(max_length - len(middle)) // 2" ], [ "LOAD_FAST", "max_length" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "middle" ], [ "CALL_FUNCTION", "len(middle)" ], [ "BINARY_SUBTRACT", "max_length - len(middle)" ], [ "LOAD_FAST", "left" ], [ "BINARY_SUBTRACT", "max_length - len(middle) - left" ], [ "LOAD_FAST", "seq" ], [ "LOAD_FAST", "left" ], [ "BINARY_SUBSCR", "seq[:left]" ], [ "LOAD_FAST", "middle" ], [ "BINARY_ADD", "seq[:left] + middle" ], [ "LOAD_FAST", "seq" ], [ "LOAD_FAST", "right" ], [ "UNARY_NEGATIVE", "-right" ], [ "BINARY_SUBSCR", "seq[-right:]" ], [ "BINARY_ADD", "seq[:left] + middle + seq[-right:]" ], [ "LOAD_FAST", "seq" ], [ "LOAD_GLOBAL", "truncate" ], [ "LOAD_FAST", "string" ], [ "LOAD_FAST", "max_length" ], [ "CALL_FUNCTION", "truncate(string, max_length, '...')" ], [ "LOAD_GLOBAL", "truncate" ], [ "LOAD_FAST", "lst" ], [ "LOAD_FAST", "max_length" ], [ "CALL_FUNCTION", "truncate(lst, max_length, ['...'])" ], [ "LOAD_FAST", "split" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "six" ], [ "LOAD_ATTR", "six.string_types" ], [ "CALL_FUNCTION", "isinstance(x, six.string_types)" ], [ "LOAD_FAST", "x" ], [ "LOAD_METHOD", "x.replace" ], [ "CALL_METHOD", "x.replace(',', ' ')" ], [ "LOAD_METHOD", "x.replace(',', ' ').split" ], [ "CALL_METHOD", "x.replace(',', ' ').split()" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "set" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "isinstance(x, (list, set, tuple))" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "tuple" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tuple(x)" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_METHOD", "os.path.basename" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_filename" ], [ "CALL_METHOD", "os.path.basename(code.co_filename)" ], [ "LOAD_FAST", "result" ], [ "LOAD_METHOD", "result.endswith" ], [ "CALL_METHOD", "result.endswith('.pyc')" ], [ "LOAD_FAST", "result" ], [ "BINARY_SUBSCR", "result[:-1]" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "COMPARE_OP", "frame.f_code.co_name in ('', '', '')" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "code('{}.x')" ], [ "LOAD_GLOBAL", "SyntaxError" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "code('({})')" ], [ "LOAD_FAST", "without_parens" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "code('({}).x')" ], [ "COMPARE_OP", "without_parens != code('({}).x')" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "s" ], [ "LOAD_METHOD", "s.format" ], [ "LOAD_DEREF", "source" ], [ "CALL_METHOD", "s.format(source)" ], [ "CALL_FUNCTION", "compile(s.format(source), '', 'eval')" ], [ "LOAD_ATTR", "compile(s.format(source), '', 'eval').co_code" ], [ "LOAD_GLOBAL", "needs_parentheses" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "needs_parentheses(source)" ], [ "LOAD_METHOD", "'({})'.format" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "'({})'.format(source)" ], [ "LOAD_FAST", "source" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "REPR_TARGET_LENGTH" ], [ "CALL_FUNCTION_KW", "cheap_repr(x, target_length=REPR_TARGET_LENGTH)" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "ArgDefaultDict" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(ArgDefaultDict, self)" ], [ "LOAD_METHOD", "super(ArgDefaultDict, self).__init__" ], [ "CALL_METHOD", "super(ArgDefaultDict, self).__init__()" ], [ "LOAD_FAST", "factory" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.factory" ], [ "LOAD_FAST", "key" ], [ "CALL_METHOD", "self.factory(key)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "key" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "lst" ], [ "CALL_FUNCTION", "len(lst)" ], [ "COMPARE_OP", "len(lst) == 1" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "CALL_FUNCTION", "str(i + 1)" ], [ "BINARY_ADD", "' ' + str(i + 1)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_GLOBAL", "os" ], [ "CALL_FUNCTION", "hasattr(os, 'PathLike')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.PathLike" ], [ "CALL_FUNCTION", "isinstance(x, os.PathLike)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "hasattr(x, '__fspath__')" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "hasattr(x, 'open')" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.__class__" ], [ "LOAD_ATTR", "x.__class__.__name__" ], [ "LOAD_METHOD", "x.__class__.__name__.lower" ], [ "CALL_METHOD", "x.__class__.__name__.lower()" ], [ "COMPARE_OP", "'path' in x.__class__.__name__.lower()" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION", "len(args)" ], [ "COMPARE_OP", "len(args) == 1" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.isfunction" ], [ "LOAD_FAST", "args" ], [ "BINARY_SUBSCR", "args[0]" ], [ "CALL_METHOD", "inspect.isfunction(args[0])" ], [ "LOAD_FAST", "kwargs" ], [ "UNARY_NOT", "not kwargs" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_ADD", "max_length + 2" ], [ "COMPARE_OP", "length <= max_length + 2" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "range(length)" ], [ "LOAD_GLOBAL", "chain" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_FLOOR_DIVIDE", "max_length // 2" ], [ "CALL_FUNCTION", "range(max_length // 2)" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_FLOOR_DIVIDE", "max_length // 2" ], [ "BINARY_SUBTRACT", "length - max_length // 2" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "range(length - max_length // 2,\n length)" ], [ "CALL_FUNCTION", "chain(range(max_length // 2),\n range(length - max_length // 2,\n length))" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "len(x)" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "n == 0" ], [ "LOAD_GLOBAL", "repr" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "repr(x)" ], [ "LOAD_FAST", "helper" ], [ "LOAD_ATTR", "helper.level" ], [ "BINARY_SUBTRACT", "helper.level - 1" ], [ "LOAD_GLOBAL", "_repr_series_one_line" ], [ "LOAD_ATTR", "_repr_series_one_line.maxparts" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "n" ], [ "LOAD_FAST", "maxparts" ], [ "CALL_FUNCTION", "_sample_indices(n, maxparts)" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.index" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "x.index[i:i + 1]" ], [ "LOAD_ATTR", "x.index[i:i + 1].format" ], [ "CALL_FUNCTION_KW", "x.index[i:i + 1].format(sparsify=False)" ], [ "BINARY_SUBSCR", "x.index[i:i + 1].format(sparsify=False)[0]" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.iloc" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "x.iloc[i]" ], [ "LOAD_FAST", "pieces" ], [ "LOAD_METHOD", "pieces.append" ], [ "LOAD_FAST", "k" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "v" ], [ "LOAD_FAST", "newlevel" ], [ "CALL_FUNCTION", "cheap_repr(v, newlevel)" ], [ "BINARY_MODULO", "'%s = %s' % (k, cheap_repr(v, newlevel))" ], [ "CALL_METHOD", "pieces.append('%s = %s' % (k, cheap_repr(v, newlevel)))" ], [ "LOAD_FAST", "n" ], [ "LOAD_FAST", "maxparts" ], [ "BINARY_ADD", "maxparts + 2" ], [ "COMPARE_OP", "n > maxparts + 2" ], [ "LOAD_FAST", "pieces" ], [ "LOAD_METHOD", "pieces.insert" ], [ "LOAD_FAST", "maxparts" ], [ "BINARY_FLOOR_DIVIDE", "maxparts // 2" ], [ "CALL_METHOD", "pieces.insert(maxparts // 2, '...')" ], [ "LOAD_METHOD", "'; '.join" ], [ "LOAD_FAST", "pieces" ], [ "CALL_METHOD", "'; '.join(pieces)" ] ] }executing-0.8.0/tests/sample_results/3.9.json000066400000000000000000021435261410133640400211330ustar00rootroot00000000000000{ "bird.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOAD_METHOD", "standard_library.install_aliases" ], [ "CALL_METHOD", "standard_library.install_aliases()" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "warn_if_outdated" ], [ "LOAD_NAME", "__version__" ], [ "CALL_FUNCTION", "warn_if_outdated('birdseye', __version__)" ], [ "LOAD_NAME", "namedtuple" ], [ "CALL_FUNCTION", "namedtuple('CodeInfo', 'db_func traced_file arg_names')" ], [ "LOAD_NAME", "TreeTracerBase" ], [ "LOAD_NAME", "BirdsEye" ], [ "CALL_FUNCTION", "BirdsEye()" ], [ "LOAD_NAME", "NamedTuple" ], [ "LOAD_NAME", "int" ], [ "LOAD_NAME", "bool" ], [ "LOAD_NAME", "int" ], [ "LOAD_NAME", "str" ], [ "CALL_FUNCTION", "NamedTuple('HTMLPosition', [\n ('index', int),\n ('is_start', bool),\n ('depth', int),\n ('html', str),\n])" ], [ "LOAD_NAME", "eye" ], [ "LOAD_ATTR", "eye.enter_call" ], [ "LOAD_ATTR", "eye.enter_call.__code__" ], [ "LOAD_NAME", "eye" ], [ "LOAD_ATTR", "eye.exit_call" ], [ "LOAD_ATTR", "eye.exit_call.__code__" ], [ "LOAD_NAME", "eye" ], [ "LOAD_ATTR", "eye.after_expr" ], [ "LOAD_ATTR", "eye.after_expr.__code__" ], [ "LOAD_NAME", "eye" ], [ "LOAD_ATTR", "eye.after_stmt" ], [ "LOAD_ATTR", "eye.after_stmt.__code__" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "Iterable" ], [ "LOAD_NAME", "Iteration" ], [ "BINARY_SUBSCR", "Iterable[Iteration]" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "TypeRegistry" ], [ "CALL_FUNCTION", "TypeRegistry()" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "try_register_repr" ], [ "CALL_FUNCTION", "try_register_repr('pandas', 'Series')" ], [ "CALL_FUNCTION", "try_register_repr('pandas', 'Series')" ], [ "LOAD_NAME", "cached_property" ], [ "CALL_FUNCTION", "cached_property" ], [ "LOAD_NAME", "lru_cache" ], [ "CALL_FUNCTION", "lru_cache()" ], [ "CALL_FUNCTION", "lru_cache()" ], [ "LOAD_NAME", "retry_db" ], [ "CALL_FUNCTION", "retry_db" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "BirdsEye" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(BirdsEye, self)" ], [ "LOAD_METHOD", "super(BirdsEye, self).__init__" ], [ "CALL_METHOD", "super(BirdsEye, self).__init__()" ], [ "LOAD_FAST", "db_uri" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "num_samples" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "dict" ], [ "CALL_FUNCTION_KW", "dict(\n attributes=50,\n dict=50,\n list=30,\n set=30,\n pandas_rows=20,\n pandas_cols=100,\n )" ], [ "LOAD_GLOBAL", "dict" ], [ "CALL_FUNCTION_KW", "dict(\n attributes=50,\n dict=10,\n list=6,\n set=6,\n pandas_rows=6,\n pandas_cols=10,\n )" ], [ "CALL_FUNCTION_KW", "dict(\n big=dict(\n attributes=50,\n dict=50,\n list=30,\n set=30,\n pandas_rows=20,\n pandas_cols=100,\n ),\n small=dict(\n attributes=50,\n dict=10,\n list=6,\n set=6,\n pandas_rows=6,\n pandas_cols=10,\n ),\n )" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "Database" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._db_uri" ], [ "CALL_FUNCTION", "Database(self._db_uri)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.walk" ], [ "LOAD_FAST", "root" ], [ "CALL_METHOD", "ast.walk(root)" ], [ "LOAD_GLOBAL", "tracer" ], [ "LOAD_METHOD", "tracer.loops" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "tracer.loops(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "CALL_FUNCTION", "isinstance(node, ast.expr)" ], [ "LOAD_GLOBAL", "is_interesting_expression" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "is_interesting_expression(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "BirdsEye" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(BirdsEye, self)" ], [ "LOAD_METHOD", "super(BirdsEye, self).compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "flags" ], [ "CALL_METHOD", "super(BirdsEye, self).compile(source, filename, flags)" ], [ "LOAD_GLOBAL", "ASTTokens" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.root" ], [ "CALL_FUNCTION_KW", "ASTTokens(source, tree=traced_file.root)" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "CONTAINS_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.For)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.body" ], [ "BINARY_SUBSCR", "node.parent.body[0]" ], [ "IS_OP", "node is node.parent.body[0]" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._add_iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self._add_iteration(node._loops, frame)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.While)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.test" ], [ "IS_OP", "node is node.parent.test" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._add_iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self._add_iteration(node._loops, frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_ATTR", "self.stack[frame].iteration" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "loops" ], [ "CALL_FUNCTION", "enumerate(loops)" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.loops" ], [ "LOAD_FAST", "loop_node" ], [ "LOAD_ATTR", "loop_node._tree_index" ], [ "BINARY_SUBSCR", "iteration.loops[loop_node._tree_index]" ], [ "LOAD_FAST", "i" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "loops" ], [ "CALL_FUNCTION", "len(loops)" ], [ "BINARY_SUBTRACT", "len(loops) - 1" ], [ "COMPARE_OP", "i == len(loops) - 1" ], [ "LOAD_FAST", "loop" ], [ "LOAD_METHOD", "loop.append" ], [ "LOAD_GLOBAL", "Iteration" ], [ "CALL_FUNCTION", "Iteration()" ], [ "CALL_METHOD", "loop.append(Iteration())" ], [ "LOAD_FAST", "loop" ], [ "LOAD_METHOD", "loop.last" ], [ "CALL_METHOD", "loop.last()" ], [ "LOAD_GLOBAL", "_tracing_recursively" ], [ "LOAD_DEREF", "frame" ], [ "CALL_FUNCTION", "_tracing_recursively(frame)" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "CONTAINS_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._is_interesting_expression" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "BINARY_SUBSCR", "self._code_infos[frame.f_code]" ], [ "LOAD_ATTR", "self._code_infos[frame.f_code].traced_file" ], [ "LOAD_ATTR", "self._code_infos[frame.f_code].traced_file.is_ipython_cell" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Expr" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.Expr)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.parent" ], [ "LOAD_ATTR", "node.parent.parent.body" ], [ "BINARY_SUBSCR", "node.parent.parent.body[-1]" ], [ "IS_OP", "node.parent is node.parent.parent.body[-1]" ], [ "LOAD_DEREF", "value" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "is_obvious_builtin" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_DEREF", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_ATTR", "self.stack[frame].expression_values" ], [ "LOAD_FAST", "node" ], [ "BINARY_SUBSCR", "self.stack[frame].expression_values[node]" ], [ "CALL_FUNCTION", "is_obvious_builtin(node, self.stack[frame].expression_values[node])" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_DEREF", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_FAST", "exc_value" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self._exception_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_FAST", "exc_value" ], [ "CALL_METHOD", "self._exception_value(node, frame, exc_value)" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOAD_ATTR", "NodeValue.expression" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.num_samples" ], [ "LOAD_DEREF", "value" ], [ "LOAD_GLOBAL", "max" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "CALL_FUNCTION", "len(node._loops)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self._is_first_loop_iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "frame" ], [ "CALL_METHOD", "self._is_first_loop_iteration(node, frame)" ], [ "UNARY_NOT", "not self._is_first_loop_iteration(node, frame)" ], [ "BINARY_MULTIPLY", "len(node._loops) * (not self._is_first_loop_iteration(node, frame))" ], [ "BINARY_SUBTRACT", "3 - len(node._loops) * (not self._is_first_loop_iteration(node, frame))" ], [ "CALL_FUNCTION", "max(1, 3 - len(node._loops) * (not self._is_first_loop_iteration(node, frame)))" ], [ "CALL_FUNCTION_KW", "NodeValue.expression(\n self.num_samples,\n value,\n level=max(1, 3 - len(node._loops) * (not self._is_first_loop_iteration(node, frame))),\n )" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self._set_node_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_FAST", "node_value" ], [ "CALL_METHOD", "self._set_node_value(node, frame, node_value)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self._check_inner_call" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node_value" ], [ "CALL_METHOD", "self._check_inner_call(frame_info, node, node_value)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.comprehension)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.iter" ], [ "IS_OP", "node is node.parent.iter" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.GeneratorExp" ], [ "CALL_FUNCTION", "isinstance(node.parent.parent, ast.GeneratorExp)" ], [ "UNARY_NOT", "not isinstance(node.parent.parent, ast.GeneratorExp)" ], [ "LOAD_FAST", "is_special_comprehension_iter" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self._set_node_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOAD_METHOD", "NodeValue.covered" ], [ "CALL_METHOD", "NodeValue.covered()" ], [ "CALL_METHOD", "self._set_node_value(node.parent, frame, NodeValue.covered())" ], [ "LOAD_FAST", "exc_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "BINARY_ADD", "node._loops + (node.parent,)" ], [ "LOAD_GLOBAL", "ChangeValue" ], [ "LOAD_FAST", "comprehension_iter_proxy" ], [ "CALL_FUNCTION", "comprehension_iter_proxy()" ], [ "CALL_FUNCTION", "ChangeValue(comprehension_iter_proxy())" ], [ "LOAD_DEREF", "value" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self._add_iteration" ], [ "LOAD_DEREF", "loops" ], [ "LOAD_DEREF", "frame" ], [ "CALL_METHOD", "self._add_iteration(loops, frame)" ], [ "LOAD_FAST", "item" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.inner_calls" ], [ "LOAD_METHOD", "frame_info.inner_calls.pop" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "frame_info.inner_calls.pop(node, None)" ], [ "LOAD_FAST", "inner_calls" ], [ "LOAD_FAST", "node_value" ], [ "LOAD_METHOD", "node_value.set_meta" ], [ "LOAD_FAST", "inner_calls" ], [ "CALL_METHOD", "node_value.set_meta('inner_calls', inner_calls)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_ATTR", "self.stack[frame].iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.loops" ], [ "LOAD_FAST", "loop_node" ], [ "LOAD_ATTR", "loop_node._tree_index" ], [ "BINARY_SUBSCR", "iteration.loops[loop_node._tree_index]" ], [ "LOAD_FAST", "loop" ], [ "LOAD_METHOD", "loop.last" ], [ "CALL_METHOD", "loop.last()" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.index" ], [ "COMPARE_OP", "iteration.index > 0" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_ATTR", "self.stack[frame].iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.loops" ], [ "LOAD_FAST", "loop_node" ], [ "LOAD_ATTR", "loop_node._tree_index" ], [ "BINARY_SUBSCR", "iteration.loops[loop_node._tree_index]" ], [ "LOAD_FAST", "loop" ], [ "LOAD_METHOD", "loop.recorded_node" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "loop.recorded_node(node)" ], [ "LOAD_FAST", "loop" ], [ "LOAD_METHOD", "loop.last" ], [ "CALL_METHOD", "loop.last()" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.vals" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOAD_METHOD", "NodeValue.exception" ], [ "LOAD_FAST", "exc_value" ], [ "CALL_METHOD", "NodeValue.exception(exc_value)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._set_node_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "value" ], [ "CALL_METHOD", "self._set_node_value(node, frame, value)" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "CONTAINS_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_GLOBAL", "_tracing_recursively" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "_tracing_recursively(frame)" ], [ "LOAD_FAST", "exc_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "exc_node" ], [ "IS_OP", "node is exc_node" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._exception_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "exc_value" ], [ "CALL_METHOD", "self._exception_value(node, frame, exc_value)" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOAD_METHOD", "NodeValue.covered" ], [ "CALL_METHOD", "NodeValue.covered()" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._set_node_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "value" ], [ "CALL_METHOD", "self._set_node_value(node, frame, value)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._check_inner_call" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "value" ], [ "CALL_METHOD", "self._check_inner_call(self.stack[frame], node, value)" ], [ "LOAD_FAST", "enter_info" ], [ "LOAD_ATTR", "enter_info.current_frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "CONTAINS_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_GLOBAL", "_tracing_recursively" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "_tracing_recursively(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_GLOBAL", "get_unfrozen_datetime" ], [ "CALL_FUNCTION", "get_unfrozen_datetime()" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_GLOBAL", "Iteration" ], [ "CALL_FUNCTION", "Iteration()" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "BINARY_SUBSCR", "self._code_infos[frame.f_code]" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "enter_info" ], [ "LOAD_ATTR", "enter_info.enter_node" ], [ "LOAD_ATTR", "enter_info.enter_node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Module" ], [ "CALL_FUNCTION", "isinstance(enter_info.enter_node.parent, ast.Module)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "LOAD_METHOD", "frame.f_locals.copy" ], [ "CALL_METHOD", "frame.f_locals.copy()" ], [ "LOAD_FAST", "code_info" ], [ "LOAD_ATTR", "code_info.arg_names" ], [ "LOAD_DEREF", "f_locals" ], [ "LOAD_METHOD", "f_locals.items" ], [ "CALL_METHOD", "f_locals.items()" ], [ "BINARY_ADD", "[(name, f_locals.pop(name))\n for name in code_info.arg_names\n if name] + [\n\n # Local variables other than actual arguments. These are variables from\n # the enclosing scope. It's handy to treat them like arguments in the UI\n it for it in f_locals.items()\n if it[0][0] != '.' # Appears when using nested tuple arguments\n ]" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_METHOD", "json.dumps" ], [ "LOAD_FAST", "arguments" ], [ "CALL_METHOD", "json.dumps([[k, cheap_repr(v)] for k, v in arguments])" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._call_id" ], [ "CALL_METHOD", "self._call_id()" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "defaultdict(list)" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_METHOD", "self.stack.get" ], [ "LOAD_FAST", "enter_info" ], [ "LOAD_ATTR", "enter_info.caller_frame" ], [ "CALL_METHOD", "self.stack.get(enter_info.caller_frame)" ], [ "LOAD_FAST", "prev" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "prev" ], [ "CALL_FUNCTION", "getattr(prev, 'inner_calls', None)" ], [ "LOAD_FAST", "inner_calls" ], [ "IS_OP", "inner_calls is not None" ], [ "LOAD_FAST", "inner_calls" ], [ "LOAD_FAST", "enter_info" ], [ "LOAD_ATTR", "enter_info.call_node" ], [ "BINARY_SUBSCR", "inner_calls[enter_info.call_node]" ], [ "LOAD_METHOD", "inner_calls[enter_info.call_node].append" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.call_id" ], [ "CALL_METHOD", "inner_calls[enter_info.call_node].append(frame_info.call_id)" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "name" ], [ "LOAD_DEREF", "f_locals" ], [ "LOAD_METHOD", "f_locals.pop" ], [ "LOAD_FAST", "name" ], [ "CALL_METHOD", "f_locals.pop(name)" ], [ "LOAD_FAST", "it" ], [ "BINARY_SUBSCR", "it[0]" ], [ "BINARY_SUBSCR", "it[0][0]" ], [ "COMPARE_OP", "it[0][0] != '.'" ], [ "LOAD_FAST", "it" ], [ "LOAD_FAST", "k" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "cheap_repr(v)" ], [ "LOAD_GLOBAL", "uuid4" ], [ "CALL_FUNCTION", "uuid4()" ], [ "LOAD_ATTR", "uuid4().hex" ], [ "LOAD_DEREF", "exit_info" ], [ "LOAD_ATTR", "exit_info.current_frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "CONTAINS_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_GLOBAL", "_tracing_recursively" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "_tracing_recursively(frame)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.iteration" ], [ "LOAD_GLOBAL", "_deep_dict" ], [ "CALL_FUNCTION", "_deep_dict()" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self._extract_node_values" ], [ "LOAD_DEREF", "top_iteration" ], [ "LOAD_DEREF", "node_values" ], [ "CALL_METHOD", "self._extract_node_values(top_iteration, (), node_values)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "BINARY_SUBSCR", "self._code_infos[frame.f_code]" ], [ "LOAD_ATTR", "self._code_infos[frame.f_code].db_func" ], [ "LOAD_DEREF", "exit_info" ], [ "LOAD_ATTR", "exit_info.exc_value" ], [ "LOAD_FAST", "exc" ], [ "LOAD_METHOD", "''.join" ], [ "LOAD_GLOBAL", "traceback" ], [ "LOAD_METHOD", "traceback.format_exception" ], [ "LOAD_GLOBAL", "type" ], [ "LOAD_FAST", "exc" ], [ "CALL_FUNCTION", "type(exc)" ], [ "LOAD_FAST", "exc" ], [ "LOAD_DEREF", "exit_info" ], [ "LOAD_ATTR", "exit_info.exc_tb" ], [ "CALL_METHOD", "traceback.format_exception(type(exc), exc, exit_info.exc_tb)" ], [ "CALL_METHOD", "''.join(traceback.format_exception(type(exc), exc, exit_info.exc_tb))" ], [ "LOAD_GLOBAL", "exception_string" ], [ "LOAD_FAST", "exc" ], [ "CALL_FUNCTION", "exception_string(exc)" ], [ "LOAD_GLOBAL", "retry_db" ], [ "CALL_FUNCTION", "retry_db" ], [ "LOAD_FAST", "add_call" ], [ "CALL_FUNCTION", "add_call()" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.call_id" ], [ "LOAD_DEREF", "self" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.db" ], [ "LOAD_ATTR", "self.db.Call" ], [ "LOAD_FAST", "Call" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.call_id" ], [ "LOAD_DEREF", "db_func" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.arguments" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_DEREF", "exit_info" ], [ "LOAD_ATTR", "exit_info.return_value" ], [ "CALL_FUNCTION", "cheap_repr(exit_info.return_value)" ], [ "LOAD_DEREF", "exception" ], [ "LOAD_DEREF", "traceback_str" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_ATTR", "json.dumps" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_DEREF", "node_values" ], [ "LOAD_DEREF", "top_iteration" ], [ "LOAD_METHOD", "top_iteration.extract_iterations" ], [ "CALL_METHOD", "top_iteration.extract_iterations()" ], [ "BINARY_SUBSCR", "top_iteration.extract_iterations()['loops']" ], [ "LOAD_GLOBAL", "type_registry" ], [ "LOAD_METHOD", "type_registry.names" ], [ "CALL_METHOD", "type_registry.names()" ], [ "LOAD_GLOBAL", "type_registry" ], [ "LOAD_ATTR", "type_registry.num_special_types" ], [ "CALL_FUNCTION_KW", "dict(\n node_values=node_values,\n loop_iterations=top_iteration.extract_iterations()['loops'],\n type_names=type_registry.names(),\n num_special_types=type_registry.num_special_types,\n )" ], [ "LOAD_GLOBAL", "ProtocolEncoder" ], [ "CALL_FUNCTION_KW", "json.dumps(\n dict(\n node_values=node_values,\n loop_iterations=top_iteration.extract_iterations()['loops'],\n type_names=type_registry.names(),\n num_special_types=type_registry.num_special_types,\n ),\n cls=ProtocolEncoder,\n separators=(',', ':')\n )" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.start_time" ], [ "CALL_FUNCTION_KW", "Call(id=frame_info.call_id,\n function_id=db_func,\n arguments=frame_info.arguments,\n return_value=cheap_repr(exit_info.return_value),\n exception=exception,\n traceback=traceback_str,\n data=json.dumps(\n dict(\n node_values=node_values,\n loop_iterations=top_iteration.extract_iterations()['loops'],\n type_names=type_registry.names(),\n num_special_types=type_registry.num_special_types,\n ),\n cls=ProtocolEncoder,\n separators=(',', ':')\n ),\n start_time=frame_info.start_time)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.db" ], [ "LOAD_METHOD", "self.db.session_scope" ], [ "CALL_METHOD", "self.db.session_scope()" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.add" ], [ "LOAD_FAST", "call" ], [ "CALL_METHOD", "session.add(call)" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.vals" ], [ "LOAD_METHOD", "iteration.vals.items" ], [ "CALL_METHOD", "iteration.vals.items()" ], [ "LOAD_FAST", "tree_index" ], [ "LOAD_FAST", "path" ], [ "BINARY_ADD", "(tree_index,) + path" ], [ "LOAD_FAST", "node_values" ], [ "LOAD_FAST", "full_path" ], [ "BINARY_SUBSCR", "full_path[:-1]" ], [ "LOAD_FAST", "d" ], [ "LOAD_FAST", "path_k" ], [ "BINARY_SUBSCR", "d[path_k]" ], [ "LOAD_FAST", "node_value" ], [ "LOAD_FAST", "d" ], [ "LOAD_FAST", "full_path" ], [ "BINARY_SUBSCR", "full_path[-1]" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.loops" ], [ "LOAD_METHOD", "iteration.loops.values" ], [ "CALL_METHOD", "iteration.loops.values()" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "loop" ], [ "CALL_FUNCTION", "enumerate(loop)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._extract_node_values" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "path + (i,)" ], [ "LOAD_FAST", "node_values" ], [ "CALL_METHOD", "self._extract_node_values(iteration, path + (i,), node_values)" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "BirdsEye" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(BirdsEye, self)" ], [ "LOAD_METHOD", "super(BirdsEye, self).trace_function" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "super(BirdsEye, self).trace_function(func)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_METHOD", "self._code_infos.get" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_ATTR", "new_func.__code__" ], [ "CALL_METHOD", "self._code_infos.get(new_func.__code__)" ], [ "LOAD_FAST", "code_info" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.getsourcelines" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "inspect.getsourcelines(func)" ], [ "LOAD_FAST", "start_lineno" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "lines" ], [ "CALL_FUNCTION", "len(lines)" ], [ "BINARY_ADD", "start_lineno + len(lines)" ], [ "LOAD_GLOBAL", "safe_qualname" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "safe_qualname(func)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.getsourcefile" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "inspect.getsourcefile(func)" ], [ "LOAD_FAST", "source_file" ], [ "LOAD_METHOD", "source_file.startswith" ], [ "CALL_METHOD", "source_file.startswith('= 0" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.getsourcefile" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "inspect.getsourcefile(frame)" ], [ "LOAD_FAST", "filename" ], [ "IS_OP", "filename is not None" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_METHOD", "os.path.abspath" ], [ "LOAD_FAST", "filename" ], [ "CALL_METHOD", "os.path.abspath(filename)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "LOAD_METHOD", "frame.f_globals.get" ], [ "CALL_METHOD", "frame.f_globals.get('__name__')" ], [ "COMPARE_OP", "frame.f_globals.get('__name__') != '__main__'" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._treetrace_hidden_with_stmt" ], [ "LOAD_ATTR", "self._treetrace_hidden_with_stmt.__name__" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "CONTAINS_OP", "self._treetrace_hidden_with_stmt.__name__ not in frame.f_globals" ], [ "LOAD_GLOBAL", "RuntimeError" ], [ "CALL_FUNCTION", "RuntimeError(\n 'To trace an imported module, you must import birdseye before '\n 'importing that module.')" ], [ "LOAD_GLOBAL", "read_source_file" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "read_source_file(filename)" ], [ "LOAD_METHOD", "read_source_file(filename).splitlines" ], [ "CALL_METHOD", "read_source_file(filename).splitlines()" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lineno" ], [ "BINARY_MULTIPLY", "[''] * frame.f_lineno" ], [ "LOAD_FAST", "lines" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lineno" ], [ "LOAD_METHOD", "'\\n'.join" ], [ "LOAD_FAST", "lines" ], [ "CALL_METHOD", "'\\n'.join(lines)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.exec_string" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "LOAD_FAST", "deep" ], [ "CALL_METHOD", "self.exec_string(source, filename, frame.f_globals, frame.f_locals, deep)" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_METHOD", "sys.exit" ], [ "CALL_METHOD", "sys.exit(0)" ], [ "LOAD_FAST", "globs" ], [ "LOAD_FAST", "locs" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self.compile" ], [ "LOAD_DEREF", "source" ], [ "LOAD_DEREF", "filename" ], [ "CALL_METHOD", "self.compile(source, filename)" ], [ "LOAD_FAST", "globs" ], [ "LOAD_METHOD", "globs.update" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self._trace_methods_dict" ], [ "LOAD_DEREF", "traced_file" ], [ "CALL_METHOD", "self._trace_methods_dict(traced_file)" ], [ "CALL_METHOD", "globs.update(self._trace_methods_dict(traced_file))" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self._trace" ], [ "LOAD_GLOBAL", "FILE_SENTINEL_NAME" ], [ "LOAD_DEREF", "filename" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.code" ], [ "LOAD_DEREF", "source" ], [ "CALL_METHOD", "self._trace(FILE_SENTINEL_NAME, filename, traced_file, traced_file.code, 'module', source)" ], [ "LOAD_FAST", "deep" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.nodes" ], [ "LOAD_DEREF", "find_code" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.code" ], [ "CALL_FUNCTION", "find_code(traced_file.code)" ], [ "LOAD_GLOBAL", "exec" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.code" ], [ "LOAD_FAST", "globs" ], [ "LOAD_FAST", "locs" ], [ "CALL_FUNCTION", "exec(traced_file.code, globs, locs)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(node, ast.FunctionDef)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.lineno" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "root_code" ], [ "LOAD_ATTR", "root_code.co_consts" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.iscode" ], [ "LOAD_FAST", "code" ], [ "CALL_METHOD", "inspect.iscode(code)" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "LOAD_METHOD", "code.co_name.startswith" ], [ "CALL_METHOD", "code.co_name.startswith('<')" ], [ "LOAD_DEREF", "find_code" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "find_code(code)" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_firstlineno" ], [ "LOAD_DEREF", "nodes_by_lineno" ], [ "LOAD_METHOD", "nodes_by_lineno.get" ], [ "LOAD_FAST", "lineno" ], [ "CALL_METHOD", "nodes_by_lineno.get(lineno)" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._trace" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "LOAD_DEREF", "filename" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_FAST", "code" ], [ "LOAD_DEREF", "source" ], [ "LOAD_FAST", "lineno" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.last_token" ], [ "LOAD_ATTR", "node.last_token.end" ], [ "BINARY_SUBSCR", "node.last_token.end[0]" ], [ "BINARY_ADD", "node.last_token.end[0] + 1" ], [ "CALL_FUNCTION_KW", "self._trace(\n code.co_name, filename, traced_file, code,\n typ='function',\n source=source,\n start_lineno=lineno,\n end_lineno=node.last_token.end[0] + 1,\n )" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_DEREF", "start_lineno" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "source" ], [ "LOAD_METHOD", "source.splitlines" ], [ "CALL_METHOD", "source.splitlines()" ], [ "CALL_FUNCTION", "len(source.splitlines())" ], [ "BINARY_ADD", "start_lineno + len(source.splitlines())" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._nodes_of_interest" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_DEREF", "start_lineno" ], [ "LOAD_FAST", "end_lineno" ], [ "CALL_METHOD", "self._nodes_of_interest(traced_file, start_lineno, end_lineno)" ], [ "CALL_FUNCTION", "list(self._nodes_of_interest(traced_file, start_lineno, end_lineno))" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._nodes_html" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_DEREF", "start_lineno" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_FAST", "traced_file" ], [ "CALL_METHOD", "self._nodes_html(nodes, start_lineno, end_lineno, traced_file)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "nodes" ], [ "CALL_FUNCTION_KW", "dict(\n # This maps each node to the loops enclosing that node\n node_loops={\n node._tree_index: [n._tree_index for n in node._loops]\n for node, _ in nodes\n if node._loops\n },\n )" ], [ "LOAD_FAST", "typ" ], [ "COMPARE_OP", "typ == 'function'" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.tokens" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_FAST", "nodes" ], [ "CALL_FUNCTION", "only(node\n for node, _ in nodes\n if isinstance(node, ast.FunctionDef)\n and node.first_token.start[0] == start_lineno)" ], [ "LOAD_GLOBAL", "source_without_decorators" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_FAST", "func_node" ], [ "CALL_FUNCTION", "source_without_decorators(tokens, func_node)" ], [ "LOAD_FAST", "data_dict" ], [ "LOAD_ATTR", "data_dict.update" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._node_ranges" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_FAST", "func_startpos" ], [ "CALL_METHOD", "self._node_ranges(nodes, tokens, func_startpos)" ], [ "CALL_FUNCTION", "list(self._node_ranges(nodes, tokens, func_startpos))" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._loop_ranges" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_FAST", "func_startpos" ], [ "CALL_METHOD", "self._loop_ranges(nodes, tokens, func_startpos)" ], [ "CALL_FUNCTION", "list(self._loop_ranges(nodes, tokens, func_startpos))" ], [ "CALL_FUNCTION_KW", "data_dict.update(\n node_ranges=list(self._node_ranges(nodes, tokens, func_startpos)),\n loop_ranges=list(self._loop_ranges(nodes, tokens, func_startpos)),\n )" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_ATTR", "json.dumps" ], [ "LOAD_FAST", "data_dict" ], [ "CALL_FUNCTION_KW", "json.dumps(data_dict, sort_keys=True)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._db_func" ], [ "LOAD_FAST", "data" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "html_body" ], [ "LOAD_FAST", "name" ], [ "LOAD_DEREF", "start_lineno" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "typ" ], [ "CALL_METHOD", "self._db_func(data, filename, html_body, name, start_lineno, source, typ)" ], [ "LOAD_GLOBAL", "CodeInfo" ], [ "LOAD_FAST", "db_func" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_FAST", "arg_names" ], [ "CALL_FUNCTION", "CodeInfo(db_func, traced_file, arg_names)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "n" ], [ "LOAD_ATTR", "n._tree_index" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(node, ast.FunctionDef)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.first_token" ], [ "LOAD_ATTR", "node.first_token.start" ], [ "BINARY_SUBSCR", "node.first_token.start[0]" ], [ "LOAD_DEREF", "start_lineno" ], [ "COMPARE_OP", "node.first_token.start[0] == start_lineno" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "classes" ], [ "CONTAINS_OP", "'loop' not in classes" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.target" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.test" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_METHOD", "tokens.get_text_range" ], [ "LOAD_FAST", "target" ], [ "CALL_METHOD", "tokens.get_text_range(target)" ], [ "LOAD_FAST", "func_start" ], [ "LOAD_FAST", "func_start" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "CALL_FUNCTION_KW", "dict(\n tree_index=node._tree_index,\n start=start,\n end=end\n )" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_METHOD", "tokens.get_text_range" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "tokens.get_text_range(node)" ], [ "LOAD_FAST", "func_start" ], [ "LOAD_FAST", "func_start" ], [ "LOAD_FAST", "start" ], [ "COMPARE_OP", "start < 0" ], [ "LOAD_FAST", "end" ], [ "COMPARE_OP", "end < 0" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(node, ast.FunctionDef)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._depth" ], [ "LOAD_FAST", "classes" ], [ "CALL_FUNCTION_KW", "dict(\n tree_index=node._tree_index,\n start=start,\n end=end,\n depth=node._depth,\n classes=classes,\n )" ], [ "LOAD_FAST", "h" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "name" ], [ "BINARY_ADD", "filename + name" ], [ "LOAD_FAST", "html_body" ], [ "BINARY_ADD", "filename + name + html_body" ], [ "LOAD_FAST", "data" ], [ "BINARY_ADD", "filename + name + html_body + data" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "start_lineno" ], [ "CALL_FUNCTION", "str(start_lineno)" ], [ "BINARY_ADD", "filename + name + html_body + data + str(start_lineno)" ], [ "CALL_FUNCTION", "h(filename + name + html_body + data + str(start_lineno))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.db" ], [ "LOAD_ATTR", "self.db.Function" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.db" ], [ "LOAD_METHOD", "self.db.session_scope" ], [ "CALL_METHOD", "self.db.session_scope()" ], [ "LOAD_GLOBAL", "one_or_none" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.query" ], [ "LOAD_FAST", "Function" ], [ "CALL_METHOD", "session.query(Function)" ], [ "LOAD_ATTR", "session.query(Function).filter_by" ], [ "LOAD_FAST", "function_hash" ], [ "CALL_FUNCTION_KW", "session.query(Function).filter_by(hash=function_hash)" ], [ "CALL_FUNCTION", "one_or_none(session.query(Function).filter_by(hash=function_hash))" ], [ "LOAD_FAST", "db_func" ], [ "LOAD_FAST", "Function" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "typ" ], [ "LOAD_FAST", "html_body" ], [ "LOAD_FAST", "start_lineno" ], [ "LOAD_FAST", "data" ], [ "LOAD_FAST", "h" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "h(source)" ], [ "LOAD_FAST", "function_hash" ], [ "CALL_FUNCTION_KW", "Function(file=filename,\n name=name,\n type=typ,\n html_body=html_body,\n lineno=start_lineno,\n data=data,\n body_hash=h(source),\n hash=function_hash)" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.add" ], [ "LOAD_FAST", "db_func" ], [ "CALL_METHOD", "session.add(db_func)" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.commit" ], [ "CALL_METHOD", "session.commit()" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "db_func" ], [ "LOAD_ATTR", "db_func.id" ], [ "LOAD_GLOBAL", "int" ], [ "CALL_FUNCTION", "isinstance(db_func.id, int)" ], [ "LOAD_FAST", "db_func" ], [ "LOAD_ATTR", "db_func.id" ], [ "LOAD_GLOBAL", "hashlib" ], [ "LOAD_METHOD", "hashlib.sha256" ], [ "LOAD_FAST", "s" ], [ "LOAD_METHOD", "s.encode" ], [ "CALL_METHOD", "s.encode('utf8')" ], [ "CALL_METHOD", "hashlib.sha256(s.encode('utf8'))" ], [ "LOAD_METHOD", "hashlib.sha256(s.encode('utf8')).hexdigest" ], [ "CALL_METHOD", "hashlib.sha256(s.encode('utf8')).hexdigest()" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.nodes" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "CALL_FUNCTION", "isinstance(node, (ast.While, ast.For, ast.comprehension))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.GeneratorExp" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.GeneratorExp)" ], [ "LOAD_FAST", "classes" ], [ "LOAD_METHOD", "classes.append" ], [ "CALL_METHOD", "classes.append('loop')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "CALL_FUNCTION", "isinstance(node, ast.stmt)" ], [ "LOAD_FAST", "classes" ], [ "LOAD_METHOD", "classes.append" ], [ "CALL_METHOD", "classes.append('stmt')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "CALL_FUNCTION", "isinstance(node, ast.expr)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._is_interesting_expression" ], [ "LOAD_FAST", "classes" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.AST" ], [ "CALL_FUNCTION", "isinstance(node, ast.AST)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "hasattr(node, 'first_token')" ], [ "LOAD_FAST", "start_lineno" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.first_token" ], [ "LOAD_ATTR", "node.first_token.start" ], [ "BINARY_SUBSCR", "node.first_token.start[0]" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.tokens" ], [ "LOAD_METHOD", "traced_file.tokens.get_text_range" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "traced_file.tokens.get_text_range(node)" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "classes" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.root" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.walk" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.root" ], [ "CALL_METHOD", "ast.walk(traced_file.root)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.iter_child_nodes" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.iter_child_nodes(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._depth" ], [ "BINARY_ADD", "node._depth + 1" ], [ "LOAD_FAST", "child" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "positions" ], [ "LOAD_METHOD", "positions.extend" ], [ "LOAD_GLOBAL", "map" ], [ "LOAD_GLOBAL", "HTMLPosition" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._depth" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._depth" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_METHOD", "' '.join" ], [ "LOAD_FAST", "classes" ], [ "CALL_METHOD", "' '.join(classes)" ], [ "BINARY_MODULO", "'' % (node._tree_index, ' '.join(classes))" ], [ "CALL_FUNCTION", "map(\n HTMLPosition,\n [start, end],\n [True, False], # is_start\n [node._depth, node._depth],\n ['' % (node._tree_index, ' '.join(classes)),\n ''])" ], [ "CALL_METHOD", "positions.extend(map(\n HTMLPosition,\n [start, end],\n [True, False], # is_start\n [node._depth, node._depth],\n ['' % (node._tree_index, ' '.join(classes)),\n '']))" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._separate_comprehensions" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_FAST", "positions" ], [ "LOAD_FAST", "traced_file" ], [ "CALL_METHOD", "self._separate_comprehensions(\n [n[0] for n in nodes],\n end_lineno, positions, traced_file)" ], [ "LOAD_FAST", "positions" ], [ "LOAD_METHOD", "positions.append" ], [ "LOAD_GLOBAL", "HTMLPosition" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.source" ], [ "CALL_FUNCTION", "len(traced_file.source)" ], [ "CALL_FUNCTION", "HTMLPosition(len(traced_file.source), False, 0, '')" ], [ "CALL_METHOD", "positions.append(HTMLPosition(len(traced_file.source), False, 0, ''))" ], [ "LOAD_FAST", "positions" ], [ "LOAD_METHOD", "positions.sort" ], [ "CALL_METHOD", "positions.sort()" ], [ "LOAD_FAST", "positions" ], [ "LOAD_FAST", "html_parts" ], [ "LOAD_METHOD", "html_parts.append" ], [ "LOAD_GLOBAL", "html" ], [ "LOAD_METHOD", "html.escape" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.source" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "position" ], [ "LOAD_ATTR", "position.index" ], [ "BINARY_SUBSCR", "traced_file.source[start:position.index]" ], [ "CALL_METHOD", "html.escape(traced_file.source[start:position.index])" ], [ "CALL_METHOD", "html_parts.append(html.escape(traced_file.source[start:position.index]))" ], [ "LOAD_FAST", "html_parts" ], [ "LOAD_METHOD", "html_parts.append" ], [ "LOAD_FAST", "position" ], [ "LOAD_ATTR", "position.html" ], [ "CALL_METHOD", "html_parts.append(position.html)" ], [ "LOAD_FAST", "position" ], [ "LOAD_ATTR", "position.index" ], [ "LOAD_METHOD", "''.join" ], [ "LOAD_FAST", "html_parts" ], [ "CALL_METHOD", "''.join(html_parts)" ], [ "LOAD_METHOD", "'\\n'.join" ], [ "LOAD_FAST", "html_body" ], [ "LOAD_METHOD", "html_body.split" ], [ "CALL_METHOD", "html_body.split('\\n')" ], [ "LOAD_FAST", "start_lineno" ], [ "BINARY_SUBTRACT", "start_lineno - 1" ], [ "LOAD_FAST", "end_lineno" ], [ "BINARY_SUBTRACT", "end_lineno - 1" ], [ "BINARY_SUBSCR", "html_body.split('\\n')[start_lineno - 1:end_lineno - 1]" ], [ "CALL_METHOD", "'\\n'.join(html_body.split('\\n')[start_lineno - 1:end_lineno - 1])" ], [ "LOAD_FAST", "html_body" ], [ "LOAD_METHOD", "html_body.strip" ], [ "CALL_METHOD", "html_body.strip('\\n')" ], [ "LOAD_FAST", "n" ], [ "BINARY_SUBSCR", "n[0]" ], [ "LOAD_GLOBAL", "group_by_key_func" ], [ "LOAD_GLOBAL", "of_type" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "LOAD_FAST", "nodes" ], [ "CALL_FUNCTION", "of_type((ast.comprehension, ast.While, ast.For), nodes)" ], [ "CALL_FUNCTION", "group_by_key_func(of_type((ast.comprehension, ast.While, ast.For), nodes),\n lambda c: c.first_token.start[0]\n )" ], [ "LOAD_FAST", "comprehensions" ], [ "LOAD_METHOD", "comprehensions.values" ], [ "CALL_METHOD", "comprehensions.values()" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_FAST", "comp_list" ], [ "CALL_FUNCTION_KW", "sorted(comp_list, key=lambda c: c.first_token.startpos)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "comp" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "CALL_FUNCTION", "isinstance(comp, ast.comprehension)" ], [ "LOAD_FAST", "comp" ], [ "LOAD_FAST", "comp" ], [ "LOAD_ATTR", "comp.parent" ], [ "LOAD_ATTR", "comp.parent.generators" ], [ "BINARY_SUBSCR", "comp.parent.generators[0]" ], [ "IS_OP", "comp is comp.parent.generators[0]" ], [ "LOAD_FAST", "get_start" ], [ "LOAD_FAST", "comp" ], [ "LOAD_ATTR", "comp.parent" ], [ "CALL_FUNCTION", "get_start(comp.parent)" ], [ "LOAD_FAST", "prev_start" ], [ "IS_OP", "prev_start is not None" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "prev_start" ], [ "COMPARE_OP", "start < prev_start" ], [ "LOAD_FAST", "get_start" ], [ "LOAD_FAST", "comp" ], [ "CALL_FUNCTION", "get_start(comp)" ], [ "LOAD_FAST", "get_start" ], [ "LOAD_FAST", "comp" ], [ "CALL_FUNCTION", "get_start(comp)" ], [ "LOAD_FAST", "prev_start" ], [ "IS_OP", "prev_start is not None" ], [ "LOAD_FAST", "positions" ], [ "LOAD_METHOD", "positions.append" ], [ "LOAD_GLOBAL", "HTMLPosition" ], [ "LOAD_FAST", "start" ], [ "CALL_FUNCTION", "HTMLPosition(start, True, 0, '\\n ')" ], [ "CALL_METHOD", "positions.append(HTMLPosition(start, True, 0, '\\n '))" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.first_token" ], [ "LOAD_ATTR", "c.first_token.start" ], [ "BINARY_SUBSCR", "c.first_token.start[0]" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.tokens" ], [ "LOAD_METHOD", "traced_file.tokens.get_text_range" ], [ "LOAD_FAST", "n" ], [ "CALL_METHOD", "traced_file.tokens.get_text_range(n)" ], [ "BINARY_SUBSCR", "traced_file.tokens.get_text_range(n)[0]" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.first_token" ], [ "LOAD_ATTR", "c.first_token.startpos" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "_deep_dict" ], [ "CALL_FUNCTION", "defaultdict(_deep_dict)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_GLOBAL", "_bad_codes" ], [ "CONTAINS_OP", "frame.f_code in _bad_codes" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "IterationList" ], [ "CALL_FUNCTION", "defaultdict(IterationList)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.index" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.loops" ], [ "LOAD_METHOD", "self.loops.items" ], [ "CALL_METHOD", "self.loops.items()" ], [ "LOAD_FAST", "tree_index" ], [ "LOAD_FAST", "iteration_list" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_METHOD", "iteration.extract_iterations" ], [ "CALL_METHOD", "iteration.extract_iterations()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "deque" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.side_len" ], [ "CALL_FUNCTION_KW", "deque(maxlen=self.side_len)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "Counter" ], [ "CALL_FUNCTION", "Counter()" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.length" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.side_len" ], [ "COMPARE_OP", "self.length < self.side_len" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start" ], [ "LOAD_METHOD", "self.start.append" ], [ "LOAD_FAST", "iteration" ], [ "CALL_METHOD", "self.start.append(iteration)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "CALL_FUNCTION", "len(self.end)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.side_len" ], [ "COMPARE_OP", "len(self.end) >= self.side_len" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "BINARY_SUBSCR", "self.end[0]" ], [ "LOAD_ATTR", "self.end[0].keep" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start" ], [ "LOAD_METHOD", "self.start.append" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "BINARY_SUBSCR", "self.end[0]" ], [ "CALL_METHOD", "self.start.append(self.end[0])" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "LOAD_METHOD", "self.end.append" ], [ "LOAD_FAST", "iteration" ], [ "CALL_METHOD", "self.end.append(iteration)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.length" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "chain" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "CALL_FUNCTION", "chain(self.start, self.end)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "BINARY_SUBSCR", "self.end[-1]" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start" ], [ "BINARY_SUBSCR", "self.start[-1]" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.recorded" ], [ "LOAD_FAST", "node" ], [ "BINARY_SUBSCR", "self.recorded[node]" ], [ "COMPARE_OP", "self.recorded[node] >= 2" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.last" ], [ "CALL_METHOD", "self.last()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.recorded" ], [ "LOAD_FAST", "node" ], [ "LOAD_NAME", "type" ], [ "CALL_FUNCTION", "type(None)" ], [ "LOAD_NAME", "bool" ], [ "LOAD_NAME", "int" ], [ "LOAD_NAME", "float" ], [ "LOAD_NAME", "complex" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "long" ], [ "LOAD_NAME", "basic_types" ], [ "LOAD_NAME", "list" ], [ "LOAD_NAME", "dict" ], [ "LOAD_NAME", "tuple" ], [ "LOAD_NAME", "set" ], [ "LOAD_NAME", "frozenset" ], [ "LOAD_NAME", "str" ], [ "BINARY_ADD", "basic_types + (list, dict, tuple, set, frozenset, str)" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "unicode" ], [ "LOAD_NAME", "bytes" ], [ "LOAD_NAME", "len" ], [ "LOAD_NAME", "special_types" ], [ "CALL_FUNCTION", "len(special_types)" ], [ "LOAD_GLOBAL", "Lock" ], [ "CALL_FUNCTION", "Lock()" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "CALL_FUNCTION", "defaultdict(lambda: len(self.data))" ], [ "LOAD_DEREF", "self" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.special_types" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.data" ], [ "LOAD_FAST", "t" ], [ "BINARY_SUBSCR", "self.data[t]" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.data" ], [ "CALL_FUNCTION", "len(self.data)" ], [ "LOAD_GLOBAL", "correct_type" ], [ "LOAD_FAST", "item" ], [ "CALL_FUNCTION", "correct_type(item)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.lock" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.data" ], [ "LOAD_FAST", "t" ], [ "BINARY_SUBSCR", "self.data[t]" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.data" ], [ "LOAD_METHOD", "self.data.items" ], [ "CALL_METHOD", "self.data.items()" ], [ "CALL_FUNCTION", "dict((v, k) for k, v in self.data.items())" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_DEREF", "rev" ], [ "CALL_FUNCTION", "len(rev)" ], [ "CALL_FUNCTION", "range(len(rev))" ], [ "LOAD_FAST", "v" ], [ "LOAD_FAST", "k" ], [ "LOAD_GLOBAL", "safe_qualname" ], [ "LOAD_DEREF", "rev" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "rev[i]" ], [ "CALL_FUNCTION", "safe_qualname(rev[i])" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_FAST", "val_repr" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "type_index" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.meta" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.meta" ], [ "LOAD_FAST", "key" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.children" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.children" ], [ "LOAD_METHOD", "self.children.append" ], [ "LOAD_FAST", "key" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOAD_METHOD", "NodeValue.expression" ], [ "LOAD_FAST", "samples" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "level" ], [ "CALL_METHOD", "NodeValue.expression(samples, value, level)" ], [ "CALL_METHOD", "self.children.append((key, NodeValue.expression(samples, value, level)))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.val_repr" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.type_index" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.meta" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.children" ], [ "LOAD_FAST", "result" ], [ "LOAD_METHOD", "result.extend" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.children" ], [ "CALL_METHOD", "result.extend(self.children)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "cls" ], [ "CALL_FUNCTION", "cls('', -2)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_GLOBAL", "exception_string" ], [ "LOAD_FAST", "exc_value" ], [ "CALL_FUNCTION", "exception_string(exc_value)" ], [ "CALL_FUNCTION", "cls(exception_string(exc_value), -1)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "cheap_repr(val)" ], [ "LOAD_GLOBAL", "type_registry" ], [ "LOAD_FAST", "val" ], [ "BINARY_SUBSCR", "type_registry[val]" ], [ "CALL_FUNCTION", "cls(cheap_repr(val), type_registry[val])" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "TypeRegistry" ], [ "LOAD_ATTR", "TypeRegistry.basic_types" ], [ "LOAD_GLOBAL", "BirdsEye" ], [ "CALL_FUNCTION", "isinstance(val, (TypeRegistry.basic_types, BirdsEye))" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "QuerySet" ], [ "CALL_FUNCTION", "isinstance(val, QuerySet)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "len(val)" ], [ "LOAD_FAST", "result" ], [ "LOAD_METHOD", "result.set_meta" ], [ "LOAD_FAST", "length" ], [ "CALL_METHOD", "result.set_meta('len', length)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "ModuleType" ], [ "CALL_FUNCTION", "isinstance(val, ModuleType)" ], [ "LOAD_GLOBAL", "min" ], [ "LOAD_FAST", "level" ], [ "CALL_FUNCTION", "min(level, 2)" ], [ "LOAD_GLOBAL", "partial" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.add_child" ], [ "LOAD_FAST", "samples" ], [ "LOAD_FAST", "level" ], [ "BINARY_SUBTRACT", "level - 1" ], [ "CALL_FUNCTION", "partial(result.add_child, samples, level - 1)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Series" ], [ "LOAD_GLOBAL", "ndarray" ], [ "CALL_FUNCTION", "isinstance(val, (Series, ndarray))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "ndarray" ], [ "CALL_FUNCTION", "isinstance(val, ndarray)" ], [ "LOAD_FAST", "attrs" ], [ "LOAD_METHOD", "attrs.append" ], [ "CALL_METHOD", "attrs.append('shape')" ], [ "LOAD_FAST", "attrs" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "val" ], [ "LOAD_FAST", "name" ], [ "CALL_FUNCTION", "getattr(val, name)" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "attr" ], [ "CALL_FUNCTION", "add_child(name, attr)" ], [ "LOAD_FAST", "level" ], [ "COMPARE_OP", "level >= 3" ], [ "LOAD_FAST", "level" ], [ "COMPARE_OP", "level >= 2" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Series" ], [ "CALL_FUNCTION", "isinstance(val, Series)" ], [ "LOAD_FAST", "samples" ], [ "LOAD_FAST", "sample_type" ], [ "BINARY_SUBSCR", "samples[sample_type]" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "DataFrame" ], [ "CALL_FUNCTION", "isinstance(val, DataFrame)" ], [ "LOAD_FAST", "result" ], [ "LOAD_METHOD", "result.set_meta" ], [ "LOAD_FAST", "meta" ], [ "CALL_METHOD", "result.set_meta('dataframe', meta)" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['pandas_rows']" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['pandas_cols']" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_rows" ], [ "BINARY_ADD", "max_rows + 2" ], [ "COMPARE_OP", "length > max_rows + 2" ], [ "LOAD_FAST", "max_rows" ], [ "BINARY_FLOOR_DIVIDE", "max_rows // 2" ], [ "LOAD_FAST", "meta" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.columns" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "columns" ], [ "CALL_FUNCTION", "len(columns)" ], [ "LOAD_FAST", "num_cols" ], [ "LOAD_FAST", "max_cols" ], [ "BINARY_ADD", "max_cols + 2" ], [ "COMPARE_OP", "num_cols > max_cols + 2" ], [ "LOAD_FAST", "max_cols" ], [ "BINARY_FLOOR_DIVIDE", "max_cols // 2" ], [ "LOAD_FAST", "meta" ], [ "LOAD_GLOBAL", "set" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "num_cols" ], [ "LOAD_FAST", "max_cols" ], [ "CALL_FUNCTION", "_sample_indices(num_cols, max_cols)" ], [ "CALL_FUNCTION", "set(_sample_indices(num_cols, max_cols))" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_GLOBAL", "zip" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.columns" ], [ "LOAD_ATTR", "val.columns.format" ], [ "CALL_FUNCTION_KW", "val.columns.format(sparsify=False)" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.columns" ], [ "CALL_FUNCTION", "zip(val.columns.format(sparsify=False),\n val.columns)" ], [ "CALL_FUNCTION", "enumerate(zip(val.columns.format(sparsify=False),\n val.columns))" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "indices" ], [ "CONTAINS_OP", "i in indices" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_FAST", "formatted_name" ], [ "LOAD_FAST", "val" ], [ "LOAD_FAST", "label" ], [ "BINARY_SUBSCR", "val[label]" ], [ "CALL_FUNCTION", "add_child(formatted_name, val[label])" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Series" ], [ "CALL_FUNCTION", "isinstance(val, Series)" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['pandas_rows']" ], [ "CALL_FUNCTION", "_sample_indices(length, samples['pandas_rows'])" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.index" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "val.index[i:i + 1]" ], [ "LOAD_ATTR", "val.index[i:i + 1].format" ], [ "CALL_FUNCTION_KW", "val.index[i:i + 1].format(sparsify=False)" ], [ "BINARY_SUBSCR", "val.index[i:i + 1].format(sparsify=False)[0]" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.iloc" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "val.iloc[i]" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_FAST", "k" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child(k, v)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "level" ], [ "COMPARE_OP", "level <= 0" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "bytes" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "unicode" ], [ "LOAD_GLOBAL", "xrange" ], [ "CALL_FUNCTION", "isinstance(val,\n (str, bytes, range)\n if PY3 else\n (str, unicode, xrange))" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Sequence" ], [ "LOAD_GLOBAL", "ndarray" ], [ "CALL_FUNCTION", "isinstance(val, (Sequence, ndarray))" ], [ "LOAD_FAST", "length" ], [ "IS_OP", "length is not None" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['list']" ], [ "CALL_FUNCTION", "_sample_indices(length, samples['list'])" ], [ "LOAD_FAST", "val" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "val[i]" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "i" ], [ "CALL_FUNCTION", "str(i)" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child(str(i), v)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Mapping" ], [ "CALL_FUNCTION", "isinstance(val, Mapping)" ], [ "LOAD_GLOBAL", "islice" ], [ "LOAD_GLOBAL", "_safe_iter" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "iteritems" ], [ "CALL_FUNCTION", "_safe_iter(val, iteritems)" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['dict']" ], [ "CALL_FUNCTION", "islice(_safe_iter(val, iteritems), samples['dict'])" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "k" ], [ "CALL_FUNCTION", "cheap_repr(k)" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child(cheap_repr(k), v)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Set" ], [ "CALL_FUNCTION", "isinstance(val, Set)" ], [ "LOAD_GLOBAL", "_safe_iter" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "_safe_iter(val)" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['set']" ], [ "LOAD_FAST", "length" ], [ "IS_OP", "length is None" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "num_items" ], [ "BINARY_ADD", "num_items + 2" ], [ "COMPARE_OP", "length > num_items + 2" ], [ "LOAD_GLOBAL", "islice" ], [ "LOAD_FAST", "vals" ], [ "LOAD_FAST", "num_items" ], [ "CALL_FUNCTION", "islice(vals, num_items)" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "vals" ], [ "CALL_FUNCTION", "enumerate(vals)" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_FAST", "i" ], [ "BINARY_MODULO", "'<%s>' % i" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child('<%s>' % i, v)" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "getattr(val, '__dict__', None)" ], [ "LOAD_FAST", "d" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_GLOBAL", "islice" ], [ "LOAD_GLOBAL", "_safe_iter" ], [ "LOAD_FAST", "d" ], [ "CALL_FUNCTION", "_safe_iter(d)" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['attributes']" ], [ "CALL_FUNCTION", "islice(_safe_iter(d),\n samples['attributes'])" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION_KW", "sorted(islice(_safe_iter(d),\n samples['attributes']),\n key=str)" ], [ "LOAD_FAST", "d" ], [ "LOAD_FAST", "k" ], [ "BINARY_SUBSCR", "d[k]" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "TracedFile" ], [ "CALL_FUNCTION", "isinstance(v, TracedFile)" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "k" ], [ "CALL_FUNCTION", "str(k)" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child(str(k), v)" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "type" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "type(val)" ], [ "CALL_FUNCTION", "getattr(type(val), '__slots__', None)" ], [ "CALL_FUNCTION", "sorted(getattr(type(val), '__slots__', None) or ())" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "val" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "getattr(val, s)" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "str(s)" ], [ "LOAD_FAST", "attr" ], [ "CALL_FUNCTION", "add_child(str(s), attr)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "x" ], [ "LOAD_FAST", "f" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "f(val)" ], [ "LOAD_FAST", "x" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_ADD", "max_length + 2" ], [ "COMPARE_OP", "length <= max_length + 2" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "range(length)" ], [ "LOAD_GLOBAL", "chain" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_FLOOR_DIVIDE", "max_length // 2" ], [ "CALL_FUNCTION", "range(max_length // 2)" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_FLOOR_DIVIDE", "max_length // 2" ], [ "BINARY_SUBTRACT", "length - max_length // 2" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "range(length - max_length // 2,\n length)" ], [ "CALL_FUNCTION", "chain(range(max_length // 2),\n range(length - max_length // 2,\n length))" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "len(x)" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "n == 0" ], [ "LOAD_GLOBAL", "repr" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "repr(x)" ], [ "LOAD_FAST", "helper" ], [ "LOAD_ATTR", "helper.level" ], [ "BINARY_SUBTRACT", "helper.level - 1" ], [ "LOAD_GLOBAL", "_repr_series_one_line" ], [ "LOAD_ATTR", "_repr_series_one_line.maxparts" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "n" ], [ "LOAD_FAST", "maxparts" ], [ "CALL_FUNCTION", "_sample_indices(n, maxparts)" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.index" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "x.index[i:i + 1]" ], [ "LOAD_ATTR", "x.index[i:i + 1].format" ], [ "CALL_FUNCTION_KW", "x.index[i:i + 1].format(sparsify=False)" ], [ "BINARY_SUBSCR", "x.index[i:i + 1].format(sparsify=False)[0]" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.iloc" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "x.iloc[i]" ], [ "LOAD_FAST", "pieces" ], [ "LOAD_METHOD", "pieces.append" ], [ "LOAD_FAST", "k" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "v" ], [ "LOAD_FAST", "newlevel" ], [ "CALL_FUNCTION", "cheap_repr(v, newlevel)" ], [ "BINARY_MODULO", "'%s = %s' % (k, cheap_repr(v, newlevel))" ], [ "CALL_METHOD", "pieces.append('%s = %s' % (k, cheap_repr(v, newlevel)))" ], [ "LOAD_FAST", "n" ], [ "LOAD_FAST", "maxparts" ], [ "BINARY_ADD", "maxparts + 2" ], [ "COMPARE_OP", "n > maxparts + 2" ], [ "LOAD_FAST", "pieces" ], [ "LOAD_METHOD", "pieces.insert" ], [ "LOAD_FAST", "maxparts" ], [ "BINARY_FLOOR_DIVIDE", "maxparts // 2" ], [ "CALL_METHOD", "pieces.insert(maxparts // 2, '...')" ], [ "LOAD_METHOD", "'; '.join" ], [ "LOAD_FAST", "pieces" ], [ "CALL_METHOD", "'; '.join(pieces)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "CALL_FUNCTION", "isinstance(node, ast.expr)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Num" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Str" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "ast" ], [ "CALL_FUNCTION", "getattr(ast, 'NameConstant', ())" ], [ "CALL_FUNCTION", "isinstance(node, (ast.Num, ast.Str, getattr(ast, 'NameConstant', ())))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "getattr(node, 'ctx', None)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Store" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Del" ], [ "CALL_FUNCTION", "isinstance(getattr(node, 'ctx', None),\n (ast.Store, ast.Del))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.UnaryOp" ], [ "CALL_FUNCTION", "isinstance(node, ast.UnaryOp)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.op" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.UAdd" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.USub" ], [ "CALL_FUNCTION", "isinstance(node.op, (ast.UAdd, ast.USub))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.operand" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Num" ], [ "CALL_FUNCTION", "isinstance(node.operand, ast.Num)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.List" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Tuple" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Dict" ], [ "CALL_FUNCTION", "isinstance(node, (ast.List, ast.Tuple, ast.Dict))" ], [ "LOAD_GLOBAL", "any" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.iter_child_nodes" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.iter_child_nodes(node)" ], [ "CALL_FUNCTION", "any(is_interesting_expression(n) for n in ast.iter_child_nodes(node))" ], [ "UNARY_NOT", "not any(is_interesting_expression(n) for n in ast.iter_child_nodes(node))" ], [ "UNARY_NOT", "not (isinstance(node, (ast.Num, ast.Str, getattr(ast, 'NameConstant', ()))) or\n isinstance(getattr(node, 'ctx', None),\n (ast.Store, ast.Del)) or\n (isinstance(node, ast.UnaryOp) and\n isinstance(node.op, (ast.UAdd, ast.USub)) and\n isinstance(node.operand, ast.Num)) or\n (isinstance(node, (ast.List, ast.Tuple, ast.Dict)) and\n not any(is_interesting_expression(n) for n in ast.iter_child_nodes(node))))" ], [ "LOAD_GLOBAL", "is_interesting_expression" ], [ "LOAD_FAST", "n" ], [ "CALL_FUNCTION", "is_interesting_expression(n)" ], [ "LOAD_GLOBAL", "cast" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "__builtins__" ], [ "CALL_FUNCTION", "cast(dict, __builtins__)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Name" ], [ "CALL_FUNCTION", "isinstance(node, ast.Name)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.id" ], [ "LOAD_FAST", "builtins" ], [ "CONTAINS_OP", "node.id in builtins" ], [ "LOAD_FAST", "builtins" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.id" ], [ "BINARY_SUBSCR", "builtins[node.id]" ], [ "LOAD_FAST", "value" ], [ "IS_OP", "builtins[node.id] is value" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "ast" ], [ "CALL_FUNCTION", "getattr(ast, 'NameConstant', ())" ], [ "CALL_FUNCTION", "isinstance(node, getattr(ast, 'NameConstant', ()))" ] ], "configuration.py": [ [ "LOAD_NAME", "ctypes" ], [ "LOAD_ATTR", "ctypes.windll" ], [ "LOAD_ATTR", "ctypes.windll.kernel32" ], [ "LOAD_NAME", "kernel32" ], [ "LOAD_METHOD", "kernel32.SetConsoleMode" ], [ "LOAD_NAME", "kernel32" ], [ "LOAD_METHOD", "kernel32.GetStdHandle" ], [ "CALL_METHOD", "kernel32.GetStdHandle(-11)" ], [ "CALL_METHOD", "kernel32.SetConsoleMode(kernel32.GetStdHandle(-11), 7)" ], [ "LOAD_NAME", "Exception" ], [ "LOAD_NAME", "os" ], [ "LOAD_ATTR", "os.name" ], [ "COMPARE_OP", "os.name != 'nt'" ], [ "LOAD_NAME", "DefaultFormatter" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "object" ], [ "LOAD_FAST", "builtins" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_GLOBAL", "builtins_module" ], [ "LOAD_FAST", "snoop" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.snoop" ], [ "CALL_FUNCTION", "setattr(builtins_module, snoop, package.snoop)" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_GLOBAL", "builtins_module" ], [ "LOAD_FAST", "pp" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.pp" ], [ "CALL_FUNCTION", "setattr(builtins_module, pp, package.pp)" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_GLOBAL", "builtins_module" ], [ "LOAD_FAST", "spy" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.spy" ], [ "CALL_FUNCTION", "setattr(builtins_module, spy, package.spy)" ], [ "LOAD_GLOBAL", "Config" ], [ "LOAD_FAST", "out" ], [ "LOAD_FAST", "prefix" ], [ "LOAD_FAST", "columns" ], [ "LOAD_FAST", "overwrite" ], [ "LOAD_FAST", "color" ], [ "LOAD_FAST", "enabled" ], [ "LOAD_FAST", "watch_extras" ], [ "LOAD_FAST", "replace_watch_extras" ], [ "LOAD_FAST", "formatter_class" ], [ "CALL_FUNCTION_KW", "Config(\n out=out,\n prefix=prefix,\n columns=columns,\n overwrite=overwrite,\n color=color,\n enabled=enabled,\n watch_extras=watch_extras,\n replace_watch_extras=replace_watch_extras,\n formatter_class=formatter_class,\n )" ], [ "LOAD_FAST", "config" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.snoop" ], [ "LOAD_FAST", "config" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.pp" ], [ "LOAD_FAST", "config" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.spy" ], [ "LOAD_NAME", "DefaultFormatter" ], [ "LOAD_GLOBAL", "can_color" ], [ "LOAD_FAST", "color" ], [ "IS_OP", "color is None" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "out" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.stderr" ], [ "CALL_FUNCTION", "getattr(out or sys.stderr, 'isatty', lambda: False)" ], [ "LOAD_GLOBAL", "bool" ], [ "LOAD_FAST", "isatty" ], [ "CALL_FUNCTION", "isatty()" ], [ "CALL_FUNCTION", "bool(isatty())" ], [ "LOAD_GLOBAL", "get_write_function" ], [ "LOAD_FAST", "out" ], [ "LOAD_FAST", "overwrite" ], [ "CALL_FUNCTION", "get_write_function(out, overwrite)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "formatter_class" ], [ "LOAD_FAST", "prefix" ], [ "LOAD_FAST", "columns" ], [ "LOAD_FAST", "color" ], [ "CALL_FUNCTION", "formatter_class(prefix, columns, color)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "enabled" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "PP" ], [ "LOAD_DEREF", "self" ], [ "CALL_FUNCTION", "PP(self)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "Tracer" ], [ "LOAD_FAST", "ConfiguredTracer" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "Spy" ], [ "LOAD_DEREF", "self" ], [ "CALL_FUNCTION", "Spy(self)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "threading" ], [ "LOAD_METHOD", "threading.local" ], [ "CALL_METHOD", "threading.local()" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "replace_watch_extras" ], [ "IS_OP", "replace_watch_extras is not None" ], [ "LOAD_GLOBAL", "ensure_tuple" ], [ "LOAD_FAST", "replace_watch_extras" ], [ "CALL_FUNCTION", "ensure_tuple(replace_watch_extras)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "len_shape_watch" ], [ "LOAD_GLOBAL", "dtype_watch" ], [ "LOAD_GLOBAL", "ensure_tuple" ], [ "LOAD_FAST", "watch_extras" ], [ "CALL_FUNCTION", "ensure_tuple(watch_extras)" ], [ "BINARY_ADD", "(len_shape_watch, dtype_watch) + ensure_tuple(watch_extras)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_CLASSDEREF", "self" ], [ "LOAD_FAST", "value" ], [ "LOAD_ATTR", "value.shape" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.ismethod" ], [ "LOAD_FAST", "shape" ], [ "CALL_METHOD", "inspect.ismethod(shape)" ], [ "LOAD_METHOD", "'{}.shape'.format" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "'{}.shape'.format(source)" ], [ "LOAD_FAST", "shape" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "value" ], [ "LOAD_GLOBAL", "QuerySet" ], [ "CALL_FUNCTION", "isinstance(value, QuerySet)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "len(value)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "value" ], [ "LOAD_GLOBAL", "six" ], [ "LOAD_ATTR", "six.string_types" ], [ "CALL_FUNCTION", "isinstance(value, six.string_types)" ], [ "LOAD_FAST", "length" ], [ "COMPARE_OP", "length < 50" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "value" ], [ "LOAD_GLOBAL", "Mapping" ], [ "LOAD_GLOBAL", "Set" ], [ "LOAD_GLOBAL", "Sequence" ], [ "CALL_FUNCTION", "isinstance(value, (Mapping, Set, Sequence))" ], [ "LOAD_FAST", "length" ], [ "COMPARE_OP", "length == 0" ], [ "LOAD_METHOD", "'len({})'.format" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "'len({})'.format(source)" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "value" ], [ "LOAD_ATTR", "value.dtype" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.ismethod" ], [ "LOAD_FAST", "dtype" ], [ "CALL_METHOD", "inspect.ismethod(dtype)" ], [ "LOAD_METHOD", "'{}.dtype'.format" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "'{}.dtype'.format(source)" ], [ "LOAD_FAST", "dtype" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_DEREF", "output" ], [ "LOAD_GLOBAL", "six" ], [ "LOAD_ATTR", "six.string_types" ], [ "CALL_FUNCTION", "isinstance(output, six.string_types)" ], [ "LOAD_GLOBAL", "is_pathlike" ], [ "LOAD_DEREF", "output" ], [ "CALL_FUNCTION", "is_pathlike(output)" ], [ "LOAD_FAST", "is_path" ], [ "LOAD_GLOBAL", "FileWriter" ], [ "LOAD_DEREF", "output" ], [ "LOAD_FAST", "overwrite" ], [ "CALL_FUNCTION", "FileWriter(output, overwrite)" ], [ "LOAD_ATTR", "FileWriter(output, overwrite).write" ], [ "LOAD_GLOBAL", "callable" ], [ "LOAD_DEREF", "output" ], [ "CALL_FUNCTION", "callable(output)" ], [ "LOAD_DEREF", "output" ], [ "LOAD_FAST", "write" ], [ "LOAD_DEREF", "output" ], [ "LOAD_FAST", "stream" ], [ "IS_OP", "stream is None" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.stderr" ], [ "LOAD_FAST", "stream" ], [ "LOAD_METHOD", "stream.write" ], [ "LOAD_FAST", "s" ], [ "CALL_METHOD", "stream.write(s)" ], [ "LOAD_GLOBAL", "UnicodeEncodeError" ], [ "LOAD_FAST", "stream" ], [ "LOAD_METHOD", "stream.write" ], [ "LOAD_GLOBAL", "shitcode" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "shitcode(s)" ], [ "CALL_METHOD", "stream.write(shitcode(s))" ], [ "LOAD_GLOBAL", "six" ], [ "LOAD_METHOD", "six.text_type" ], [ "LOAD_FAST", "path" ], [ "CALL_METHOD", "six.text_type(path)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "overwrite" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "open" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.path" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.overwrite" ], [ "CALL_FUNCTION_KW", "open(self.path, 'w' if self.overwrite else 'a', encoding='utf-8')" ], [ "LOAD_FAST", "f" ], [ "LOAD_METHOD", "f.write" ], [ "LOAD_FAST", "s" ], [ "CALL_METHOD", "f.write(s)" ], [ "LOAD_FAST", "self" ] ], "db.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOAD_METHOD", "standard_library.install_aliases" ], [ "CALL_METHOD", "standard_library.install_aliases()" ], [ "LOAD_NAME", "RESERVED_WORDS" ], [ "LOAD_METHOD", "RESERVED_WORDS.add" ], [ "CALL_METHOD", "RESERVED_WORDS.add('function')" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "retry" ], [ "LOAD_NAME", "InterfaceError" ], [ "LOAD_NAME", "OperationalError" ], [ "LOAD_NAME", "InternalError" ], [ "LOAD_NAME", "ProgrammingError" ], [ "CALL_FUNCTION", "retry(3, (InterfaceError, OperationalError, InternalError, ProgrammingError))" ], [ "LOAD_NAME", "contextmanager" ], [ "CALL_FUNCTION", "contextmanager" ], [ "LOAD_FAST", "db_uri" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.environ" ], [ "LOAD_METHOD", "os.environ.get" ], [ "CALL_METHOD", "os.environ.get('BIRDSEYE_DB')" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_METHOD", "os.path.join" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_METHOD", "os.path.expanduser" ], [ "CALL_METHOD", "os.path.expanduser('~')" ], [ "CALL_METHOD", "os.path.join(os.path.expanduser('~'),\n '.birdseye.db')" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "dict" ], [ "CALL_FUNCTION_KW", "dict(\n pool_recycle=280,\n echo=False, # for convenience when debugging\n )" ], [ "LOAD_GLOBAL", "create_engine" ], [ "LOAD_FAST", "db_uri" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "create_engine(db_uri, **kwargs)" ], [ "LOAD_GLOBAL", "ArgumentError" ], [ "LOAD_FAST", "db_uri" ], [ "BINARY_ADD", "'sqlite:///' + db_uri" ], [ "LOAD_GLOBAL", "create_engine" ], [ "LOAD_FAST", "db_uri" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "create_engine(db_uri, **kwargs)" ], [ "LOAD_FAST", "engine" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "sessionmaker" ], [ "LOAD_FAST", "engine" ], [ "CALL_FUNCTION_KW", "sessionmaker(bind=engine)" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "object" ], [ "LOAD_GLOBAL", "declarative_base" ], [ "LOAD_FAST", "Base" ], [ "CALL_FUNCTION_KW", "declarative_base(cls=Base)" ], [ "LOAD_FAST", "Base" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "object" ], [ "LOAD_FAST", "engine" ], [ "LOAD_ATTR", "engine.name" ], [ "COMPARE_OP", "engine.name == 'mysql'" ], [ "LOAD_GLOBAL", "LONGTEXT" ], [ "LOAD_GLOBAL", "Text" ], [ "LOAD_FAST", "Base" ], [ "LOAD_FAST", "Base" ], [ "LOAD_FAST", "Call" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "Function" ], [ "LOAD_FAST", "self" ], [ "LOAD_DEREF", "KeyValue" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "KeyValueStore" ], [ "CALL_FUNCTION", "KeyValueStore()" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "_skip_version_check" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.table_exists" ], [ "LOAD_FAST", "Function" ], [ "CALL_METHOD", "self.table_exists(Function)" ], [ "LOAD_FAST", "Base" ], [ "LOAD_ATTR", "Base.metadata" ], [ "LOAD_METHOD", "Base.metadata.create_all" ], [ "LOAD_FAST", "engine" ], [ "CALL_METHOD", "Base.metadata.create_all(engine)" ], [ "LOAD_GLOBAL", "DB_VERSION" ], [ "LOAD_FAST", "kv" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.table_exists" ], [ "LOAD_DEREF", "KeyValue" ], [ "CALL_METHOD", "self.table_exists(KeyValue)" ], [ "LOAD_GLOBAL", "int" ], [ "LOAD_FAST", "kv" ], [ "LOAD_ATTR", "kv.version" ], [ "CALL_FUNCTION", "int(kv.version)" ], [ "LOAD_GLOBAL", "DB_VERSION" ], [ "COMPARE_OP", "int(kv.version) < DB_VERSION" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_METHOD", "sys.exit" ], [ "CALL_METHOD", "sys.exit('The birdseye database schema is out of date. '\n 'Run \"python -m birdseye.clear_db\" to delete the existing tables.')" ], [ "LOAD_NAME", "declared_attr" ], [ "CALL_FUNCTION", "declared_attr" ], [ "LOAD_FAST", "cls" ], [ "LOAD_ATTR", "cls.__name__" ], [ "LOAD_METHOD", "cls.__name__.lower" ], [ "CALL_METHOD", "cls.__name__.lower()" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "String" ], [ "CALL_FUNCTION", "String(50)" ], [ "CALL_FUNCTION_KW", "Column(String(50), primary_key=True)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "__getitem__" ], [ "LOAD_NAME", "__setitem__" ], [ "LOAD_DEREF", "db_self" ], [ "LOAD_METHOD", "db_self.session_scope" ], [ "CALL_METHOD", "db_self.session_scope()" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session\n .query" ], [ "LOAD_DEREF", "KeyValue" ], [ "LOAD_ATTR", "KeyValue.value" ], [ "CALL_METHOD", "session\n .query(KeyValue.value)" ], [ "LOAD_ATTR", "session\n .query(KeyValue.value)\n .filter_by" ], [ "LOAD_FAST", "item" ], [ "CALL_FUNCTION_KW", "session\n .query(KeyValue.value)\n .filter_by(key=item)" ], [ "LOAD_METHOD", "session\n .query(KeyValue.value)\n .filter_by(key=item)\n .scalar" ], [ "CALL_METHOD", "session\n .query(KeyValue.value)\n .filter_by(key=item)\n .scalar()" ], [ "LOAD_DEREF", "db_self" ], [ "LOAD_METHOD", "db_self.session_scope" ], [ "CALL_METHOD", "db_self.session_scope()" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.query" ], [ "LOAD_DEREF", "KeyValue" ], [ "CALL_METHOD", "session.query(KeyValue)" ], [ "LOAD_ATTR", "session.query(KeyValue).filter_by" ], [ "LOAD_FAST", "key" ], [ "CALL_FUNCTION_KW", "session.query(KeyValue).filter_by(key=key)" ], [ "LOAD_METHOD", "session.query(KeyValue).filter_by(key=key).delete" ], [ "CALL_METHOD", "session.query(KeyValue).filter_by(key=key).delete()" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.add" ], [ "LOAD_DEREF", "KeyValue" ], [ "LOAD_FAST", "key" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "str(value)" ], [ "CALL_FUNCTION_KW", "KeyValue(key=key, value=str(value))" ], [ "CALL_METHOD", "session.add(KeyValue(key=key, value=str(value)))" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "String" ], [ "CALL_FUNCTION_KW", "String(length=32)" ], [ "CALL_FUNCTION_KW", "Column(String(length=32), primary_key=True)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Integer" ], [ "LOAD_NAME", "ForeignKey" ], [ "CALL_FUNCTION", "ForeignKey('function.id')" ], [ "CALL_FUNCTION_KW", "Column(Integer, ForeignKey('function.id'), index=True)" ], [ "LOAD_NAME", "relationship" ], [ "LOAD_NAME", "backref" ], [ "CALL_FUNCTION_KW", "backref('calls', lazy='dynamic')" ], [ "CALL_FUNCTION_KW", "relationship('Function', backref=backref('calls', lazy='dynamic'))" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_CLASSDEREF", "LongText" ], [ "CALL_FUNCTION", "Column(LongText)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "DateTime" ], [ "CALL_FUNCTION_KW", "Column(DateTime, index=True)" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "id" ], [ "LOAD_NAME", "function_id" ], [ "LOAD_NAME", "return_value" ], [ "LOAD_NAME", "traceback" ], [ "LOAD_NAME", "exception" ], [ "LOAD_NAME", "start_time" ], [ "LOAD_NAME", "arguments" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._pretty_time" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start_time" ], [ "CALL_METHOD", "self._pretty_time(self.start_time)" ], [ "LOAD_FAST", "dt" ], [ "LOAD_GLOBAL", "Markup" ], [ "LOAD_FAST", "dt" ], [ "LOAD_METHOD", "dt.strftime" ], [ "CALL_METHOD", "dt.strftime('%Y-%m-%d %H:%M:%S')" ], [ "LOAD_GLOBAL", "naturaltime" ], [ "LOAD_FAST", "dt" ], [ "CALL_FUNCTION", "naturaltime(dt)" ], [ "BINARY_MODULO", "'%s (%s)' % (\n dt.strftime('%Y-%m-%d %H:%M:%S'),\n naturaltime(dt))" ], [ "CALL_FUNCTION", "Markup('%s (%s)' % (\n dt.strftime('%Y-%m-%d %H:%M:%S'),\n naturaltime(dt)))" ], [ "LOAD_GLOBAL", "Markup" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.success" ], [ "BINARY_MODULO", "'' % (\n ('ok', 'green') if self.success else\n ('remove', 'red'))" ], [ "CALL_FUNCTION", "Markup('' % (\n ('ok', 'green') if self.success else\n ('remove', 'red')))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.exception" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.traceback" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.return_value" ], [ "COMPARE_OP", "self.return_value == 'None'" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.traceback" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.success" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.return_value" ], [ "CALL_FUNCTION", "str(self.return_value)" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.exception" ], [ "CALL_FUNCTION", "str(self.exception)" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_METHOD", "json.loads" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.arguments" ], [ "CALL_METHOD", "json.loads(self.arguments)" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_METHOD", "json.loads" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.data" ], [ "CALL_METHOD", "json.loads(self.data)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.arguments_list" ], [ "LOAD_GLOBAL", "select_attrs" ], [ "LOAD_FAST", "call" ], [ "CALL_FUNCTION", "select_attrs(call, 'id function_id return_value traceback '\n 'exception start_time')" ], [ "CALL_FUNCTION_EX", "dict(arguments=call.arguments_list,\n **select_attrs(call, 'id function_id return_value traceback '\n 'exception start_time'))" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Integer" ], [ "LOAD_NAME", "Sequence" ], [ "CALL_FUNCTION", "Sequence('function_id_seq')" ], [ "CALL_FUNCTION_KW", "Column(Integer, Sequence('function_id_seq'), primary_key=True)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_CLASSDEREF", "LongText" ], [ "CALL_FUNCTION", "Column(LongText)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Integer" ], [ "CALL_FUNCTION", "Column(Integer)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_CLASSDEREF", "LongText" ], [ "CALL_FUNCTION", "Column(LongText)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "String" ], [ "CALL_FUNCTION_KW", "String(length=64)" ], [ "CALL_FUNCTION_KW", "Column(String(length=64), index=True)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "String" ], [ "CALL_FUNCTION_KW", "String(length=64)" ], [ "CALL_FUNCTION_KW", "Column(String(length=64), index=True)" ], [ "LOAD_NAME", "UniqueConstraint" ], [ "CALL_FUNCTION_KW", "UniqueConstraint('hash',\n name='everything_unique')" ], [ "LOAD_NAME", "Index" ], [ "CALL_FUNCTION_KW", "Index('idx_file', 'file', mysql_length=256)" ], [ "LOAD_NAME", "Index" ], [ "CALL_FUNCTION_KW", "Index('idx_name', 'name', mysql_length=32)" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "file" ], [ "LOAD_NAME", "name" ], [ "LOAD_NAME", "lineno" ], [ "LOAD_NAME", "hash" ], [ "LOAD_NAME", "body_hash" ], [ "LOAD_NAME", "type" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_METHOD", "json.loads" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.data" ], [ "CALL_METHOD", "json.loads(self.data)" ], [ "LOAD_GLOBAL", "select_attrs" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "select_attrs(func, 'file name lineno hash body_hash type')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.engine" ], [ "LOAD_ATTR", "self.engine.dialect" ], [ "LOAD_METHOD", "self.engine.dialect.has_table" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.engine" ], [ "LOAD_FAST", "table" ], [ "LOAD_ATTR", "table.__name__" ], [ "CALL_METHOD", "self.engine.dialect.has_table(self.engine, table.__name__)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.session_scope" ], [ "CALL_METHOD", "self.session_scope()" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.query" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.Function" ], [ "LOAD_ATTR", "self.Function.file" ], [ "CALL_METHOD", "session.query(self.Function.file)" ], [ "LOAD_METHOD", "session.query(self.Function.file).distinct" ], [ "CALL_METHOD", "session.query(self.Function.file).distinct()" ], [ "LOAD_FAST", "paths" ], [ "LOAD_METHOD", "paths.sort" ], [ "CALL_METHOD", "paths.sort()" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "paths" ], [ "CONTAINS_OP", "IPYTHON_FILE_PATH in paths" ], [ "LOAD_FAST", "paths" ], [ "LOAD_METHOD", "paths.remove" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "CALL_METHOD", "paths.remove(IPYTHON_FILE_PATH)" ], [ "LOAD_FAST", "paths" ], [ "LOAD_METHOD", "paths.insert" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "CALL_METHOD", "paths.insert(0, IPYTHON_FILE_PATH)" ], [ "LOAD_FAST", "paths" ], [ "LOAD_GLOBAL", "is_ipython_cell" ], [ "LOAD_FAST", "f" ], [ "BINARY_SUBSCR", "f[0]" ], [ "CALL_FUNCTION", "is_ipython_cell(f[0])" ], [ "LOAD_FAST", "f" ], [ "BINARY_SUBSCR", "f[0]" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.Call" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.Function" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._KeyValue" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.table_exists" ], [ "LOAD_FAST", "model" ], [ "CALL_METHOD", "self.table_exists(model)" ], [ "LOAD_FAST", "model" ], [ "LOAD_ATTR", "model.__table__" ], [ "LOAD_METHOD", "model.__table__.drop" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.engine" ], [ "CALL_METHOD", "model.__table__.drop(self.engine)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.Session" ], [ "CALL_METHOD", "self.Session()" ], [ "LOAD_FAST", "session" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.commit" ], [ "CALL_METHOD", "session.commit()" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.rollback" ], [ "CALL_METHOD", "session.rollback()" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.close" ], [ "CALL_METHOD", "session.close()" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.close" ], [ "CALL_METHOD", "session.close()" ], [ "LOAD_GLOBAL", "functools" ], [ "LOAD_METHOD", "functools.wraps" ], [ "LOAD_DEREF", "func" ], [ "CALL_METHOD", "functools.wraps(func)" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "LOAD_GLOBAL", "retry_db" ], [ "LOAD_FAST", "wrapper" ], [ "CALL_FUNCTION", "retry_db(wrapper)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self.session_scope" ], [ "CALL_METHOD", "self.session_scope()" ], [ "LOAD_DEREF", "func" ], [ "LOAD_FAST", "session" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "func(session, *args, **kwargs)" ] ], "executing.py": [ [ "LOAD_NAME", "sys" ], [ "LOAD_ATTR", "sys.version_info" ], [ "BINARY_SUBSCR", "sys.version_info[0]" ], [ "COMPARE_OP", "sys.version_info[0] == 3" ], [ "LOAD_NAME", "PY3" ], [ "LOAD_NAME", "lru_cache" ], [ "CALL_FUNCTION_KW", "lru_cache(maxsize=None)" ], [ "LOAD_NAME", "str" ], [ "LOAD_NAME", "unicode" ], [ "LOAD_NAME", "dis" ], [ "LOAD_ATTR", "dis.get_instructions" ], [ "LOAD_NAME", "AttributeError" ], [ "LOAD_NAME", "namedtuple" ], [ "CALL_FUNCTION", "namedtuple('Instruction', 'offset argval opname')" ], [ "LOAD_NAME", "Exception" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.NodeVisitor" ], [ "LOAD_NAME", "sum" ], [ "LOAD_NAME", "__future__" ], [ "LOAD_ATTR", "__future__.all_feature_names" ], [ "CALL_FUNCTION", "sum(\n getattr(__future__, fname).compiler_flag\n for fname in __future__.all_feature_names\n)" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "RLock" ], [ "CALL_FUNCTION", "RLock()" ], [ "LOAD_NAME", "cache" ], [ "CALL_FUNCTION", "cache" ], [ "LOAD_GLOBAL", "functools" ], [ "LOAD_METHOD", "functools.wraps" ], [ "LOAD_DEREF", "func" ], [ "CALL_METHOD", "functools.wraps(func)" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "LOAD_FAST", "wrapper" ], [ "LOAD_FAST", "args" ], [ "LOAD_DEREF", "d" ], [ "CONTAINS_OP", "args in d" ], [ "LOAD_DEREF", "d" ], [ "LOAD_FAST", "args" ], [ "BINARY_SUBSCR", "d[args]" ], [ "LOAD_DEREF", "func" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION_EX", "func(*args)" ], [ "LOAD_DEREF", "d" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "co" ], [ "LOAD_ATTR", "co.co_code" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "len(code)" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "i < n" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "code[i]" ], [ "LOAD_GLOBAL", "ord" ], [ "LOAD_FAST", "c" ], [ "CALL_FUNCTION", "ord(c)" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "LOAD_FAST", "op" ], [ "LOAD_GLOBAL", "HAVE_ARGUMENT" ], [ "COMPARE_OP", "op >= HAVE_ARGUMENT" ], [ "LOAD_GLOBAL", "ord" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "code[i]" ], [ "CALL_FUNCTION", "ord(code[i])" ], [ "LOAD_GLOBAL", "ord" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "code[i + 1]" ], [ "CALL_FUNCTION", "ord(code[i + 1])" ], [ "BINARY_MULTIPLY", "ord(code[i + 1]) * 256" ], [ "BINARY_ADD", "ord(code[i]) + ord(code[i + 1]) * 256" ], [ "LOAD_FAST", "extended_arg" ], [ "BINARY_ADD", "ord(code[i]) + ord(code[i + 1]) * 256 + extended_arg" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 2" ], [ "LOAD_FAST", "op" ], [ "LOAD_GLOBAL", "EXTENDED_ARG" ], [ "COMPARE_OP", "op == EXTENDED_ARG" ], [ "LOAD_FAST", "oparg" ], [ "BINARY_MULTIPLY", "oparg * 65536" ], [ "LOAD_FAST", "op" ], [ "LOAD_GLOBAL", "hasconst" ], [ "CONTAINS_OP", "op in hasconst" ], [ "LOAD_FAST", "co" ], [ "LOAD_ATTR", "co.co_consts" ], [ "LOAD_FAST", "oparg" ], [ "BINARY_SUBSCR", "co.co_consts[oparg]" ], [ "LOAD_GLOBAL", "Instruction" ], [ "LOAD_FAST", "offset" ], [ "LOAD_FAST", "argval" ], [ "LOAD_GLOBAL", "opname" ], [ "LOAD_FAST", "op" ], [ "BINARY_SUBSCR", "opname[op]" ], [ "CALL_FUNCTION", "Instruction(offset, argval, opname[op])" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "it" ], [ "LOAD_GLOBAL", "Sized" ], [ "CALL_FUNCTION", "isinstance(it, Sized)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "len(it)" ], [ "COMPARE_OP", "len(it) != 1" ], [ "LOAD_GLOBAL", "NotOneValueFound" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "len(it)" ], [ "BINARY_MODULO", "'Expected one value, found %s' % len(it)" ], [ "CALL_FUNCTION", "NotOneValueFound('Expected one value, found %s' % len(it))" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "list(it)" ], [ "BINARY_SUBSCR", "list(it)[0]" ], [ "LOAD_GLOBAL", "tuple" ], [ "LOAD_GLOBAL", "islice" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "islice(it, 2)" ], [ "CALL_FUNCTION", "tuple(islice(it, 2))" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "lst" ], [ "CALL_FUNCTION", "len(lst)" ], [ "COMPARE_OP", "len(lst) == 0" ], [ "LOAD_GLOBAL", "NotOneValueFound" ], [ "CALL_FUNCTION", "NotOneValueFound('Expected one value, found 0')" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "lst" ], [ "CALL_FUNCTION", "len(lst)" ], [ "COMPARE_OP", "len(lst) > 1" ], [ "LOAD_GLOBAL", "NotOneValueFound" ], [ "CALL_FUNCTION", "NotOneValueFound('Expected one value, found several')" ], [ "LOAD_FAST", "lst" ], [ "BINARY_SUBSCR", "lst[0]" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "cache" ], [ "CALL_FUNCTION", "cache" ], [ "LOAD_NAME", "cache" ], [ "CALL_FUNCTION", "cache" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "text" ], [ "LOAD_GLOBAL", "text_type" ], [ "CALL_FUNCTION", "isinstance(text, text_type)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.decode_source" ], [ "LOAD_FAST", "text" ], [ "CALL_METHOD", "self.decode_source(text)" ], [ "LOAD_FAST", "text" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_FAST", "text" ], [ "LOAD_METHOD", "''.join" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "text" ], [ "LOAD_METHOD", "text.splitlines" ], [ "CALL_METHOD", "text.splitlines(True)" ], [ "CALL_FUNCTION", "enumerate(text.splitlines(True))" ], [ "CALL_METHOD", "''.join([\n '\\n' if i < 2 and encoding_pattern.match(line)\n else line\n for i, line in enumerate(text.splitlines(True))\n ])" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "defaultdict(list)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "text" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.parse" ], [ "LOAD_FAST", "ast_text" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION_KW", "ast.parse(ast_text, filename=filename)" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "SyntaxError" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.walk" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tree" ], [ "CALL_METHOD", "ast.walk(self.tree)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.iter_child_nodes" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.iter_child_nodes(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "hasattr(node, 'lineno')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._nodes_by_line" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.lineno" ], [ "BINARY_SUBSCR", "self._nodes_by_line[node.lineno]" ], [ "LOAD_METHOD", "self._nodes_by_line[node.lineno].append" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self._nodes_by_line[node.lineno].append(node)" ], [ "LOAD_GLOBAL", "QualnameVisitor" ], [ "CALL_FUNCTION", "QualnameVisitor()" ], [ "LOAD_FAST", "visitor" ], [ "LOAD_METHOD", "visitor.visit" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tree" ], [ "CALL_METHOD", "visitor.visit(self.tree)" ], [ "LOAD_FAST", "visitor" ], [ "LOAD_ATTR", "visitor.qualnames" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "i" ], [ "COMPARE_OP", "i < 2" ], [ "LOAD_GLOBAL", "encoding_pattern" ], [ "LOAD_METHOD", "encoding_pattern.match" ], [ "LOAD_FAST", "line" ], [ "CALL_METHOD", "encoding_pattern.match(line)" ], [ "LOAD_FAST", "line" ], [ "LOAD_FAST", "cls" ], [ "LOAD_METHOD", "cls.for_filename" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_filename" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "CALL_METHOD", "cls.for_filename(frame.f_code.co_filename, frame.f_globals or {})" ], [ "LOAD_FAST", "cls" ], [ "LOAD_METHOD", "cls._class_local" ], [ "CALL_METHOD", "cls._class_local('__source_cache', {})" ], [ "LOAD_FAST", "source_cache" ], [ "LOAD_FAST", "filename" ], [ "BINARY_SUBSCR", "source_cache[filename]" ], [ "LOAD_GLOBAL", "KeyError" ], [ "LOAD_GLOBAL", "linecache" ], [ "LOAD_METHOD", "linecache.getlines" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "module_globals" ], [ "CALL_METHOD", "linecache.getlines(filename, module_globals)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_FAST", "filename" ], [ "LOAD_METHOD", "''.join" ], [ "LOAD_FAST", "lines" ], [ "CALL_METHOD", "''.join(lines)" ], [ "CALL_FUNCTION", "cls(filename, ''.join(lines))" ], [ "LOAD_FAST", "source_cache" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_GLOBAL", "linecache" ], [ "CALL_FUNCTION", "hasattr(linecache, 'lazycache')" ], [ "LOAD_GLOBAL", "linecache" ], [ "LOAD_METHOD", "linecache.lazycache" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_filename" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "CALL_METHOD", "linecache.lazycache(frame.f_code.co_filename, frame.f_globals)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lasti" ], [ "LOAD_FAST", "cls" ], [ "LOAD_METHOD", "cls._class_local" ], [ "CALL_METHOD", "cls._class_local('__executing_cache', {})" ], [ "LOAD_FAST", "executing_cache" ], [ "LOAD_FAST", "key" ], [ "BINARY_SUBSCR", "executing_cache[key]" ], [ "LOAD_GLOBAL", "KeyError" ], [ "LOAD_FAST", "cls" ], [ "LOAD_METHOD", "cls.for_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "cls.for_frame(frame)" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.tree" ], [ "LOAD_FAST", "source" ], [ "LOAD_METHOD", "source.statements_at_line" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lineno" ], [ "CALL_METHOD", "source.statements_at_line(frame.f_lineno)" ], [ "LOAD_GLOBAL", "NodeFinder" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "stmts" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.tree" ], [ "CALL_FUNCTION", "NodeFinder(frame, stmts, source.tree)" ], [ "LOAD_ATTR", "NodeFinder(frame, stmts, source.tree).result" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_GLOBAL", "statement_containing_node" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "statement_containing_node(node)" ], [ "LOAD_FAST", "new_stmts" ], [ "LOAD_FAST", "stmts" ], [ "COMPARE_OP", "new_stmts <= stmts" ], [ "LOAD_FAST", "new_stmts" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "stmts" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "executing_cache" ], [ "LOAD_FAST", "key" ], [ "LOAD_GLOBAL", "Executing" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION_EX", "Executing(frame, *args)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_ATTR", "cls.__dict__" ], [ "LOAD_METHOD", "cls.__dict__.get" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "default" ], [ "CALL_METHOD", "cls.__dict__.get(name, default)" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_FAST", "cls" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "setattr(cls, name, result)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._nodes_by_line" ], [ "LOAD_FAST", "lineno" ], [ "BINARY_SUBSCR", "self._nodes_by_line[lineno]" ], [ "LOAD_GLOBAL", "statement_containing_node" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "statement_containing_node(node)" ], [ "LOAD_FAST", "ASTTokens" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.text" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tree" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.filename" ], [ "CALL_FUNCTION_KW", "ASTTokens(\n self.text,\n tree=self.tree,\n filename=self.filename,\n )" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "source" ], [ "LOAD_GLOBAL", "bytes" ], [ "CALL_FUNCTION", "isinstance(source, bytes)" ], [ "LOAD_GLOBAL", "detect_encoding" ], [ "LOAD_GLOBAL", "io" ], [ "LOAD_METHOD", "io.BytesIO" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "io.BytesIO(source)" ], [ "LOAD_ATTR", "io.BytesIO(source).readline" ], [ "CALL_FUNCTION", "detect_encoding(io.BytesIO(source).readline)" ], [ "LOAD_FAST", "source" ], [ "LOAD_METHOD", "source.decode" ], [ "LOAD_FAST", "encoding" ], [ "CALL_METHOD", "source.decode(encoding)" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_filename" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.filename" ], [ "COMPARE_OP", "code.co_filename == self.filename" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._qualnames" ], [ "LOAD_METHOD", "self._qualnames.get" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_firstlineno" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "CALL_METHOD", "self._qualnames.get((code.co_name, code.co_firstlineno), code.co_name)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "stmts" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.source" ], [ "LOAD_METHOD", "self.source.code_qualname" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_code" ], [ "CALL_METHOD", "self.source.code_qualname(self.frame.f_code)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.source" ], [ "LOAD_METHOD", "self.source.asttokens" ], [ "CALL_METHOD", "self.source.asttokens()" ], [ "LOAD_METHOD", "self.source.asttokens().get_text" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.node" ], [ "CALL_METHOD", "self.source.asttokens().get_text(self.node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.source" ], [ "LOAD_METHOD", "self.source.asttokens" ], [ "CALL_METHOD", "self.source.asttokens()" ], [ "LOAD_METHOD", "self.source.asttokens().get_text_range" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.node" ], [ "CALL_METHOD", "self.source.asttokens().get_text_range(self.node)" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "QualnameVisitor" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(QualnameVisitor, self)" ], [ "LOAD_METHOD", "super(QualnameVisitor, self).__init__" ], [ "CALL_METHOD", "super(QualnameVisitor, self).__init__()" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.name" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_METHOD", "self.stack.append" ], [ "LOAD_FAST", "name" ], [ "CALL_METHOD", "self.stack.append(name)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.qualnames" ], [ "LOAD_METHOD", "self.qualnames.setdefault" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.lineno" ], [ "LOAD_METHOD", "\".\".join" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "CALL_METHOD", "\".\".join(self.stack)" ], [ "CALL_METHOD", "self.qualnames.setdefault((name, node.lineno), \".\".join(self.stack))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_METHOD", "self.stack.append" ], [ "CALL_METHOD", "self.stack.append('')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Lambda" ], [ "CALL_FUNCTION", "isinstance(node, ast.Lambda)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.body" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.body" ], [ "LOAD_FAST", "children" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.visit" ], [ "LOAD_FAST", "child" ], [ "CALL_METHOD", "self.visit(child)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_METHOD", "self.stack.pop" ], [ "CALL_METHOD", "self.stack.pop()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_METHOD", "self.stack.pop" ], [ "CALL_METHOD", "self.stack.pop()" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.iter_fields" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.iter_fields(node)" ], [ "LOAD_FAST", "field" ], [ "COMPARE_OP", "field == 'body'" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.AST" ], [ "CALL_FUNCTION", "isinstance(child, ast.AST)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.visit" ], [ "LOAD_FAST", "child" ], [ "CALL_METHOD", "self.visit(child)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "isinstance(child, list)" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "grandchild" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.AST" ], [ "CALL_FUNCTION", "isinstance(grandchild, ast.AST)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.visit" ], [ "LOAD_FAST", "grandchild" ], [ "CALL_METHOD", "self.visit(grandchild)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.visit_FunctionDef" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self.visit_FunctionDef(node, '')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_METHOD", "self.stack.append" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.name" ], [ "CALL_METHOD", "self.stack.append(node.name)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.generic_visit" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self.generic_visit(node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_METHOD", "self.stack.pop" ], [ "CALL_METHOD", "self.stack.pop()" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "__future__" ], [ "LOAD_FAST", "fname" ], [ "CALL_FUNCTION", "getattr(__future__, fname)" ], [ "LOAD_ATTR", "getattr(__future__, fname).compiler_flag" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "matching_code" ], [ "LOAD_ATTR", "matching_code.co_filename" ], [ "LOAD_GLOBAL", "future_flags" ], [ "LOAD_FAST", "matching_code" ], [ "LOAD_ATTR", "matching_code.co_flags" ], [ "BINARY_AND", "future_flags & matching_code.co_flags" ], [ "CALL_FUNCTION_KW", "compile(\n source,\n matching_code.co_filename,\n 'exec',\n flags=future_flags & matching_code.co_flags,\n dont_inherit=True,\n )" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "tree" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_code" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lasti" ], [ "BINARY_SUBSCR", "frame.f_code.co_code[frame.f_lasti]" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_GLOBAL", "ord" ], [ "LOAD_FAST", "b" ], [ "CALL_FUNCTION", "ord(b)" ], [ "LOAD_GLOBAL", "dis" ], [ "LOAD_ATTR", "dis.opname" ], [ "LOAD_FAST", "b" ], [ "BINARY_SUBSCR", "dis.opname[b]" ], [ "LOAD_FAST", "op_name" ], [ "LOAD_METHOD", "op_name.startswith" ], [ "CALL_METHOD", "op_name.startswith('CALL_')" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Call" ], [ "LOAD_FAST", "op_name" ], [ "COMPARE_OP", "op_name == 'BINARY_SUBSCR'" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Subscript" ], [ "LOAD_FAST", "op_name" ], [ "LOAD_METHOD", "op_name.startswith" ], [ "CALL_METHOD", "op_name.startswith('BINARY_')" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.BinOp" ], [ "LOAD_FAST", "op_name" ], [ "LOAD_METHOD", "op_name.startswith" ], [ "CALL_METHOD", "op_name.startswith('UNARY_')" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.UnaryOp" ], [ "LOAD_FAST", "op_name" ], [ "CONTAINS_OP", "op_name in ('LOAD_ATTR', 'LOAD_METHOD', 'LOOKUP_METHOD')" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Attribute" ], [ "LOAD_FAST", "op_name" ], [ "COMPARE_OP", "op_name == 'COMPARE_OP'" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Compare" ], [ "LOAD_GLOBAL", "RuntimeError" ], [ "LOAD_FAST", "op_name" ], [ "CALL_FUNCTION", "RuntimeError(op_name)" ], [ "LOAD_GLOBAL", "lock" ], [ "LOAD_FAST", "stmts" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.matching_nodes" ], [ "LOAD_FAST", "exprs" ], [ "CALL_METHOD", "self.matching_nodes(exprs)" ], [ "CALL_FUNCTION", "list(self.matching_nodes(exprs))" ], [ "CALL_FUNCTION", "only(list(self.matching_nodes(exprs)))" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.walk" ], [ "LOAD_FAST", "stmt" ], [ "CALL_METHOD", "ast.walk(stmt)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "typ" ], [ "CALL_FUNCTION", "isinstance(node, typ)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "hasattr(node, \"ctx\")" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.ctx" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Load" ], [ "CALL_FUNCTION", "isinstance(node.ctx, ast.Load)" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "exprs" ], [ "CALL_FUNCTION", "enumerate(exprs)" ], [ "LOAD_GLOBAL", "get_setter" ], [ "LOAD_FAST", "expr" ], [ "CALL_FUNCTION", "get_setter(expr)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.BinOp" ], [ "LOAD_FAST", "expr" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.Pow" ], [ "CALL_METHOD", "ast.Pow()" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Str" ], [ "LOAD_GLOBAL", "sentinel" ], [ "CALL_FUNCTION_KW", "ast.Str(s=sentinel)" ], [ "CALL_FUNCTION_KW", "ast.BinOp(\n left=expr,\n op=ast.Pow(),\n right=ast.Str(s=sentinel),\n )" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.fix_missing_locations" ], [ "LOAD_FAST", "replacement" ], [ "CALL_METHOD", "ast.fix_missing_locations(replacement)" ], [ "LOAD_FAST", "setter" ], [ "LOAD_FAST", "replacement" ], [ "CALL_FUNCTION", "setter(replacement)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.compile_instructions" ], [ "CALL_METHOD", "self.compile_instructions()" ], [ "LOAD_GLOBAL", "SyntaxError" ], [ "LOAD_FAST", "setter" ], [ "LOAD_FAST", "expr" ], [ "CALL_FUNCTION", "setter(expr)" ], [ "LOAD_FAST", "setter" ], [ "LOAD_FAST", "expr" ], [ "CALL_FUNCTION", "setter(expr)" ], [ "LOAD_FAST", "setter" ], [ "LOAD_FAST", "expr" ], [ "CALL_FUNCTION", "setter(expr)" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "instructions" ], [ "CALL_FUNCTION", "enumerate(instructions)" ], [ "LOAD_FAST", "indices" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_FAST", "indices" ], [ "CALL_FUNCTION", "only(indices)" ], [ "BINARY_SUBTRACT", "only(indices) - 1" ], [ "LOAD_FAST", "instructions" ], [ "LOAD_FAST", "arg_index" ], [ "BINARY_SUBSCR", "instructions[arg_index]" ], [ "LOAD_ATTR", "instructions[arg_index].opname" ], [ "COMPARE_OP", "instructions[arg_index].opname == 'EXTENDED_ARG'" ], [ "LOAD_FAST", "instructions" ], [ "LOAD_FAST", "arg_index" ], [ "BINARY_SUBSCR", "instructions[arg_index]" ], [ "LOAD_ATTR", "instructions[arg_index].offset" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_lasti" ], [ "COMPARE_OP", "instructions[arg_index].offset == self.frame.f_lasti" ], [ "LOAD_FAST", "expr" ], [ "LOAD_FAST", "instruction" ], [ "LOAD_ATTR", "instruction.argval" ], [ "LOAD_GLOBAL", "sentinel" ], [ "COMPARE_OP", "instruction.argval == sentinel" ], [ "LOAD_FAST", "i" ], [ "LOAD_GLOBAL", "compile_similar_to" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tree" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_code" ], [ "CALL_FUNCTION", "compile_similar_to(self.tree, self.frame.f_code)" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_GLOBAL", "find_codes" ], [ "LOAD_FAST", "module_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_code" ], [ "CALL_FUNCTION", "find_codes(module_code, self.frame.f_code)" ], [ "CALL_FUNCTION", "only(find_codes(module_code, self.frame.f_code))" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "get_instructions" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "get_instructions(code)" ], [ "CALL_FUNCTION", "list(get_instructions(code))" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.iter_fields" ], [ "LOAD_DEREF", "parent" ], [ "CALL_METHOD", "ast.iter_fields(parent)" ], [ "LOAD_DEREF", "field" ], [ "LOAD_FAST", "node" ], [ "IS_OP", "field is node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_DEREF", "field" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "isinstance(field, list)" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_DEREF", "field" ], [ "CALL_FUNCTION", "enumerate(field)" ], [ "LOAD_FAST", "item" ], [ "LOAD_FAST", "node" ], [ "IS_OP", "item is node" ], [ "LOAD_FAST", "setter" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_DEREF", "parent" ], [ "LOAD_DEREF", "name" ], [ "LOAD_FAST", "new_node" ], [ "CALL_FUNCTION", "setattr(parent, name, new_node)" ], [ "LOAD_FAST", "new_node" ], [ "LOAD_DEREF", "field" ], [ "LOAD_DEREF", "i" ], [ "LOAD_DEREF", "matches" ], [ "LOAD_FAST", "root_code" ], [ "CALL_FUNCTION", "matches(root_code)" ], [ "LOAD_DEREF", "code_options" ], [ "LOAD_METHOD", "code_options.append" ], [ "LOAD_FAST", "root_code" ], [ "CALL_METHOD", "code_options.append(root_code)" ], [ "LOAD_DEREF", "finder" ], [ "LOAD_FAST", "root_code" ], [ "CALL_FUNCTION", "finder(root_code)" ], [ "LOAD_DEREF", "code_options" ], [ "LOAD_GLOBAL", "all" ], [ "LOAD_GLOBAL", "attrgetter" ], [ "CALL_FUNCTION", "attrgetter('co_firstlineno')" ], [ "LOAD_GLOBAL", "attrgetter" ], [ "CALL_FUNCTION", "attrgetter('co_name')" ], [ "LOAD_GLOBAL", "code_names" ], [ "CALL_FUNCTION", "all(\n f(c) == f(matching)\n for f in [\n attrgetter('co_firstlineno'),\n attrgetter('co_name'),\n code_names,\n ]\n )" ], [ "LOAD_FAST", "f" ], [ "LOAD_DEREF", "c" ], [ "CALL_FUNCTION", "f(c)" ], [ "LOAD_FAST", "f" ], [ "LOAD_DEREF", "matching" ], [ "CALL_FUNCTION", "f(matching)" ], [ "COMPARE_OP", "f(c) == f(matching)" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_consts" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.iscode" ], [ "LOAD_FAST", "const" ], [ "CALL_METHOD", "inspect.iscode(const)" ], [ "LOAD_DEREF", "matches" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "matches(const)" ], [ "LOAD_DEREF", "code_options" ], [ "LOAD_METHOD", "code_options.append" ], [ "LOAD_FAST", "const" ], [ "CALL_METHOD", "code_options.append(const)" ], [ "LOAD_DEREF", "finder" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "finder(const)" ], [ "LOAD_GLOBAL", "frozenset" ], [ "CALL_FUNCTION", "frozenset()" ], [ "LOAD_METHOD", "frozenset().union" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_names" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_varnames" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_freevars" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_cellvars" ], [ "CALL_METHOD", "frozenset().union(\n code.co_names,\n code.co_varnames,\n code.co_freevars,\n code.co_cellvars,\n )" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "CALL_FUNCTION", "isinstance(node, ast.stmt)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_FAST", "node" ] ], "import_hook.py": [ [ "LOAD_NAME", "object" ], [ "LOAD_FAST", "spec" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "deep" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "eye" ], [ "LOAD_ATTR", "eye.exec_string" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.source" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._spec" ], [ "LOAD_ATTR", "self._spec.origin" ], [ "LOAD_FAST", "module" ], [ "LOAD_ATTR", "module.__dict__" ], [ "LOAD_FAST", "module" ], [ "LOAD_ATTR", "module.__dict__" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.deep" ], [ "CALL_FUNCTION_KW", "eye.exec_string(\n source=self.source,\n filename=self._spec.origin,\n globs=module.__dict__,\n locs=module.__dict__,\n deep=self.deep,\n )" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._spec" ], [ "LOAD_ATTR", "self._spec.loader" ], [ "LOAD_METHOD", "self._spec.loader.get_filename" ], [ "LOAD_FAST", "fullname" ], [ "CALL_METHOD", "self._spec.loader.get_filename(fullname)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._spec" ], [ "LOAD_ATTR", "self._spec.loader" ], [ "LOAD_METHOD", "self._spec.loader.is_package" ], [ "LOAD_FAST", "fullname" ], [ "CALL_METHOD", "self._spec.loader.is_package(fullname)" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.meta_path" ], [ "LOAD_FAST", "finder" ], [ "LOAD_FAST", "self" ], [ "IS_OP", "finder is self" ], [ "LOAD_FAST", "finder" ], [ "LOAD_ATTR", "finder.__module__" ], [ "CONTAINS_OP", "'pytest' in finder.__module__" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "finder" ], [ "CALL_FUNCTION", "hasattr(finder, 'find_spec')" ], [ "LOAD_FAST", "finder" ], [ "LOAD_ATTR", "finder.find_spec" ], [ "LOAD_FAST", "fullname" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "target" ], [ "CALL_FUNCTION_KW", "finder.find_spec(fullname, path, target=target)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "finder" ], [ "CALL_FUNCTION", "hasattr(finder, 'load_module')" ], [ "LOAD_GLOBAL", "spec_from_loader" ], [ "LOAD_FAST", "fullname" ], [ "LOAD_FAST", "finder" ], [ "CALL_FUNCTION", "spec_from_loader(fullname, finder)" ], [ "LOAD_FAST", "spec" ], [ "IS_OP", "spec is not None" ], [ "LOAD_FAST", "spec" ], [ "LOAD_ATTR", "spec.origin" ], [ "COMPARE_OP", "spec.origin != 'builtin'" ], [ "LOAD_FAST", "spec" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._find_plain_spec" ], [ "LOAD_FAST", "fullname" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "target" ], [ "CALL_METHOD", "self._find_plain_spec(fullname, path, target)" ], [ "LOAD_FAST", "spec" ], [ "IS_OP", "spec is None" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "spec" ], [ "LOAD_ATTR", "spec.loader" ], [ "CALL_FUNCTION", "hasattr(spec.loader, 'get_source')" ], [ "LOAD_GLOBAL", "callable" ], [ "LOAD_FAST", "spec" ], [ "LOAD_ATTR", "spec.loader" ], [ "LOAD_ATTR", "spec.loader.get_source" ], [ "CALL_FUNCTION", "callable(spec.loader.get_source)" ], [ "LOAD_FAST", "fullname" ], [ "COMPARE_OP", "fullname != 'org'" ], [ "LOAD_GLOBAL", "logging" ], [ "LOAD_METHOD", "logging.debug" ], [ "LOAD_FAST", "fullname" ], [ "CALL_METHOD", "logging.debug('Failed finding spec for %s', fullname)" ], [ "LOAD_FAST", "spec" ], [ "LOAD_ATTR", "spec.loader" ], [ "LOAD_METHOD", "spec.loader.get_source" ], [ "LOAD_FAST", "fullname" ], [ "CALL_METHOD", "spec.loader.get_source(fullname)" ], [ "LOAD_GLOBAL", "ImportError" ], [ "LOAD_GLOBAL", "logging" ], [ "LOAD_METHOD", "logging.debug" ], [ "LOAD_FAST", "fullname" ], [ "CALL_METHOD", "logging.debug('Loader for %s was unable to find the sources',\n fullname)" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_GLOBAL", "logging" ], [ "LOAD_METHOD", "logging.exception" ], [ "LOAD_FAST", "fullname" ], [ "CALL_METHOD", "logging.exception('Loader for %s raised an error', fullname)" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "source" ], [ "CONTAINS_OP", "'birdseye' not in source" ], [ "LOAD_GLOBAL", "should_trace" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "should_trace(source)" ], [ "LOAD_FAST", "trace_stmt" ], [ "LOAD_GLOBAL", "BirdsEyeLoader" ], [ "LOAD_FAST", "spec" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "deep" ], [ "CALL_FUNCTION", "BirdsEyeLoader(spec, source, deep)" ], [ "LOAD_GLOBAL", "spec_from_loader" ], [ "LOAD_FAST", "fullname" ], [ "LOAD_FAST", "loader" ], [ "CALL_FUNCTION", "spec_from_loader(fullname, loader)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.parse" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "ast.parse(source)" ], [ "LOAD_ATTR", "ast.parse(source).body" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Import" ], [ "CALL_FUNCTION", "isinstance(stmt, ast.Import)" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_ATTR", "stmt.names" ], [ "LOAD_FAST", "alias" ], [ "LOAD_ATTR", "alias.name" ], [ "LOAD_METHOD", "alias.name.startswith" ], [ "CALL_METHOD", "alias.name.startswith('birdseye.trace_module')" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_FAST", "alias" ], [ "LOAD_ATTR", "alias.name" ], [ "LOAD_METHOD", "alias.name.endswith" ], [ "CALL_METHOD", "alias.name.endswith('deep')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.ImportFrom" ], [ "CALL_FUNCTION", "isinstance(stmt, ast.ImportFrom)" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_ATTR", "stmt.module" ], [ "COMPARE_OP", "stmt.module == 'birdseye'" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_ATTR", "stmt.names" ], [ "LOAD_FAST", "alias" ], [ "LOAD_ATTR", "alias.name" ], [ "LOAD_METHOD", "alias.name.startswith" ], [ "CALL_METHOD", "alias.name.startswith('trace_module')" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_FAST", "alias" ], [ "LOAD_ATTR", "alias.name" ], [ "LOAD_METHOD", "alias.name.endswith" ], [ "CALL_METHOD", "alias.name.endswith('deep')" ], [ "LOAD_FAST", "deep" ], [ "LOAD_FAST", "trace_stmt" ] ], "ipython.py": [ [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "BytesIO" ], [ "LOAD_NAME", "StringIO" ], [ "LOAD_NAME", "stream_proxy" ], [ "LOAD_NAME", "sys" ], [ "LOAD_ATTR", "sys.stderr" ], [ "CALL_FUNCTION", "stream_proxy(sys.stderr)" ], [ "LOAD_NAME", "sys" ], [ "LOAD_NAME", "stream_proxy" ], [ "LOAD_NAME", "sys" ], [ "LOAD_ATTR", "sys.stdout" ], [ "CALL_FUNCTION", "stream_proxy(sys.stdout)" ], [ "LOAD_NAME", "sys" ], [ "LOAD_NAME", "Environment" ], [ "LOAD_NAME", "PackageLoader" ], [ "CALL_FUNCTION", "PackageLoader('birdseye', 'templates')" ], [ "LOAD_NAME", "select_autoescape" ], [ "CALL_FUNCTION", "select_autoescape(['html', 'xml'])" ], [ "CALL_FUNCTION_KW", "Environment(\n loader=PackageLoader('birdseye', 'templates'),\n autoescape=select_autoescape(['html', 'xml'])\n)" ], [ "LOAD_NAME", "magics_class" ], [ "LOAD_NAME", "Magics" ], [ "CALL_FUNCTION", "magics_class" ], [ "LOAD_GLOBAL", "LocalProxy" ], [ "LOAD_FAST", "p" ], [ "CALL_FUNCTION", "LocalProxy(p)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.currentframe" ], [ "CALL_METHOD", "inspect.currentframe()" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_GLOBAL", "ThreadingMixIn" ], [ "LOAD_ATTR", "ThreadingMixIn.process_request_thread" ], [ "LOAD_ATTR", "ThreadingMixIn.process_request_thread.__code__" ], [ "COMPARE_OP", "frame.f_code == ThreadingMixIn.process_request_thread.__code__" ], [ "LOAD_GLOBAL", "fake_stream" ], [ "CALL_FUNCTION", "fake_stream()" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_GLOBAL", "thread_proxies" ], [ "LOAD_METHOD", "thread_proxies.get" ], [ "LOAD_GLOBAL", "currentThread" ], [ "CALL_FUNCTION", "currentThread()" ], [ "LOAD_ATTR", "currentThread().ident" ], [ "LOAD_DEREF", "original" ], [ "CALL_METHOD", "thread_proxies.get(currentThread().ident,\n original)" ], [ "LOAD_FAST", "show_server_output" ], [ "LOAD_GLOBAL", "fake_stream" ], [ "CALL_FUNCTION", "fake_stream()" ], [ "LOAD_GLOBAL", "thread_proxies" ], [ "LOAD_GLOBAL", "currentThread" ], [ "CALL_FUNCTION", "currentThread()" ], [ "LOAD_ATTR", "currentThread().ident" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_ATTR", "server.app" ], [ "LOAD_ATTR", "server.app.run" ], [ "LOAD_FAST", "port" ], [ "LOAD_FAST", "bind_host" ], [ "CALL_FUNCTION_KW", "server.app.run(\n debug=True,\n port=port,\n host=bind_host,\n use_reloader=False,\n )" ], [ "LOAD_GLOBAL", "socket" ], [ "LOAD_ATTR", "socket.error" ], [ "LOAD_NAME", "Unicode" ], [ "CALL_FUNCTION_KW", "Unicode(\n u'', config=True,\n help='If set, a server will not be automatically started by %%eye. '\n 'The iframe containing birdseye output will use this value as the base '\n 'of its URL.'\n )" ], [ "LOAD_NAME", "Int" ], [ "CALL_FUNCTION_KW", "Int(\n 7777, config=True,\n help='Port number for the server started by %%eye.'\n )" ], [ "LOAD_NAME", "Unicode" ], [ "CALL_FUNCTION_KW", "Unicode(\n '127.0.0.1', config=True,\n help='Host that the server started by %%eye listens on. '\n 'Set to 0.0.0.0 to make it accessible anywhere.'\n )" ], [ "LOAD_NAME", "Bool" ], [ "CALL_FUNCTION_KW", "Bool(\n False, config=True,\n help='Set to True to show stdout and stderr from the server started by %%eye.'\n )" ], [ "LOAD_NAME", "Unicode" ], [ "CALL_FUNCTION_KW", "Unicode(\n u'', config=True,\n help='The database URL that the server started by %%eye reads from. '\n 'Equivalent to the environment variable BIRDSEYE_DB.'\n )" ], [ "LOAD_NAME", "cell_magic" ], [ "CALL_FUNCTION", "cell_magic" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.server_url" ], [ "LOAD_GLOBAL", "Database" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.db_url" ], [ "CALL_FUNCTION", "Database(self.db_url)" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_ATTR", "server.db" ], [ "LOAD_ATTR", "server.db.Function" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_ATTR", "server.db" ], [ "LOAD_ATTR", "server.db.Call" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_ATTR", "server.db" ], [ "LOAD_ATTR", "server.db.Session" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_GLOBAL", "Thread" ], [ "LOAD_GLOBAL", "run_server" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.port" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.bind_host" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.show_server_output" ], [ "CALL_FUNCTION_KW", "Thread(\n target=run_server,\n args=(\n self.port,\n self.bind_host,\n self.show_server_output,\n ),\n )" ], [ "LOAD_METHOD", "Thread(\n target=run_server,\n args=(\n self.port,\n self.bind_host,\n self.show_server_output,\n ),\n ).start" ], [ "CALL_METHOD", "Thread(\n target=run_server,\n args=(\n self.port,\n self.bind_host,\n self.show_server_output,\n ),\n ).start()" ], [ "LOAD_GLOBAL", "Database" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.db_url" ], [ "CALL_FUNCTION", "Database(self.db_url)" ], [ "LOAD_GLOBAL", "eye" ], [ "LOAD_GLOBAL", "eye" ], [ "LOAD_METHOD", "eye.exec_ipython_cell" ], [ "LOAD_FAST", "cell" ], [ "LOAD_FAST", "callback" ], [ "CALL_METHOD", "eye.exec_ipython_cell(cell, callback)" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "call_id" ], [ "IS_OP", "call_id is None" ], [ "LOAD_GLOBAL", "HTML" ], [ "LOAD_GLOBAL", "templates_env" ], [ "LOAD_METHOD", "templates_env.get_template" ], [ "CALL_METHOD", "templates_env.get_template('ipython_iframe.html')" ], [ "LOAD_ATTR", "templates_env.get_template('ipython_iframe.html').render" ], [ "LOAD_FAST", "call_id" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.server_url" ], [ "LOAD_METHOD", "self.server_url.rstrip" ], [ "CALL_METHOD", "self.server_url.rstrip('/')" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.port" ], [ "LOAD_GLOBAL", "uuid4" ], [ "CALL_FUNCTION", "uuid4()" ], [ "LOAD_ATTR", "uuid4().hex" ], [ "CALL_FUNCTION_KW", "templates_env.get_template('ipython_iframe.html').render(\n call_id=call_id,\n url=self.server_url.rstrip('/'),\n port=self.port,\n container_id=uuid4().hex,\n )" ], [ "CALL_FUNCTION", "HTML(templates_env.get_template('ipython_iframe.html').render(\n call_id=call_id,\n url=self.server_url.rstrip('/'),\n port=self.port,\n container_id=uuid4().hex,\n ))" ], [ "LOAD_GLOBAL", "display" ], [ "LOAD_FAST", "html" ], [ "CALL_FUNCTION", "display(html)" ] ], "server.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOAD_METHOD", "standard_library.install_aliases" ], [ "CALL_METHOD", "standard_library.install_aliases()" ], [ "LOAD_NAME", "Flask" ], [ "CALL_FUNCTION", "Flask('birdseye')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.jinja_env" ], [ "LOAD_NAME", "Humanize" ], [ "LOAD_NAME", "app" ], [ "CALL_FUNCTION", "Humanize(app)" ], [ "LOAD_NAME", "PathConverter" ], [ "LOAD_NAME", "FileConverter" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.url_map" ], [ "LOAD_ATTR", "app.url_map.converters" ], [ "LOAD_NAME", "Database" ], [ "CALL_FUNCTION", "Database()" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.Session" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.Function" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.Call" ], [ "LOAD_NAME", "app" ], [ "LOAD_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/file/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/file/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/file//__function__/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/file//__function__/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/api/file//__function__//latest_call/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/api/file//__function__//latest_call/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "LOAD_NAME", "app" ], [ "LOAD_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/call/')" ], [ "CALL_FUNCTION", "app.route('/call/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/ipython_call/')" ], [ "CALL_FUNCTION", "app.route('/ipython_call/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/ipython_iframe/')" ], [ "CALL_FUNCTION", "app.route('/ipython_iframe/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION_KW", "app.route('/kill', methods=['POST'])" ], [ "CALL_FUNCTION", "app.route('/kill', methods=['POST'])" ], [ "LOAD_NAME", "app" ], [ "LOAD_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/api/call/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/api/call/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/api/calls_by_body_hash/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/api/calls_by_body_hash/')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.route" ], [ "CALL_FUNCTION_KW", "app.route('/api/body_hashes_present/', methods=['POST'])" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/api/body_hashes_present/', methods=['POST'])" ], [ "LOAD_NAME", "sys" ], [ "LOAD_ATTR", "sys.argv" ], [ "BINARY_SUBSCR", "sys.argv[1:]" ], [ "LOAD_NAME", "__name__" ], [ "COMPARE_OP", "__name__ == '__main__'" ], [ "LOAD_NAME", "main" ], [ "CALL_FUNCTION", "main()" ], [ "LOAD_GLOBAL", "db" ], [ "LOAD_METHOD", "db.all_file_paths" ], [ "CALL_METHOD", "db.all_file_paths()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_columns" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.basic_columns" ], [ "BINARY_ADD", "Call.basic_columns + Function.basic_columns" ], [ "CALL_FUNCTION_EX", "session.query(*(Call.basic_columns + Function.basic_columns))" ], [ "LOAD_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)" ], [ "LOAD_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .order_by" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.start_time" ], [ "LOAD_METHOD", "Call.start_time.desc" ], [ "CALL_METHOD", "Call.start_time.desc()" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .order_by(Call.start_time.desc())" ], [ "BINARY_SUBSCR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .order_by(Call.start_time.desc())[:100]" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "CALL_FUNCTION", "OrderedDict()" ], [ "LOAD_FAST", "recent_calls" ], [ "LOAD_GLOBAL", "is_ipython_cell" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.file" ], [ "CALL_FUNCTION", "is_ipython_cell(row.file)" ], [ "LOAD_FAST", "files" ], [ "LOAD_METHOD", "files.setdefault" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.file" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "CALL_FUNCTION", "OrderedDict()" ], [ "CALL_METHOD", "files.setdefault(\n row.file, OrderedDict()\n )" ], [ "LOAD_METHOD", "files.setdefault(\n row.file, OrderedDict()\n ).setdefault" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.name" ], [ "LOAD_FAST", "row" ], [ "CALL_METHOD", "files.setdefault(\n row.file, OrderedDict()\n ).setdefault(\n row.name, row\n )" ], [ "LOAD_FAST", "all_paths" ], [ "LOAD_FAST", "files" ], [ "LOAD_METHOD", "files.setdefault" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "CALL_FUNCTION", "OrderedDict()" ], [ "CALL_METHOD", "files.setdefault(\n path, OrderedDict()\n )" ], [ "LOAD_GLOBAL", "partial" ], [ "LOAD_GLOBAL", "short_path" ], [ "LOAD_FAST", "all_paths" ], [ "CALL_FUNCTION_KW", "partial(short_path, all_paths=all_paths)" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "short" ], [ "LOAD_FAST", "files" ], [ "CALL_FUNCTION_KW", "render_template('index.html',\n short=short,\n files=files)" ], [ "LOAD_GLOBAL", "fix_abs_path" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "fix_abs_path(path)" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_columns" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.basic_columns" ], [ "BINARY_ADD", "Call.basic_columns + Function.basic_columns" ], [ "CALL_FUNCTION_EX", "session.query(*(Call.basic_columns + Function.basic_columns))" ], [ "LOAD_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)" ], [ "LOAD_ATTR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION_KW", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path)" ], [ "LOAD_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path)\n .subquery" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path)\n .subquery('filtered_calls')" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.query" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.name" ], [ "LOAD_GLOBAL", "sqlalchemy" ], [ "LOAD_ATTR", "sqlalchemy.func" ], [ "LOAD_METHOD", "sqlalchemy.func.max" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.start_time" ], [ "CALL_METHOD", "sqlalchemy.func.max(filtered_calls.c.start_time)" ], [ "LOAD_METHOD", "sqlalchemy.func.max(filtered_calls.c.start_time).label" ], [ "CALL_METHOD", "sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')" ], [ "CALL_METHOD", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n )" ], [ "LOAD_METHOD", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n ).group_by" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.name" ], [ "CALL_METHOD", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n ).group_by(\n filtered_calls.c.name,\n )" ], [ "LOAD_METHOD", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n ).group_by(\n filtered_calls.c.name,\n ).subquery" ], [ "CALL_METHOD", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n ).group_by(\n filtered_calls.c.name,\n ).subquery('latest_calls')" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.query" ], [ "LOAD_FAST", "filtered_calls" ], [ "CALL_METHOD", "session.query(filtered_calls)" ], [ "LOAD_METHOD", "session.query(filtered_calls).join" ], [ "LOAD_FAST", "latest_calls" ], [ "LOAD_GLOBAL", "sqlalchemy" ], [ "LOAD_METHOD", "sqlalchemy.and_" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.name" ], [ "LOAD_FAST", "latest_calls" ], [ "LOAD_ATTR", "latest_calls.c" ], [ "LOAD_ATTR", "latest_calls.c.name" ], [ "COMPARE_OP", "filtered_calls.c.name == latest_calls.c.name" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.start_time" ], [ "LOAD_FAST", "latest_calls" ], [ "LOAD_ATTR", "latest_calls.c" ], [ "LOAD_ATTR", "latest_calls.c.maxtime" ], [ "COMPARE_OP", "filtered_calls.c.start_time == latest_calls.c.maxtime" ], [ "CALL_METHOD", "sqlalchemy.and_(\n filtered_calls.c.name == latest_calls.c.name,\n filtered_calls.c.start_time == latest_calls.c.maxtime,\n )" ], [ "CALL_METHOD", "session.query(filtered_calls).join(\n latest_calls,\n sqlalchemy.and_(\n filtered_calls.c.name == latest_calls.c.name,\n filtered_calls.c.start_time == latest_calls.c.maxtime,\n )\n )" ], [ "LOAD_METHOD", "session.query(filtered_calls).join(\n latest_calls,\n sqlalchemy.and_(\n filtered_calls.c.name == latest_calls.c.name,\n filtered_calls.c.start_time == latest_calls.c.maxtime,\n )\n ).order_by" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.start_time" ], [ "LOAD_METHOD", "filtered_calls.c.start_time.desc" ], [ "CALL_METHOD", "filtered_calls.c.start_time.desc()" ], [ "CALL_METHOD", "session.query(filtered_calls).join(\n latest_calls,\n sqlalchemy.and_(\n filtered_calls.c.name == latest_calls.c.name,\n filtered_calls.c.start_time == latest_calls.c.maxtime,\n )\n ).order_by(filtered_calls.c.start_time.desc())" ], [ "LOAD_GLOBAL", "group_by_attr" ], [ "LOAD_FAST", "query" ], [ "CALL_FUNCTION", "group_by_attr(query, 'type')" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.query" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.name" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.type" ], [ "CALL_METHOD", "session.query(Function.name, Function.type)" ], [ "LOAD_ATTR", "session.query(Function.name, Function.type)\n .filter_by" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION_KW", "session.query(Function.name, Function.type)\n .filter_by(file=path)" ], [ "LOAD_METHOD", "session.query(Function.name, Function.type)\n .filter_by(file=path)\n .distinct" ], [ "CALL_METHOD", "session.query(Function.name, Function.type)\n .filter_by(file=path)\n .distinct()" ], [ "CALL_FUNCTION", "sorted(session.query(Function.name, Function.type)\n .filter_by(file=path)\n .distinct())" ], [ "LOAD_FAST", "query" ], [ "LOAD_FAST", "all_funcs" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.name" ], [ "LOAD_FAST", "func_names" ], [ "CONTAINS_OP", "func.name not in func_names" ], [ "LOAD_FAST", "funcs" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.type" ], [ "BINARY_SUBSCR", "funcs[func.type]" ], [ "LOAD_METHOD", "funcs[func.type].append" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "funcs[func.type].append(func)" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "funcs" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "COMPARE_OP", "path == IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "basename" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "basename(path)" ], [ "CALL_FUNCTION_KW", "render_template('file.html',\n funcs=funcs,\n is_ipython=path == IPYTHON_FILE_PATH,\n full_path=path,\n short_path=basename(path))" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.name" ], [ "LOAD_GLOBAL", "fix_abs_path" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "fix_abs_path(path)" ], [ "LOAD_GLOBAL", "get_calls" ], [ "LOAD_FAST", "session" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "func_name" ], [ "CALL_FUNCTION", "get_calls(session, path, func_name, 200)" ], [ "LOAD_FAST", "query" ], [ "LOAD_FAST", "query" ], [ "BINARY_SUBSCR", "query[0]" ], [ "LOAD_FAST", "query" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.query" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_METHOD", "session.query(Function)" ], [ "LOAD_ATTR", "session.query(Function).filter_by" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "func_name" ], [ "CALL_FUNCTION_KW", "session.query(Function).filter_by(file=path, name=func_name)" ], [ "BINARY_SUBSCR", "session.query(Function).filter_by(file=path, name=func_name)[0]" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "func" ], [ "LOAD_GLOBAL", "basename" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "basename(path)" ], [ "LOAD_FAST", "calls" ], [ "CALL_FUNCTION_KW", "render_template('function.html',\n func=func,\n short_path=basename(path),\n calls=calls)" ], [ "LOAD_GLOBAL", "withattrs" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_FUNCTION", "Call()" ], [ "LOAD_FAST", "row" ], [ "LOAD_METHOD", "row._asdict" ], [ "CALL_METHOD", "row._asdict()" ], [ "CALL_FUNCTION_EX", "withattrs(Call(), **row._asdict())" ], [ "LOAD_GLOBAL", "fix_abs_path" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "fix_abs_path(path)" ], [ "LOAD_GLOBAL", "get_calls" ], [ "LOAD_FAST", "session" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "func_name" ], [ "CALL_FUNCTION", "get_calls(session, path, func_name, 1)" ], [ "BINARY_SUBSCR", "get_calls(session, path, func_name, 1)[0]" ], [ "LOAD_GLOBAL", "jsonify" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.id" ], [ "LOAD_GLOBAL", "url_for" ], [ "LOAD_GLOBAL", "call_view" ], [ "LOAD_ATTR", "call_view.__name__" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.id" ], [ "CALL_FUNCTION_KW", "url_for(call_view.__name__,\n call_id=call.id)" ], [ "CALL_FUNCTION_KW", "dict(\n id=call.id,\n url=url_for(call_view.__name__,\n call_id=call.id),\n )" ], [ "CALL_FUNCTION", "jsonify(dict(\n id=call.id,\n url=url_for(call_view.__name__,\n call_id=call.id),\n ))" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_columns" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.basic_columns" ], [ "BINARY_ADD", "Call.basic_columns + Function.basic_columns" ], [ "CALL_FUNCTION_EX", "session.query(*(Call.basic_columns + Function.basic_columns))" ], [ "LOAD_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)" ], [ "LOAD_ATTR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "func_name" ], [ "CALL_FUNCTION_KW", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path, name=func_name)" ], [ "LOAD_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path, name=func_name)\n .order_by" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.start_time" ], [ "LOAD_METHOD", "Call.start_time.desc" ], [ "CALL_METHOD", "Call.start_time.desc()" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path, name=func_name)\n .order_by(Call.start_time.desc())" ], [ "LOAD_FAST", "limit" ], [ "BINARY_SUBSCR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path, name=func_name)\n .order_by(Call.start_time.desc())[:limit]" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_METHOD", "session.query(Call)" ], [ "LOAD_ATTR", "session.query(Call).filter_by" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION_KW", "session.query(Call).filter_by(id=call_id)" ], [ "LOAD_METHOD", "session.query(Call).filter_by(id=call_id).one" ], [ "CALL_METHOD", "session.query(Call).filter_by(id=call_id).one()" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.function" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "template" ], [ "LOAD_GLOBAL", "basename" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.file" ], [ "CALL_FUNCTION", "basename(func.file)" ], [ "LOAD_FAST", "call" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION_KW", "render_template(template,\n short_path=basename(func.file),\n call=call,\n func=func)" ], [ "LOAD_GLOBAL", "base_call_view" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION", "base_call_view(call_id, 'call.html')" ], [ "LOAD_GLOBAL", "base_call_view" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION", "base_call_view(call_id, 'ipython_call.html')" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION_KW", "render_template('ipython_iframe.html',\n container_id='1234',\n port=7777,\n call_id=call_id)" ], [ "LOAD_GLOBAL", "request" ], [ "LOAD_ATTR", "request.environ" ], [ "LOAD_METHOD", "request.environ.get" ], [ "CALL_METHOD", "request.environ.get('werkzeug.server.shutdown')" ], [ "LOAD_FAST", "func" ], [ "IS_OP", "func is None" ], [ "LOAD_GLOBAL", "RuntimeError" ], [ "CALL_FUNCTION", "RuntimeError('Not running with the Werkzeug Server')" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "func()" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_METHOD", "session.query(Call)" ], [ "LOAD_ATTR", "session.query(Call).filter_by" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION_KW", "session.query(Call).filter_by(id=call_id)" ], [ "LOAD_METHOD", "session.query(Call).filter_by(id=call_id).one" ], [ "CALL_METHOD", "session.query(Call).filter_by(id=call_id).one()" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.function" ], [ "LOAD_GLOBAL", "DecentJSONEncoder" ], [ "CALL_FUNCTION", "DecentJSONEncoder()" ], [ "LOAD_METHOD", "DecentJSONEncoder().encode" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.parsed_data" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_METHOD", "Call.basic_dict" ], [ "LOAD_FAST", "call" ], [ "CALL_METHOD", "Call.basic_dict(call)" ], [ "CALL_FUNCTION_EX", "dict(data=call.parsed_data, **Call.basic_dict(call))" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.parsed_data" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_METHOD", "Function.basic_dict" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "Function.basic_dict(func)" ], [ "CALL_FUNCTION_EX", "dict(data=func.parsed_data, **Function.basic_dict(func))" ], [ "CALL_FUNCTION_KW", "dict(\n call=dict(data=call.parsed_data, **Call.basic_dict(call)),\n function=dict(data=func.parsed_data, **Function.basic_dict(func)))" ], [ "CALL_METHOD", "DecentJSONEncoder().encode(dict(\n call=dict(data=call.parsed_data, **Call.basic_dict(call)),\n function=dict(data=func.parsed_data, **Function.basic_dict(func))))" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_columns" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.data" ], [ "BINARY_ADD", "Call.basic_columns + (Function.data,)" ], [ "CALL_FUNCTION_EX", "session.query(*Call.basic_columns + (Function.data,))" ], [ "LOAD_METHOD", "session.query(*Call.basic_columns + (Function.data,))\n .join" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_METHOD", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)" ], [ "LOAD_ATTR", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by" ], [ "LOAD_FAST", "body_hash" ], [ "CALL_FUNCTION_KW", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by(body_hash=body_hash)" ], [ "LOAD_METHOD", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by(body_hash=body_hash)\n .order_by" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.start_time" ], [ "LOAD_METHOD", "Call.start_time.desc" ], [ "CALL_METHOD", "Call.start_time.desc()" ], [ "CALL_METHOD", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by(body_hash=body_hash)\n .order_by(Call.start_time.desc())" ], [ "BINARY_SUBSCR", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by(body_hash=body_hash)\n .order_by(Call.start_time.desc())[:200]" ], [ "LOAD_FAST", "query" ], [ "LOAD_FAST", "query" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "function_data_set" ], [ "LOAD_GLOBAL", "json" ], [ "LOAD_METHOD", "json.loads" ], [ "LOAD_DEREF", "function_data" ], [ "CALL_METHOD", "json.loads(function_data)" ], [ "LOAD_FAST", "add" ], [ "LOAD_FAST", "ranges" ], [ "CALL_FUNCTION", "add('node_ranges', ranges)" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "add" ], [ "LOAD_FAST", "current_loop_ranges" ], [ "CALL_FUNCTION", "add('loop_ranges', current_loop_ranges)" ], [ "LOAD_FAST", "loop_ranges" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "current_loop_ranges" ], [ "CONTAINS_OP", "loop_ranges in (set(), current_loop_ranges)" ], [ "LOAD_FAST", "current_loop_ranges" ], [ "LOAD_FAST", "ranges" ], [ "LOAD_FAST", "loop_ranges" ], [ "LOAD_GLOBAL", "DecentJSONEncoder" ], [ "CALL_FUNCTION", "DecentJSONEncoder()" ], [ "LOAD_METHOD", "DecentJSONEncoder().encode" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "calls" ], [ "LOAD_FAST", "ranges" ], [ "LOAD_FAST", "loop_ranges" ], [ "CALL_FUNCTION_KW", "dict(\n calls=calls, ranges=ranges, loop_ranges=loop_ranges)" ], [ "CALL_METHOD", "DecentJSONEncoder().encode(dict(\n calls=calls, ranges=ranges, loop_ranges=loop_ranges))" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_METHOD", "Call.basic_dict" ], [ "LOAD_GLOBAL", "withattrs" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_FUNCTION", "Call()" ], [ "LOAD_FAST", "row" ], [ "LOAD_METHOD", "row._asdict" ], [ "CALL_METHOD", "row._asdict()" ], [ "CALL_FUNCTION_EX", "withattrs(Call(), **row._asdict())" ], [ "CALL_METHOD", "Call.basic_dict(withattrs(Call(), **row._asdict()))" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.data" ], [ "LOAD_DEREF", "function_data" ], [ "LOAD_FAST", "key" ], [ "BINARY_SUBSCR", "function_data[key]" ], [ "LOAD_FAST", "ranges_set" ], [ "LOAD_METHOD", "ranges_set.add" ], [ "LOAD_FAST", "node" ], [ "BINARY_SUBSCR", "node['start']" ], [ "LOAD_FAST", "node" ], [ "BINARY_SUBSCR", "node['end']" ], [ "CALL_METHOD", "ranges_set.add((node['start'], node['end']))" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "CALL_FUNCTION_KW", "dict(start=start, end=end)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "CALL_FUNCTION_KW", "dict(start=start, end=end)" ], [ "LOAD_GLOBAL", "request" ], [ "LOAD_METHOD", "request.get_json" ], [ "CALL_METHOD", "request.get_json()" ], [ "LOAD_FAST", "session" ], [ "LOAD_METHOD", "session.query" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.body_hash" ], [ "LOAD_GLOBAL", "sqlalchemy" ], [ "LOAD_ATTR", "sqlalchemy.func" ], [ "LOAD_METHOD", "sqlalchemy.func.count" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.id" ], [ "CALL_METHOD", "sqlalchemy.func.count(Call.id)" ], [ "CALL_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))" ], [ "LOAD_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)" ], [ "LOAD_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)\n .filter" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.body_hash" ], [ "LOAD_METHOD", "Function.body_hash.in_" ], [ "LOAD_FAST", "hashes" ], [ "CALL_METHOD", "Function.body_hash.in_(hashes)" ], [ "CALL_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)\n .filter(Function.body_hash.in_(hashes))" ], [ "LOAD_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)\n .filter(Function.body_hash.in_(hashes))\n .group_by" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.body_hash" ], [ "CALL_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)\n .filter(Function.body_hash.in_(hashes))\n .group_by(Function.body_hash)" ], [ "LOAD_GLOBAL", "DecentJSONEncoder" ], [ "CALL_FUNCTION", "DecentJSONEncoder()" ], [ "LOAD_METHOD", "DecentJSONEncoder().encode" ], [ "LOAD_FAST", "query" ], [ "CALL_METHOD", "DecentJSONEncoder().encode([\n dict(hash=h, count=count)\n for h, count in query\n ])" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "h" ], [ "LOAD_FAST", "count" ], [ "CALL_FUNCTION_KW", "dict(hash=h, count=count)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "argv" ], [ "CALL_FUNCTION", "len(argv)" ], [ "COMPARE_OP", "len(argv) == 1" ], [ "LOAD_FAST", "argv" ], [ "BINARY_SUBSCR", "argv[0]" ], [ "LOAD_METHOD", "argv[0].isdigit" ], [ "CALL_METHOD", "argv[0].isdigit()" ], [ "LOAD_FAST", "argv" ], [ "LOAD_METHOD", "argv.insert" ], [ "CALL_METHOD", "argv.insert(0, '--port')" ], [ "LOAD_GLOBAL", "argparse" ], [ "LOAD_ATTR", "argparse.ArgumentParser" ], [ "CALL_FUNCTION_KW", "argparse.ArgumentParser(description=\"Bird's Eye: A graphical Python debugger\")" ], [ "LOAD_FAST", "parser" ], [ "LOAD_ATTR", "parser.add_argument" ], [ "LOAD_GLOBAL", "int" ], [ "CALL_FUNCTION_KW", "parser.add_argument('-p', '--port', help='HTTP port, default is 7777', default=7777, type=int)" ], [ "LOAD_FAST", "parser" ], [ "LOAD_ATTR", "parser.add_argument" ], [ "CALL_FUNCTION_KW", "parser.add_argument('--host', help=\"HTTP host, default is 'localhost'\", default='localhost')" ], [ "LOAD_FAST", "parser" ], [ "LOAD_METHOD", "parser.parse_args" ], [ "LOAD_FAST", "argv" ], [ "CALL_METHOD", "parser.parse_args(argv)" ], [ "LOAD_GLOBAL", "app" ], [ "LOAD_ATTR", "app.run" ], [ "LOAD_FAST", "args" ], [ "LOAD_ATTR", "args.port" ], [ "LOAD_FAST", "args" ], [ "LOAD_ATTR", "args.host" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.environ" ], [ "LOAD_METHOD", "os.environ.get" ], [ "CALL_METHOD", "os.environ.get('BIRDSEYE_RELOADER')" ], [ "COMPARE_OP", "os.environ.get('BIRDSEYE_RELOADER') == '1'" ], [ "CALL_FUNCTION_KW", "app.run(\n port=args.port,\n host=args.host,\n use_reloader=os.environ.get('BIRDSEYE_RELOADER') == '1',\n )" ] ], "tests.py": [ [ "LOAD_NAME", "unittest" ], [ "LOAD_ATTR", "unittest.TestCase" ], [ "LOAD_NAME", "unittest" ], [ "LOAD_ATTR", "unittest.TestCase" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "TestFile" ], [ "CALL_FUNCTION", "TestFile()" ], [ "LOAD_METHOD", "TestFile().test_file" ], [ "CALL_METHOD", "TestFile().test_file()" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "Tester" ], [ "CALL_FUNCTION", "Tester()" ], [ "LOAD_NAME", "tester" ], [ "CALL_FUNCTION", "tester([1, 2, 3])" ], [ "COMPARE_OP", "tester([1, 2, 3]) == [1, 2, 3]" ], [ "LOAD_NAME", "tester" ], [ "LOAD_ATTR", "tester.asd" ], [ "LOAD_NAME", "tester" ], [ "IS_OP", "tester.asd is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_SUBSCR", "tester[19]" ], [ "LOAD_NAME", "tester" ], [ "IS_OP", "tester[19] is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_POWER", "tester ** 4" ], [ "LOAD_NAME", "tester" ], [ "IS_OP", "tester ** 4 is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_MULTIPLY", "tester * 3" ], [ "LOAD_NAME", "tester" ], [ "IS_OP", "tester * 3 is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_SUBTRACT", "tester - 2" ], [ "LOAD_NAME", "tester" ], [ "IS_OP", "tester - 2 is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_ADD", "tester + 1" ], [ "LOAD_NAME", "tester" ], [ "IS_OP", "tester + 1 is tester" ], [ "LOAD_NAME", "tester" ], [ "UNARY_NEGATIVE", "-tester" ], [ "LOAD_NAME", "tester" ], [ "IS_OP", "-tester is tester" ], [ "LOAD_NAME", "tester" ], [ "UNARY_POSITIVE", "+tester" ], [ "LOAD_NAME", "tester" ], [ "IS_OP", "+tester is tester" ], [ "LOAD_NAME", "tester" ], [ "UNARY_INVERT", "~tester" ], [ "LOAD_NAME", "tester" ], [ "IS_OP", "~tester is tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester < 7" ], [ "LOAD_NAME", "tester" ], [ "IS_OP", "(tester < 7) is tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester >= 78" ], [ "LOAD_NAME", "tester" ], [ "IS_OP", "(tester >= 78) is tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester != 79" ], [ "LOAD_NAME", "tester" ], [ "IS_OP", "(tester != 79) is tester" ], [ "LOAD_NAME", "tester" ], [ "LOAD_METHOD", "tester.foo" ], [ "CALL_METHOD", "tester.foo(45, False)" ], [ "COMPARE_OP", "tester.foo(45, False) == 45" ], [ "LOAD_NAME", "__name__" ], [ "COMPARE_OP", "__name__ == '__main__'" ], [ "LOAD_NAME", "unittest" ], [ "LOAD_METHOD", "unittest.main" ], [ "CALL_METHOD", "unittest.main()" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(1)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(2)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(3)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(9\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n 8)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n 99\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(33)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([4,\n 5, 6, [\n 7]])" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "LOAD_GLOBAL", "decorator_with_args" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('123')" ], [ "LOAD_GLOBAL", "int" ], [ "CALL_FUNCTION", "int()" ], [ "CALL_FUNCTION_KW", "decorator_with_args(tester('123'), x=int())" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "tuple([1, 2])" ], [ "CALL_FUNCTION", "list(tuple([1, 2]))" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "CALL_FUNCTION_KW", "tester(list(tuple([1, 2])), returns=empty_decorator)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "tuple(\n [3, 4])" ], [ "CALL_FUNCTION", "list(\n tuple(\n [3, 4]))" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "CALL_FUNCTION_KW", "tester(\n list(\n tuple(\n [3, 4])),\n returns=empty_decorator)" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "LOAD_GLOBAL", "decorator_with_args" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "str()" ], [ "LOAD_GLOBAL", "int" ], [ "CALL_FUNCTION", "int()" ], [ "CALL_FUNCTION_KW", "decorator_with_args(\n str(),\n x=int())" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "tuple([5, 6])" ], [ "CALL_FUNCTION", "list(tuple([5, 6]))" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "CALL_FUNCTION_KW", "tester(list(tuple([5, 6])), returns=empty_decorator)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "tuple([7, 8])" ], [ "CALL_FUNCTION", "list(tuple([7, 8]))" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "CALL_FUNCTION_KW", "tester(list(tuple([7, 8])), returns=empty_decorator)" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "LOAD_GLOBAL", "decorator_with_args" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('sdf')" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('123234')" ], [ "CALL_FUNCTION_KW", "decorator_with_args(tester('sdf'), x=tester('123234'))" ], [ "CALL_FUNCTION", "decorator_with_args(tester('sdf'), x=tester('123234'))" ], [ "CALL_FUNCTION", "empty_decorator" ], [ "CALL_FUNCTION", "tester(list(tuple([7, 8])), returns=empty_decorator)" ], [ "CALL_FUNCTION", "tester(list(tuple([5, 6])), returns=empty_decorator)" ], [ "CALL_FUNCTION", "decorator_with_args(\n str(),\n x=int())" ], [ "CALL_FUNCTION", "empty_decorator" ], [ "CALL_FUNCTION", "tester(\n list(\n tuple(\n [3, 4])),\n returns=empty_decorator)" ], [ "CALL_FUNCTION", "tester(list(tuple([1, 2])), returns=empty_decorator)" ], [ "CALL_FUNCTION", "decorator_with_args(tester('123'), x=int())" ], [ "CALL_FUNCTION", "empty_decorator" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "str([{tester(x) for x in [1]}, {tester(y) for y in [1]}])" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "str([{tester(x) for x in [1]},\n {tester(x) for x in [1]}])" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "list(tester(x) for x in [1])" ], [ "CALL_FUNCTION", "str([{tester(x) for x in [1]}, list(tester(x) for x in [1])])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "y" ], [ "CALL_FUNCTION", "tester(y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertEqual" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(3)" ], [ "CALL_FUNCTION", "(lambda x: (tester(x), tester(x)))(tester(3))" ], [ "CALL_METHOD", "self.assertEqual(\n (lambda x: (tester(x), tester(x)))(tester(3)),\n (3, 3),\n )" ], [ "CALL_FUNCTION", "(lambda: (lambda: tester(1))())()" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertEqual" ], [ "CALL_FUNCTION", "(lambda: [tester(x) for x in tester([1, 2])])()" ], [ "CALL_METHOD", "self.assertEqual(\n (lambda: [tester(x) for x in tester([1, 2])])(),\n [1, 2],\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "CALL_FUNCTION", "(lambda: tester(1))()" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(1)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x): {tester(b+x): {tester(c+x) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_FAST", "foo" ], [ "CALL_FUNCTION", "foo()" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "CALL_FUNCTION", "tester(a+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "CALL_FUNCTION", "tester(b+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "CALL_FUNCTION", "tester(c+x)" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x): {tester(b+x): {tester(c+x) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+y): {tester(b+y): {tester(c+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x+y): {tester(b+x+y): {tester(c+x+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_FAST", "bar" ], [ "CALL_FUNCTION", "bar()" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "CALL_FUNCTION", "tester(a+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "CALL_FUNCTION", "tester(b+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "CALL_FUNCTION", "tester(c+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+y" ], [ "CALL_FUNCTION", "tester(a+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+y" ], [ "CALL_FUNCTION", "tester(b+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+y" ], [ "CALL_FUNCTION", "tester(c+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+x+y" ], [ "CALL_FUNCTION", "tester(a+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+x+y" ], [ "CALL_FUNCTION", "tester(b+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+x+y" ], [ "CALL_FUNCTION", "tester(c+x+y)" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x): {tester(b+x): {tester(c+x) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+y): {tester(b+y): {tester(c+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x+y): {tester(b+x+y): {tester(c+x+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x+y+z): {tester(b+x+y+z): {tester(c+x+y+z) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "CALL_FUNCTION", "tester(a+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "CALL_FUNCTION", "tester(b+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "CALL_FUNCTION", "tester(c+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+y" ], [ "CALL_FUNCTION", "tester(a+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+y" ], [ "CALL_FUNCTION", "tester(b+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+y" ], [ "CALL_FUNCTION", "tester(c+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+x+y" ], [ "CALL_FUNCTION", "tester(a+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+x+y" ], [ "CALL_FUNCTION", "tester(b+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+x+y" ], [ "CALL_FUNCTION", "tester(c+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+x+y" ], [ "LOAD_DEREF", "z" ], [ "BINARY_ADD", "a+x+y+z" ], [ "CALL_FUNCTION", "tester(a+x+y+z)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+x+y" ], [ "LOAD_DEREF", "z" ], [ "BINARY_ADD", "b+x+y+z" ], [ "CALL_FUNCTION", "tester(b+x+y+z)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+x+y" ], [ "LOAD_DEREF", "z" ], [ "BINARY_ADD", "c+x+y+z" ], [ "CALL_FUNCTION", "tester(c+x+y+z)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION_KW", "dict(x=tester)" ], [ "BINARY_SUBSCR", "dict(x=tester)['x']" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "dict(x=tester)['x'](tester)" ], [ "CALL_FUNCTION_KW", "dict(x=tester)['x'](tester)(3, check_func=False)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertRaises" ], [ "LOAD_GLOBAL", "TypeError" ], [ "CALL_METHOD", "self.assertRaises(TypeError)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2, 3])" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(0)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(4)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(5)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "tester(ValueError)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(9)" ], [ "LOAD_GLOBAL", "TypeError" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(10)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(10)" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "str()" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertRaises" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "Exception" ], [ "CALL_FUNCTION", "tester(Exception)" ], [ "CALL_METHOD", "self.assertRaises(tester(Exception))" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(0)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(0)" ], [ "LOAD_GLOBAL", "tester" ], [ "BINARY_TRUE_DIVIDE", "1 / 0" ], [ "CALL_FUNCTION", "tester(1 / 0)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "gen" ], [ "CALL_FUNCTION", "gen()" ], [ "CALL_FUNCTION", "list(gen())" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "gen2" ], [ "CALL_FUNCTION", "list(gen2)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(4)" ], [ "LOAD_GLOBAL", "time" ], [ "LOAD_METHOD", "time.time" ], [ "CALL_METHOD", "time.time()" ], [ "LOAD_GLOBAL", "range" ], [ "CALL_FUNCTION", "range(10000)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_METHOD", "Source.executing" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.currentframe" ], [ "CALL_METHOD", "inspect.currentframe()" ], [ "CALL_METHOD", "Source.executing(inspect.currentframe())" ], [ "LOAD_ATTR", "Source.executing(inspect.currentframe()).node" ], [ "LOAD_FAST", "node" ], [ "IS_OP", "node is None" ], [ "LOAD_FAST", "new_node" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertIs" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "new_node" ], [ "CALL_METHOD", "self.assertIs(node, new_node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertLess" ], [ "LOAD_GLOBAL", "time" ], [ "LOAD_METHOD", "time.time" ], [ "CALL_METHOD", "time.time()" ], [ "LOAD_FAST", "start" ], [ "BINARY_SUBTRACT", "time.time() - start" ], [ "CALL_METHOD", "self.assertLess(time.time() - start, 1)" ], [ "LOAD_FAST", "check" ], [ "CALL_FUNCTION", "check(u'# coding=utf8\\n\u00e9', 'utf8')" ], [ "LOAD_FAST", "check" ], [ "CALL_FUNCTION", "check(u'# coding=gbk\\n\u00e9', 'gbk')" ], [ "LOAD_FAST", "check" ], [ "LOAD_GLOBAL", "UnicodeDecodeError" ], [ "CALL_FUNCTION_KW", "check(u'# coding=utf8\\n\u00e9', 'gbk', exception=UnicodeDecodeError)" ], [ "LOAD_FAST", "check" ], [ "CALL_FUNCTION_KW", "check(u'# coding=gbk\\n\u00e9', 'utf8', matches=False)" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_FAST", "check" ], [ "CALL_FUNCTION", "check(u'\u00e9', 'utf8')" ], [ "LOAD_FAST", "check" ], [ "LOAD_GLOBAL", "SyntaxError" ], [ "CALL_FUNCTION_KW", "check(u'\u00e9', 'gbk', exception=SyntaxError)" ], [ "LOAD_FAST", "source" ], [ "LOAD_METHOD", "source.encode" ], [ "LOAD_FAST", "encoding" ], [ "CALL_METHOD", "source.encode(encoding)" ], [ "LOAD_FAST", "exception" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self.assertRaises" ], [ "LOAD_FAST", "exception" ], [ "CALL_METHOD", "self.assertRaises(exception)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_METHOD", "Source.decode_source" ], [ "LOAD_FAST", "encoded" ], [ "CALL_METHOD", "Source.decode_source(encoded)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_METHOD", "Source.decode_source" ], [ "LOAD_FAST", "encoded" ], [ "CALL_METHOD", "Source.decode_source(encoded)" ], [ "LOAD_FAST", "matches" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self.assertEqual" ], [ "LOAD_FAST", "decoded" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "self.assertEqual(decoded, source)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self.assertNotEqual" ], [ "LOAD_FAST", "decoded" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "self.assertNotEqual(decoded, source)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('a')" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('''\n ab''')" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('''\n abc\n def\n '''\n )" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n '''\n 123\n 456\n '''\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n '''\n 345\n 456786\n '''\n )" ], [ "CALL_FUNCTION", "str([\n tester(\n '''\n 123\n 456\n '''\n ),\n tester(\n '''\n 345\n 456786\n '''\n ),\n ])" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n [\n '''\n 123\n 456\n '''\n '''\n 345\n 456786\n '''\n ,\n '''\n 123\n 456\n ''',\n '''\n 345\n 456786\n '''\n ]\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(1)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(2)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(3)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_METHOD", "Source.for_filename" ], [ "LOAD_GLOBAL", "__file__" ], [ "CALL_METHOD", "Source.for_filename(__file__)" ], [ "LOAD_METHOD", "Source.for_filename(__file__).code_qualname" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.__code__" ], [ "CALL_METHOD", "Source.for_filename(__file__).code_qualname(func.__code__)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertEqual" ], [ "LOAD_FAST", "qn" ], [ "LOAD_FAST", "qualname" ], [ "CALL_METHOD", "self.assertEqual(qn, qualname)" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_FAST", "check_actual_qualname" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertEqual" ], [ "LOAD_FAST", "qn" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.__qualname__" ], [ "CALL_METHOD", "self.assertEqual(qn, func.__qualname__)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertTrue" ], [ "LOAD_FAST", "qn" ], [ "LOAD_METHOD", "qn.endswith" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.__name__" ], [ "CALL_METHOD", "qn.endswith(func.__name__)" ], [ "CALL_METHOD", "self.assertTrue(qn.endswith(func.__name__))" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assert_qualname" ], [ "LOAD_GLOBAL", "C" ], [ "LOAD_ATTR", "C.f" ], [ "CALL_METHOD", "self.assert_qualname(C.f, 'C.f')" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assert_qualname" ], [ "LOAD_GLOBAL", "C" ], [ "LOAD_ATTR", "C.D" ], [ "LOAD_ATTR", "C.D.g" ], [ "CALL_METHOD", "self.assert_qualname(C.D.g, 'C.D.g')" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assert_qualname" ], [ "LOAD_GLOBAL", "f" ], [ "CALL_METHOD", "self.assert_qualname(f, 'f')" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assert_qualname" ], [ "LOAD_GLOBAL", "f" ], [ "CALL_FUNCTION", "f()" ], [ "CALL_METHOD", "self.assert_qualname(f(), 'f..g')" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assert_qualname" ], [ "LOAD_GLOBAL", "C" ], [ "LOAD_ATTR", "C.D" ], [ "LOAD_METHOD", "C.D.h" ], [ "CALL_METHOD", "C.D.h()" ], [ "CALL_METHOD", "self.assert_qualname(C.D.h(), 'C.D.h..i..j')" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assert_qualname" ], [ "LOAD_GLOBAL", "lamb" ], [ "CALL_METHOD", "self.assert_qualname(lamb, '')" ], [ "LOAD_GLOBAL", "lambda_maker" ], [ "CALL_FUNCTION", "lambda_maker()" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assert_qualname" ], [ "LOAD_FAST", "foo" ], [ "CALL_METHOD", "self.assert_qualname(foo, 'lambda_maker..foo')" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assert_qualname" ], [ "LOAD_FAST", "foo" ], [ "LOAD_ATTR", "foo.x" ], [ "CALL_METHOD", "self.assert_qualname(foo.x, 'lambda_maker..')" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assert_qualname" ], [ "LOAD_FAST", "foo" ], [ "CALL_FUNCTION", "foo()" ], [ "CALL_METHOD", "self.assert_qualname(foo(), 'lambda_maker..foo..')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.assert_qualname" ], [ "LOAD_FAST", "foo" ], [ "CALL_FUNCTION", "foo()" ], [ "CALL_FUNCTION", "foo()()" ], [ "CALL_FUNCTION_KW", "self.assert_qualname(foo()(), 'lambda_maker..foo..', check_actual_qualname=False)" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "range" ], [ "CALL_FUNCTION", "range(66000)" ], [ "CALL_FUNCTION", "list(range(66000))" ], [ "BINARY_MODULO", "'tester(6)\\n%s\\ntester(9)' % list(range(66000))" ], [ "LOAD_GLOBAL", "tempfile" ], [ "LOAD_METHOD", "tempfile.mkstemp" ], [ "CALL_METHOD", "tempfile.mkstemp()" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "compile(source, filename, 'exec')" ], [ "LOAD_GLOBAL", "open" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "open(filename, 'w')" ], [ "LOAD_FAST", "outfile" ], [ "LOAD_METHOD", "outfile.write" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "outfile.write(source)" ], [ "LOAD_GLOBAL", "exec" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "exec(code)" ], [ "LOAD_GLOBAL", "range" ], [ "CALL_FUNCTION", "range(5)" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "n" ], [ "CALL_FUNCTION", "range(n)" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "n == 1" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertEqual" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_FAST", "gen" ], [ "CALL_FUNCTION", "only(gen)" ], [ "CALL_METHOD", "self.assertEqual(only(gen), 0)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertRaises" ], [ "LOAD_GLOBAL", "NotOneValueFound" ], [ "CALL_METHOD", "self.assertRaises(NotOneValueFound)" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_FAST", "gen" ], [ "CALL_FUNCTION", "only(gen)" ], [ "LOAD_FAST", "i" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_METHOD", "os.path.join" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_METHOD", "os.path.dirname" ], [ "LOAD_GLOBAL", "__file__" ], [ "CALL_METHOD", "os.path.dirname(__file__)" ], [ "CALL_METHOD", "os.path.join(os.path.dirname(__file__), 'not_code.txt', )" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_METHOD", "Source.for_filename" ], [ "LOAD_FAST", "path" ], [ "CALL_METHOD", "Source.for_filename(path)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertIsNone" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.tree" ], [ "CALL_METHOD", "self.assertIsNone(source.tree)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.currentframe" ], [ "CALL_METHOD", "inspect.currentframe()" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_METHOD", "Source.executing" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "Source.executing(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertEqual" ], [ "LOAD_FAST", "executing" ], [ "LOAD_METHOD", "executing.code_qualname" ], [ "CALL_METHOD", "executing.code_qualname()" ], [ "CALL_METHOD", "self.assertEqual(executing.code_qualname(), 'TestStuff.test_executing_methods')" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.version" ], [ "LOAD_METHOD", "sys.version.lower" ], [ "CALL_METHOD", "sys.version.lower()" ], [ "CONTAINS_OP", "'pypy' not in sys.version.lower()" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertEqual" ], [ "LOAD_FAST", "executing" ], [ "LOAD_METHOD", "executing.text" ], [ "CALL_METHOD", "executing.text()" ], [ "LOAD_FAST", "text" ], [ "CALL_METHOD", "self.assertEqual(executing.text(), text)" ], [ "LOAD_FAST", "executing" ], [ "LOAD_METHOD", "executing.text_range" ], [ "CALL_METHOD", "executing.text_range()" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.assertEqual" ], [ "LOAD_FAST", "executing" ], [ "LOAD_ATTR", "executing.source" ], [ "LOAD_ATTR", "executing.source.text" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "BINARY_SUBSCR", "executing.source.text[start:end]" ], [ "LOAD_FAST", "text" ], [ "CALL_METHOD", "self.assertEqual(executing.source.text[start:end], text)" ], [ "LOAD_GLOBAL", "C" ], [ "CALL_FUNCTION", "C()" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_FAST", "c" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.x" ], [ "LOAD_ATTR", "c.x.x" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.x" ], [ "LOAD_ATTR", "c.x.y" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.y" ], [ "LOAD_ATTR", "c.y.x" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.y" ], [ "LOAD_ATTR", "c.y.y" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.x" ], [ "LOAD_ATTR", "c.x.asd" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.y" ], [ "LOAD_ATTR", "c.y.qwe" ], [ "CALL_FUNCTION", "str((c.x.x, c.x.y, c.y.x, c.y.y, c.x.asd, c.y.qwe))" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_METHOD", "Source.for_frame" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.currentframe" ], [ "CALL_METHOD", "inspect.currentframe()" ], [ "CALL_METHOD", "Source.for_frame(inspect.currentframe())" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.text" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.filename" ], [ "CALL_FUNCTION", "compile(source.text, source.filename, 'exec')" ], [ "LOAD_GLOBAL", "get_instructions" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "get_instructions(code)" ], [ "LOAD_FAST", "instructions" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.starts_line" ], [ "IS_OP", "inst.starts_line is not None" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.starts_line" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.opname" ], [ "LOAD_METHOD", "inst.opname.startswith" ], [ "CALL_METHOD", "inst.opname.startswith(\n ('BINARY_', 'UNARY_', 'LOAD_ATTR', 'LOAD_METHOD', 'LOOKUP_METHOD', 'COMPARE_OP'))" ], [ "LOAD_GLOBAL", "C" ], [ "CALL_FUNCTION", "C()" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.offset" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "frame" ], [ "LOAD_GLOBAL", "globals" ], [ "CALL_FUNCTION", "globals()" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "lineno" ], [ "LOAD_FAST", "frame" ], [ "LOAD_GLOBAL", "print" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.opname" ], [ "CALL_FUNCTION", "print(inst.opname)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_METHOD", "Source.executing" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "Source.executing(frame)" ], [ "LOAD_ATTR", "Source.executing(frame).node" ], [ "IS_OP", "Source.executing(frame).node is not None" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_FAST", "i" ], [ "CALL_FUNCTION", "i()" ], [ "LOAD_FAST", "j" ], [ "LOAD_FAST", "g" ], [ "LOAD_FAST", "assign" ], [ "CALL_FUNCTION", "assign(lambda: 1)" ], [ "CALL_FUNCTION", "assign(lambda: 1)" ], [ "LOAD_FAST", "foo" ], [ "LOAD_FAST", "decorator" ], [ "LOAD_DEREF", "x" ], [ "LOAD_FAST", "func" ], [ "LOAD_FAST", "func" ], [ "LOAD_NAME", "__add__" ], [ "LOAD_NAME", "__invert__" ], [ "LOAD_NAME", "__lt__" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.currentframe" ], [ "CALL_METHOD", "inspect.currentframe()" ], [ "LOAD_ATTR", "inspect.currentframe().f_back" ], [ "LOAD_ATTR", "inspect.currentframe().f_back.f_back" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_METHOD", "Source.lazycache" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "Source.lazycache(frame)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_METHOD", "Source.executing" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "Source.executing(frame)" ], [ "LOAD_ATTR", "Source.executing(frame).node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "typ" ], [ "CALL_FUNCTION", "isinstance(node, typ)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "typ" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.currentframe" ], [ "CALL_METHOD", "inspect.currentframe()" ], [ "LOAD_ATTR", "inspect.currentframe().f_back" ], [ "LOAD_ATTR", "inspect.currentframe().f_back.f_back" ], [ "LOAD_GLOBAL", "eval" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.Expression" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.Expression(node)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_filename" ], [ "CALL_FUNCTION", "compile(ast.Expression(node), frame.f_code.co_filename, 'eval')" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "CALL_FUNCTION", "eval(\n compile(ast.Expression(node), frame.f_code.co_filename, 'eval'),\n frame.f_globals,\n frame.f_locals,\n )" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "value" ], [ "COMPARE_OP", "result == value" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Call" ], [ "CALL_METHOD", "self.get_node(ast.Call)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.check" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.args" ], [ "BINARY_SUBSCR", "call.args[0]" ], [ "LOAD_FAST", "arg" ], [ "CALL_METHOD", "self.check(call.args[0], arg)" ], [ "LOAD_FAST", "check_func" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.check" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.func" ], [ "LOAD_FAST", "self" ], [ "CALL_METHOD", "self.check(call.func, self)" ], [ "LOAD_FAST", "returns" ], [ "IS_OP", "returns is None" ], [ "LOAD_FAST", "arg" ], [ "LOAD_FAST", "returns" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Attribute" ], [ "CALL_METHOD", "self.get_node(ast.Attribute)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.value" ], [ "LOAD_FAST", "self" ], [ "CALL_METHOD", "self.check(node.value, self)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.attr" ], [ "LOAD_FAST", "item" ], [ "COMPARE_OP", "node.attr == item" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Subscript" ], [ "CALL_METHOD", "self.get_node(ast.Subscript)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.value" ], [ "LOAD_FAST", "self" ], [ "CALL_METHOD", "self.check(node.value, self)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.slice" ], [ "LOAD_ATTR", "node.slice.value" ], [ "LOAD_FAST", "item" ], [ "CALL_METHOD", "self.check(node.slice.value, item)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.BinOp" ], [ "CALL_METHOD", "self.get_node(ast.BinOp)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.left" ], [ "LOAD_FAST", "self" ], [ "CALL_METHOD", "self.check(node.left, self)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.right" ], [ "LOAD_FAST", "other" ], [ "CALL_METHOD", "self.check(node.right, other)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.UnaryOp" ], [ "CALL_METHOD", "self.get_node(ast.UnaryOp)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.operand" ], [ "LOAD_FAST", "self" ], [ "CALL_METHOD", "self.check(node.operand, self)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Compare" ], [ "CALL_METHOD", "self.get_node(ast.Compare)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.left" ], [ "LOAD_FAST", "self" ], [ "CALL_METHOD", "self.check(node.left, self)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.comparators" ], [ "BINARY_SUBSCR", "node.comparators[0]" ], [ "LOAD_FAST", "other" ], [ "CALL_METHOD", "self.check(node.comparators[0], other)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "func" ], [ "LOAD_GLOBAL", "empty_decorator" ] ], "tracer.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOAD_METHOD", "standard_library.install_aliases" ], [ "CALL_METHOD", "standard_library.install_aliases()" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "NamedTuple" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "Union" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "BINARY_SUBSCR", "Union[ast.expr, ast.stmt]" ], [ "BINARY_SUBSCR", "Optional[Union[ast.expr, ast.stmt]]" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.AST" ], [ "LOAD_NAME", "FrameType" ], [ "LOAD_NAME", "FrameType" ], [ "CALL_FUNCTION", "NamedTuple('EnterCallInfo', [\n\n # Node from where the call was made\n ('call_node', Optional[Union[ast.expr, ast.stmt]]),\n\n # Node where the call begins\n ('enter_node', ast.AST),\n\n # Frame from which the call was made\n ('caller_frame', FrameType),\n\n # Frame of the call\n ('current_frame', FrameType)])" ], [ "LOAD_NAME", "NamedTuple" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "Union" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "BINARY_SUBSCR", "Union[ast.expr, ast.stmt]" ], [ "BINARY_SUBSCR", "Optional[Union[ast.expr, ast.stmt]]" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.Return" ], [ "BINARY_SUBSCR", "Optional[ast.Return]" ], [ "LOAD_NAME", "FrameType" ], [ "LOAD_NAME", "FrameType" ], [ "LOAD_NAME", "Any" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "Exception" ], [ "BINARY_SUBSCR", "Optional[Exception]" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "TracebackType" ], [ "BINARY_SUBSCR", "Optional[TracebackType]" ], [ "CALL_FUNCTION", "NamedTuple('ExitCallInfo', [\n\n # Node from where the call was made\n ('call_node', Optional[Union[ast.expr, ast.stmt]]),\n\n # Node where the call explicitly returned\n ('return_node', Optional[ast.Return]),\n\n # Frame from which the call was made\n ('caller_frame', FrameType),\n\n # Frame of the call\n ('current_frame', FrameType),\n\n # Node where the call explicitly returned\n ('return_value', Any),\n\n # Exception raised in the call causing it to end,\n # will propagate to the caller\n ('exc_value', Optional[Exception]),\n\n # Traceback corresponding to exc_value\n ('exc_tb', Optional[TracebackType])])" ], [ "LOAD_NAME", "namedtuple" ], [ "CALL_FUNCTION", "namedtuple('ChangeValue', 'value')" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.NodeTransformer" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "Union" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "BINARY_SUBSCR", "Union[ast.For, ast.While, ast.comprehension]" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.PyCF_ONLY_AST" ], [ "LOAD_FAST", "flags" ], [ "BINARY_OR", "ast.PyCF_ONLY_AST | flags" ], [ "CALL_FUNCTION_KW", "compile(source, filename, 'exec', ast.PyCF_ONLY_AST | flags, dont_inherit=True)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.set_basic_node_attributes" ], [ "CALL_METHOD", "self.set_basic_node_attributes()" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_METHOD", "tracer.parse_extra" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "CALL_METHOD", "tracer.parse_extra(self.root, source, filename)" ], [ "LOAD_FAST", "new_root" ], [ "IS_OP", "new_root is not None" ], [ "LOAD_FAST", "new_root" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.set_basic_node_attributes" ], [ "CALL_METHOD", "self.set_basic_node_attributes()" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.set_enter_call_nodes" ], [ "CALL_METHOD", "self.set_enter_call_nodes()" ], [ "LOAD_GLOBAL", "deepcopy" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "CALL_FUNCTION", "deepcopy(self.root)" ], [ "LOAD_GLOBAL", "_NodeVisitor" ], [ "CALL_FUNCTION", "_NodeVisitor()" ], [ "LOAD_METHOD", "_NodeVisitor().visit" ], [ "LOAD_FAST", "new_root" ], [ "CALL_METHOD", "_NodeVisitor().visit(new_root)" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "new_root" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "flags" ], [ "CALL_FUNCTION_KW", "compile(new_root, filename, \"exec\", dont_inherit=True, flags=flags)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.walk" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "CALL_METHOD", "ast.walk(self.root)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.iter_child_nodes" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.iter_child_nodes(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.nodes" ], [ "CALL_FUNCTION", "len(self.nodes)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.nodes" ], [ "LOAD_METHOD", "self.nodes.append" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self.nodes.append(node)" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "LOAD_ATTR", "self.root.body" ], [ "CALL_FUNCTION", "enumerate(self.root.body)" ], [ "LOAD_GLOBAL", "is_future_import" ], [ "LOAD_FAST", "stmt" ], [ "CALL_FUNCTION", "is_future_import(stmt)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "LOAD_ATTR", "self.root.body" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "self.root.body[:i + 1]" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.walk" ], [ "LOAD_FAST", "s" ], [ "CALL_METHOD", "ast.walk(s)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.nodes" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Module" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(node, (ast.Module, ast.FunctionDef))" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.body" ], [ "LOAD_GLOBAL", "is_future_import" ], [ "LOAD_FAST", "stmt" ], [ "CALL_FUNCTION", "is_future_import(stmt)" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_NAME", "lru_cache" ], [ "CALL_FUNCTION", "lru_cache()" ], [ "CALL_FUNCTION", "lru_cache()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "defaultdict(list)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "TracedFile" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "flags" ], [ "CALL_FUNCTION", "TracedFile(self, source, filename, flags)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._treetrace_hidden_with_stmt" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._treetrace_hidden_before_expr" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._treetrace_hidden_after_expr" ], [ "LOAD_FAST", "f" ], [ "LOAD_ATTR", "f.__name__" ], [ "LOAD_GLOBAL", "partial" ], [ "LOAD_FAST", "f" ], [ "LOAD_DEREF", "traced_file" ], [ "CALL_FUNCTION", "partial(f, traced_file)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_DEREF", "func" ], [ "LOAD_GLOBAL", "FunctionType" ], [ "CALL_FUNCTION", "isinstance(func, FunctionType)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError('You can only trace user-defined functions. '\n 'The birdseye decorator must be applied first, '\n 'at the bottom of the list.')" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.iscoroutinefunction" ], [ "LOAD_DEREF", "func" ], [ "CALL_METHOD", "inspect.iscoroutinefunction(func)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.isasyncgenfunction" ], [ "LOAD_DEREF", "func" ], [ "CALL_METHOD", "inspect.isasyncgenfunction(func)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError('You cannot trace async functions')" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_GLOBAL", "is_lambda" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "is_lambda(func)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError('You cannot trace lambdas')" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.getsourcefile" ], [ "LOAD_DEREF", "func" ], [ "CALL_METHOD", "inspect.getsourcefile(func)" ], [ "LOAD_GLOBAL", "is_ipython_cell" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "is_ipython_cell(filename)" ], [ "LOAD_FAST", "get_ipython" ], [ "CALL_FUNCTION", "get_ipython()" ], [ "LOAD_ATTR", "get_ipython().compile" ], [ "LOAD_ATTR", "get_ipython().compile.flags" ], [ "LOAD_METHOD", "''.join" ], [ "LOAD_FAST", "linecache" ], [ "LOAD_ATTR", "linecache.cache" ], [ "LOAD_FAST", "filename" ], [ "BINARY_SUBSCR", "linecache.cache[filename]" ], [ "BINARY_SUBSCR", "linecache.cache[filename][2]" ], [ "CALL_METHOD", "''.join(linecache.cache[filename][2])" ], [ "LOAD_GLOBAL", "read_source_file" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "read_source_file(filename)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "flags" ], [ "CALL_METHOD", "self.compile(source, filename, flags)" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__dict__" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError('The birdseye decorator must be applied first, '\n 'at the bottom of the list.')" ], [ "LOAD_DEREF", "find_code" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.code" ], [ "CALL_FUNCTION", "find_code(traced_file.code)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_DEREF", "code_options" ], [ "CALL_FUNCTION", "len(code_options)" ], [ "COMPARE_OP", "len(code_options) > 1" ], [ "LOAD_GLOBAL", "is_lambda" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "is_lambda(func)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError(\"Failed to trace lambda. Convert the function to a def.\")" ], [ "LOAD_DEREF", "code_options" ], [ "BINARY_SUBSCR", "code_options[0]" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__globals__" ], [ "LOAD_METHOD", "func.__globals__.update" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._trace_methods_dict" ], [ "LOAD_FAST", "traced_file" ], [ "CALL_METHOD", "self._trace_methods_dict(traced_file)" ], [ "CALL_METHOD", "func.__globals__.update(self._trace_methods_dict(traced_file))" ], [ "LOAD_GLOBAL", "FunctionType" ], [ "LOAD_FAST", "new_func_code" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__globals__" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__name__" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__defaults__" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__closure__" ], [ "CALL_FUNCTION", "FunctionType(new_func_code, func.__globals__, func.__name__, func.__defaults__, func.__closure__)" ], [ "LOAD_GLOBAL", "update_wrapper" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "update_wrapper(new_func, func)" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "getattr(func, '__kwdefaults__', None)" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_FAST", "root_code" ], [ "LOAD_ATTR", "root_code.co_consts" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.iscode" ], [ "LOAD_FAST", "const" ], [ "CALL_METHOD", "inspect.iscode(const)" ], [ "LOAD_FAST", "const" ], [ "LOAD_ATTR", "const.co_firstlineno" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__code__" ], [ "LOAD_ATTR", "func.__code__.co_firstlineno" ], [ "COMPARE_OP", "const.co_firstlineno == func.__code__.co_firstlineno" ], [ "LOAD_FAST", "const" ], [ "LOAD_ATTR", "const.co_name" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__code__" ], [ "LOAD_ATTR", "func.__code__.co_name" ], [ "COMPARE_OP", "const.co_name == func.__code__.co_name" ], [ "LOAD_FAST", "matches" ], [ "LOAD_DEREF", "code_options" ], [ "LOAD_METHOD", "code_options.append" ], [ "LOAD_FAST", "const" ], [ "CALL_METHOD", "code_options.append(const)" ], [ "LOAD_DEREF", "find_code" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "find_code(const)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.isclass" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "inspect.isclass(func)" ], [ "LOAD_GLOBAL", "TypeError" ], [ "CALL_FUNCTION", "TypeError('Decorating classes is no longer supported')" ], [ "LOAD_FAST", "func" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self.trace_function" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "self.trace_function(func)" ], [ "LOAD_FAST", "optional" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.trace_function" ], [ "LOAD_FAST", "decorator" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self.trace_function" ], [ "LOAD_DEREF", "actual_func" ], [ "CALL_METHOD", "self.trace_function(actual_func)" ], [ "LOAD_GLOBAL", "wraps" ], [ "LOAD_DEREF", "actual_func" ], [ "CALL_FUNCTION", "wraps(actual_func)" ], [ "CALL_FUNCTION", "wraps(actual_func)" ], [ "LOAD_FAST", "wrapper" ], [ "LOAD_FAST", "kwargs" ], [ "LOAD_METHOD", "kwargs.pop" ], [ "CALL_METHOD", "kwargs.pop('trace_call', False)" ], [ "LOAD_FAST", "trace_call" ], [ "LOAD_DEREF", "traced" ], [ "LOAD_DEREF", "actual_func" ], [ "LOAD_FAST", "f" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "f(*args, **kwargs)" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_METHOD", "sys._getframe" ], [ "CALL_METHOD", "sys._getframe(2)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.secondary_to_main_frames" ], [ "LOAD_METHOD", "self.secondary_to_main_frames.get" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self.secondary_to_main_frames.get(frame)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "CONTAINS_OP", "frame.f_code.co_name in ('', '', '')" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_GLOBAL", "ancestors" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ancestors(node)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Lambda" ], [ "CALL_FUNCTION", "isinstance(node, (ast.FunctionDef, ast.Lambda))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.ClassDef" ], [ "CALL_FUNCTION", "isinstance(node, ast.ClassDef)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "CONTAINS_OP", "frame.f_code.co_name in ('', '')" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.secondary_to_main_frames" ], [ "LOAD_FAST", "original_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.main_to_secondary_frames" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.main_to_secondary_frames[frame]" ], [ "LOAD_METHOD", "self.main_to_secondary_frames[frame].append" ], [ "LOAD_FAST", "original_frame" ], [ "CALL_METHOD", "self.main_to_secondary_frames[frame].append(original_frame)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.nodes" ], [ "LOAD_FAST", "_tree_index" ], [ "BINARY_SUBSCR", "traced_file.nodes[_tree_index]" ], [ "LOAD_GLOBAL", "cast" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "cast(ast.stmt, node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._main_frame" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self._main_frame(node)" ], [ "LOAD_GLOBAL", "_StmtContext" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "_StmtContext(self, node, frame)" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.nodes" ], [ "LOAD_FAST", "_tree_index" ], [ "BINARY_SUBSCR", "traced_file.nodes[_tree_index]" ], [ "LOAD_GLOBAL", "cast" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "cast(ast.expr, node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._main_frame" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self._main_frame(node)" ], [ "LOAD_FAST", "frame" ], [ "IS_OP", "frame is None" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_stack" ], [ "LOAD_METHOD", "frame_info.expression_stack.append" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "frame_info.expression_stack.append(node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.before_expr" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self.before_expr(node, frame)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._main_frame" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self._main_frame(node)" ], [ "LOAD_FAST", "frame" ], [ "IS_OP", "frame is None" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._after_expr" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "value" ], [ "CALL_METHOD", "self._after_expr(node, frame, value, None, None)" ], [ "LOAD_FAST", "result" ], [ "IS_OP", "result is not None" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "ChangeValue" ], [ "CALL_FUNCTION", "isinstance(result, ChangeValue)" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.value" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_stack" ], [ "LOAD_METHOD", "frame_info.expression_stack.pop" ], [ "CALL_METHOD", "frame_info.expression_stack.pop()" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_values" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.after_expr" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "exc_value" ], [ "LOAD_FAST", "exc_tb" ], [ "CALL_METHOD", "self.after_expr(node, frame, value, exc_value, exc_tb)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._get_caller_stuff" ], [ "LOAD_FAST", "current_frame" ], [ "CALL_METHOD", "self._get_caller_stuff(current_frame)" ], [ "LOAD_GLOBAL", "FrameInfo" ], [ "CALL_FUNCTION", "FrameInfo()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "current_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.enter_call" ], [ "LOAD_GLOBAL", "EnterCallInfo" ], [ "LOAD_FAST", "call_node" ], [ "LOAD_FAST", "enter_node" ], [ "LOAD_FAST", "caller_frame" ], [ "LOAD_FAST", "current_frame" ], [ "CALL_FUNCTION", "EnterCallInfo(call_node, enter_node, caller_frame, current_frame)" ], [ "CALL_METHOD", "self.enter_call(EnterCallInfo(call_node, enter_node, caller_frame, current_frame))" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.secondary_to_main_frames" ], [ "LOAD_METHOD", "self.secondary_to_main_frames.get" ], [ "LOAD_FAST", "caller_frame" ], [ "CALL_METHOD", "self.secondary_to_main_frames.get(caller_frame)" ], [ "LOAD_FAST", "main_frame" ], [ "LOAD_FAST", "main_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "caller_frame" ], [ "BINARY_SUBSCR", "self.stack[caller_frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_stack" ], [ "LOAD_FAST", "expression_stack" ], [ "LOAD_FAST", "expression_stack" ], [ "BINARY_SUBSCR", "expression_stack[-1]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.statement_stack" ], [ "BINARY_SUBSCR", "frame_info.statement_stack[-1]" ], [ "LOAD_FAST", "caller_frame" ], [ "LOAD_FAST", "call_node" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "getattr(node, '_visit_ignore', False)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "CALL_FUNCTION", "isinstance(node, ast.expr)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "hasattr(node, \"ctx\")" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.ctx" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Load" ], [ "CALL_FUNCTION", "isinstance(node.ctx, ast.Load)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "ast" ], [ "CALL_FUNCTION", "getattr(ast, 'Starred', ())" ], [ "CALL_FUNCTION", "isinstance(node, getattr(ast, 'Starred', ()))" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.visit_expr" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self.visit_expr(node)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "CALL_FUNCTION", "isinstance(node, ast.stmt)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.visit_stmt" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self.visit_stmt(node)" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "_NodeVisitor" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self)" ], [ "LOAD_METHOD", "super(_NodeVisitor, self).generic_visit" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "super(_NodeVisitor, self).generic_visit(node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._create_simple_marker_call" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "TreeTracerBase" ], [ "LOAD_ATTR", "TreeTracerBase._treetrace_hidden_before_expr" ], [ "CALL_METHOD", "self._create_simple_marker_call(node, TreeTracerBase._treetrace_hidden_before_expr)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.copy_location" ], [ "LOAD_FAST", "before_marker" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.copy_location(before_marker, node)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Call" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Name" ], [ "LOAD_GLOBAL", "TreeTracerBase" ], [ "LOAD_ATTR", "TreeTracerBase._treetrace_hidden_after_expr" ], [ "LOAD_ATTR", "TreeTracerBase._treetrace_hidden_after_expr.__name__" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.Load" ], [ "CALL_METHOD", "ast.Load()" ], [ "CALL_FUNCTION_KW", "ast.Name(id=TreeTracerBase._treetrace_hidden_after_expr.__name__,\n ctx=ast.Load())" ], [ "LOAD_FAST", "before_marker" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "_NodeVisitor" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self)" ], [ "LOAD_METHOD", "super(_NodeVisitor, self).generic_visit" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "super(_NodeVisitor, self).generic_visit(node)" ], [ "CALL_FUNCTION_KW", "ast.Call(\n func=ast.Name(id=TreeTracerBase._treetrace_hidden_after_expr.__name__,\n ctx=ast.Load()),\n args=[\n before_marker,\n super(_NodeVisitor, self).generic_visit(node),\n ],\n keywords=[],\n )" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.copy_location" ], [ "LOAD_FAST", "after_marker" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.copy_location(after_marker, node)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.fix_missing_locations" ], [ "LOAD_FAST", "after_marker" ], [ "CALL_METHOD", "ast.fix_missing_locations(after_marker)" ], [ "LOAD_FAST", "after_marker" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._create_simple_marker_call" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "_NodeVisitor" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self)" ], [ "LOAD_METHOD", "super(_NodeVisitor, self).generic_visit" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "super(_NodeVisitor, self).generic_visit(node)" ], [ "LOAD_GLOBAL", "TreeTracerBase" ], [ "LOAD_ATTR", "TreeTracerBase._treetrace_hidden_with_stmt" ], [ "CALL_METHOD", "self._create_simple_marker_call(\n super(_NodeVisitor, self).generic_visit(node),\n TreeTracerBase._treetrace_hidden_with_stmt)" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.With" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.withitem" ], [ "LOAD_FAST", "context_expr" ], [ "CALL_FUNCTION_KW", "ast.withitem(context_expr=context_expr)" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION_KW", "ast.With(\n items=[ast.withitem(context_expr=context_expr)],\n body=[node],\n )" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.With" ], [ "LOAD_FAST", "context_expr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION_KW", "ast.With(\n context_expr=context_expr,\n body=[node],\n )" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.copy_location" ], [ "LOAD_FAST", "wrapped" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.copy_location(wrapped, node)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.fix_missing_locations" ], [ "LOAD_FAST", "wrapped" ], [ "CALL_METHOD", "ast.fix_missing_locations(wrapped)" ], [ "LOAD_FAST", "wrapped" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Call" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Name" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.__name__" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.Load" ], [ "CALL_METHOD", "ast.Load()" ], [ "CALL_FUNCTION_KW", "ast.Name(id=func.__name__,\n ctx=ast.Load())" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_METHOD", "ast.Num" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "CALL_METHOD", "ast.Num(node._tree_index)" ], [ "CALL_FUNCTION_KW", "ast.Call(\n func=ast.Name(id=func.__name__,\n ctx=ast.Load()),\n args=[ast.Num(node._tree_index)],\n keywords=[],\n )" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tracer" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "getattr(node, '_enter_call_node', False)" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_METHOD", "tracer._enter_call" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "tracer._enter_call(node, frame)" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "tracer.stack[frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.statement_stack" ], [ "LOAD_METHOD", "frame_info.statement_stack.append" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "frame_info.statement_stack.append(node)" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_METHOD", "tracer.before_stmt" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "tracer.before_stmt(node, frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tracer" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "tracer.stack[frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.statement_stack" ], [ "LOAD_METHOD", "frame_info.statement_stack.pop" ], [ "CALL_METHOD", "frame_info.statement_stack.pop()" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.exc_value" ], [ "IS_OP", "exc_val is not frame_info.exc_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_stack" ], [ "LOAD_FAST", "expression_stack" ], [ "LOAD_FAST", "expression_stack" ], [ "BINARY_SUBSCR", "expression_stack[-1]" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_METHOD", "tracer._after_expr" ], [ "LOAD_FAST", "exc_node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "exc_tb" ], [ "CALL_METHOD", "tracer._after_expr(exc_node, frame, None, exc_val, exc_tb)" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_METHOD", "tracer.after_stmt" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "exc_tb" ], [ "LOAD_FAST", "exc_node" ], [ "CALL_METHOD", "tracer.after_stmt(node, frame, exc_val, exc_tb, exc_node)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Return" ], [ "CALL_FUNCTION", "isinstance(node, ast.Return)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.return_node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Module" ], [ "CALL_FUNCTION", "isinstance(parent, (ast.FunctionDef, ast.Module))" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.body" ], [ "BINARY_SUBSCR", "parent.body[-1]" ], [ "IS_OP", "node is parent.body[-1]" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_FAST", "exiting" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_METHOD", "tracer._get_caller_stuff" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "tracer._get_caller_stuff(frame)" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_ATTR", "return_node.value" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_values" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_ATTR", "return_node.value" ], [ "BINARY_SUBSCR", "frame_info.expression_values[return_node.value]" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_METHOD", "tracer.exit_call" ], [ "LOAD_GLOBAL", "ExitCallInfo" ], [ "LOAD_FAST", "call_node" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_FAST", "caller_frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "return_value" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "exc_tb" ], [ "CALL_FUNCTION", "ExitCallInfo(call_node,\n return_node,\n caller_frame,\n frame,\n return_value,\n exc_val,\n exc_tb\n )" ], [ "CALL_METHOD", "tracer.exit_call(ExitCallInfo(call_node,\n return_node,\n caller_frame,\n frame,\n return_value,\n exc_val,\n exc_tb\n ))" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.stack" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tracer" ], [ "LOAD_ATTR", "self.tracer.main_to_secondary_frames" ], [ "LOAD_METHOD", "self.tracer.main_to_secondary_frames.pop" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self.tracer.main_to_secondary_frames.pop(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tracer" ], [ "LOAD_ATTR", "self.tracer.secondary_to_main_frames" ], [ "LOAD_FAST", "secondary_frame" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(parent, ast.FunctionDef)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "CALL_FUNCTION", "isinstance(parent, ast.For)" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.iter" ], [ "LOAD_DEREF", "node" ], [ "IS_OP", "parent.iter is not node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "CALL_FUNCTION", "isinstance(parent, ast.While)" ], [ "LOAD_DEREF", "node" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.orelse" ], [ "CONTAINS_OP", "node not in parent.orelse" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "CALL_FUNCTION", "isinstance(parent, ast.comprehension)" ], [ "LOAD_DEREF", "node" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.ifs" ], [ "CONTAINS_OP", "node in parent.ifs" ], [ "LOAD_FAST", "is_containing_loop" ], [ "LOAD_FAST", "result" ], [ "LOAD_METHOD", "result.append" ], [ "LOAD_FAST", "parent" ], [ "CALL_METHOD", "result.append(parent)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.ListComp" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.GeneratorExp" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.DictComp" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.SetComp" ], [ "CALL_FUNCTION", "isinstance(parent, (ast.ListComp,\n ast.GeneratorExp,\n ast.DictComp,\n ast.SetComp))" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.generators" ], [ "LOAD_DEREF", "node" ], [ "LOAD_FAST", "generators" ], [ "CONTAINS_OP", "node in generators" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "takewhile" ], [ "LOAD_FAST", "generators" ], [ "CALL_FUNCTION", "takewhile(lambda n: n != node, generators)" ], [ "CALL_FUNCTION", "list(takewhile(lambda n: n != node, generators))" ], [ "LOAD_FAST", "result" ], [ "LOAD_METHOD", "result.extend" ], [ "LOAD_GLOBAL", "reversed" ], [ "LOAD_FAST", "generators" ], [ "CALL_FUNCTION", "reversed(generators)" ], [ "CALL_METHOD", "result.extend(reversed(generators))" ], [ "LOAD_FAST", "parent" ], [ "LOAD_FAST", "result" ], [ "LOAD_METHOD", "result.reverse" ], [ "CALL_METHOD", "result.reverse()" ], [ "LOAD_GLOBAL", "tuple" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "tuple(result)" ], [ "LOAD_FAST", "n" ], [ "LOAD_DEREF", "node" ], [ "COMPARE_OP", "n != node" ] ], "tracer2.py": [ [ "LOAD_NAME", "find_repr_function" ], [ "LOAD_NAME", "six" ], [ "LOAD_ATTR", "six.text_type" ], [ "CALL_FUNCTION", "find_repr_function(six.text_type)" ], [ "LOAD_NAME", "find_repr_function" ], [ "LOAD_NAME", "six" ], [ "LOAD_ATTR", "six.binary_type" ], [ "CALL_FUNCTION", "find_repr_function(six.binary_type)" ], [ "LOAD_NAME", "find_repr_function" ], [ "LOAD_NAME", "object" ], [ "CALL_FUNCTION", "find_repr_function(object)" ], [ "LOAD_NAME", "find_repr_function" ], [ "LOAD_NAME", "int" ], [ "CALL_FUNCTION", "find_repr_function(int)" ], [ "LOAD_NAME", "cheap_repr" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "threading" ], [ "LOAD_METHOD", "threading.local" ], [ "CALL_METHOD", "threading.local()" ], [ "LOAD_NAME", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_METHOD", "os.path.dirname" ], [ "LOAD_ATTR", "(lambda: 0).__code__" ], [ "LOAD_ATTR", "(lambda: 0).__code__.co_filename" ], [ "CALL_METHOD", "os.path.dirname((lambda: 0).__code__.co_filename)" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_METHOD", "os.path.dirname" ], [ "LOAD_NAME", "birdseye" ], [ "LOAD_ATTR", "birdseye.__file__" ], [ "CALL_METHOD", "os.path.dirname(birdseye.__file__)" ], [ "LOAD_NAME", "type" ], [ "LOAD_NAME", "six" ], [ "LOAD_METHOD", "six.add_metaclass" ], [ "LOAD_NAME", "TracerMeta" ], [ "CALL_METHOD", "six.add_metaclass(TracerMeta)" ], [ "LOAD_NAME", "object" ], [ "CALL_FUNCTION", "six.add_metaclass(TracerMeta)" ], [ "LOAD_NAME", "object" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lineno" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "CALL_FUNCTION", "OrderedDict()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "Source" ], [ "LOAD_METHOD", "Source.for_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "Source.for_frame(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_flags" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.CO_GENERATOR" ], [ "BINARY_AND", "frame.f_code.co_flags & inspect.CO_GENERATOR" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "is_comprehension_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "is_comprehension_frame(frame)" ], [ "LOAD_GLOBAL", "re" ], [ "LOAD_METHOD", "re.match" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "CALL_METHOD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name)" ], [ "LOAD_METHOD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group" ], [ "CALL_METHOD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group(1)" ], [ "LOAD_METHOD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group(1).title" ], [ "CALL_METHOD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group(1).title()" ], [ "BINARY_ADD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group(1).title()\n + u' comprehension'" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_lineno" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.local_reprs" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.get_local_reprs" ], [ "LOAD_FAST", "watch" ], [ "LOAD_FAST", "watch_extras" ], [ "CALL_METHOD", "self.get_local_reprs(watch, watch_extras)" ], [ "CALL_FUNCTION", "OrderedDict(\n (source, my_cheap_repr(value))\n for source, value in\n self.get_local_reprs(watch, watch_extras)\n )" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.comprehension_type" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.local_reprs" ], [ "LOAD_METHOD", "self.local_reprs.items" ], [ "CALL_METHOD", "self.local_reprs.items()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.comprehension_variables" ], [ "LOAD_METHOD", "self.comprehension_variables.setdefault" ], [ "LOAD_FAST", "name" ], [ "CALL_METHOD", "self.comprehension_variables.setdefault(name, [])" ], [ "LOAD_FAST", "values" ], [ "LOAD_FAST", "values" ], [ "BINARY_SUBSCR", "values[-1]" ], [ "LOAD_FAST", "value_repr" ], [ "COMPARE_OP", "values[-1] != value_repr" ], [ "LOAD_FAST", "values" ], [ "LOAD_METHOD", "values.append" ], [ "LOAD_FAST", "value_repr" ], [ "CALL_METHOD", "values.append(value_repr)" ], [ "LOAD_GLOBAL", "truncate_list" ], [ "LOAD_FAST", "values" ], [ "CALL_FUNCTION", "truncate_list(values, 11)" ], [ "LOAD_FAST", "values" ], [ "LOAD_FAST", "event" ], [ "CONTAINS_OP", "event in ('return', 'exception')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.comprehension_variables" ], [ "LOAD_METHOD", "self.comprehension_variables.items" ], [ "CALL_METHOD", "self.comprehension_variables.items()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.local_reprs" ], [ "LOAD_METHOD", "self.local_reprs.items" ], [ "CALL_METHOD", "self.local_reprs.items()" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "old_local_reprs" ], [ "CONTAINS_OP", "name not in old_local_reprs" ], [ "LOAD_FAST", "old_local_reprs" ], [ "LOAD_FAST", "name" ], [ "BINARY_SUBSCR", "old_local_reprs[name]" ], [ "LOAD_FAST", "value_repr" ], [ "COMPARE_OP", "old_local_reprs[name] != value_repr" ], [ "LOAD_FAST", "variables" ], [ "LOAD_METHOD", "variables.append" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "value_repr" ], [ "CALL_METHOD", "variables.append((name, value_repr))" ], [ "LOAD_FAST", "variables" ], [ "LOAD_FAST", "source" ], [ "LOAD_GLOBAL", "my_cheap_repr" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "my_cheap_repr(value)" ], [ "LOAD_FAST", "name" ], [ "LOAD_METHOD", "', '.join" ], [ "LOAD_FAST", "values" ], [ "CALL_METHOD", "', '.join(values)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_varnames" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_cellvars" ], [ "BINARY_ADD", "code.co_varnames + code.co_cellvars" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_freevars" ], [ "BINARY_ADD", "code.co_varnames + code.co_cellvars + code.co_freevars" ], [ "LOAD_GLOBAL", "tuple" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "LOAD_METHOD", "frame.f_locals.keys" ], [ "CALL_METHOD", "frame.f_locals.keys()" ], [ "CALL_FUNCTION", "tuple(frame.f_locals.keys())" ], [ "BINARY_ADD", "code.co_varnames + code.co_cellvars + code.co_freevars + tuple(frame.f_locals.keys())" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "LOAD_METHOD", "frame.f_locals.items" ], [ "CALL_METHOD", "frame.f_locals.items()" ], [ "CALL_FUNCTION_KW", "sorted(\n frame.f_locals.items(),\n key=lambda key_value: vars_order.index(key_value[0])\n )" ], [ "LOAD_FAST", "watch" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_FAST", "variable" ], [ "LOAD_METHOD", "variable.items" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "variable.items(frame)" ], [ "CALL_FUNCTION", "sorted(variable.items(frame))" ], [ "LOAD_FAST", "result_items" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "watch_extras" ], [ "LOAD_FAST", "extra" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "extra(source, value)" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_FAST", "pair" ], [ "IS_OP", "pair is not None" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "pair" ], [ "CALL_FUNCTION", "len(pair)" ], [ "COMPARE_OP", "len(pair) == 2" ], [ "LOAD_FAST", "pair" ], [ "LOAD_DEREF", "vars_order" ], [ "LOAD_METHOD", "vars_order.index" ], [ "LOAD_FAST", "key_value" ], [ "BINARY_SUBSCR", "key_value[0]" ], [ "CALL_METHOD", "vars_order.index(key_value[0])" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "TracerMeta" ], [ "LOAD_FAST", "mcs" ], [ "CALL_FUNCTION", "super(TracerMeta, mcs)" ], [ "LOAD_ATTR", "super(TracerMeta, mcs).__new__" ], [ "LOAD_FAST", "mcs" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "super(TracerMeta, mcs).__new__(mcs, *args, **kwargs)" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "result()" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "no_args_decorator" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION", "no_args_decorator(args, kwargs)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_METHOD", "cls.default" ], [ "LOAD_FAST", "args" ], [ "BINARY_SUBSCR", "args[0]" ], [ "CALL_METHOD", "cls.default(args[0])" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "TracerMeta" ], [ "LOAD_FAST", "cls" ], [ "CALL_FUNCTION", "super(TracerMeta, cls)" ], [ "LOAD_ATTR", "super(TracerMeta, cls).__call__" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "super(TracerMeta, cls).__call__(*args, **kwargs)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.default" ], [ "LOAD_ATTR", "self.default.__enter__" ], [ "CALL_FUNCTION_KW", "self.default.__enter__(context=1)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.default" ], [ "LOAD_ATTR", "self.default.__exit__" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION_EX", "self.default.__exit__(*args, context=1)" ], [ "LOAD_GLOBAL", "ensure_tuple" ], [ "LOAD_FAST", "watch" ], [ "CALL_FUNCTION", "ensure_tuple(watch)" ], [ "LOAD_GLOBAL", "ensure_tuple" ], [ "LOAD_FAST", "watch_explode" ], [ "CALL_FUNCTION", "ensure_tuple(watch_explode)" ], [ "BINARY_ADD", "[\n v if isinstance(v, BaseVariable) else CommonVariable(v)\n for v in ensure_tuple(watch)\n ] + [\n v if isinstance(v, BaseVariable) else Exploding(v)\n for v in ensure_tuple(watch_explode)\n ]" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "ArgDefaultDict" ], [ "LOAD_GLOBAL", "FrameInfo" ], [ "CALL_FUNCTION", "ArgDefaultDict(FrameInfo)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "depth" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.depth" ], [ "COMPARE_OP", "self.depth >= 1" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "BaseVariable" ], [ "CALL_FUNCTION", "isinstance(v, BaseVariable)" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "CommonVariable" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "CommonVariable(v)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "BaseVariable" ], [ "CALL_FUNCTION", "isinstance(v, BaseVariable)" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "Exploding" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "Exploding(v)" ], [ "LOAD_GLOBAL", "iscoroutinefunction" ], [ "LOAD_DEREF", "function" ], [ "CALL_FUNCTION", "iscoroutinefunction(function)" ], [ "LOAD_GLOBAL", "NotImplementedError" ], [ "CALL_FUNCTION", "NotImplementedError(\"coroutines are not supported, sorry!\")" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.target_codes" ], [ "LOAD_METHOD", "self.target_codes.add" ], [ "LOAD_DEREF", "function" ], [ "LOAD_ATTR", "function.__code__" ], [ "CALL_METHOD", "self.target_codes.add(function.__code__)" ], [ "LOAD_GLOBAL", "functools" ], [ "LOAD_METHOD", "functools.wraps" ], [ "LOAD_DEREF", "function" ], [ "CALL_METHOD", "functools.wraps(function)" ], [ "CALL_FUNCTION", "functools.wraps(function)" ], [ "LOAD_GLOBAL", "functools" ], [ "LOAD_METHOD", "functools.wraps" ], [ "LOAD_DEREF", "function" ], [ "CALL_METHOD", "functools.wraps(function)" ], [ "CALL_FUNCTION", "functools.wraps(function)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.isgeneratorfunction" ], [ "LOAD_DEREF", "function" ], [ "CALL_METHOD", "inspect.isgeneratorfunction(function)" ], [ "LOAD_FAST", "generator_wrapper" ], [ "LOAD_FAST", "simple_wrapper" ], [ "LOAD_DEREF", "self" ], [ "LOAD_DEREF", "function" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "function(*args, **kwargs)" ], [ "LOAD_DEREF", "function" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "function(*args, **kwargs)" ], [ "LOAD_FAST", "gen" ], [ "LOAD_ATTR", "gen.send" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "method" ], [ "LOAD_FAST", "incoming" ], [ "CALL_FUNCTION", "method(incoming)" ], [ "LOAD_GLOBAL", "StopIteration" ], [ "LOAD_FAST", "gen" ], [ "LOAD_ATTR", "gen.send" ], [ "LOAD_FAST", "outgoing" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_FAST", "gen" ], [ "LOAD_ATTR", "gen.throw" ], [ "LOAD_FAST", "e" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.enabled" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_METHOD", "sys._getframe" ], [ "LOAD_FAST", "context" ], [ "BINARY_ADD", "context + 1" ], [ "CALL_METHOD", "sys._getframe(context + 1)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._is_internal_frame" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_METHOD", "self._is_internal_frame(calling_frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.trace" ], [ "LOAD_FAST", "calling_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.target_frames" ], [ "LOAD_METHOD", "self.target_frames.add" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_METHOD", "self.target_frames.add(calling_frame)" ], [ "LOAD_FAST", "calling_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.trace" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_METHOD", "self.trace(calling_frame, 'enter', None)" ], [ "LOAD_GLOBAL", "thread_global" ], [ "LOAD_ATTR", "thread_global.__dict__" ], [ "LOAD_METHOD", "thread_global.__dict__.setdefault" ], [ "CALL_METHOD", "thread_global.__dict__.setdefault('original_trace_functions', [])" ], [ "LOAD_FAST", "stack" ], [ "LOAD_METHOD", "stack.append" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_METHOD", "sys.gettrace" ], [ "CALL_METHOD", "sys.gettrace()" ], [ "CALL_METHOD", "stack.append(sys.gettrace())" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_METHOD", "sys.settrace" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.trace" ], [ "CALL_METHOD", "sys.settrace(self.trace)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.enabled" ], [ "LOAD_GLOBAL", "thread_global" ], [ "LOAD_ATTR", "thread_global.original_trace_functions" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_METHOD", "sys.settrace" ], [ "LOAD_FAST", "stack" ], [ "LOAD_METHOD", "stack.pop" ], [ "CALL_METHOD", "stack.pop()" ], [ "CALL_METHOD", "sys.settrace(stack.pop())" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_METHOD", "sys._getframe" ], [ "LOAD_FAST", "context" ], [ "BINARY_ADD", "context + 1" ], [ "CALL_METHOD", "sys._getframe(context + 1)" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.trace" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_METHOD", "self.trace(calling_frame, 'exit', None)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.target_frames" ], [ "LOAD_METHOD", "self.target_frames.discard" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_METHOD", "self.target_frames.discard(calling_frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame_infos" ], [ "LOAD_METHOD", "self.frame_infos.pop" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_METHOD", "self.frame_infos.pop(calling_frame, None)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_filename" ], [ "LOAD_METHOD", "frame.f_code.co_filename.startswith" ], [ "LOAD_GLOBAL", "internal_directories" ], [ "CALL_METHOD", "frame.f_code.co_filename.startswith(internal_directories)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.target_codes" ], [ "CONTAINS_OP", "frame.f_code in self.target_codes" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.target_frames" ], [ "CONTAINS_OP", "frame in self.target_frames" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._is_traced_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self._is_traced_frame(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.depth" ], [ "COMPARE_OP", "self.depth == 1" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._is_internal_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self._is_internal_frame(frame)" ], [ "LOAD_GLOBAL", "is_comprehension_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "is_comprehension_frame(frame)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_GLOBAL", "is_comprehension_frame" ], [ "LOAD_FAST", "candidate" ], [ "CALL_FUNCTION", "is_comprehension_frame(candidate)" ], [ "LOAD_FAST", "candidate" ], [ "LOAD_ATTR", "candidate.f_back" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._is_traced_frame" ], [ "LOAD_FAST", "candidate" ], [ "CALL_METHOD", "self._is_traced_frame(candidate)" ], [ "LOAD_FAST", "candidate" ], [ "LOAD_ATTR", "candidate.f_back" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.depth" ], [ "COMPARE_OP", "i >= self.depth" ], [ "LOAD_FAST", "candidate" ], [ "IS_OP", "candidate is None" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self._is_internal_frame" ], [ "LOAD_FAST", "candidate" ], [ "CALL_METHOD", "self._is_internal_frame(candidate)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.thread_local" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_ATTR", "thread_local.__dict__" ], [ "LOAD_METHOD", "thread_local.__dict__.setdefault" ], [ "CALL_METHOD", "thread_local.__dict__.setdefault('depth', -1)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame_infos" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.frame_infos[frame]" ], [ "LOAD_FAST", "event" ], [ "CONTAINS_OP", "event in ('call', 'enter')" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.last_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.last_frame" ], [ "LOAD_FAST", "frame" ], [ "IS_OP", "self.config.last_frame is not frame" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.last_line_no" ], [ "LOAD_GLOBAL", "Event" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "event" ], [ "LOAD_FAST", "arg" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_ATTR", "thread_local.depth" ], [ "LOAD_FAST", "line_no" ], [ "CALL_FUNCTION_KW", "Event(frame_info, event, arg, thread_local.depth, line_no=line_no)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.formatter" ], [ "LOAD_METHOD", "self.config.formatter.format_line_only" ], [ "LOAD_FAST", "trace_event" ], [ "CALL_METHOD", "self.config.formatter.format_line_only(trace_event)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_METHOD", "self.config.write" ], [ "LOAD_FAST", "line" ], [ "CALL_METHOD", "self.config.write(line)" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event == 'exception'" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_GLOBAL", "Event" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "event" ], [ "LOAD_FAST", "arg" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_ATTR", "thread_local.depth" ], [ "CALL_FUNCTION", "Event(frame_info, event, arg, thread_local.depth)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "COMPARE_OP", "frame.f_code.co_name == ''" ], [ "LOAD_FAST", "event" ], [ "CONTAINS_OP", "event not in ('return', 'exception')" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_METHOD", "frame_info.update_variables" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.watch" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.watch_extras" ], [ "LOAD_FAST", "event" ], [ "CALL_METHOD", "frame_info.update_variables(\n self.watch,\n self.config.watch_extras,\n event,\n )" ], [ "LOAD_FAST", "trace_event" ], [ "LOAD_FAST", "event" ], [ "CONTAINS_OP", "event in ('return', 'exit')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame_infos" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.formatter" ], [ "LOAD_METHOD", "self.config.formatter.format" ], [ "LOAD_FAST", "trace_event" ], [ "CALL_METHOD", "self.config.formatter.format(trace_event)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_METHOD", "self.config.write" ], [ "LOAD_FAST", "formatted" ], [ "CALL_METHOD", "self.config.write(formatted)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.trace" ], [ "LOAD_FAST", "config" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "NO_ASTTOKENS" ], [ "LOAD_GLOBAL", "Exception" ], [ "CALL_FUNCTION", "Exception(\"birdseye doesn't support this version of Python\")" ], [ "LOAD_GLOBAL", "ImportError" ], [ "LOAD_GLOBAL", "Exception" ], [ "CALL_FUNCTION", "Exception(\"You must install birdseye separately to use spy: pip install birdseye\")" ], [ "LOAD_GLOBAL", "no_args_decorator" ], [ "LOAD_DEREF", "args" ], [ "LOAD_DEREF", "kwargs" ], [ "CALL_FUNCTION", "no_args_decorator(args, kwargs)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_METHOD", "self._trace" ], [ "LOAD_DEREF", "args" ], [ "BINARY_SUBSCR", "args[0]" ], [ "CALL_METHOD", "self._trace(args[0])" ], [ "LOAD_FAST", "decorator" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._trace" ], [ "LOAD_FAST", "func" ], [ "LOAD_DEREF", "args" ], [ "LOAD_DEREF", "kwargs" ], [ "CALL_FUNCTION_EX", "self._trace(func, *args, **kwargs)" ], [ "LOAD_FAST", "eye" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "eye(func)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.snoop" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_EX", "self.config.snoop(*args, **kwargs)" ], [ "LOAD_DEREF", "traced" ], [ "CALL_FUNCTION", "self.config.snoop(*args, **kwargs)(traced)" ], [ "LOAD_GLOBAL", "functools" ], [ "LOAD_METHOD", "functools.wraps" ], [ "LOAD_DEREF", "func" ], [ "CALL_METHOD", "functools.wraps(func)" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "LOAD_FAST", "wrapper" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.enabled" ], [ "LOAD_DEREF", "traced" ], [ "LOAD_DEREF", "func" ], [ "LOAD_FAST", "final_func" ], [ "LOAD_FAST", "func_args" ], [ "LOAD_FAST", "func_kwargs" ], [ "CALL_FUNCTION_EX", "final_func(*func_args, **func_kwargs)" ] ], "utils.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOAD_METHOD", "standard_library.install_aliases" ], [ "CALL_METHOD", "standard_library.install_aliases()" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "type" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "version_info" ], [ "LOAD_ATTR", "version_info.major" ], [ "COMPARE_OP", "version_info.major == 2" ], [ "LOAD_NAME", "PY2" ], [ "UNARY_NOT", "not PY2" ], [ "LOAD_NAME", "TypeVar" ], [ "CALL_FUNCTION", "TypeVar('T')" ], [ "LOAD_NAME", "TypeVar" ], [ "CALL_FUNCTION", "TypeVar('RT')" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "unicode" ], [ "LOAD_NAME", "str" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "type" ], [ "LOAD_NAME", "json" ], [ "LOAD_ATTR", "json.JSONEncoder" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_GLOBAL", "ntpath" ], [ "LOAD_METHOD", "ntpath.split" ], [ "LOAD_FAST", "path" ], [ "CALL_METHOD", "ntpath.split(path)" ], [ "LOAD_FAST", "tail" ], [ "LOAD_GLOBAL", "ntpath" ], [ "LOAD_METHOD", "ntpath.basename" ], [ "LOAD_FAST", "head" ], [ "CALL_METHOD", "ntpath.basename(head)" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_METHOD", "os.path.commonprefix" ], [ "LOAD_FAST", "paths" ], [ "CALL_METHOD", "os.path.commonprefix(paths)" ], [ "LOAD_GLOBAL", "ntpath" ], [ "LOAD_METHOD", "ntpath.split" ], [ "LOAD_FAST", "prefix" ], [ "CALL_METHOD", "ntpath.split(prefix)" ], [ "BINARY_SUBSCR", "ntpath.split(prefix)[0]" ], [ "LOAD_FAST", "paths" ], [ "BINARY_SUBSCR", "paths[0]" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "prefix" ], [ "CALL_FUNCTION", "len(prefix)" ], [ "BINARY_SUBSCR", "paths[0][len(prefix)]" ], [ "LOAD_FAST", "first_char_after" ], [ "CONTAINS_OP", "first_char_after in r'\\/'" ], [ "LOAD_FAST", "first_char_after" ], [ "LOAD_FAST", "prefix" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "COMPARE_OP", "path == IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "all_paths" ], [ "LOAD_GLOBAL", "common_ancestor" ], [ "LOAD_FAST", "all_paths" ], [ "CALL_FUNCTION", "common_ancestor(all_paths)" ], [ "LOAD_FAST", "prefix" ], [ "CONTAINS_OP", "prefix in r'\\/'" ], [ "LOAD_GLOBAL", "strip_required_prefix" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "prefix" ], [ "CALL_FUNCTION", "strip_required_prefix(path, prefix)" ], [ "LOAD_GLOBAL", "path_leaf" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "path_leaf(path)" ], [ "LOAD_FAST", "f" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "COMPARE_OP", "f != IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "f" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "COMPARE_OP", "path == IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.sep" ], [ "COMPARE_OP", "os.path.sep == '/'" ], [ "LOAD_FAST", "path" ], [ "LOAD_METHOD", "path.startswith" ], [ "CALL_METHOD", "path.startswith('/')" ], [ "LOAD_FAST", "path" ], [ "BINARY_ADD", "'/' + path" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "type" ], [ "LOAD_FAST", "obj" ], [ "CALL_FUNCTION", "type(obj)" ], [ "LOAD_FAST", "t" ], [ "LOAD_GLOBAL", "types" ], [ "LOAD_ATTR", "types.InstanceType" ], [ "IS_OP", "t is types.InstanceType" ], [ "LOAD_FAST", "obj" ], [ "LOAD_ATTR", "obj.__class__" ], [ "LOAD_FAST", "t" ], [ "LOAD_FAST", "iterable" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_DEREF", "type_or_tuple" ], [ "CALL_FUNCTION", "isinstance(x, type_or_tuple)" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "next" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "next(it)" ], [ "LOAD_GLOBAL", "StopIteration" ], [ "LOAD_GLOBAL", "raise_from" ], [ "LOAD_GLOBAL", "RuntimeError" ], [ "LOAD_FAST", "e" ], [ "CALL_FUNCTION", "raise_from(RuntimeError, e)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "expression" ], [ "CALL_FUNCTION", "hasattr(expression, 'one_or_none')" ], [ "LOAD_FAST", "expression" ], [ "LOAD_METHOD", "expression.one_or_none" ], [ "CALL_METHOD", "expression.one_or_none()" ], [ "LOAD_FAST", "expression" ], [ "LOAD_METHOD", "expression.all" ], [ "CALL_METHOD", "expression.all()" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "len(result)" ], [ "COMPARE_OP", "len(result) == 0" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "len(result)" ], [ "COMPARE_OP", "len(result) == 1" ], [ "LOAD_FAST", "result" ], [ "BINARY_SUBSCR", "result[0]" ], [ "LOAD_GLOBAL", "Exception" ], [ "CALL_FUNCTION", "Exception(\"There is more than one item returned for the supplied filter\")" ], [ "LOAD_FAST", "lst" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "isinstance(x, list)" ], [ "LOAD_FAST", "result" ], [ "LOAD_METHOD", "result.extend" ], [ "LOAD_GLOBAL", "flatten_list" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "flatten_list(x)" ], [ "CALL_METHOD", "result.extend(flatten_list(x))" ], [ "LOAD_FAST", "result" ], [ "LOAD_METHOD", "result.append" ], [ "LOAD_FAST", "x" ], [ "CALL_METHOD", "result.append(x)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "f" ], [ "LOAD_ATTR", "f.__code__" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "LOAD_ATTR", "(lambda: 0).__code__" ], [ "LOAD_ATTR", "(lambda: 0).__code__.co_name" ], [ "COMPARE_OP", "code.co_name == (lambda: 0).__code__.co_name" ], [ "LOAD_FAST", "o" ], [ "LOAD_ATTR", "o.as_json" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "ProtocolEncoder" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(ProtocolEncoder, self)" ], [ "LOAD_METHOD", "super(ProtocolEncoder, self).default" ], [ "LOAD_FAST", "o" ], [ "CALL_METHOD", "super(ProtocolEncoder, self).default(o)" ], [ "LOAD_FAST", "method" ], [ "CALL_FUNCTION", "method()" ], [ "LOAD_GLOBAL", "io" ], [ "LOAD_METHOD", "io.open" ], [ "LOAD_FAST", "filename" ], [ "CALL_METHOD", "io.open(filename, 'rb')" ], [ "LOAD_GLOBAL", "detect_encoding" ], [ "LOAD_FAST", "fp" ], [ "LOAD_ATTR", "fp.readline" ], [ "CALL_FUNCTION", "detect_encoding(fp.readline)" ], [ "LOAD_FAST", "fp" ], [ "LOAD_METHOD", "fp.seek" ], [ "CALL_METHOD", "fp.seek(0)" ], [ "LOAD_GLOBAL", "io" ], [ "LOAD_ATTR", "io.TextIOWrapper" ], [ "LOAD_FAST", "fp" ], [ "LOAD_FAST", "encoding" ], [ "CALL_FUNCTION_KW", "io.TextIOWrapper(fp, encoding, line_buffering=True)" ], [ "LOAD_FAST", "text" ], [ "LOAD_FAST", "text" ], [ "LOAD_FAST", "fp" ], [ "LOAD_METHOD", "fp.close" ], [ "CALL_METHOD", "fp.close()" ], [ "LOAD_FAST", "filename" ], [ "LOAD_METHOD", "filename.endswith" ], [ "CALL_METHOD", "filename.endswith('.pyc')" ], [ "LOAD_FAST", "filename" ], [ "BINARY_SUBSCR", "filename[:-1]" ], [ "LOAD_GLOBAL", "open_with_encoding_check" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "open_with_encoding_check(filename)" ], [ "LOAD_METHOD", "''.join" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "f" ], [ "CALL_FUNCTION", "enumerate(f)" ], [ "CALL_METHOD", "''.join([\n '\\n' if i < 2 and cookie_re.match(line)\n else line\n for i, line in enumerate(f)\n ])" ], [ "LOAD_FAST", "i" ], [ "COMPARE_OP", "i < 2" ], [ "LOAD_DEREF", "cookie_re" ], [ "LOAD_METHOD", "cookie_re.match" ], [ "LOAD_FAST", "line" ], [ "CALL_METHOD", "cookie_re.match(line)" ], [ "LOAD_FAST", "line" ], [ "LOAD_GLOBAL", "safe_next" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_METHOD", "tokens.get_tokens" ], [ "LOAD_FAST", "function_node" ], [ "CALL_METHOD", "tokens.get_tokens(function_node)" ], [ "CALL_FUNCTION", "safe_next(t for t in tokens.get_tokens(function_node)\n if t.string == 'def' and t.type == token.NAME)" ], [ "LOAD_FAST", "def_token" ], [ "LOAD_ATTR", "def_token.startpos" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_ATTR", "tokens.text" ], [ "LOAD_FAST", "startpos" ], [ "LOAD_FAST", "function_node" ], [ "LOAD_ATTR", "function_node.last_token" ], [ "LOAD_ATTR", "function_node.last_token.endpos" ], [ "BINARY_SUBSCR", "tokens.text[startpos:function_node.last_token.endpos]" ], [ "LOAD_METHOD", "tokens.text[startpos:function_node.last_token.endpos].rstrip" ], [ "CALL_METHOD", "tokens.text[startpos:function_node.last_token.endpos].rstrip()" ], [ "LOAD_FAST", "source" ], [ "LOAD_METHOD", "source.startswith" ], [ "CALL_METHOD", "source.startswith('def')" ], [ "LOAD_FAST", "startpos" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "t" ], [ "LOAD_ATTR", "t.string" ], [ "COMPARE_OP", "t.string == 'def'" ], [ "LOAD_FAST", "t" ], [ "LOAD_ATTR", "t.type" ], [ "LOAD_GLOBAL", "token" ], [ "LOAD_ATTR", "token.NAME" ], [ "COMPARE_OP", "t.type == token.NAME" ], [ "LOAD_FAST", "t" ], [ "LOAD_FAST", "args" ], [ "LOAD_GLOBAL", "print" ], [ "LOAD_FAST", "arg" ], [ "CALL_FUNCTION", "print(arg)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION", "len(args)" ], [ "COMPARE_OP", "len(args) == 1" ], [ "LOAD_FAST", "args" ], [ "BINARY_SUBSCR", "args[0]" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "filename" ], [ "LOAD_METHOD", "filename.startswith" ], [ "CALL_METHOD", "filename.startswith(' max_length" ], [ "LOAD_FAST", "max_length" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "middle" ], [ "CALL_FUNCTION", "len(middle)" ], [ "BINARY_SUBTRACT", "max_length - len(middle)" ], [ "BINARY_FLOOR_DIVIDE", "(max_length - len(middle)) // 2" ], [ "LOAD_FAST", "max_length" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "middle" ], [ "CALL_FUNCTION", "len(middle)" ], [ "BINARY_SUBTRACT", "max_length - len(middle)" ], [ "LOAD_FAST", "left" ], [ "BINARY_SUBTRACT", "max_length - len(middle) - left" ], [ "LOAD_FAST", "seq" ], [ "LOAD_FAST", "left" ], [ "BINARY_SUBSCR", "seq[:left]" ], [ "LOAD_FAST", "middle" ], [ "BINARY_ADD", "seq[:left] + middle" ], [ "LOAD_FAST", "seq" ], [ "LOAD_FAST", "right" ], [ "UNARY_NEGATIVE", "-right" ], [ "BINARY_SUBSCR", "seq[-right:]" ], [ "BINARY_ADD", "seq[:left] + middle + seq[-right:]" ], [ "LOAD_FAST", "seq" ], [ "LOAD_GLOBAL", "truncate" ], [ "LOAD_FAST", "string" ], [ "LOAD_FAST", "max_length" ], [ "CALL_FUNCTION", "truncate(string, max_length, '...')" ], [ "LOAD_GLOBAL", "truncate" ], [ "LOAD_FAST", "lst" ], [ "LOAD_FAST", "max_length" ], [ "CALL_FUNCTION", "truncate(lst, max_length, ['...'])" ], [ "LOAD_FAST", "split" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "six" ], [ "LOAD_ATTR", "six.string_types" ], [ "CALL_FUNCTION", "isinstance(x, six.string_types)" ], [ "LOAD_FAST", "x" ], [ "LOAD_METHOD", "x.replace" ], [ "CALL_METHOD", "x.replace(',', ' ')" ], [ "LOAD_METHOD", "x.replace(',', ' ').split" ], [ "CALL_METHOD", "x.replace(',', ' ').split()" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "set" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "isinstance(x, (list, set, tuple))" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "tuple" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tuple(x)" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_METHOD", "os.path.basename" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_filename" ], [ "CALL_METHOD", "os.path.basename(code.co_filename)" ], [ "LOAD_FAST", "result" ], [ "LOAD_METHOD", "result.endswith" ], [ "CALL_METHOD", "result.endswith('.pyc')" ], [ "LOAD_FAST", "result" ], [ "BINARY_SUBSCR", "result[:-1]" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "CONTAINS_OP", "frame.f_code.co_name in ('', '', '')" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "code('{}.x')" ], [ "LOAD_GLOBAL", "SyntaxError" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "code('({})')" ], [ "LOAD_FAST", "without_parens" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "code('({}).x')" ], [ "COMPARE_OP", "without_parens != code('({}).x')" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "s" ], [ "LOAD_METHOD", "s.format" ], [ "LOAD_DEREF", "source" ], [ "CALL_METHOD", "s.format(source)" ], [ "CALL_FUNCTION", "compile(s.format(source), '', 'eval')" ], [ "LOAD_ATTR", "compile(s.format(source), '', 'eval').co_code" ], [ "LOAD_GLOBAL", "needs_parentheses" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "needs_parentheses(source)" ], [ "LOAD_METHOD", "'({})'.format" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "'({})'.format(source)" ], [ "LOAD_FAST", "source" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "REPR_TARGET_LENGTH" ], [ "CALL_FUNCTION_KW", "cheap_repr(x, target_length=REPR_TARGET_LENGTH)" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "ArgDefaultDict" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(ArgDefaultDict, self)" ], [ "LOAD_METHOD", "super(ArgDefaultDict, self).__init__" ], [ "CALL_METHOD", "super(ArgDefaultDict, self).__init__()" ], [ "LOAD_FAST", "factory" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_METHOD", "self.factory" ], [ "LOAD_FAST", "key" ], [ "CALL_METHOD", "self.factory(key)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "key" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "lst" ], [ "CALL_FUNCTION", "len(lst)" ], [ "COMPARE_OP", "len(lst) == 1" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "CALL_FUNCTION", "str(i + 1)" ], [ "BINARY_ADD", "' ' + str(i + 1)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_GLOBAL", "os" ], [ "CALL_FUNCTION", "hasattr(os, 'PathLike')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.PathLike" ], [ "CALL_FUNCTION", "isinstance(x, os.PathLike)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "hasattr(x, '__fspath__')" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "hasattr(x, 'open')" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.__class__" ], [ "LOAD_ATTR", "x.__class__.__name__" ], [ "LOAD_METHOD", "x.__class__.__name__.lower" ], [ "CALL_METHOD", "x.__class__.__name__.lower()" ], [ "CONTAINS_OP", "'path' in x.__class__.__name__.lower()" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION", "len(args)" ], [ "COMPARE_OP", "len(args) == 1" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_METHOD", "inspect.isfunction" ], [ "LOAD_FAST", "args" ], [ "BINARY_SUBSCR", "args[0]" ], [ "CALL_METHOD", "inspect.isfunction(args[0])" ], [ "LOAD_FAST", "kwargs" ], [ "UNARY_NOT", "not kwargs" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_ADD", "max_length + 2" ], [ "COMPARE_OP", "length <= max_length + 2" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "range(length)" ], [ "LOAD_GLOBAL", "chain" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_FLOOR_DIVIDE", "max_length // 2" ], [ "CALL_FUNCTION", "range(max_length // 2)" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_FLOOR_DIVIDE", "max_length // 2" ], [ "BINARY_SUBTRACT", "length - max_length // 2" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "range(length - max_length // 2,\n length)" ], [ "CALL_FUNCTION", "chain(range(max_length // 2),\n range(length - max_length // 2,\n length))" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "len(x)" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "n == 0" ], [ "LOAD_GLOBAL", "repr" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "repr(x)" ], [ "LOAD_FAST", "helper" ], [ "LOAD_ATTR", "helper.level" ], [ "BINARY_SUBTRACT", "helper.level - 1" ], [ "LOAD_GLOBAL", "_repr_series_one_line" ], [ "LOAD_ATTR", "_repr_series_one_line.maxparts" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "n" ], [ "LOAD_FAST", "maxparts" ], [ "CALL_FUNCTION", "_sample_indices(n, maxparts)" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.index" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "x.index[i:i + 1]" ], [ "LOAD_ATTR", "x.index[i:i + 1].format" ], [ "CALL_FUNCTION_KW", "x.index[i:i + 1].format(sparsify=False)" ], [ "BINARY_SUBSCR", "x.index[i:i + 1].format(sparsify=False)[0]" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.iloc" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "x.iloc[i]" ], [ "LOAD_FAST", "pieces" ], [ "LOAD_METHOD", "pieces.append" ], [ "LOAD_FAST", "k" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "v" ], [ "LOAD_FAST", "newlevel" ], [ "CALL_FUNCTION", "cheap_repr(v, newlevel)" ], [ "BINARY_MODULO", "'%s = %s' % (k, cheap_repr(v, newlevel))" ], [ "CALL_METHOD", "pieces.append('%s = %s' % (k, cheap_repr(v, newlevel)))" ], [ "LOAD_FAST", "n" ], [ "LOAD_FAST", "maxparts" ], [ "BINARY_ADD", "maxparts + 2" ], [ "COMPARE_OP", "n > maxparts + 2" ], [ "LOAD_FAST", "pieces" ], [ "LOAD_METHOD", "pieces.insert" ], [ "LOAD_FAST", "maxparts" ], [ "BINARY_FLOOR_DIVIDE", "maxparts // 2" ], [ "CALL_METHOD", "pieces.insert(maxparts // 2, '...')" ], [ "LOAD_METHOD", "'; '.join" ], [ "LOAD_FAST", "pieces" ], [ "CALL_METHOD", "'; '.join(pieces)" ] ] }executing-0.8.0/tests/sample_results/pypy2.7.json000066400000000000000000022112671410133640400220500ustar00rootroot00000000000000{ "bird.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOOKUP_METHOD", "standard_library.install_aliases" ], [ "CALL_METHOD", "standard_library.install_aliases()" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "warn_if_outdated" ], [ "LOAD_NAME", "__version__" ], [ "CALL_FUNCTION", "warn_if_outdated('birdseye', __version__)" ], [ "LOAD_NAME", "namedtuple" ], [ "CALL_FUNCTION", "namedtuple('CodeInfo', 'db_func traced_file arg_names')" ], [ "LOAD_NAME", "TreeTracerBase" ], [ "LOAD_NAME", "BirdsEye" ], [ "CALL_FUNCTION", "BirdsEye()" ], [ "LOAD_NAME", "NamedTuple" ], [ "LOAD_NAME", "int" ], [ "LOAD_NAME", "bool" ], [ "LOAD_NAME", "int" ], [ "LOAD_NAME", "str" ], [ "CALL_FUNCTION", "NamedTuple('HTMLPosition', [\n ('index', int),\n ('is_start', bool),\n ('depth', int),\n ('html', str),\n])" ], [ "LOAD_NAME", "eye" ], [ "LOAD_ATTR", "eye.enter_call" ], [ "LOAD_ATTR", "eye.enter_call.__code__" ], [ "LOAD_NAME", "eye" ], [ "LOAD_ATTR", "eye.exit_call" ], [ "LOAD_ATTR", "eye.exit_call.__code__" ], [ "LOAD_NAME", "eye" ], [ "LOAD_ATTR", "eye.after_expr" ], [ "LOAD_ATTR", "eye.after_expr.__code__" ], [ "LOAD_NAME", "eye" ], [ "LOAD_ATTR", "eye.after_stmt" ], [ "LOAD_ATTR", "eye.after_stmt.__code__" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "Iterable" ], [ "LOAD_NAME", "Iteration" ], [ "BINARY_SUBSCR", "Iterable[Iteration]" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "TypeRegistry" ], [ "CALL_FUNCTION", "TypeRegistry()" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "try_register_repr" ], [ "CALL_FUNCTION", "try_register_repr('pandas', 'Series')" ], [ "CALL_FUNCTION", "try_register_repr('pandas', 'Series')" ], [ "LOAD_NAME", "cached_property" ], [ "CALL_FUNCTION", "cached_property" ], [ "LOAD_NAME", "lru_cache" ], [ "CALL_FUNCTION", "lru_cache()" ], [ "CALL_FUNCTION", "lru_cache()" ], [ "LOAD_NAME", "False" ], [ "LOAD_NAME", "False" ], [ "LOAD_NAME", "retry_db" ], [ "CALL_FUNCTION", "retry_db" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "BirdsEye" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(BirdsEye, self)" ], [ "LOOKUP_METHOD", "super(BirdsEye, self).__init__" ], [ "CALL_METHOD", "super(BirdsEye, self).__init__()" ], [ "LOAD_FAST", "db_uri" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "num_samples" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "dict" ], [ "CALL_FUNCTION", "dict(\n attributes=50,\n dict=50,\n list=30,\n set=30,\n pandas_rows=20,\n pandas_cols=100,\n )" ], [ "LOAD_GLOBAL", "dict" ], [ "CALL_FUNCTION", "dict(\n attributes=50,\n dict=10,\n list=6,\n set=6,\n pandas_rows=6,\n pandas_cols=10,\n )" ], [ "CALL_FUNCTION", "dict(\n big=dict(\n attributes=50,\n dict=50,\n list=30,\n set=30,\n pandas_rows=20,\n pandas_cols=100,\n ),\n small=dict(\n attributes=50,\n dict=10,\n list=6,\n set=6,\n pandas_rows=6,\n pandas_cols=10,\n ),\n )" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "Database" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._db_uri" ], [ "CALL_FUNCTION", "Database(self._db_uri)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.walk" ], [ "LOAD_FAST", "root" ], [ "CALL_METHOD", "ast.walk(root)" ], [ "LOAD_GLOBAL", "tracer" ], [ "LOOKUP_METHOD", "tracer.loops" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "tracer.loops(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "CALL_FUNCTION", "isinstance(node, ast.expr)" ], [ "LOAD_GLOBAL", "is_interesting_expression" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "is_interesting_expression(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "BirdsEye" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(BirdsEye, self)" ], [ "LOOKUP_METHOD", "super(BirdsEye, self).compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "flags" ], [ "CALL_METHOD", "super(BirdsEye, self).compile(source, filename, flags)" ], [ "LOAD_GLOBAL", "ASTTokens" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.root" ], [ "CALL_FUNCTION", "ASTTokens(source, tree=traced_file.root)" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.For)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.body" ], [ "BINARY_SUBSCR", "node.parent.body[0]" ], [ "COMPARE_OP", "node is node.parent.body[0]" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._add_iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self._add_iteration(node._loops, frame)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.While)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.test" ], [ "COMPARE_OP", "node is node.parent.test" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._add_iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self._add_iteration(node._loops, frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_ATTR", "self.stack[frame].iteration" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "loops" ], [ "CALL_FUNCTION", "enumerate(loops)" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.loops" ], [ "LOAD_FAST", "loop_node" ], [ "LOAD_ATTR", "loop_node._tree_index" ], [ "BINARY_SUBSCR", "iteration.loops[loop_node._tree_index]" ], [ "LOAD_FAST", "i" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "loops" ], [ "CALL_FUNCTION", "len(loops)" ], [ "BINARY_SUBTRACT", "len(loops) - 1" ], [ "COMPARE_OP", "i == len(loops) - 1" ], [ "LOAD_FAST", "loop" ], [ "LOOKUP_METHOD", "loop.append" ], [ "LOAD_GLOBAL", "Iteration" ], [ "CALL_FUNCTION", "Iteration()" ], [ "CALL_METHOD", "loop.append(Iteration())" ], [ "LOAD_FAST", "loop" ], [ "LOOKUP_METHOD", "loop.last" ], [ "CALL_METHOD", "loop.last()" ], [ "LOAD_GLOBAL", "_tracing_recursively" ], [ "LOAD_DEREF", "frame" ], [ "CALL_FUNCTION", "_tracing_recursively(frame)" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._is_interesting_expression" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "BINARY_SUBSCR", "self._code_infos[frame.f_code]" ], [ "LOAD_ATTR", "self._code_infos[frame.f_code].traced_file" ], [ "LOAD_ATTR", "self._code_infos[frame.f_code].traced_file.is_ipython_cell" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Expr" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.Expr)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.parent" ], [ "LOAD_ATTR", "node.parent.parent.body" ], [ "BINARY_SUBSCR", "node.parent.parent.body[-1]" ], [ "COMPARE_OP", "node.parent is node.parent.parent.body[-1]" ], [ "LOAD_DEREF", "value" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "is_obvious_builtin" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_DEREF", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_ATTR", "self.stack[frame].expression_values" ], [ "LOAD_FAST", "node" ], [ "BINARY_SUBSCR", "self.stack[frame].expression_values[node]" ], [ "CALL_FUNCTION", "is_obvious_builtin(node, self.stack[frame].expression_values[node])" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_DEREF", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_FAST", "exc_value" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self._exception_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_FAST", "exc_value" ], [ "CALL_METHOD", "self._exception_value(node, frame, exc_value)" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOOKUP_METHOD", "NodeValue.expression" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.num_samples" ], [ "LOAD_DEREF", "value" ], [ "LOAD_GLOBAL", "max" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "CALL_FUNCTION", "len(node._loops)" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self._is_first_loop_iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "frame" ], [ "CALL_METHOD", "self._is_first_loop_iteration(node, frame)" ], [ "UNARY_NOT", "not self._is_first_loop_iteration(node, frame)" ], [ "BINARY_MULTIPLY", "len(node._loops) * (not self._is_first_loop_iteration(node, frame))" ], [ "BINARY_SUBTRACT", "3 - len(node._loops) * (not self._is_first_loop_iteration(node, frame))" ], [ "CALL_FUNCTION", "max(1, 3 - len(node._loops) * (not self._is_first_loop_iteration(node, frame)))" ], [ "CALL_METHOD", "NodeValue.expression(\n self.num_samples,\n value,\n level=max(1, 3 - len(node._loops) * (not self._is_first_loop_iteration(node, frame))),\n )" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self._set_node_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_FAST", "node_value" ], [ "CALL_METHOD", "self._set_node_value(node, frame, node_value)" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self._check_inner_call" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node_value" ], [ "CALL_METHOD", "self._check_inner_call(frame_info, node, node_value)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.comprehension)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.iter" ], [ "COMPARE_OP", "node is node.parent.iter" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.GeneratorExp" ], [ "CALL_FUNCTION", "isinstance(node.parent.parent, ast.GeneratorExp)" ], [ "UNARY_NOT", "not isinstance(node.parent.parent, ast.GeneratorExp)" ], [ "LOAD_FAST", "is_special_comprehension_iter" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self._set_node_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOOKUP_METHOD", "NodeValue.covered" ], [ "CALL_METHOD", "NodeValue.covered()" ], [ "CALL_METHOD", "self._set_node_value(node.parent, frame, NodeValue.covered())" ], [ "LOAD_FAST", "exc_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "BINARY_ADD", "node._loops + (node.parent,)" ], [ "LOAD_GLOBAL", "ChangeValue" ], [ "LOAD_FAST", "comprehension_iter_proxy" ], [ "CALL_FUNCTION", "comprehension_iter_proxy()" ], [ "CALL_FUNCTION", "ChangeValue(comprehension_iter_proxy())" ], [ "LOAD_DEREF", "value" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self._add_iteration" ], [ "LOAD_DEREF", "loops" ], [ "LOAD_DEREF", "frame" ], [ "CALL_METHOD", "self._add_iteration(loops, frame)" ], [ "LOAD_FAST", "item" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.inner_calls" ], [ "LOOKUP_METHOD", "frame_info.inner_calls.pop" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "frame_info.inner_calls.pop(node, None)" ], [ "LOAD_FAST", "inner_calls" ], [ "LOAD_FAST", "node_value" ], [ "LOOKUP_METHOD", "node_value.set_meta" ], [ "LOAD_FAST", "inner_calls" ], [ "CALL_METHOD", "node_value.set_meta('inner_calls', inner_calls)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_ATTR", "self.stack[frame].iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.loops" ], [ "LOAD_FAST", "loop_node" ], [ "LOAD_ATTR", "loop_node._tree_index" ], [ "BINARY_SUBSCR", "iteration.loops[loop_node._tree_index]" ], [ "LOAD_FAST", "loop" ], [ "LOOKUP_METHOD", "loop.last" ], [ "CALL_METHOD", "loop.last()" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.index" ], [ "COMPARE_OP", "iteration.index > 0" ], [ "LOAD_GLOBAL", "False" ], [ "LOAD_GLOBAL", "True" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_ATTR", "self.stack[frame].iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.loops" ], [ "LOAD_FAST", "loop_node" ], [ "LOAD_ATTR", "loop_node._tree_index" ], [ "BINARY_SUBSCR", "iteration.loops[loop_node._tree_index]" ], [ "LOAD_FAST", "loop" ], [ "LOOKUP_METHOD", "loop.recorded_node" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "loop.recorded_node(node)" ], [ "LOAD_FAST", "loop" ], [ "LOOKUP_METHOD", "loop.last" ], [ "CALL_METHOD", "loop.last()" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.vals" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOOKUP_METHOD", "NodeValue.exception" ], [ "LOAD_FAST", "exc_value" ], [ "CALL_METHOD", "NodeValue.exception(exc_value)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._set_node_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "value" ], [ "CALL_METHOD", "self._set_node_value(node, frame, value)" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_GLOBAL", "_tracing_recursively" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "_tracing_recursively(frame)" ], [ "LOAD_FAST", "exc_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "exc_node" ], [ "COMPARE_OP", "node is exc_node" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._exception_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "exc_value" ], [ "CALL_METHOD", "self._exception_value(node, frame, exc_value)" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOOKUP_METHOD", "NodeValue.covered" ], [ "CALL_METHOD", "NodeValue.covered()" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._set_node_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "value" ], [ "CALL_METHOD", "self._set_node_value(node, frame, value)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._check_inner_call" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "value" ], [ "CALL_METHOD", "self._check_inner_call(self.stack[frame], node, value)" ], [ "LOAD_FAST", "enter_info" ], [ "LOAD_ATTR", "enter_info.current_frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_GLOBAL", "_tracing_recursively" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "_tracing_recursively(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_GLOBAL", "get_unfrozen_datetime" ], [ "CALL_FUNCTION", "get_unfrozen_datetime()" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_GLOBAL", "Iteration" ], [ "CALL_FUNCTION", "Iteration()" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "BINARY_SUBSCR", "self._code_infos[frame.f_code]" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "enter_info" ], [ "LOAD_ATTR", "enter_info.enter_node" ], [ "LOAD_ATTR", "enter_info.enter_node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Module" ], [ "CALL_FUNCTION", "isinstance(enter_info.enter_node.parent, ast.Module)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "LOOKUP_METHOD", "frame.f_locals.copy" ], [ "CALL_METHOD", "frame.f_locals.copy()" ], [ "LOAD_FAST", "code_info" ], [ "LOAD_ATTR", "code_info.arg_names" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "f_locals" ], [ "LOOKUP_METHOD", "f_locals.pop" ], [ "LOAD_FAST", "name" ], [ "CALL_METHOD", "f_locals.pop(name)" ], [ "LOAD_FAST", "f_locals" ], [ "LOOKUP_METHOD", "f_locals.items" ], [ "CALL_METHOD", "f_locals.items()" ], [ "LOAD_FAST", "it" ], [ "BINARY_SUBSCR", "it[0]" ], [ "BINARY_SUBSCR", "it[0][0]" ], [ "COMPARE_OP", "it[0][0] != '.'" ], [ "LOAD_FAST", "it" ], [ "BINARY_ADD", "[(name, f_locals.pop(name))\n for name in code_info.arg_names\n if name] + [\n\n # Local variables other than actual arguments. These are variables from\n # the enclosing scope. It's handy to treat them like arguments in the UI\n it for it in f_locals.items()\n if it[0][0] != '.' # Appears when using nested tuple arguments\n ]" ], [ "LOAD_GLOBAL", "json" ], [ "LOOKUP_METHOD", "json.dumps" ], [ "LOAD_FAST", "arguments" ], [ "LOAD_FAST", "k" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "cheap_repr(v)" ], [ "CALL_METHOD", "json.dumps([[k, cheap_repr(v)] for k, v in arguments])" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._call_id" ], [ "CALL_METHOD", "self._call_id()" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "defaultdict(list)" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOOKUP_METHOD", "self.stack.get" ], [ "LOAD_FAST", "enter_info" ], [ "LOAD_ATTR", "enter_info.caller_frame" ], [ "CALL_METHOD", "self.stack.get(enter_info.caller_frame)" ], [ "LOAD_FAST", "prev" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "prev" ], [ "CALL_FUNCTION", "getattr(prev, 'inner_calls', None)" ], [ "LOAD_FAST", "inner_calls" ], [ "COMPARE_OP", "inner_calls is not None" ], [ "LOAD_FAST", "inner_calls" ], [ "LOAD_FAST", "enter_info" ], [ "LOAD_ATTR", "enter_info.call_node" ], [ "BINARY_SUBSCR", "inner_calls[enter_info.call_node]" ], [ "LOOKUP_METHOD", "inner_calls[enter_info.call_node].append" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.call_id" ], [ "CALL_METHOD", "inner_calls[enter_info.call_node].append(frame_info.call_id)" ], [ "LOAD_GLOBAL", "uuid4" ], [ "CALL_FUNCTION", "uuid4()" ], [ "LOAD_ATTR", "uuid4().hex" ], [ "LOAD_DEREF", "exit_info" ], [ "LOAD_ATTR", "exit_info.current_frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_GLOBAL", "_tracing_recursively" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "_tracing_recursively(frame)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.iteration" ], [ "LOAD_GLOBAL", "_deep_dict" ], [ "CALL_FUNCTION", "_deep_dict()" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self._extract_node_values" ], [ "LOAD_DEREF", "top_iteration" ], [ "LOAD_DEREF", "node_values" ], [ "CALL_METHOD", "self._extract_node_values(top_iteration, (), node_values)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "BINARY_SUBSCR", "self._code_infos[frame.f_code]" ], [ "LOAD_ATTR", "self._code_infos[frame.f_code].db_func" ], [ "LOAD_DEREF", "exit_info" ], [ "LOAD_ATTR", "exit_info.exc_value" ], [ "LOAD_FAST", "exc" ], [ "LOOKUP_METHOD", "''.join" ], [ "LOAD_GLOBAL", "traceback" ], [ "LOOKUP_METHOD", "traceback.format_exception" ], [ "LOAD_GLOBAL", "type" ], [ "LOAD_FAST", "exc" ], [ "CALL_FUNCTION", "type(exc)" ], [ "LOAD_FAST", "exc" ], [ "LOAD_DEREF", "exit_info" ], [ "LOAD_ATTR", "exit_info.exc_tb" ], [ "CALL_METHOD", "traceback.format_exception(type(exc), exc, exit_info.exc_tb)" ], [ "CALL_METHOD", "''.join(traceback.format_exception(type(exc), exc, exit_info.exc_tb))" ], [ "LOAD_GLOBAL", "exception_string" ], [ "LOAD_FAST", "exc" ], [ "CALL_FUNCTION", "exception_string(exc)" ], [ "LOAD_GLOBAL", "retry_db" ], [ "CALL_FUNCTION", "retry_db" ], [ "LOAD_FAST", "add_call" ], [ "CALL_FUNCTION", "add_call()" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.call_id" ], [ "LOAD_DEREF", "self" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.db" ], [ "LOAD_ATTR", "self.db.Call" ], [ "LOAD_FAST", "Call" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.call_id" ], [ "LOAD_DEREF", "db_func" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.arguments" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_DEREF", "exit_info" ], [ "LOAD_ATTR", "exit_info.return_value" ], [ "CALL_FUNCTION", "cheap_repr(exit_info.return_value)" ], [ "LOAD_DEREF", "exception" ], [ "LOAD_DEREF", "traceback_str" ], [ "LOAD_GLOBAL", "json" ], [ "LOOKUP_METHOD", "json.dumps" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_DEREF", "node_values" ], [ "LOAD_DEREF", "top_iteration" ], [ "LOOKUP_METHOD", "top_iteration.extract_iterations" ], [ "CALL_METHOD", "top_iteration.extract_iterations()" ], [ "BINARY_SUBSCR", "top_iteration.extract_iterations()['loops']" ], [ "LOAD_GLOBAL", "type_registry" ], [ "LOOKUP_METHOD", "type_registry.names" ], [ "CALL_METHOD", "type_registry.names()" ], [ "LOAD_GLOBAL", "type_registry" ], [ "LOAD_ATTR", "type_registry.num_special_types" ], [ "CALL_FUNCTION", "dict(\n node_values=node_values,\n loop_iterations=top_iteration.extract_iterations()['loops'],\n type_names=type_registry.names(),\n num_special_types=type_registry.num_special_types,\n )" ], [ "LOAD_GLOBAL", "ProtocolEncoder" ], [ "CALL_METHOD", "json.dumps(\n dict(\n node_values=node_values,\n loop_iterations=top_iteration.extract_iterations()['loops'],\n type_names=type_registry.names(),\n num_special_types=type_registry.num_special_types,\n ),\n cls=ProtocolEncoder,\n separators=(',', ':')\n )" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.start_time" ], [ "CALL_FUNCTION", "Call(id=frame_info.call_id,\n function_id=db_func,\n arguments=frame_info.arguments,\n return_value=cheap_repr(exit_info.return_value),\n exception=exception,\n traceback=traceback_str,\n data=json.dumps(\n dict(\n node_values=node_values,\n loop_iterations=top_iteration.extract_iterations()['loops'],\n type_names=type_registry.names(),\n num_special_types=type_registry.num_special_types,\n ),\n cls=ProtocolEncoder,\n separators=(',', ':')\n ),\n start_time=frame_info.start_time)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.db" ], [ "LOOKUP_METHOD", "self.db.session_scope" ], [ "CALL_METHOD", "self.db.session_scope()" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.add" ], [ "LOAD_FAST", "call" ], [ "CALL_METHOD", "session.add(call)" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.vals" ], [ "LOOKUP_METHOD", "iteration.vals.items" ], [ "CALL_METHOD", "iteration.vals.items()" ], [ "LOAD_FAST", "tree_index" ], [ "LOAD_FAST", "path" ], [ "BINARY_ADD", "(tree_index,) + path" ], [ "LOAD_FAST", "node_values" ], [ "LOAD_FAST", "full_path" ], [ "SLICE+2", "full_path[:-1]" ], [ "LOAD_FAST", "d" ], [ "LOAD_FAST", "path_k" ], [ "BINARY_SUBSCR", "d[path_k]" ], [ "LOAD_FAST", "node_value" ], [ "LOAD_FAST", "d" ], [ "LOAD_FAST", "full_path" ], [ "BINARY_SUBSCR", "full_path[-1]" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.loops" ], [ "LOOKUP_METHOD", "iteration.loops.values" ], [ "CALL_METHOD", "iteration.loops.values()" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "loop" ], [ "CALL_FUNCTION", "enumerate(loop)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._extract_node_values" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "path + (i,)" ], [ "LOAD_FAST", "node_values" ], [ "CALL_METHOD", "self._extract_node_values(iteration, path + (i,), node_values)" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "BirdsEye" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(BirdsEye, self)" ], [ "LOOKUP_METHOD", "super(BirdsEye, self).trace_function" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "super(BirdsEye, self).trace_function(func)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOOKUP_METHOD", "self._code_infos.get" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_ATTR", "new_func.__code__" ], [ "CALL_METHOD", "self._code_infos.get(new_func.__code__)" ], [ "LOAD_FAST", "code_info" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.getsourcelines" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "inspect.getsourcelines(func)" ], [ "LOAD_FAST", "start_lineno" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "lines" ], [ "CALL_FUNCTION", "len(lines)" ], [ "BINARY_ADD", "start_lineno + len(lines)" ], [ "LOAD_GLOBAL", "safe_qualname" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "safe_qualname(func)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.getsourcefile" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "inspect.getsourcefile(func)" ], [ "LOAD_FAST", "source_file" ], [ "LOOKUP_METHOD", "source_file.startswith" ], [ "CALL_METHOD", "source_file.startswith('= 0" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.getsourcefile" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "inspect.getsourcefile(frame)" ], [ "LOAD_FAST", "filename" ], [ "COMPARE_OP", "filename is not None" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOOKUP_METHOD", "os.path.abspath" ], [ "LOAD_FAST", "filename" ], [ "CALL_METHOD", "os.path.abspath(filename)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "LOOKUP_METHOD", "frame.f_globals.get" ], [ "CALL_METHOD", "frame.f_globals.get('__name__')" ], [ "COMPARE_OP", "frame.f_globals.get('__name__') != '__main__'" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._treetrace_hidden_with_stmt" ], [ "LOAD_ATTR", "self._treetrace_hidden_with_stmt.__name__" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "COMPARE_OP", "self._treetrace_hidden_with_stmt.__name__ not in frame.f_globals" ], [ "LOAD_GLOBAL", "RuntimeError" ], [ "CALL_FUNCTION", "RuntimeError(\n 'To trace an imported module, you must import birdseye before '\n 'importing that module.')" ], [ "LOAD_GLOBAL", "read_source_file" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "read_source_file(filename)" ], [ "LOOKUP_METHOD", "read_source_file(filename).splitlines" ], [ "CALL_METHOD", "read_source_file(filename).splitlines()" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lineno" ], [ "BINARY_MULTIPLY", "[''] * frame.f_lineno" ], [ "LOAD_FAST", "lines" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lineno" ], [ "LOOKUP_METHOD", "'\\n'.join" ], [ "LOAD_FAST", "lines" ], [ "CALL_METHOD", "'\\n'.join(lines)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.exec_string" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "LOAD_FAST", "deep" ], [ "CALL_METHOD", "self.exec_string(source, filename, frame.f_globals, frame.f_locals, deep)" ], [ "LOAD_GLOBAL", "sys" ], [ "LOOKUP_METHOD", "sys.exit" ], [ "CALL_METHOD", "sys.exit(0)" ], [ "LOAD_FAST", "globs" ], [ "LOAD_FAST", "locs" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self.compile" ], [ "LOAD_DEREF", "source" ], [ "LOAD_DEREF", "filename" ], [ "CALL_METHOD", "self.compile(source, filename)" ], [ "LOAD_FAST", "globs" ], [ "LOOKUP_METHOD", "globs.update" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self._trace_methods_dict" ], [ "LOAD_DEREF", "traced_file" ], [ "CALL_METHOD", "self._trace_methods_dict(traced_file)" ], [ "CALL_METHOD", "globs.update(self._trace_methods_dict(traced_file))" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self._trace" ], [ "LOAD_NAME", "FILE_SENTINEL_NAME" ], [ "LOAD_DEREF", "filename" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.code" ], [ "LOAD_DEREF", "source" ], [ "CALL_METHOD", "self._trace(FILE_SENTINEL_NAME, filename, traced_file, traced_file.code, 'module', source)" ], [ "LOAD_FAST", "deep" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.nodes" ], [ "LOAD_DEREF", "find_code" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.code" ], [ "CALL_FUNCTION", "find_code(traced_file.code)" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.code" ], [ "LOAD_FAST", "globs" ], [ "LOAD_FAST", "locs" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(node, ast.FunctionDef)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.lineno" ], [ "LOAD_FAST", "root_code" ], [ "LOAD_ATTR", "root_code.co_consts" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.iscode" ], [ "LOAD_FAST", "code" ], [ "CALL_METHOD", "inspect.iscode(code)" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "LOOKUP_METHOD", "code.co_name.startswith" ], [ "CALL_METHOD", "code.co_name.startswith('<')" ], [ "LOAD_DEREF", "find_code" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "find_code(code)" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_firstlineno" ], [ "LOAD_DEREF", "nodes_by_lineno" ], [ "LOOKUP_METHOD", "nodes_by_lineno.get" ], [ "LOAD_FAST", "lineno" ], [ "CALL_METHOD", "nodes_by_lineno.get(lineno)" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self._trace" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "LOAD_DEREF", "filename" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_FAST", "code" ], [ "LOAD_DEREF", "source" ], [ "LOAD_FAST", "lineno" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.last_token" ], [ "LOAD_ATTR", "node.last_token.end" ], [ "BINARY_SUBSCR", "node.last_token.end[0]" ], [ "BINARY_ADD", "node.last_token.end[0] + 1" ], [ "CALL_METHOD", "self._trace(\n code.co_name, filename, traced_file, code,\n typ='function',\n source=source,\n start_lineno=lineno,\n end_lineno=node.last_token.end[0] + 1,\n )" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_DEREF", "start_lineno" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "source" ], [ "LOOKUP_METHOD", "source.splitlines" ], [ "CALL_METHOD", "source.splitlines()" ], [ "CALL_FUNCTION", "len(source.splitlines())" ], [ "BINARY_ADD", "start_lineno + len(source.splitlines())" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._nodes_of_interest" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_DEREF", "start_lineno" ], [ "LOAD_FAST", "end_lineno" ], [ "CALL_METHOD", "self._nodes_of_interest(traced_file, start_lineno, end_lineno)" ], [ "CALL_FUNCTION", "list(self._nodes_of_interest(traced_file, start_lineno, end_lineno))" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._nodes_html" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_DEREF", "start_lineno" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_FAST", "traced_file" ], [ "CALL_METHOD", "self._nodes_html(nodes, start_lineno, end_lineno, traced_file)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "nodes" ], [ "CALL_FUNCTION", "dict(\n # This maps each node to the loops enclosing that node\n node_loops={\n node._tree_index: [n._tree_index for n in node._loops]\n for node, _ in nodes\n if node._loops\n },\n )" ], [ "LOAD_FAST", "typ" ], [ "COMPARE_OP", "typ == 'function'" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.tokens" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_FAST", "nodes" ], [ "CALL_FUNCTION", "only(node\n for node, _ in nodes\n if isinstance(node, ast.FunctionDef)\n and node.first_token.start[0] == start_lineno)" ], [ "LOAD_GLOBAL", "source_without_decorators" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_FAST", "func_node" ], [ "CALL_FUNCTION", "source_without_decorators(tokens, func_node)" ], [ "LOAD_FAST", "data_dict" ], [ "LOOKUP_METHOD", "data_dict.update" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._node_ranges" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_FAST", "func_startpos" ], [ "CALL_METHOD", "self._node_ranges(nodes, tokens, func_startpos)" ], [ "CALL_FUNCTION", "list(self._node_ranges(nodes, tokens, func_startpos))" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._loop_ranges" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_FAST", "func_startpos" ], [ "CALL_METHOD", "self._loop_ranges(nodes, tokens, func_startpos)" ], [ "CALL_FUNCTION", "list(self._loop_ranges(nodes, tokens, func_startpos))" ], [ "CALL_METHOD", "data_dict.update(\n node_ranges=list(self._node_ranges(nodes, tokens, func_startpos)),\n loop_ranges=list(self._loop_ranges(nodes, tokens, func_startpos)),\n )" ], [ "LOAD_GLOBAL", "json" ], [ "LOOKUP_METHOD", "json.dumps" ], [ "LOAD_FAST", "data_dict" ], [ "LOAD_GLOBAL", "True" ], [ "CALL_METHOD", "json.dumps(data_dict, sort_keys=True)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._db_func" ], [ "LOAD_FAST", "data" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "html_body" ], [ "LOAD_FAST", "name" ], [ "LOAD_DEREF", "start_lineno" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "typ" ], [ "CALL_METHOD", "self._db_func(data, filename, html_body, name, start_lineno, source, typ)" ], [ "LOAD_GLOBAL", "CodeInfo" ], [ "LOAD_FAST", "db_func" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_FAST", "arg_names" ], [ "CALL_FUNCTION", "CodeInfo(db_func, traced_file, arg_names)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "n" ], [ "LOAD_ATTR", "n._tree_index" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(node, ast.FunctionDef)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.first_token" ], [ "LOAD_ATTR", "node.first_token.start" ], [ "BINARY_SUBSCR", "node.first_token.start[0]" ], [ "LOAD_DEREF", "start_lineno" ], [ "COMPARE_OP", "node.first_token.start[0] == start_lineno" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "classes" ], [ "COMPARE_OP", "'loop' not in classes" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.target" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.test" ], [ "LOAD_FAST", "tokens" ], [ "LOOKUP_METHOD", "tokens.get_text_range" ], [ "LOAD_FAST", "target" ], [ "CALL_METHOD", "tokens.get_text_range(target)" ], [ "LOAD_FAST", "func_start" ], [ "LOAD_FAST", "func_start" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "CALL_FUNCTION", "dict(\n tree_index=node._tree_index,\n start=start,\n end=end\n )" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "tokens" ], [ "LOOKUP_METHOD", "tokens.get_text_range" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "tokens.get_text_range(node)" ], [ "LOAD_FAST", "func_start" ], [ "LOAD_FAST", "func_start" ], [ "LOAD_FAST", "start" ], [ "COMPARE_OP", "start < 0" ], [ "LOAD_FAST", "end" ], [ "COMPARE_OP", "end < 0" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(node, ast.FunctionDef)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._depth" ], [ "LOAD_FAST", "classes" ], [ "CALL_FUNCTION", "dict(\n tree_index=node._tree_index,\n start=start,\n end=end,\n depth=node._depth,\n classes=classes,\n )" ], [ "LOAD_FAST", "h" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "name" ], [ "BINARY_ADD", "filename + name" ], [ "LOAD_FAST", "html_body" ], [ "BINARY_ADD", "filename + name + html_body" ], [ "LOAD_FAST", "data" ], [ "BINARY_ADD", "filename + name + html_body + data" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "start_lineno" ], [ "CALL_FUNCTION", "str(start_lineno)" ], [ "BINARY_ADD", "filename + name + html_body + data + str(start_lineno)" ], [ "CALL_FUNCTION", "h(filename + name + html_body + data + str(start_lineno))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.db" ], [ "LOAD_ATTR", "self.db.Function" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.db" ], [ "LOOKUP_METHOD", "self.db.session_scope" ], [ "CALL_METHOD", "self.db.session_scope()" ], [ "LOAD_GLOBAL", "one_or_none" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.query" ], [ "LOAD_FAST", "Function" ], [ "CALL_METHOD", "session.query(Function)" ], [ "LOOKUP_METHOD", "session.query(Function).filter_by" ], [ "LOAD_FAST", "function_hash" ], [ "CALL_METHOD", "session.query(Function).filter_by(hash=function_hash)" ], [ "CALL_FUNCTION", "one_or_none(session.query(Function).filter_by(hash=function_hash))" ], [ "LOAD_FAST", "db_func" ], [ "LOAD_FAST", "Function" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "typ" ], [ "LOAD_FAST", "html_body" ], [ "LOAD_FAST", "start_lineno" ], [ "LOAD_FAST", "data" ], [ "LOAD_FAST", "h" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "h(source)" ], [ "LOAD_FAST", "function_hash" ], [ "CALL_FUNCTION", "Function(file=filename,\n name=name,\n type=typ,\n html_body=html_body,\n lineno=start_lineno,\n data=data,\n body_hash=h(source),\n hash=function_hash)" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.add" ], [ "LOAD_FAST", "db_func" ], [ "CALL_METHOD", "session.add(db_func)" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.commit" ], [ "CALL_METHOD", "session.commit()" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "db_func" ], [ "LOAD_ATTR", "db_func.id" ], [ "LOAD_GLOBAL", "int" ], [ "CALL_FUNCTION", "isinstance(db_func.id, int)" ], [ "LOAD_FAST", "db_func" ], [ "LOAD_ATTR", "db_func.id" ], [ "LOAD_GLOBAL", "hashlib" ], [ "LOOKUP_METHOD", "hashlib.sha256" ], [ "LOAD_FAST", "s" ], [ "LOOKUP_METHOD", "s.encode" ], [ "CALL_METHOD", "s.encode('utf8')" ], [ "CALL_METHOD", "hashlib.sha256(s.encode('utf8'))" ], [ "LOOKUP_METHOD", "hashlib.sha256(s.encode('utf8')).hexdigest" ], [ "CALL_METHOD", "hashlib.sha256(s.encode('utf8')).hexdigest()" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.nodes" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "CALL_FUNCTION", "isinstance(node, (ast.While, ast.For, ast.comprehension))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.GeneratorExp" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.GeneratorExp)" ], [ "LOAD_FAST", "classes" ], [ "LOOKUP_METHOD", "classes.append" ], [ "CALL_METHOD", "classes.append('loop')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "CALL_FUNCTION", "isinstance(node, ast.stmt)" ], [ "LOAD_FAST", "classes" ], [ "LOOKUP_METHOD", "classes.append" ], [ "CALL_METHOD", "classes.append('stmt')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "CALL_FUNCTION", "isinstance(node, ast.expr)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._is_interesting_expression" ], [ "LOAD_FAST", "classes" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.AST" ], [ "CALL_FUNCTION", "isinstance(node, ast.AST)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "hasattr(node, 'first_token')" ], [ "LOAD_FAST", "start_lineno" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.first_token" ], [ "LOAD_ATTR", "node.first_token.start" ], [ "BINARY_SUBSCR", "node.first_token.start[0]" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.tokens" ], [ "LOOKUP_METHOD", "traced_file.tokens.get_text_range" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "traced_file.tokens.get_text_range(node)" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "classes" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.root" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.walk" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.root" ], [ "CALL_METHOD", "ast.walk(traced_file.root)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.iter_child_nodes" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.iter_child_nodes(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._depth" ], [ "BINARY_ADD", "node._depth + 1" ], [ "LOAD_FAST", "child" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "positions" ], [ "LOOKUP_METHOD", "positions.extend" ], [ "LOAD_GLOBAL", "map" ], [ "LOAD_GLOBAL", "HTMLPosition" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "LOAD_GLOBAL", "True" ], [ "LOAD_GLOBAL", "False" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._depth" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._depth" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOOKUP_METHOD", "' '.join" ], [ "LOAD_FAST", "classes" ], [ "CALL_METHOD", "' '.join(classes)" ], [ "BINARY_MODULO", "'' % (node._tree_index, ' '.join(classes))" ], [ "CALL_FUNCTION", "map(\n HTMLPosition,\n [start, end],\n [True, False], # is_start\n [node._depth, node._depth],\n ['' % (node._tree_index, ' '.join(classes)),\n ''])" ], [ "CALL_METHOD", "positions.extend(map(\n HTMLPosition,\n [start, end],\n [True, False], # is_start\n [node._depth, node._depth],\n ['' % (node._tree_index, ' '.join(classes)),\n '']))" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._separate_comprehensions" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "n" ], [ "BINARY_SUBSCR", "n[0]" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_FAST", "positions" ], [ "LOAD_FAST", "traced_file" ], [ "CALL_METHOD", "self._separate_comprehensions(\n [n[0] for n in nodes],\n end_lineno, positions, traced_file)" ], [ "LOAD_FAST", "positions" ], [ "LOOKUP_METHOD", "positions.append" ], [ "LOAD_GLOBAL", "HTMLPosition" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.source" ], [ "CALL_FUNCTION", "len(traced_file.source)" ], [ "LOAD_GLOBAL", "False" ], [ "CALL_FUNCTION", "HTMLPosition(len(traced_file.source), False, 0, '')" ], [ "CALL_METHOD", "positions.append(HTMLPosition(len(traced_file.source), False, 0, ''))" ], [ "LOAD_FAST", "positions" ], [ "LOOKUP_METHOD", "positions.sort" ], [ "CALL_METHOD", "positions.sort()" ], [ "LOAD_FAST", "positions" ], [ "LOAD_FAST", "html_parts" ], [ "LOOKUP_METHOD", "html_parts.append" ], [ "LOAD_GLOBAL", "html" ], [ "LOOKUP_METHOD", "html.escape" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.source" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "position" ], [ "LOAD_ATTR", "position.index" ], [ "SLICE+3", "traced_file.source[start:position.index]" ], [ "CALL_METHOD", "html.escape(traced_file.source[start:position.index])" ], [ "CALL_METHOD", "html_parts.append(html.escape(traced_file.source[start:position.index]))" ], [ "LOAD_FAST", "html_parts" ], [ "LOOKUP_METHOD", "html_parts.append" ], [ "LOAD_FAST", "position" ], [ "LOAD_ATTR", "position.html" ], [ "CALL_METHOD", "html_parts.append(position.html)" ], [ "LOAD_FAST", "position" ], [ "LOAD_ATTR", "position.index" ], [ "LOOKUP_METHOD", "''.join" ], [ "LOAD_FAST", "html_parts" ], [ "CALL_METHOD", "''.join(html_parts)" ], [ "LOOKUP_METHOD", "'\\n'.join" ], [ "LOAD_FAST", "html_body" ], [ "LOOKUP_METHOD", "html_body.split" ], [ "CALL_METHOD", "html_body.split('\\n')" ], [ "LOAD_FAST", "start_lineno" ], [ "BINARY_SUBTRACT", "start_lineno - 1" ], [ "LOAD_FAST", "end_lineno" ], [ "BINARY_SUBTRACT", "end_lineno - 1" ], [ "SLICE+3", "html_body.split('\\n')[start_lineno - 1:end_lineno - 1]" ], [ "CALL_METHOD", "'\\n'.join(html_body.split('\\n')[start_lineno - 1:end_lineno - 1])" ], [ "LOAD_FAST", "html_body" ], [ "LOOKUP_METHOD", "html_body.strip" ], [ "CALL_METHOD", "html_body.strip('\\n')" ], [ "LOAD_GLOBAL", "group_by_key_func" ], [ "LOAD_GLOBAL", "of_type" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "LOAD_FAST", "nodes" ], [ "CALL_FUNCTION", "of_type((ast.comprehension, ast.While, ast.For), nodes)" ], [ "CALL_FUNCTION", "group_by_key_func(of_type((ast.comprehension, ast.While, ast.For), nodes),\n lambda c: c.first_token.start[0]\n )" ], [ "LOAD_FAST", "comprehensions" ], [ "LOOKUP_METHOD", "comprehensions.values" ], [ "CALL_METHOD", "comprehensions.values()" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_FAST", "comp_list" ], [ "CALL_FUNCTION", "sorted(comp_list, key=lambda c: c.first_token.startpos)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "comp" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "CALL_FUNCTION", "isinstance(comp, ast.comprehension)" ], [ "LOAD_FAST", "comp" ], [ "LOAD_FAST", "comp" ], [ "LOAD_ATTR", "comp.parent" ], [ "LOAD_ATTR", "comp.parent.generators" ], [ "BINARY_SUBSCR", "comp.parent.generators[0]" ], [ "COMPARE_OP", "comp is comp.parent.generators[0]" ], [ "LOAD_FAST", "get_start" ], [ "LOAD_FAST", "comp" ], [ "LOAD_ATTR", "comp.parent" ], [ "CALL_FUNCTION", "get_start(comp.parent)" ], [ "LOAD_FAST", "prev_start" ], [ "COMPARE_OP", "prev_start is not None" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "prev_start" ], [ "COMPARE_OP", "start < prev_start" ], [ "LOAD_FAST", "get_start" ], [ "LOAD_FAST", "comp" ], [ "CALL_FUNCTION", "get_start(comp)" ], [ "LOAD_FAST", "get_start" ], [ "LOAD_FAST", "comp" ], [ "CALL_FUNCTION", "get_start(comp)" ], [ "LOAD_FAST", "prev_start" ], [ "COMPARE_OP", "prev_start is not None" ], [ "LOAD_FAST", "positions" ], [ "LOOKUP_METHOD", "positions.append" ], [ "LOAD_GLOBAL", "HTMLPosition" ], [ "LOAD_FAST", "start" ], [ "LOAD_GLOBAL", "True" ], [ "CALL_FUNCTION", "HTMLPosition(start, True, 0, '\\n ')" ], [ "CALL_METHOD", "positions.append(HTMLPosition(start, True, 0, '\\n '))" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.first_token" ], [ "LOAD_ATTR", "c.first_token.start" ], [ "BINARY_SUBSCR", "c.first_token.start[0]" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.tokens" ], [ "LOOKUP_METHOD", "traced_file.tokens.get_text_range" ], [ "LOAD_FAST", "n" ], [ "CALL_METHOD", "traced_file.tokens.get_text_range(n)" ], [ "BINARY_SUBSCR", "traced_file.tokens.get_text_range(n)[0]" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.first_token" ], [ "LOAD_ATTR", "c.first_token.startpos" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "_deep_dict" ], [ "CALL_FUNCTION", "defaultdict(_deep_dict)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_GLOBAL", "_bad_codes" ], [ "COMPARE_OP", "frame.f_code in _bad_codes" ], [ "LOAD_GLOBAL", "True" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "IterationList" ], [ "CALL_FUNCTION", "defaultdict(IterationList)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "False" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.index" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.loops" ], [ "LOOKUP_METHOD", "self.loops.items" ], [ "CALL_METHOD", "self.loops.items()" ], [ "LOAD_FAST", "iteration_list" ], [ "LOAD_FAST", "iteration" ], [ "LOOKUP_METHOD", "iteration.extract_iterations" ], [ "CALL_METHOD", "iteration.extract_iterations()" ], [ "LOAD_FAST", "tree_index" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "deque" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.side_len" ], [ "CALL_FUNCTION", "deque(maxlen=self.side_len)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "Counter" ], [ "CALL_FUNCTION", "Counter()" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.length" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.side_len" ], [ "COMPARE_OP", "self.length < self.side_len" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start" ], [ "LOOKUP_METHOD", "self.start.append" ], [ "LOAD_FAST", "iteration" ], [ "CALL_METHOD", "self.start.append(iteration)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "CALL_FUNCTION", "len(self.end)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.side_len" ], [ "COMPARE_OP", "len(self.end) >= self.side_len" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "BINARY_SUBSCR", "self.end[0]" ], [ "LOAD_ATTR", "self.end[0].keep" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start" ], [ "LOOKUP_METHOD", "self.start.append" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "BINARY_SUBSCR", "self.end[0]" ], [ "CALL_METHOD", "self.start.append(self.end[0])" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "LOOKUP_METHOD", "self.end.append" ], [ "LOAD_FAST", "iteration" ], [ "CALL_METHOD", "self.end.append(iteration)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.length" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "chain" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "CALL_FUNCTION", "chain(self.start, self.end)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "BINARY_SUBSCR", "self.end[-1]" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start" ], [ "BINARY_SUBSCR", "self.start[-1]" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.recorded" ], [ "LOAD_FAST", "node" ], [ "BINARY_SUBSCR", "self.recorded[node]" ], [ "COMPARE_OP", "self.recorded[node] >= 2" ], [ "LOAD_GLOBAL", "True" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.last" ], [ "CALL_METHOD", "self.last()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.recorded" ], [ "LOAD_FAST", "node" ], [ "LOAD_NAME", "type" ], [ "CALL_FUNCTION", "type(None)" ], [ "LOAD_NAME", "bool" ], [ "LOAD_NAME", "int" ], [ "LOAD_NAME", "float" ], [ "LOAD_NAME", "complex" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "long" ], [ "LOAD_NAME", "basic_types" ], [ "LOAD_NAME", "list" ], [ "LOAD_NAME", "dict" ], [ "LOAD_NAME", "tuple" ], [ "LOAD_NAME", "set" ], [ "LOAD_NAME", "frozenset" ], [ "LOAD_NAME", "str" ], [ "BINARY_ADD", "basic_types + (list, dict, tuple, set, frozenset, str)" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "unicode" ], [ "LOAD_NAME", "bytes" ], [ "LOAD_NAME", "len" ], [ "LOAD_NAME", "special_types" ], [ "CALL_FUNCTION", "len(special_types)" ], [ "LOAD_GLOBAL", "Lock" ], [ "CALL_FUNCTION", "Lock()" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "CALL_FUNCTION", "defaultdict(lambda: len(self.data))" ], [ "LOAD_DEREF", "self" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.special_types" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.data" ], [ "LOAD_FAST", "t" ], [ "BINARY_SUBSCR", "self.data[t]" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.data" ], [ "CALL_FUNCTION", "len(self.data)" ], [ "LOAD_GLOBAL", "correct_type" ], [ "LOAD_FAST", "item" ], [ "CALL_FUNCTION", "correct_type(item)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.lock" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.data" ], [ "LOAD_FAST", "t" ], [ "BINARY_SUBSCR", "self.data[t]" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.data" ], [ "LOOKUP_METHOD", "self.data.items" ], [ "CALL_METHOD", "self.data.items()" ], [ "CALL_FUNCTION", "dict((v, k) for k, v in self.data.items())" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "rev" ], [ "CALL_FUNCTION", "len(rev)" ], [ "CALL_FUNCTION", "range(len(rev))" ], [ "LOAD_GLOBAL", "safe_qualname" ], [ "LOAD_FAST", "rev" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "rev[i]" ], [ "CALL_FUNCTION", "safe_qualname(rev[i])" ], [ "LOAD_FAST", "v" ], [ "LOAD_FAST", "k" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_FAST", "val_repr" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "type_index" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.meta" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.meta" ], [ "LOAD_FAST", "key" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.children" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.children" ], [ "LOOKUP_METHOD", "self.children.append" ], [ "LOAD_FAST", "key" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOOKUP_METHOD", "NodeValue.expression" ], [ "LOAD_FAST", "samples" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "level" ], [ "CALL_METHOD", "NodeValue.expression(samples, value, level)" ], [ "CALL_METHOD", "self.children.append((key, NodeValue.expression(samples, value, level)))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.val_repr" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.type_index" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.meta" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.children" ], [ "LOAD_FAST", "result" ], [ "LOOKUP_METHOD", "result.extend" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.children" ], [ "CALL_METHOD", "result.extend(self.children)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "cls" ], [ "CALL_FUNCTION", "cls('', -2)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_GLOBAL", "exception_string" ], [ "LOAD_FAST", "exc_value" ], [ "CALL_FUNCTION", "exception_string(exc_value)" ], [ "CALL_FUNCTION", "cls(exception_string(exc_value), -1)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "cheap_repr(val)" ], [ "LOAD_GLOBAL", "type_registry" ], [ "LOAD_FAST", "val" ], [ "BINARY_SUBSCR", "type_registry[val]" ], [ "CALL_FUNCTION", "cls(cheap_repr(val), type_registry[val])" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "TypeRegistry" ], [ "LOAD_ATTR", "TypeRegistry.basic_types" ], [ "LOAD_GLOBAL", "BirdsEye" ], [ "CALL_FUNCTION", "isinstance(val, (TypeRegistry.basic_types, BirdsEye))" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "QuerySet" ], [ "CALL_FUNCTION", "isinstance(val, QuerySet)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "len(val)" ], [ "LOAD_FAST", "result" ], [ "LOOKUP_METHOD", "result.set_meta" ], [ "LOAD_FAST", "length" ], [ "CALL_METHOD", "result.set_meta('len', length)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "ModuleType" ], [ "CALL_FUNCTION", "isinstance(val, ModuleType)" ], [ "LOAD_GLOBAL", "min" ], [ "LOAD_FAST", "level" ], [ "CALL_FUNCTION", "min(level, 2)" ], [ "LOAD_GLOBAL", "partial" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.add_child" ], [ "LOAD_FAST", "samples" ], [ "LOAD_FAST", "level" ], [ "BINARY_SUBTRACT", "level - 1" ], [ "CALL_FUNCTION", "partial(result.add_child, samples, level - 1)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Series" ], [ "LOAD_GLOBAL", "ndarray" ], [ "CALL_FUNCTION", "isinstance(val, (Series, ndarray))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "ndarray" ], [ "CALL_FUNCTION", "isinstance(val, ndarray)" ], [ "LOAD_FAST", "attrs" ], [ "LOOKUP_METHOD", "attrs.append" ], [ "CALL_METHOD", "attrs.append('shape')" ], [ "LOAD_FAST", "attrs" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "val" ], [ "LOAD_FAST", "name" ], [ "CALL_FUNCTION", "getattr(val, name)" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "attr" ], [ "CALL_FUNCTION", "add_child(name, attr)" ], [ "LOAD_FAST", "level" ], [ "COMPARE_OP", "level >= 3" ], [ "LOAD_FAST", "level" ], [ "COMPARE_OP", "level >= 2" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Series" ], [ "CALL_FUNCTION", "isinstance(val, Series)" ], [ "LOAD_FAST", "samples" ], [ "LOAD_FAST", "sample_type" ], [ "BINARY_SUBSCR", "samples[sample_type]" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "DataFrame" ], [ "CALL_FUNCTION", "isinstance(val, DataFrame)" ], [ "LOAD_FAST", "result" ], [ "LOOKUP_METHOD", "result.set_meta" ], [ "LOAD_FAST", "meta" ], [ "CALL_METHOD", "result.set_meta('dataframe', meta)" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['pandas_rows']" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['pandas_cols']" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_rows" ], [ "BINARY_ADD", "max_rows + 2" ], [ "COMPARE_OP", "length > max_rows + 2" ], [ "LOAD_FAST", "max_rows" ], [ "BINARY_FLOOR_DIVIDE", "max_rows // 2" ], [ "LOAD_FAST", "meta" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.columns" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "columns" ], [ "CALL_FUNCTION", "len(columns)" ], [ "LOAD_FAST", "num_cols" ], [ "LOAD_FAST", "max_cols" ], [ "BINARY_ADD", "max_cols + 2" ], [ "COMPARE_OP", "num_cols > max_cols + 2" ], [ "LOAD_FAST", "max_cols" ], [ "BINARY_FLOOR_DIVIDE", "max_cols // 2" ], [ "LOAD_FAST", "meta" ], [ "LOAD_GLOBAL", "set" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "num_cols" ], [ "LOAD_FAST", "max_cols" ], [ "CALL_FUNCTION", "_sample_indices(num_cols, max_cols)" ], [ "CALL_FUNCTION", "set(_sample_indices(num_cols, max_cols))" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_GLOBAL", "zip" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.columns" ], [ "LOOKUP_METHOD", "val.columns.format" ], [ "LOAD_GLOBAL", "False" ], [ "CALL_METHOD", "val.columns.format(sparsify=False)" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.columns" ], [ "CALL_FUNCTION", "zip(val.columns.format(sparsify=False),\n val.columns)" ], [ "CALL_FUNCTION", "enumerate(zip(val.columns.format(sparsify=False),\n val.columns))" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "indices" ], [ "COMPARE_OP", "i in indices" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_FAST", "formatted_name" ], [ "LOAD_FAST", "val" ], [ "LOAD_FAST", "label" ], [ "BINARY_SUBSCR", "val[label]" ], [ "CALL_FUNCTION", "add_child(formatted_name, val[label])" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Series" ], [ "CALL_FUNCTION", "isinstance(val, Series)" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['pandas_rows']" ], [ "CALL_FUNCTION", "_sample_indices(length, samples['pandas_rows'])" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.index" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "SLICE+3", "val.index[i:i + 1]" ], [ "LOOKUP_METHOD", "val.index[i:i + 1].format" ], [ "LOAD_GLOBAL", "False" ], [ "CALL_METHOD", "val.index[i:i + 1].format(sparsify=False)" ], [ "BINARY_SUBSCR", "val.index[i:i + 1].format(sparsify=False)[0]" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.iloc" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "val.iloc[i]" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_FAST", "k" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child(k, v)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "level" ], [ "COMPARE_OP", "level <= 0" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "bytes" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "unicode" ], [ "LOAD_GLOBAL", "xrange" ], [ "CALL_FUNCTION", "isinstance(val,\n (str, bytes, range)\n if PY3 else\n (str, unicode, xrange))" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Sequence" ], [ "LOAD_GLOBAL", "ndarray" ], [ "CALL_FUNCTION", "isinstance(val, (Sequence, ndarray))" ], [ "LOAD_FAST", "length" ], [ "COMPARE_OP", "length is not None" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['list']" ], [ "CALL_FUNCTION", "_sample_indices(length, samples['list'])" ], [ "LOAD_FAST", "val" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "val[i]" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "i" ], [ "CALL_FUNCTION", "str(i)" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child(str(i), v)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Mapping" ], [ "CALL_FUNCTION", "isinstance(val, Mapping)" ], [ "LOAD_GLOBAL", "islice" ], [ "LOAD_GLOBAL", "_safe_iter" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "iteritems" ], [ "CALL_FUNCTION", "_safe_iter(val, iteritems)" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['dict']" ], [ "CALL_FUNCTION", "islice(_safe_iter(val, iteritems), samples['dict'])" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "k" ], [ "CALL_FUNCTION", "cheap_repr(k)" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child(cheap_repr(k), v)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Set" ], [ "CALL_FUNCTION", "isinstance(val, Set)" ], [ "LOAD_GLOBAL", "_safe_iter" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "_safe_iter(val)" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['set']" ], [ "LOAD_FAST", "length" ], [ "COMPARE_OP", "length is None" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "num_items" ], [ "BINARY_ADD", "num_items + 2" ], [ "COMPARE_OP", "length > num_items + 2" ], [ "LOAD_GLOBAL", "islice" ], [ "LOAD_FAST", "vals" ], [ "LOAD_FAST", "num_items" ], [ "CALL_FUNCTION", "islice(vals, num_items)" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "vals" ], [ "CALL_FUNCTION", "enumerate(vals)" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_FAST", "i" ], [ "BINARY_MODULO", "'<%s>' % i" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child('<%s>' % i, v)" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "getattr(val, '__dict__', None)" ], [ "LOAD_FAST", "d" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_GLOBAL", "islice" ], [ "LOAD_GLOBAL", "_safe_iter" ], [ "LOAD_FAST", "d" ], [ "CALL_FUNCTION", "_safe_iter(d)" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['attributes']" ], [ "CALL_FUNCTION", "islice(_safe_iter(d),\n samples['attributes'])" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "sorted(islice(_safe_iter(d),\n samples['attributes']),\n key=str)" ], [ "LOAD_FAST", "d" ], [ "LOAD_FAST", "k" ], [ "BINARY_SUBSCR", "d[k]" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "TracedFile" ], [ "CALL_FUNCTION", "isinstance(v, TracedFile)" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "k" ], [ "CALL_FUNCTION", "str(k)" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child(str(k), v)" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "type" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "type(val)" ], [ "CALL_FUNCTION", "getattr(type(val), '__slots__', None)" ], [ "CALL_FUNCTION", "sorted(getattr(type(val), '__slots__', None) or ())" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "val" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "getattr(val, s)" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "str(s)" ], [ "LOAD_FAST", "attr" ], [ "CALL_FUNCTION", "add_child(str(s), attr)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "x" ], [ "LOAD_FAST", "f" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "f(val)" ], [ "LOAD_FAST", "x" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_ADD", "max_length + 2" ], [ "COMPARE_OP", "length <= max_length + 2" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "range(length)" ], [ "LOAD_GLOBAL", "chain" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_FLOOR_DIVIDE", "max_length // 2" ], [ "CALL_FUNCTION", "range(max_length // 2)" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_FLOOR_DIVIDE", "max_length // 2" ], [ "BINARY_SUBTRACT", "length - max_length // 2" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "range(length - max_length // 2,\n length)" ], [ "CALL_FUNCTION", "chain(range(max_length // 2),\n range(length - max_length // 2,\n length))" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "len(x)" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "n == 0" ], [ "LOAD_GLOBAL", "repr" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "repr(x)" ], [ "LOAD_FAST", "helper" ], [ "LOAD_ATTR", "helper.level" ], [ "BINARY_SUBTRACT", "helper.level - 1" ], [ "LOAD_GLOBAL", "_repr_series_one_line" ], [ "LOAD_ATTR", "_repr_series_one_line.maxparts" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "n" ], [ "LOAD_FAST", "maxparts" ], [ "CALL_FUNCTION", "_sample_indices(n, maxparts)" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.index" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "SLICE+3", "x.index[i:i + 1]" ], [ "LOOKUP_METHOD", "x.index[i:i + 1].format" ], [ "LOAD_GLOBAL", "False" ], [ "CALL_METHOD", "x.index[i:i + 1].format(sparsify=False)" ], [ "BINARY_SUBSCR", "x.index[i:i + 1].format(sparsify=False)[0]" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.iloc" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "x.iloc[i]" ], [ "LOAD_FAST", "pieces" ], [ "LOOKUP_METHOD", "pieces.append" ], [ "LOAD_FAST", "k" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "v" ], [ "LOAD_FAST", "newlevel" ], [ "CALL_FUNCTION", "cheap_repr(v, newlevel)" ], [ "BINARY_MODULO", "'%s = %s' % (k, cheap_repr(v, newlevel))" ], [ "CALL_METHOD", "pieces.append('%s = %s' % (k, cheap_repr(v, newlevel)))" ], [ "LOAD_FAST", "n" ], [ "LOAD_FAST", "maxparts" ], [ "BINARY_ADD", "maxparts + 2" ], [ "COMPARE_OP", "n > maxparts + 2" ], [ "LOAD_FAST", "pieces" ], [ "LOOKUP_METHOD", "pieces.insert" ], [ "LOAD_FAST", "maxparts" ], [ "BINARY_FLOOR_DIVIDE", "maxparts // 2" ], [ "CALL_METHOD", "pieces.insert(maxparts // 2, '...')" ], [ "LOOKUP_METHOD", "'; '.join" ], [ "LOAD_FAST", "pieces" ], [ "CALL_METHOD", "'; '.join(pieces)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "CALL_FUNCTION", "isinstance(node, ast.expr)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Num" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Str" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "ast" ], [ "CALL_FUNCTION", "getattr(ast, 'NameConstant', ())" ], [ "CALL_FUNCTION", "isinstance(node, (ast.Num, ast.Str, getattr(ast, 'NameConstant', ())))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "getattr(node, 'ctx', None)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Store" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Del" ], [ "CALL_FUNCTION", "isinstance(getattr(node, 'ctx', None),\n (ast.Store, ast.Del))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.UnaryOp" ], [ "CALL_FUNCTION", "isinstance(node, ast.UnaryOp)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.op" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.UAdd" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.USub" ], [ "CALL_FUNCTION", "isinstance(node.op, (ast.UAdd, ast.USub))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.operand" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Num" ], [ "CALL_FUNCTION", "isinstance(node.operand, ast.Num)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.List" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Tuple" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Dict" ], [ "CALL_FUNCTION", "isinstance(node, (ast.List, ast.Tuple, ast.Dict))" ], [ "LOAD_GLOBAL", "any" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.iter_child_nodes" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.iter_child_nodes(node)" ], [ "CALL_FUNCTION", "any(is_interesting_expression(n) for n in ast.iter_child_nodes(node))" ], [ "UNARY_NOT", "not any(is_interesting_expression(n) for n in ast.iter_child_nodes(node))" ], [ "UNARY_NOT", "not (isinstance(node, (ast.Num, ast.Str, getattr(ast, 'NameConstant', ()))) or\n isinstance(getattr(node, 'ctx', None),\n (ast.Store, ast.Del)) or\n (isinstance(node, ast.UnaryOp) and\n isinstance(node.op, (ast.UAdd, ast.USub)) and\n isinstance(node.operand, ast.Num)) or\n (isinstance(node, (ast.List, ast.Tuple, ast.Dict)) and\n not any(is_interesting_expression(n) for n in ast.iter_child_nodes(node))))" ], [ "LOAD_GLOBAL", "is_interesting_expression" ], [ "LOAD_FAST", "n" ], [ "CALL_FUNCTION", "is_interesting_expression(n)" ], [ "LOAD_GLOBAL", "cast" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "__builtins__" ], [ "CALL_FUNCTION", "cast(dict, __builtins__)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Name" ], [ "CALL_FUNCTION", "isinstance(node, ast.Name)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.id" ], [ "LOAD_FAST", "builtins" ], [ "COMPARE_OP", "node.id in builtins" ], [ "LOAD_FAST", "builtins" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.id" ], [ "BINARY_SUBSCR", "builtins[node.id]" ], [ "LOAD_FAST", "value" ], [ "COMPARE_OP", "builtins[node.id] is value" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "ast" ], [ "CALL_FUNCTION", "getattr(ast, 'NameConstant', ())" ], [ "CALL_FUNCTION", "isinstance(node, getattr(ast, 'NameConstant', ()))" ] ], "configuration.py": [ [ "LOAD_NAME", "ctypes" ], [ "LOAD_ATTR", "ctypes.windll" ], [ "LOAD_ATTR", "ctypes.windll.kernel32" ], [ "LOAD_NAME", "kernel32" ], [ "LOOKUP_METHOD", "kernel32.SetConsoleMode" ], [ "LOAD_NAME", "kernel32" ], [ "LOOKUP_METHOD", "kernel32.GetStdHandle" ], [ "CALL_METHOD", "kernel32.GetStdHandle(-11)" ], [ "CALL_METHOD", "kernel32.SetConsoleMode(kernel32.GetStdHandle(-11), 7)" ], [ "LOAD_NAME", "True" ], [ "LOAD_NAME", "Exception" ], [ "LOAD_NAME", "os" ], [ "LOAD_ATTR", "os.name" ], [ "COMPARE_OP", "os.name != 'nt'" ], [ "LOAD_NAME", "True" ], [ "LOAD_NAME", "False" ], [ "LOAD_NAME", "True" ], [ "LOAD_NAME", "DefaultFormatter" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "object" ], [ "LOAD_FAST", "builtins" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_GLOBAL", "builtins_module" ], [ "LOAD_FAST", "snoop" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.snoop" ], [ "CALL_FUNCTION", "setattr(builtins_module, snoop, package.snoop)" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_GLOBAL", "builtins_module" ], [ "LOAD_FAST", "pp" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.pp" ], [ "CALL_FUNCTION", "setattr(builtins_module, pp, package.pp)" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_GLOBAL", "builtins_module" ], [ "LOAD_FAST", "spy" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.spy" ], [ "CALL_FUNCTION", "setattr(builtins_module, spy, package.spy)" ], [ "LOAD_GLOBAL", "Config" ], [ "LOAD_FAST", "out" ], [ "LOAD_FAST", "prefix" ], [ "LOAD_FAST", "columns" ], [ "LOAD_FAST", "overwrite" ], [ "LOAD_FAST", "color" ], [ "LOAD_FAST", "enabled" ], [ "LOAD_FAST", "watch_extras" ], [ "LOAD_FAST", "replace_watch_extras" ], [ "LOAD_FAST", "formatter_class" ], [ "CALL_FUNCTION", "Config(\n out=out,\n prefix=prefix,\n columns=columns,\n overwrite=overwrite,\n color=color,\n enabled=enabled,\n watch_extras=watch_extras,\n replace_watch_extras=replace_watch_extras,\n formatter_class=formatter_class,\n )" ], [ "LOAD_FAST", "config" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.snoop" ], [ "LOAD_FAST", "config" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.pp" ], [ "LOAD_FAST", "config" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.spy" ], [ "LOAD_NAME", "False" ], [ "LOAD_NAME", "True" ], [ "LOAD_NAME", "DefaultFormatter" ], [ "LOAD_GLOBAL", "can_color" ], [ "LOAD_FAST", "color" ], [ "COMPARE_OP", "color is None" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "out" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.stderr" ], [ "CALL_FUNCTION", "getattr(out or sys.stderr, 'isatty', lambda: False)" ], [ "LOAD_GLOBAL", "bool" ], [ "LOAD_FAST", "isatty" ], [ "CALL_FUNCTION", "isatty()" ], [ "CALL_FUNCTION", "bool(isatty())" ], [ "LOAD_GLOBAL", "False" ], [ "LOAD_GLOBAL", "get_write_function" ], [ "LOAD_FAST", "out" ], [ "LOAD_FAST", "overwrite" ], [ "CALL_FUNCTION", "get_write_function(out, overwrite)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "formatter_class" ], [ "LOAD_FAST", "prefix" ], [ "LOAD_FAST", "columns" ], [ "LOAD_FAST", "color" ], [ "CALL_FUNCTION", "formatter_class(prefix, columns, color)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "enabled" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "PP" ], [ "LOAD_DEREF", "self" ], [ "CALL_FUNCTION", "PP(self)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "Tracer" ], [ "LOAD_FAST", "ConfiguredTracer" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "Spy" ], [ "LOAD_DEREF", "self" ], [ "CALL_FUNCTION", "Spy(self)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "threading" ], [ "LOOKUP_METHOD", "threading.local" ], [ "CALL_METHOD", "threading.local()" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "replace_watch_extras" ], [ "COMPARE_OP", "replace_watch_extras is not None" ], [ "LOAD_GLOBAL", "ensure_tuple" ], [ "LOAD_FAST", "replace_watch_extras" ], [ "CALL_FUNCTION", "ensure_tuple(replace_watch_extras)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "len_shape_watch" ], [ "LOAD_GLOBAL", "dtype_watch" ], [ "LOAD_GLOBAL", "ensure_tuple" ], [ "LOAD_FAST", "watch_extras" ], [ "CALL_FUNCTION", "ensure_tuple(watch_extras)" ], [ "BINARY_ADD", "(len_shape_watch, dtype_watch) + ensure_tuple(watch_extras)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "False" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "value" ], [ "LOAD_ATTR", "value.shape" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.ismethod" ], [ "LOAD_FAST", "shape" ], [ "CALL_METHOD", "inspect.ismethod(shape)" ], [ "LOOKUP_METHOD", "'{}.shape'.format" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "'{}.shape'.format(source)" ], [ "LOAD_FAST", "shape" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "value" ], [ "LOAD_GLOBAL", "QuerySet" ], [ "CALL_FUNCTION", "isinstance(value, QuerySet)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "len(value)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "value" ], [ "LOAD_GLOBAL", "six" ], [ "LOAD_ATTR", "six.string_types" ], [ "CALL_FUNCTION", "isinstance(value, six.string_types)" ], [ "LOAD_FAST", "length" ], [ "COMPARE_OP", "length < 50" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "value" ], [ "LOAD_GLOBAL", "Mapping" ], [ "LOAD_GLOBAL", "Set" ], [ "LOAD_GLOBAL", "Sequence" ], [ "CALL_FUNCTION", "isinstance(value, (Mapping, Set, Sequence))" ], [ "LOAD_FAST", "length" ], [ "COMPARE_OP", "length == 0" ], [ "LOOKUP_METHOD", "'len({})'.format" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "'len({})'.format(source)" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "value" ], [ "LOAD_ATTR", "value.dtype" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.ismethod" ], [ "LOAD_FAST", "dtype" ], [ "CALL_METHOD", "inspect.ismethod(dtype)" ], [ "LOOKUP_METHOD", "'{}.dtype'.format" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "'{}.dtype'.format(source)" ], [ "LOAD_FAST", "dtype" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_DEREF", "output" ], [ "LOAD_GLOBAL", "six" ], [ "LOAD_ATTR", "six.string_types" ], [ "CALL_FUNCTION", "isinstance(output, six.string_types)" ], [ "LOAD_GLOBAL", "is_pathlike" ], [ "LOAD_DEREF", "output" ], [ "CALL_FUNCTION", "is_pathlike(output)" ], [ "LOAD_FAST", "is_path" ], [ "LOAD_GLOBAL", "FileWriter" ], [ "LOAD_DEREF", "output" ], [ "LOAD_FAST", "overwrite" ], [ "CALL_FUNCTION", "FileWriter(output, overwrite)" ], [ "LOAD_ATTR", "FileWriter(output, overwrite).write" ], [ "LOAD_GLOBAL", "callable" ], [ "LOAD_DEREF", "output" ], [ "CALL_FUNCTION", "callable(output)" ], [ "LOAD_DEREF", "output" ], [ "LOAD_FAST", "write" ], [ "LOAD_DEREF", "output" ], [ "LOAD_FAST", "stream" ], [ "COMPARE_OP", "stream is None" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.stderr" ], [ "LOAD_FAST", "stream" ], [ "LOOKUP_METHOD", "stream.write" ], [ "LOAD_FAST", "s" ], [ "CALL_METHOD", "stream.write(s)" ], [ "LOAD_GLOBAL", "UnicodeEncodeError" ], [ "LOAD_FAST", "stream" ], [ "LOOKUP_METHOD", "stream.write" ], [ "LOAD_GLOBAL", "shitcode" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "shitcode(s)" ], [ "CALL_METHOD", "stream.write(shitcode(s))" ], [ "LOAD_GLOBAL", "six" ], [ "LOOKUP_METHOD", "six.text_type" ], [ "LOAD_FAST", "path" ], [ "CALL_METHOD", "six.text_type(path)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "overwrite" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "open" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.path" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.overwrite" ], [ "CALL_FUNCTION", "open(self.path, 'w' if self.overwrite else 'a', encoding='utf-8')" ], [ "LOAD_FAST", "f" ], [ "LOOKUP_METHOD", "f.write" ], [ "LOAD_FAST", "s" ], [ "CALL_METHOD", "f.write(s)" ], [ "LOAD_GLOBAL", "False" ], [ "LOAD_FAST", "self" ] ], "db.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOOKUP_METHOD", "standard_library.install_aliases" ], [ "CALL_METHOD", "standard_library.install_aliases()" ], [ "LOAD_NAME", "RESERVED_WORDS" ], [ "LOOKUP_METHOD", "RESERVED_WORDS.add" ], [ "CALL_METHOD", "RESERVED_WORDS.add('function')" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "retry" ], [ "LOAD_NAME", "InterfaceError" ], [ "LOAD_NAME", "OperationalError" ], [ "LOAD_NAME", "InternalError" ], [ "LOAD_NAME", "ProgrammingError" ], [ "CALL_FUNCTION", "retry(3, (InterfaceError, OperationalError, InternalError, ProgrammingError))" ], [ "LOAD_NAME", "False" ], [ "LOAD_NAME", "contextmanager" ], [ "CALL_FUNCTION", "contextmanager" ], [ "LOAD_FAST", "db_uri" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.environ" ], [ "LOOKUP_METHOD", "os.environ.get" ], [ "CALL_METHOD", "os.environ.get('BIRDSEYE_DB')" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOOKUP_METHOD", "os.path.join" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOOKUP_METHOD", "os.path.expanduser" ], [ "CALL_METHOD", "os.path.expanduser('~')" ], [ "CALL_METHOD", "os.path.join(os.path.expanduser('~'),\n '.birdseye.db')" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "False" ], [ "CALL_FUNCTION", "dict(\n pool_recycle=280,\n echo=False, # for convenience when debugging\n )" ], [ "LOAD_GLOBAL", "create_engine" ], [ "LOAD_FAST", "db_uri" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_KW", "create_engine(db_uri, **kwargs)" ], [ "LOAD_GLOBAL", "ArgumentError" ], [ "LOAD_FAST", "db_uri" ], [ "BINARY_ADD", "'sqlite:///' + db_uri" ], [ "LOAD_GLOBAL", "create_engine" ], [ "LOAD_FAST", "db_uri" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_KW", "create_engine(db_uri, **kwargs)" ], [ "LOAD_FAST", "engine" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "sessionmaker" ], [ "LOAD_FAST", "engine" ], [ "CALL_FUNCTION", "sessionmaker(bind=engine)" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "object" ], [ "LOAD_GLOBAL", "declarative_base" ], [ "LOAD_FAST", "Base" ], [ "CALL_FUNCTION", "declarative_base(cls=Base)" ], [ "LOAD_FAST", "Base" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "object" ], [ "LOAD_FAST", "engine" ], [ "LOAD_ATTR", "engine.name" ], [ "COMPARE_OP", "engine.name == 'mysql'" ], [ "LOAD_GLOBAL", "LONGTEXT" ], [ "LOAD_GLOBAL", "Text" ], [ "LOAD_FAST", "Base" ], [ "LOAD_FAST", "Base" ], [ "LOAD_FAST", "Call" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "Function" ], [ "LOAD_FAST", "self" ], [ "LOAD_DEREF", "KeyValue" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "KeyValueStore" ], [ "CALL_FUNCTION", "KeyValueStore()" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "_skip_version_check" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.table_exists" ], [ "LOAD_FAST", "Function" ], [ "CALL_METHOD", "self.table_exists(Function)" ], [ "LOAD_FAST", "Base" ], [ "LOAD_ATTR", "Base.metadata" ], [ "LOOKUP_METHOD", "Base.metadata.create_all" ], [ "LOAD_FAST", "engine" ], [ "CALL_METHOD", "Base.metadata.create_all(engine)" ], [ "LOAD_GLOBAL", "DB_VERSION" ], [ "LOAD_FAST", "kv" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.table_exists" ], [ "LOAD_DEREF", "KeyValue" ], [ "CALL_METHOD", "self.table_exists(KeyValue)" ], [ "LOAD_GLOBAL", "int" ], [ "LOAD_FAST", "kv" ], [ "LOAD_ATTR", "kv.version" ], [ "CALL_FUNCTION", "int(kv.version)" ], [ "LOAD_GLOBAL", "DB_VERSION" ], [ "COMPARE_OP", "int(kv.version) < DB_VERSION" ], [ "LOAD_GLOBAL", "sys" ], [ "LOOKUP_METHOD", "sys.exit" ], [ "CALL_METHOD", "sys.exit('The birdseye database schema is out of date. '\n 'Run \"python -m birdseye.clear_db\" to delete the existing tables.')" ], [ "LOAD_NAME", "declared_attr" ], [ "CALL_FUNCTION", "declared_attr" ], [ "LOAD_FAST", "cls" ], [ "LOAD_ATTR", "cls.__name__" ], [ "LOOKUP_METHOD", "cls.__name__.lower" ], [ "CALL_METHOD", "cls.__name__.lower()" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "String" ], [ "CALL_FUNCTION", "String(50)" ], [ "LOAD_NAME", "True" ], [ "CALL_FUNCTION", "Column(String(50), primary_key=True)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "__getitem__" ], [ "LOAD_NAME", "__setitem__" ], [ "LOAD_DEREF", "db_self" ], [ "LOOKUP_METHOD", "db_self.session_scope" ], [ "CALL_METHOD", "db_self.session_scope()" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session\n .query" ], [ "LOAD_DEREF", "KeyValue" ], [ "LOAD_ATTR", "KeyValue.value" ], [ "CALL_METHOD", "session\n .query(KeyValue.value)" ], [ "LOOKUP_METHOD", "session\n .query(KeyValue.value)\n .filter_by" ], [ "LOAD_FAST", "item" ], [ "CALL_METHOD", "session\n .query(KeyValue.value)\n .filter_by(key=item)" ], [ "LOOKUP_METHOD", "session\n .query(KeyValue.value)\n .filter_by(key=item)\n .scalar" ], [ "CALL_METHOD", "session\n .query(KeyValue.value)\n .filter_by(key=item)\n .scalar()" ], [ "LOAD_DEREF", "db_self" ], [ "LOOKUP_METHOD", "db_self.session_scope" ], [ "CALL_METHOD", "db_self.session_scope()" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.query" ], [ "LOAD_DEREF", "KeyValue" ], [ "CALL_METHOD", "session.query(KeyValue)" ], [ "LOOKUP_METHOD", "session.query(KeyValue).filter_by" ], [ "LOAD_FAST", "key" ], [ "CALL_METHOD", "session.query(KeyValue).filter_by(key=key)" ], [ "LOOKUP_METHOD", "session.query(KeyValue).filter_by(key=key).delete" ], [ "CALL_METHOD", "session.query(KeyValue).filter_by(key=key).delete()" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.add" ], [ "LOAD_DEREF", "KeyValue" ], [ "LOAD_FAST", "key" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "str(value)" ], [ "CALL_FUNCTION", "KeyValue(key=key, value=str(value))" ], [ "CALL_METHOD", "session.add(KeyValue(key=key, value=str(value)))" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "String" ], [ "CALL_FUNCTION", "String(length=32)" ], [ "LOAD_NAME", "True" ], [ "CALL_FUNCTION", "Column(String(length=32), primary_key=True)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Integer" ], [ "LOAD_NAME", "ForeignKey" ], [ "CALL_FUNCTION", "ForeignKey('function.id')" ], [ "LOAD_NAME", "True" ], [ "CALL_FUNCTION", "Column(Integer, ForeignKey('function.id'), index=True)" ], [ "LOAD_NAME", "relationship" ], [ "LOAD_NAME", "backref" ], [ "CALL_FUNCTION", "backref('calls', lazy='dynamic')" ], [ "CALL_FUNCTION", "relationship('Function', backref=backref('calls', lazy='dynamic'))" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_DEREF", "LongText" ], [ "CALL_FUNCTION", "Column(LongText)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "DateTime" ], [ "LOAD_NAME", "True" ], [ "CALL_FUNCTION", "Column(DateTime, index=True)" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "id" ], [ "LOAD_NAME", "function_id" ], [ "LOAD_NAME", "return_value" ], [ "LOAD_NAME", "traceback" ], [ "LOAD_NAME", "exception" ], [ "LOAD_NAME", "start_time" ], [ "LOAD_NAME", "arguments" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._pretty_time" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start_time" ], [ "CALL_METHOD", "self._pretty_time(self.start_time)" ], [ "LOAD_FAST", "dt" ], [ "LOAD_GLOBAL", "Markup" ], [ "LOAD_FAST", "dt" ], [ "LOOKUP_METHOD", "dt.strftime" ], [ "CALL_METHOD", "dt.strftime('%Y-%m-%d %H:%M:%S')" ], [ "LOAD_GLOBAL", "naturaltime" ], [ "LOAD_FAST", "dt" ], [ "CALL_FUNCTION", "naturaltime(dt)" ], [ "BINARY_MODULO", "'%s (%s)' % (\n dt.strftime('%Y-%m-%d %H:%M:%S'),\n naturaltime(dt))" ], [ "CALL_FUNCTION", "Markup('%s (%s)' % (\n dt.strftime('%Y-%m-%d %H:%M:%S'),\n naturaltime(dt)))" ], [ "LOAD_GLOBAL", "Markup" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.success" ], [ "BINARY_MODULO", "'' % (\n ('ok', 'green') if self.success else\n ('remove', 'red'))" ], [ "CALL_FUNCTION", "Markup('' % (\n ('ok', 'green') if self.success else\n ('remove', 'red')))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.exception" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.traceback" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.return_value" ], [ "COMPARE_OP", "self.return_value == 'None'" ], [ "LOAD_GLOBAL", "False" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.traceback" ], [ "LOAD_GLOBAL", "True" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.success" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.return_value" ], [ "CALL_FUNCTION", "str(self.return_value)" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.exception" ], [ "CALL_FUNCTION", "str(self.exception)" ], [ "LOAD_GLOBAL", "json" ], [ "LOOKUP_METHOD", "json.loads" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.arguments" ], [ "CALL_METHOD", "json.loads(self.arguments)" ], [ "LOAD_GLOBAL", "json" ], [ "LOOKUP_METHOD", "json.loads" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.data" ], [ "CALL_METHOD", "json.loads(self.data)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.arguments_list" ], [ "LOAD_GLOBAL", "select_attrs" ], [ "LOAD_FAST", "call" ], [ "CALL_FUNCTION", "select_attrs(call, 'id function_id return_value traceback '\n 'exception start_time')" ], [ "CALL_FUNCTION_KW", "dict(arguments=call.arguments_list,\n **select_attrs(call, 'id function_id return_value traceback '\n 'exception start_time'))" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Integer" ], [ "LOAD_NAME", "Sequence" ], [ "CALL_FUNCTION", "Sequence('function_id_seq')" ], [ "LOAD_NAME", "True" ], [ "CALL_FUNCTION", "Column(Integer, Sequence('function_id_seq'), primary_key=True)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_DEREF", "LongText" ], [ "CALL_FUNCTION", "Column(LongText)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Integer" ], [ "CALL_FUNCTION", "Column(Integer)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_DEREF", "LongText" ], [ "CALL_FUNCTION", "Column(LongText)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "String" ], [ "CALL_FUNCTION", "String(length=64)" ], [ "LOAD_NAME", "True" ], [ "CALL_FUNCTION", "Column(String(length=64), index=True)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "String" ], [ "CALL_FUNCTION", "String(length=64)" ], [ "LOAD_NAME", "True" ], [ "CALL_FUNCTION", "Column(String(length=64), index=True)" ], [ "LOAD_NAME", "UniqueConstraint" ], [ "CALL_FUNCTION", "UniqueConstraint('hash',\n name='everything_unique')" ], [ "LOAD_NAME", "Index" ], [ "CALL_FUNCTION", "Index('idx_file', 'file', mysql_length=256)" ], [ "LOAD_NAME", "Index" ], [ "CALL_FUNCTION", "Index('idx_name', 'name', mysql_length=32)" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "file" ], [ "LOAD_NAME", "name" ], [ "LOAD_NAME", "lineno" ], [ "LOAD_NAME", "hash" ], [ "LOAD_NAME", "body_hash" ], [ "LOAD_NAME", "type" ], [ "LOAD_GLOBAL", "json" ], [ "LOOKUP_METHOD", "json.loads" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.data" ], [ "CALL_METHOD", "json.loads(self.data)" ], [ "LOAD_GLOBAL", "select_attrs" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "select_attrs(func, 'file name lineno hash body_hash type')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.engine" ], [ "LOAD_ATTR", "self.engine.dialect" ], [ "LOOKUP_METHOD", "self.engine.dialect.has_table" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.engine" ], [ "LOAD_FAST", "table" ], [ "LOAD_ATTR", "table.__name__" ], [ "CALL_METHOD", "self.engine.dialect.has_table(self.engine, table.__name__)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.session_scope" ], [ "CALL_METHOD", "self.session_scope()" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.query" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.Function" ], [ "LOAD_ATTR", "self.Function.file" ], [ "CALL_METHOD", "session.query(self.Function.file)" ], [ "LOOKUP_METHOD", "session.query(self.Function.file).distinct" ], [ "CALL_METHOD", "session.query(self.Function.file).distinct()" ], [ "LOAD_GLOBAL", "is_ipython_cell" ], [ "LOAD_FAST", "f" ], [ "BINARY_SUBSCR", "f[0]" ], [ "CALL_FUNCTION", "is_ipython_cell(f[0])" ], [ "LOAD_FAST", "f" ], [ "BINARY_SUBSCR", "f[0]" ], [ "LOAD_FAST", "paths" ], [ "LOOKUP_METHOD", "paths.sort" ], [ "CALL_METHOD", "paths.sort()" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "paths" ], [ "COMPARE_OP", "IPYTHON_FILE_PATH in paths" ], [ "LOAD_FAST", "paths" ], [ "LOOKUP_METHOD", "paths.remove" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "CALL_METHOD", "paths.remove(IPYTHON_FILE_PATH)" ], [ "LOAD_FAST", "paths" ], [ "LOOKUP_METHOD", "paths.insert" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "CALL_METHOD", "paths.insert(0, IPYTHON_FILE_PATH)" ], [ "LOAD_FAST", "paths" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.Call" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.Function" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._KeyValue" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.table_exists" ], [ "LOAD_FAST", "model" ], [ "CALL_METHOD", "self.table_exists(model)" ], [ "LOAD_FAST", "model" ], [ "LOAD_ATTR", "model.__table__" ], [ "LOOKUP_METHOD", "model.__table__.drop" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.engine" ], [ "CALL_METHOD", "model.__table__.drop(self.engine)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.Session" ], [ "CALL_METHOD", "self.Session()" ], [ "LOAD_FAST", "session" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.commit" ], [ "CALL_METHOD", "session.commit()" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.rollback" ], [ "CALL_METHOD", "session.rollback()" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.close" ], [ "CALL_METHOD", "session.close()" ], [ "LOAD_GLOBAL", "functools" ], [ "LOOKUP_METHOD", "functools.wraps" ], [ "LOAD_DEREF", "func" ], [ "CALL_METHOD", "functools.wraps(func)" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "LOAD_GLOBAL", "retry_db" ], [ "LOAD_FAST", "wrapper" ], [ "CALL_FUNCTION", "retry_db(wrapper)" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self.session_scope" ], [ "CALL_METHOD", "self.session_scope()" ], [ "LOAD_DEREF", "func" ], [ "LOAD_FAST", "session" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "func(session, *args, **kwargs)" ] ], "executing.py": [ [ "LOAD_NAME", "sys" ], [ "LOAD_ATTR", "sys.version_info" ], [ "BINARY_SUBSCR", "sys.version_info[0]" ], [ "COMPARE_OP", "sys.version_info[0] == 3" ], [ "LOAD_NAME", "PY3" ], [ "LOAD_NAME", "lru_cache" ], [ "CALL_FUNCTION", "lru_cache(maxsize=None)" ], [ "LOAD_NAME", "str" ], [ "LOAD_NAME", "unicode" ], [ "LOAD_NAME", "dis" ], [ "LOAD_ATTR", "dis.get_instructions" ], [ "LOAD_NAME", "AttributeError" ], [ "LOAD_NAME", "namedtuple" ], [ "CALL_FUNCTION", "namedtuple('Instruction', 'offset argval opname')" ], [ "LOAD_NAME", "Exception" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.NodeVisitor" ], [ "LOAD_NAME", "sum" ], [ "LOAD_NAME", "__future__" ], [ "LOAD_ATTR", "__future__.all_feature_names" ], [ "CALL_FUNCTION", "sum(\n getattr(__future__, fname).compiler_flag\n for fname in __future__.all_feature_names\n)" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "RLock" ], [ "CALL_FUNCTION", "RLock()" ], [ "LOAD_NAME", "cache" ], [ "CALL_FUNCTION", "cache" ], [ "LOAD_GLOBAL", "functools" ], [ "LOOKUP_METHOD", "functools.wraps" ], [ "LOAD_DEREF", "func" ], [ "CALL_METHOD", "functools.wraps(func)" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "LOAD_FAST", "wrapper" ], [ "LOAD_FAST", "args" ], [ "LOAD_DEREF", "d" ], [ "COMPARE_OP", "args in d" ], [ "LOAD_DEREF", "d" ], [ "LOAD_FAST", "args" ], [ "BINARY_SUBSCR", "d[args]" ], [ "LOAD_DEREF", "func" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION_VAR", "func(*args)" ], [ "LOAD_DEREF", "d" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "co" ], [ "LOAD_ATTR", "co.co_code" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "len(code)" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "i < n" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "code[i]" ], [ "LOAD_GLOBAL", "ord" ], [ "LOAD_FAST", "c" ], [ "CALL_FUNCTION", "ord(c)" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "LOAD_FAST", "op" ], [ "LOAD_GLOBAL", "HAVE_ARGUMENT" ], [ "COMPARE_OP", "op >= HAVE_ARGUMENT" ], [ "LOAD_GLOBAL", "ord" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "code[i]" ], [ "CALL_FUNCTION", "ord(code[i])" ], [ "LOAD_GLOBAL", "ord" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "code[i + 1]" ], [ "CALL_FUNCTION", "ord(code[i + 1])" ], [ "BINARY_MULTIPLY", "ord(code[i + 1]) * 256" ], [ "BINARY_ADD", "ord(code[i]) + ord(code[i + 1]) * 256" ], [ "LOAD_FAST", "extended_arg" ], [ "BINARY_ADD", "ord(code[i]) + ord(code[i + 1]) * 256 + extended_arg" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 2" ], [ "LOAD_FAST", "op" ], [ "LOAD_GLOBAL", "EXTENDED_ARG" ], [ "COMPARE_OP", "op == EXTENDED_ARG" ], [ "LOAD_FAST", "oparg" ], [ "BINARY_MULTIPLY", "oparg * 65536" ], [ "LOAD_FAST", "op" ], [ "LOAD_GLOBAL", "hasconst" ], [ "COMPARE_OP", "op in hasconst" ], [ "LOAD_FAST", "co" ], [ "LOAD_ATTR", "co.co_consts" ], [ "LOAD_FAST", "oparg" ], [ "BINARY_SUBSCR", "co.co_consts[oparg]" ], [ "LOAD_GLOBAL", "Instruction" ], [ "LOAD_FAST", "offset" ], [ "LOAD_FAST", "argval" ], [ "LOAD_GLOBAL", "opname" ], [ "LOAD_FAST", "op" ], [ "BINARY_SUBSCR", "opname[op]" ], [ "CALL_FUNCTION", "Instruction(offset, argval, opname[op])" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "it" ], [ "LOAD_GLOBAL", "Sized" ], [ "CALL_FUNCTION", "isinstance(it, Sized)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "len(it)" ], [ "COMPARE_OP", "len(it) != 1" ], [ "LOAD_GLOBAL", "NotOneValueFound" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "len(it)" ], [ "BINARY_MODULO", "'Expected one value, found %s' % len(it)" ], [ "CALL_FUNCTION", "NotOneValueFound('Expected one value, found %s' % len(it))" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "list(it)" ], [ "BINARY_SUBSCR", "list(it)[0]" ], [ "LOAD_GLOBAL", "tuple" ], [ "LOAD_GLOBAL", "islice" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "islice(it, 2)" ], [ "CALL_FUNCTION", "tuple(islice(it, 2))" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "lst" ], [ "CALL_FUNCTION", "len(lst)" ], [ "COMPARE_OP", "len(lst) == 0" ], [ "LOAD_GLOBAL", "NotOneValueFound" ], [ "CALL_FUNCTION", "NotOneValueFound('Expected one value, found 0')" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "lst" ], [ "CALL_FUNCTION", "len(lst)" ], [ "COMPARE_OP", "len(lst) > 1" ], [ "LOAD_GLOBAL", "NotOneValueFound" ], [ "CALL_FUNCTION", "NotOneValueFound('Expected one value, found several')" ], [ "LOAD_FAST", "lst" ], [ "BINARY_SUBSCR", "lst[0]" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "cache" ], [ "CALL_FUNCTION", "cache" ], [ "LOAD_NAME", "cache" ], [ "CALL_FUNCTION", "cache" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "text" ], [ "LOAD_GLOBAL", "text_type" ], [ "CALL_FUNCTION", "isinstance(text, text_type)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.decode_source" ], [ "LOAD_FAST", "text" ], [ "CALL_METHOD", "self.decode_source(text)" ], [ "LOAD_FAST", "text" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_FAST", "text" ], [ "LOOKUP_METHOD", "''.join" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "text" ], [ "LOOKUP_METHOD", "text.splitlines" ], [ "LOAD_GLOBAL", "True" ], [ "CALL_METHOD", "text.splitlines(True)" ], [ "CALL_FUNCTION", "enumerate(text.splitlines(True))" ], [ "LOAD_FAST", "i" ], [ "COMPARE_OP", "i < 2" ], [ "LOAD_GLOBAL", "encoding_pattern" ], [ "LOOKUP_METHOD", "encoding_pattern.match" ], [ "LOAD_FAST", "line" ], [ "CALL_METHOD", "encoding_pattern.match(line)" ], [ "LOAD_FAST", "line" ], [ "CALL_METHOD", "''.join([\n '\\n' if i < 2 and encoding_pattern.match(line)\n else line\n for i, line in enumerate(text.splitlines(True))\n ])" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "defaultdict(list)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "text" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.parse" ], [ "LOAD_FAST", "ast_text" ], [ "LOAD_FAST", "filename" ], [ "CALL_METHOD", "ast.parse(ast_text, filename=filename)" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "SyntaxError" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.walk" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tree" ], [ "CALL_METHOD", "ast.walk(self.tree)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.iter_child_nodes" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.iter_child_nodes(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "hasattr(node, 'lineno')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._nodes_by_line" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.lineno" ], [ "BINARY_SUBSCR", "self._nodes_by_line[node.lineno]" ], [ "LOOKUP_METHOD", "self._nodes_by_line[node.lineno].append" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self._nodes_by_line[node.lineno].append(node)" ], [ "LOAD_GLOBAL", "QualnameVisitor" ], [ "CALL_FUNCTION", "QualnameVisitor()" ], [ "LOAD_FAST", "visitor" ], [ "LOOKUP_METHOD", "visitor.visit" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tree" ], [ "CALL_METHOD", "visitor.visit(self.tree)" ], [ "LOAD_FAST", "visitor" ], [ "LOAD_ATTR", "visitor.qualnames" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "cls" ], [ "LOOKUP_METHOD", "cls.for_filename" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_filename" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "CALL_METHOD", "cls.for_filename(frame.f_code.co_filename, frame.f_globals or {})" ], [ "LOAD_FAST", "cls" ], [ "LOOKUP_METHOD", "cls._class_local" ], [ "CALL_METHOD", "cls._class_local('__source_cache', {})" ], [ "LOAD_FAST", "source_cache" ], [ "LOAD_FAST", "filename" ], [ "BINARY_SUBSCR", "source_cache[filename]" ], [ "LOAD_GLOBAL", "KeyError" ], [ "LOAD_GLOBAL", "linecache" ], [ "LOOKUP_METHOD", "linecache.getlines" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "module_globals" ], [ "CALL_METHOD", "linecache.getlines(filename, module_globals)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_FAST", "filename" ], [ "LOOKUP_METHOD", "''.join" ], [ "LOAD_FAST", "lines" ], [ "CALL_METHOD", "''.join(lines)" ], [ "CALL_FUNCTION", "cls(filename, ''.join(lines))" ], [ "LOAD_FAST", "source_cache" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_GLOBAL", "linecache" ], [ "CALL_FUNCTION", "hasattr(linecache, 'lazycache')" ], [ "LOAD_GLOBAL", "linecache" ], [ "LOOKUP_METHOD", "linecache.lazycache" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_filename" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "CALL_METHOD", "linecache.lazycache(frame.f_code.co_filename, frame.f_globals)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lasti" ], [ "LOAD_FAST", "cls" ], [ "LOOKUP_METHOD", "cls._class_local" ], [ "CALL_METHOD", "cls._class_local('__executing_cache', {})" ], [ "LOAD_FAST", "executing_cache" ], [ "LOAD_FAST", "key" ], [ "BINARY_SUBSCR", "executing_cache[key]" ], [ "LOAD_GLOBAL", "KeyError" ], [ "LOAD_FAST", "cls" ], [ "LOOKUP_METHOD", "cls.for_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "cls.for_frame(frame)" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.tree" ], [ "LOAD_FAST", "source" ], [ "LOOKUP_METHOD", "source.statements_at_line" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lineno" ], [ "CALL_METHOD", "source.statements_at_line(frame.f_lineno)" ], [ "LOAD_GLOBAL", "NodeFinder" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "stmts" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.tree" ], [ "CALL_FUNCTION", "NodeFinder(frame, stmts, source.tree)" ], [ "LOAD_ATTR", "NodeFinder(frame, stmts, source.tree).result" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_GLOBAL", "statement_containing_node" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "statement_containing_node(node)" ], [ "LOAD_FAST", "new_stmts" ], [ "LOAD_FAST", "stmts" ], [ "COMPARE_OP", "new_stmts <= stmts" ], [ "LOAD_FAST", "new_stmts" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "stmts" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "executing_cache" ], [ "LOAD_FAST", "key" ], [ "LOAD_GLOBAL", "Executing" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION_VAR", "Executing(frame, *args)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_ATTR", "cls.__dict__" ], [ "LOOKUP_METHOD", "cls.__dict__.get" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "default" ], [ "CALL_METHOD", "cls.__dict__.get(name, default)" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_FAST", "cls" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "setattr(cls, name, result)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._nodes_by_line" ], [ "LOAD_FAST", "lineno" ], [ "BINARY_SUBSCR", "self._nodes_by_line[lineno]" ], [ "LOAD_GLOBAL", "statement_containing_node" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "statement_containing_node(node)" ], [ "LOAD_FAST", "ASTTokens" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.text" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tree" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.filename" ], [ "CALL_FUNCTION", "ASTTokens(\n self.text,\n tree=self.tree,\n filename=self.filename,\n )" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "source" ], [ "LOAD_GLOBAL", "bytes" ], [ "CALL_FUNCTION", "isinstance(source, bytes)" ], [ "LOAD_GLOBAL", "detect_encoding" ], [ "LOAD_GLOBAL", "io" ], [ "LOOKUP_METHOD", "io.BytesIO" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "io.BytesIO(source)" ], [ "LOAD_ATTR", "io.BytesIO(source).readline" ], [ "CALL_FUNCTION", "detect_encoding(io.BytesIO(source).readline)" ], [ "LOAD_FAST", "source" ], [ "LOOKUP_METHOD", "source.decode" ], [ "LOAD_FAST", "encoding" ], [ "CALL_METHOD", "source.decode(encoding)" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_filename" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.filename" ], [ "COMPARE_OP", "code.co_filename == self.filename" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._qualnames" ], [ "LOOKUP_METHOD", "self._qualnames.get" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_firstlineno" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "CALL_METHOD", "self._qualnames.get((code.co_name, code.co_firstlineno), code.co_name)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "stmts" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.source" ], [ "LOOKUP_METHOD", "self.source.code_qualname" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_code" ], [ "CALL_METHOD", "self.source.code_qualname(self.frame.f_code)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.source" ], [ "LOOKUP_METHOD", "self.source.asttokens" ], [ "CALL_METHOD", "self.source.asttokens()" ], [ "LOOKUP_METHOD", "self.source.asttokens().get_text" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.node" ], [ "CALL_METHOD", "self.source.asttokens().get_text(self.node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.source" ], [ "LOOKUP_METHOD", "self.source.asttokens" ], [ "CALL_METHOD", "self.source.asttokens()" ], [ "LOOKUP_METHOD", "self.source.asttokens().get_text_range" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.node" ], [ "CALL_METHOD", "self.source.asttokens().get_text_range(self.node)" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "QualnameVisitor" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(QualnameVisitor, self)" ], [ "LOOKUP_METHOD", "super(QualnameVisitor, self).__init__" ], [ "CALL_METHOD", "super(QualnameVisitor, self).__init__()" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.name" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOOKUP_METHOD", "self.stack.append" ], [ "LOAD_FAST", "name" ], [ "CALL_METHOD", "self.stack.append(name)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.qualnames" ], [ "LOOKUP_METHOD", "self.qualnames.setdefault" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.lineno" ], [ "LOOKUP_METHOD", "\".\".join" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "CALL_METHOD", "\".\".join(self.stack)" ], [ "CALL_METHOD", "self.qualnames.setdefault((name, node.lineno), \".\".join(self.stack))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOOKUP_METHOD", "self.stack.append" ], [ "CALL_METHOD", "self.stack.append('')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Lambda" ], [ "CALL_FUNCTION", "isinstance(node, ast.Lambda)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.body" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.body" ], [ "LOAD_FAST", "children" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.visit" ], [ "LOAD_FAST", "child" ], [ "CALL_METHOD", "self.visit(child)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOOKUP_METHOD", "self.stack.pop" ], [ "CALL_METHOD", "self.stack.pop()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOOKUP_METHOD", "self.stack.pop" ], [ "CALL_METHOD", "self.stack.pop()" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.iter_fields" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.iter_fields(node)" ], [ "LOAD_FAST", "field" ], [ "COMPARE_OP", "field == 'body'" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.AST" ], [ "CALL_FUNCTION", "isinstance(child, ast.AST)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.visit" ], [ "LOAD_FAST", "child" ], [ "CALL_METHOD", "self.visit(child)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "isinstance(child, list)" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "grandchild" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.AST" ], [ "CALL_FUNCTION", "isinstance(grandchild, ast.AST)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.visit" ], [ "LOAD_FAST", "grandchild" ], [ "CALL_METHOD", "self.visit(grandchild)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.visit_FunctionDef" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self.visit_FunctionDef(node, '')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOOKUP_METHOD", "self.stack.append" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.name" ], [ "CALL_METHOD", "self.stack.append(node.name)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.generic_visit" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self.generic_visit(node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOOKUP_METHOD", "self.stack.pop" ], [ "CALL_METHOD", "self.stack.pop()" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "__future__" ], [ "LOAD_FAST", "fname" ], [ "CALL_FUNCTION", "getattr(__future__, fname)" ], [ "LOAD_ATTR", "getattr(__future__, fname).compiler_flag" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "matching_code" ], [ "LOAD_ATTR", "matching_code.co_filename" ], [ "LOAD_GLOBAL", "future_flags" ], [ "LOAD_FAST", "matching_code" ], [ "LOAD_ATTR", "matching_code.co_flags" ], [ "BINARY_AND", "future_flags & matching_code.co_flags" ], [ "LOAD_GLOBAL", "True" ], [ "CALL_FUNCTION", "compile(\n source,\n matching_code.co_filename,\n 'exec',\n flags=future_flags & matching_code.co_flags,\n dont_inherit=True,\n )" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "tree" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_code" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lasti" ], [ "BINARY_SUBSCR", "frame.f_code.co_code[frame.f_lasti]" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_GLOBAL", "ord" ], [ "LOAD_FAST", "b" ], [ "CALL_FUNCTION", "ord(b)" ], [ "LOAD_GLOBAL", "dis" ], [ "LOAD_ATTR", "dis.opname" ], [ "LOAD_FAST", "b" ], [ "BINARY_SUBSCR", "dis.opname[b]" ], [ "LOAD_FAST", "op_name" ], [ "LOOKUP_METHOD", "op_name.startswith" ], [ "CALL_METHOD", "op_name.startswith('CALL_')" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Call" ], [ "LOAD_FAST", "op_name" ], [ "COMPARE_OP", "op_name == 'BINARY_SUBSCR'" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Subscript" ], [ "LOAD_FAST", "op_name" ], [ "LOOKUP_METHOD", "op_name.startswith" ], [ "CALL_METHOD", "op_name.startswith('BINARY_')" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.BinOp" ], [ "LOAD_FAST", "op_name" ], [ "LOOKUP_METHOD", "op_name.startswith" ], [ "CALL_METHOD", "op_name.startswith('UNARY_')" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.UnaryOp" ], [ "LOAD_FAST", "op_name" ], [ "COMPARE_OP", "op_name in ('LOAD_ATTR', 'LOAD_METHOD', 'LOOKUP_METHOD')" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Attribute" ], [ "LOAD_FAST", "op_name" ], [ "COMPARE_OP", "op_name == 'COMPARE_OP'" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Compare" ], [ "LOAD_GLOBAL", "RuntimeError" ], [ "LOAD_FAST", "op_name" ], [ "CALL_FUNCTION", "RuntimeError(op_name)" ], [ "LOAD_GLOBAL", "lock" ], [ "LOAD_FAST", "stmts" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.matching_nodes" ], [ "LOAD_FAST", "exprs" ], [ "CALL_METHOD", "self.matching_nodes(exprs)" ], [ "CALL_FUNCTION", "list(self.matching_nodes(exprs))" ], [ "CALL_FUNCTION", "only(list(self.matching_nodes(exprs)))" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.walk" ], [ "LOAD_FAST", "stmt" ], [ "CALL_METHOD", "ast.walk(stmt)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "typ" ], [ "CALL_FUNCTION", "isinstance(node, typ)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "hasattr(node, \"ctx\")" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.ctx" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Load" ], [ "CALL_FUNCTION", "isinstance(node.ctx, ast.Load)" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "exprs" ], [ "CALL_FUNCTION", "enumerate(exprs)" ], [ "LOAD_GLOBAL", "get_setter" ], [ "LOAD_FAST", "expr" ], [ "CALL_FUNCTION", "get_setter(expr)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.BinOp" ], [ "LOAD_FAST", "expr" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.Pow" ], [ "CALL_METHOD", "ast.Pow()" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.Str" ], [ "LOAD_GLOBAL", "sentinel" ], [ "CALL_METHOD", "ast.Str(s=sentinel)" ], [ "CALL_METHOD", "ast.BinOp(\n left=expr,\n op=ast.Pow(),\n right=ast.Str(s=sentinel),\n )" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.fix_missing_locations" ], [ "LOAD_FAST", "replacement" ], [ "CALL_METHOD", "ast.fix_missing_locations(replacement)" ], [ "LOAD_FAST", "setter" ], [ "LOAD_FAST", "replacement" ], [ "CALL_FUNCTION", "setter(replacement)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.compile_instructions" ], [ "CALL_METHOD", "self.compile_instructions()" ], [ "LOAD_GLOBAL", "SyntaxError" ], [ "LOAD_FAST", "setter" ], [ "LOAD_FAST", "expr" ], [ "CALL_FUNCTION", "setter(expr)" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "instructions" ], [ "CALL_FUNCTION", "enumerate(instructions)" ], [ "LOAD_FAST", "instruction" ], [ "LOAD_ATTR", "instruction.argval" ], [ "LOAD_GLOBAL", "sentinel" ], [ "COMPARE_OP", "instruction.argval == sentinel" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "indices" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_FAST", "indices" ], [ "CALL_FUNCTION", "only(indices)" ], [ "BINARY_SUBTRACT", "only(indices) - 1" ], [ "LOAD_FAST", "instructions" ], [ "LOAD_FAST", "arg_index" ], [ "BINARY_SUBSCR", "instructions[arg_index]" ], [ "LOAD_ATTR", "instructions[arg_index].opname" ], [ "COMPARE_OP", "instructions[arg_index].opname == 'EXTENDED_ARG'" ], [ "LOAD_FAST", "instructions" ], [ "LOAD_FAST", "arg_index" ], [ "BINARY_SUBSCR", "instructions[arg_index]" ], [ "LOAD_ATTR", "instructions[arg_index].offset" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_lasti" ], [ "COMPARE_OP", "instructions[arg_index].offset == self.frame.f_lasti" ], [ "LOAD_FAST", "expr" ], [ "LOAD_GLOBAL", "compile_similar_to" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tree" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_code" ], [ "CALL_FUNCTION", "compile_similar_to(self.tree, self.frame.f_code)" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_GLOBAL", "find_codes" ], [ "LOAD_FAST", "module_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_code" ], [ "CALL_FUNCTION", "find_codes(module_code, self.frame.f_code)" ], [ "CALL_FUNCTION", "only(find_codes(module_code, self.frame.f_code))" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "get_instructions" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "get_instructions(code)" ], [ "CALL_FUNCTION", "list(get_instructions(code))" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.iter_fields" ], [ "LOAD_DEREF", "parent" ], [ "CALL_METHOD", "ast.iter_fields(parent)" ], [ "LOAD_DEREF", "field" ], [ "LOAD_FAST", "node" ], [ "COMPARE_OP", "field is node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_DEREF", "field" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "isinstance(field, list)" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_DEREF", "field" ], [ "CALL_FUNCTION", "enumerate(field)" ], [ "LOAD_FAST", "item" ], [ "LOAD_FAST", "node" ], [ "COMPARE_OP", "item is node" ], [ "LOAD_FAST", "setter" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_DEREF", "parent" ], [ "LOAD_DEREF", "name" ], [ "LOAD_FAST", "new_node" ], [ "CALL_FUNCTION", "setattr(parent, name, new_node)" ], [ "LOAD_FAST", "new_node" ], [ "LOAD_DEREF", "field" ], [ "LOAD_DEREF", "i" ], [ "LOAD_DEREF", "matches" ], [ "LOAD_FAST", "root_code" ], [ "CALL_FUNCTION", "matches(root_code)" ], [ "LOAD_DEREF", "code_options" ], [ "LOOKUP_METHOD", "code_options.append" ], [ "LOAD_FAST", "root_code" ], [ "CALL_METHOD", "code_options.append(root_code)" ], [ "LOAD_DEREF", "finder" ], [ "LOAD_FAST", "root_code" ], [ "CALL_FUNCTION", "finder(root_code)" ], [ "LOAD_DEREF", "code_options" ], [ "LOAD_GLOBAL", "all" ], [ "LOAD_GLOBAL", "attrgetter" ], [ "CALL_FUNCTION", "attrgetter('co_firstlineno')" ], [ "LOAD_GLOBAL", "attrgetter" ], [ "CALL_FUNCTION", "attrgetter('co_name')" ], [ "LOAD_GLOBAL", "code_names" ], [ "CALL_FUNCTION", "all(\n f(c) == f(matching)\n for f in [\n attrgetter('co_firstlineno'),\n attrgetter('co_name'),\n code_names,\n ]\n )" ], [ "LOAD_FAST", "f" ], [ "LOAD_DEREF", "c" ], [ "CALL_FUNCTION", "f(c)" ], [ "LOAD_FAST", "f" ], [ "LOAD_DEREF", "matching" ], [ "CALL_FUNCTION", "f(matching)" ], [ "COMPARE_OP", "f(c) == f(matching)" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_consts" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.iscode" ], [ "LOAD_FAST", "const" ], [ "CALL_METHOD", "inspect.iscode(const)" ], [ "LOAD_DEREF", "matches" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "matches(const)" ], [ "LOAD_DEREF", "code_options" ], [ "LOOKUP_METHOD", "code_options.append" ], [ "LOAD_FAST", "const" ], [ "CALL_METHOD", "code_options.append(const)" ], [ "LOAD_DEREF", "finder" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "finder(const)" ], [ "LOAD_GLOBAL", "frozenset" ], [ "CALL_FUNCTION", "frozenset()" ], [ "LOOKUP_METHOD", "frozenset().union" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_names" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_varnames" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_freevars" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_cellvars" ], [ "CALL_METHOD", "frozenset().union(\n code.co_names,\n code.co_varnames,\n code.co_freevars,\n code.co_cellvars,\n )" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "CALL_FUNCTION", "isinstance(node, ast.stmt)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_FAST", "node" ] ], "import_hook.py": [ [ "LOAD_NAME", "object" ], [ "LOAD_FAST", "spec" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "deep" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "eye" ], [ "LOOKUP_METHOD", "eye.exec_string" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.source" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._spec" ], [ "LOAD_ATTR", "self._spec.origin" ], [ "LOAD_FAST", "module" ], [ "LOAD_ATTR", "module.__dict__" ], [ "LOAD_FAST", "module" ], [ "LOAD_ATTR", "module.__dict__" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.deep" ], [ "CALL_METHOD", "eye.exec_string(\n source=self.source,\n filename=self._spec.origin,\n globs=module.__dict__,\n locs=module.__dict__,\n deep=self.deep,\n )" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._spec" ], [ "LOAD_ATTR", "self._spec.loader" ], [ "LOOKUP_METHOD", "self._spec.loader.get_filename" ], [ "LOAD_FAST", "fullname" ], [ "CALL_METHOD", "self._spec.loader.get_filename(fullname)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._spec" ], [ "LOAD_ATTR", "self._spec.loader" ], [ "LOOKUP_METHOD", "self._spec.loader.is_package" ], [ "LOAD_FAST", "fullname" ], [ "CALL_METHOD", "self._spec.loader.is_package(fullname)" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.meta_path" ], [ "LOAD_FAST", "finder" ], [ "LOAD_FAST", "self" ], [ "COMPARE_OP", "finder is self" ], [ "LOAD_FAST", "finder" ], [ "LOAD_ATTR", "finder.__module__" ], [ "COMPARE_OP", "'pytest' in finder.__module__" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "finder" ], [ "CALL_FUNCTION", "hasattr(finder, 'find_spec')" ], [ "LOAD_FAST", "finder" ], [ "LOOKUP_METHOD", "finder.find_spec" ], [ "LOAD_FAST", "fullname" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "target" ], [ "CALL_METHOD", "finder.find_spec(fullname, path, target=target)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "finder" ], [ "CALL_FUNCTION", "hasattr(finder, 'load_module')" ], [ "LOAD_GLOBAL", "spec_from_loader" ], [ "LOAD_FAST", "fullname" ], [ "LOAD_FAST", "finder" ], [ "CALL_FUNCTION", "spec_from_loader(fullname, finder)" ], [ "LOAD_FAST", "spec" ], [ "COMPARE_OP", "spec is not None" ], [ "LOAD_FAST", "spec" ], [ "LOAD_ATTR", "spec.origin" ], [ "COMPARE_OP", "spec.origin != 'builtin'" ], [ "LOAD_FAST", "spec" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._find_plain_spec" ], [ "LOAD_FAST", "fullname" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "target" ], [ "CALL_METHOD", "self._find_plain_spec(fullname, path, target)" ], [ "LOAD_FAST", "spec" ], [ "COMPARE_OP", "spec is None" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "spec" ], [ "LOAD_ATTR", "spec.loader" ], [ "CALL_FUNCTION", "hasattr(spec.loader, 'get_source')" ], [ "LOAD_GLOBAL", "callable" ], [ "LOAD_FAST", "spec" ], [ "LOAD_ATTR", "spec.loader" ], [ "LOAD_ATTR", "spec.loader.get_source" ], [ "CALL_FUNCTION", "callable(spec.loader.get_source)" ], [ "LOAD_FAST", "fullname" ], [ "COMPARE_OP", "fullname != 'org'" ], [ "LOAD_GLOBAL", "logging" ], [ "LOOKUP_METHOD", "logging.debug" ], [ "LOAD_FAST", "fullname" ], [ "CALL_METHOD", "logging.debug('Failed finding spec for %s', fullname)" ], [ "LOAD_FAST", "spec" ], [ "LOAD_ATTR", "spec.loader" ], [ "LOOKUP_METHOD", "spec.loader.get_source" ], [ "LOAD_FAST", "fullname" ], [ "CALL_METHOD", "spec.loader.get_source(fullname)" ], [ "LOAD_GLOBAL", "ImportError" ], [ "LOAD_GLOBAL", "logging" ], [ "LOOKUP_METHOD", "logging.debug" ], [ "LOAD_FAST", "fullname" ], [ "CALL_METHOD", "logging.debug('Loader for %s was unable to find the sources',\n fullname)" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_GLOBAL", "logging" ], [ "LOOKUP_METHOD", "logging.exception" ], [ "LOAD_FAST", "fullname" ], [ "CALL_METHOD", "logging.exception('Loader for %s raised an error', fullname)" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "source" ], [ "COMPARE_OP", "'birdseye' not in source" ], [ "LOAD_GLOBAL", "should_trace" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "should_trace(source)" ], [ "LOAD_FAST", "trace_stmt" ], [ "LOAD_GLOBAL", "BirdsEyeLoader" ], [ "LOAD_FAST", "spec" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "deep" ], [ "CALL_FUNCTION", "BirdsEyeLoader(spec, source, deep)" ], [ "LOAD_GLOBAL", "spec_from_loader" ], [ "LOAD_FAST", "fullname" ], [ "LOAD_FAST", "loader" ], [ "CALL_FUNCTION", "spec_from_loader(fullname, loader)" ], [ "LOAD_GLOBAL", "False" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.parse" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "ast.parse(source)" ], [ "LOAD_ATTR", "ast.parse(source).body" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Import" ], [ "CALL_FUNCTION", "isinstance(stmt, ast.Import)" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_ATTR", "stmt.names" ], [ "LOAD_FAST", "alias" ], [ "LOAD_ATTR", "alias.name" ], [ "LOOKUP_METHOD", "alias.name.startswith" ], [ "CALL_METHOD", "alias.name.startswith('birdseye.trace_module')" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_FAST", "alias" ], [ "LOAD_ATTR", "alias.name" ], [ "LOOKUP_METHOD", "alias.name.endswith" ], [ "CALL_METHOD", "alias.name.endswith('deep')" ], [ "LOAD_GLOBAL", "True" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.ImportFrom" ], [ "CALL_FUNCTION", "isinstance(stmt, ast.ImportFrom)" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_ATTR", "stmt.module" ], [ "COMPARE_OP", "stmt.module == 'birdseye'" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_ATTR", "stmt.names" ], [ "LOAD_FAST", "alias" ], [ "LOAD_ATTR", "alias.name" ], [ "LOOKUP_METHOD", "alias.name.startswith" ], [ "CALL_METHOD", "alias.name.startswith('trace_module')" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_FAST", "alias" ], [ "LOAD_ATTR", "alias.name" ], [ "LOOKUP_METHOD", "alias.name.endswith" ], [ "CALL_METHOD", "alias.name.endswith('deep')" ], [ "LOAD_GLOBAL", "True" ], [ "LOAD_FAST", "deep" ], [ "LOAD_FAST", "trace_stmt" ] ], "ipython.py": [ [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "BytesIO" ], [ "LOAD_NAME", "StringIO" ], [ "LOAD_NAME", "stream_proxy" ], [ "LOAD_NAME", "sys" ], [ "LOAD_ATTR", "sys.stderr" ], [ "CALL_FUNCTION", "stream_proxy(sys.stderr)" ], [ "LOAD_NAME", "sys" ], [ "LOAD_NAME", "stream_proxy" ], [ "LOAD_NAME", "sys" ], [ "LOAD_ATTR", "sys.stdout" ], [ "CALL_FUNCTION", "stream_proxy(sys.stdout)" ], [ "LOAD_NAME", "sys" ], [ "LOAD_NAME", "Environment" ], [ "LOAD_NAME", "PackageLoader" ], [ "CALL_FUNCTION", "PackageLoader('birdseye', 'templates')" ], [ "LOAD_NAME", "select_autoescape" ], [ "CALL_FUNCTION", "select_autoescape(['html', 'xml'])" ], [ "CALL_FUNCTION", "Environment(\n loader=PackageLoader('birdseye', 'templates'),\n autoescape=select_autoescape(['html', 'xml'])\n)" ], [ "LOAD_NAME", "magics_class" ], [ "LOAD_NAME", "Magics" ], [ "CALL_FUNCTION", "magics_class" ], [ "LOAD_GLOBAL", "LocalProxy" ], [ "LOAD_FAST", "p" ], [ "CALL_FUNCTION", "LocalProxy(p)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.currentframe" ], [ "CALL_METHOD", "inspect.currentframe()" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_GLOBAL", "ThreadingMixIn" ], [ "LOAD_ATTR", "ThreadingMixIn.process_request_thread" ], [ "LOAD_ATTR", "ThreadingMixIn.process_request_thread.__code__" ], [ "COMPARE_OP", "frame.f_code == ThreadingMixIn.process_request_thread.__code__" ], [ "LOAD_GLOBAL", "fake_stream" ], [ "CALL_FUNCTION", "fake_stream()" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_GLOBAL", "thread_proxies" ], [ "LOOKUP_METHOD", "thread_proxies.get" ], [ "LOAD_GLOBAL", "currentThread" ], [ "CALL_FUNCTION", "currentThread()" ], [ "LOAD_ATTR", "currentThread().ident" ], [ "LOAD_DEREF", "original" ], [ "CALL_METHOD", "thread_proxies.get(currentThread().ident,\n original)" ], [ "LOAD_FAST", "show_server_output" ], [ "LOAD_GLOBAL", "fake_stream" ], [ "CALL_FUNCTION", "fake_stream()" ], [ "LOAD_GLOBAL", "thread_proxies" ], [ "LOAD_GLOBAL", "currentThread" ], [ "CALL_FUNCTION", "currentThread()" ], [ "LOAD_ATTR", "currentThread().ident" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_ATTR", "server.app" ], [ "LOOKUP_METHOD", "server.app.run" ], [ "LOAD_GLOBAL", "True" ], [ "LOAD_FAST", "port" ], [ "LOAD_FAST", "bind_host" ], [ "LOAD_GLOBAL", "False" ], [ "CALL_METHOD", "server.app.run(\n debug=True,\n port=port,\n host=bind_host,\n use_reloader=False,\n )" ], [ "LOAD_GLOBAL", "socket" ], [ "LOAD_ATTR", "socket.error" ], [ "LOAD_NAME", "Unicode" ], [ "LOAD_NAME", "True" ], [ "CALL_FUNCTION", "Unicode(\n u'', config=True,\n help='If set, a server will not be automatically started by %%eye. '\n 'The iframe containing birdseye output will use this value as the base '\n 'of its URL.'\n )" ], [ "LOAD_NAME", "Int" ], [ "LOAD_NAME", "True" ], [ "CALL_FUNCTION", "Int(\n 7777, config=True,\n help='Port number for the server started by %%eye.'\n )" ], [ "LOAD_NAME", "Unicode" ], [ "LOAD_NAME", "True" ], [ "CALL_FUNCTION", "Unicode(\n '127.0.0.1', config=True,\n help='Host that the server started by %%eye listens on. '\n 'Set to 0.0.0.0 to make it accessible anywhere.'\n )" ], [ "LOAD_NAME", "Bool" ], [ "LOAD_NAME", "False" ], [ "LOAD_NAME", "True" ], [ "CALL_FUNCTION", "Bool(\n False, config=True,\n help='Set to True to show stdout and stderr from the server started by %%eye.'\n )" ], [ "LOAD_NAME", "Unicode" ], [ "LOAD_NAME", "True" ], [ "CALL_FUNCTION", "Unicode(\n u'', config=True,\n help='The database URL that the server started by %%eye reads from. '\n 'Equivalent to the environment variable BIRDSEYE_DB.'\n )" ], [ "LOAD_NAME", "cell_magic" ], [ "CALL_FUNCTION", "cell_magic" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.server_url" ], [ "LOAD_GLOBAL", "Database" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.db_url" ], [ "CALL_FUNCTION", "Database(self.db_url)" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_ATTR", "server.db" ], [ "LOAD_ATTR", "server.db.Function" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_ATTR", "server.db" ], [ "LOAD_ATTR", "server.db.Call" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_ATTR", "server.db" ], [ "LOAD_ATTR", "server.db.Session" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_GLOBAL", "Thread" ], [ "LOAD_GLOBAL", "run_server" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.port" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.bind_host" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.show_server_output" ], [ "CALL_FUNCTION", "Thread(\n target=run_server,\n args=(\n self.port,\n self.bind_host,\n self.show_server_output,\n ),\n )" ], [ "LOOKUP_METHOD", "Thread(\n target=run_server,\n args=(\n self.port,\n self.bind_host,\n self.show_server_output,\n ),\n ).start" ], [ "CALL_METHOD", "Thread(\n target=run_server,\n args=(\n self.port,\n self.bind_host,\n self.show_server_output,\n ),\n ).start()" ], [ "LOAD_GLOBAL", "Database" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.db_url" ], [ "CALL_FUNCTION", "Database(self.db_url)" ], [ "LOAD_GLOBAL", "eye" ], [ "LOAD_GLOBAL", "eye" ], [ "LOOKUP_METHOD", "eye.exec_ipython_cell" ], [ "LOAD_FAST", "cell" ], [ "LOAD_FAST", "callback" ], [ "CALL_METHOD", "eye.exec_ipython_cell(cell, callback)" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "call_id" ], [ "COMPARE_OP", "call_id is None" ], [ "LOAD_GLOBAL", "HTML" ], [ "LOAD_GLOBAL", "templates_env" ], [ "LOOKUP_METHOD", "templates_env.get_template" ], [ "CALL_METHOD", "templates_env.get_template('ipython_iframe.html')" ], [ "LOOKUP_METHOD", "templates_env.get_template('ipython_iframe.html').render" ], [ "LOAD_FAST", "call_id" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.server_url" ], [ "LOOKUP_METHOD", "self.server_url.rstrip" ], [ "CALL_METHOD", "self.server_url.rstrip('/')" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.port" ], [ "LOAD_GLOBAL", "uuid4" ], [ "CALL_FUNCTION", "uuid4()" ], [ "LOAD_ATTR", "uuid4().hex" ], [ "CALL_METHOD", "templates_env.get_template('ipython_iframe.html').render(\n call_id=call_id,\n url=self.server_url.rstrip('/'),\n port=self.port,\n container_id=uuid4().hex,\n )" ], [ "CALL_FUNCTION", "HTML(templates_env.get_template('ipython_iframe.html').render(\n call_id=call_id,\n url=self.server_url.rstrip('/'),\n port=self.port,\n container_id=uuid4().hex,\n ))" ], [ "LOAD_GLOBAL", "display" ], [ "LOAD_FAST", "html" ], [ "CALL_FUNCTION", "display(html)" ] ], "server.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOOKUP_METHOD", "standard_library.install_aliases" ], [ "CALL_METHOD", "standard_library.install_aliases()" ], [ "LOAD_NAME", "Flask" ], [ "CALL_FUNCTION", "Flask('birdseye')" ], [ "LOAD_NAME", "True" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.jinja_env" ], [ "LOAD_NAME", "Humanize" ], [ "LOAD_NAME", "app" ], [ "CALL_FUNCTION", "Humanize(app)" ], [ "LOAD_NAME", "PathConverter" ], [ "LOAD_NAME", "FileConverter" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.url_map" ], [ "LOAD_ATTR", "app.url_map.converters" ], [ "LOAD_NAME", "Database" ], [ "CALL_FUNCTION", "Database()" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.Session" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.Function" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.Call" ], [ "LOAD_NAME", "app" ], [ "LOOKUP_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/')" ], [ "LOAD_NAME", "app" ], [ "LOOKUP_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/file/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/file/')" ], [ "LOAD_NAME", "app" ], [ "LOOKUP_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/file//__function__/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/file//__function__/')" ], [ "LOAD_NAME", "app" ], [ "LOOKUP_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/api/file//__function__//latest_call/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/api/file//__function__//latest_call/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "LOAD_NAME", "app" ], [ "LOOKUP_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/call/')" ], [ "CALL_FUNCTION", "app.route('/call/')" ], [ "LOAD_NAME", "app" ], [ "LOOKUP_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/ipython_call/')" ], [ "CALL_FUNCTION", "app.route('/ipython_call/')" ], [ "LOAD_NAME", "app" ], [ "LOOKUP_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/ipython_iframe/')" ], [ "CALL_FUNCTION", "app.route('/ipython_iframe/')" ], [ "LOAD_NAME", "app" ], [ "LOOKUP_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/kill', methods=['POST'])" ], [ "CALL_FUNCTION", "app.route('/kill', methods=['POST'])" ], [ "LOAD_NAME", "app" ], [ "LOOKUP_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/api/call/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/api/call/')" ], [ "LOAD_NAME", "app" ], [ "LOOKUP_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/api/calls_by_body_hash/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/api/calls_by_body_hash/')" ], [ "LOAD_NAME", "app" ], [ "LOOKUP_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/api/body_hashes_present/', methods=['POST'])" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/api/body_hashes_present/', methods=['POST'])" ], [ "LOAD_NAME", "sys" ], [ "LOAD_ATTR", "sys.argv" ], [ "SLICE+1", "sys.argv[1:]" ], [ "LOAD_NAME", "__name__" ], [ "COMPARE_OP", "__name__ == '__main__'" ], [ "LOAD_NAME", "main" ], [ "CALL_FUNCTION", "main()" ], [ "LOAD_GLOBAL", "db" ], [ "LOOKUP_METHOD", "db.all_file_paths" ], [ "CALL_METHOD", "db.all_file_paths()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_columns" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.basic_columns" ], [ "BINARY_ADD", "Call.basic_columns + Function.basic_columns" ], [ "CALL_FUNCTION_VAR", "session.query(*(Call.basic_columns + Function.basic_columns))" ], [ "LOOKUP_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)" ], [ "LOOKUP_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .order_by" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.start_time" ], [ "LOOKUP_METHOD", "Call.start_time.desc" ], [ "CALL_METHOD", "Call.start_time.desc()" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .order_by(Call.start_time.desc())" ], [ "SLICE+2", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .order_by(Call.start_time.desc())[:100]" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "CALL_FUNCTION", "OrderedDict()" ], [ "LOAD_FAST", "recent_calls" ], [ "LOAD_GLOBAL", "is_ipython_cell" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.file" ], [ "CALL_FUNCTION", "is_ipython_cell(row.file)" ], [ "LOAD_FAST", "files" ], [ "LOOKUP_METHOD", "files.setdefault" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.file" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "CALL_FUNCTION", "OrderedDict()" ], [ "CALL_METHOD", "files.setdefault(\n row.file, OrderedDict()\n )" ], [ "LOOKUP_METHOD", "files.setdefault(\n row.file, OrderedDict()\n ).setdefault" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.name" ], [ "LOAD_FAST", "row" ], [ "CALL_METHOD", "files.setdefault(\n row.file, OrderedDict()\n ).setdefault(\n row.name, row\n )" ], [ "LOAD_FAST", "all_paths" ], [ "LOAD_FAST", "files" ], [ "LOOKUP_METHOD", "files.setdefault" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "CALL_FUNCTION", "OrderedDict()" ], [ "CALL_METHOD", "files.setdefault(\n path, OrderedDict()\n )" ], [ "LOAD_GLOBAL", "partial" ], [ "LOAD_GLOBAL", "short_path" ], [ "LOAD_FAST", "all_paths" ], [ "CALL_FUNCTION", "partial(short_path, all_paths=all_paths)" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "short" ], [ "LOAD_FAST", "files" ], [ "CALL_FUNCTION", "render_template('index.html',\n short=short,\n files=files)" ], [ "LOAD_GLOBAL", "fix_abs_path" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "fix_abs_path(path)" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_columns" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.basic_columns" ], [ "BINARY_ADD", "Call.basic_columns + Function.basic_columns" ], [ "CALL_FUNCTION_VAR", "session.query(*(Call.basic_columns + Function.basic_columns))" ], [ "LOOKUP_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)" ], [ "LOOKUP_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by" ], [ "LOAD_FAST", "path" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path)" ], [ "LOOKUP_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path)\n .subquery" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path)\n .subquery('filtered_calls')" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.query" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.name" ], [ "LOAD_GLOBAL", "sqlalchemy" ], [ "LOAD_ATTR", "sqlalchemy.func" ], [ "LOOKUP_METHOD", "sqlalchemy.func.max" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.start_time" ], [ "CALL_METHOD", "sqlalchemy.func.max(filtered_calls.c.start_time)" ], [ "LOOKUP_METHOD", "sqlalchemy.func.max(filtered_calls.c.start_time).label" ], [ "CALL_METHOD", "sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')" ], [ "CALL_METHOD", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n )" ], [ "LOOKUP_METHOD", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n ).group_by" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.name" ], [ "CALL_METHOD", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n ).group_by(\n filtered_calls.c.name,\n )" ], [ "LOOKUP_METHOD", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n ).group_by(\n filtered_calls.c.name,\n ).subquery" ], [ "CALL_METHOD", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n ).group_by(\n filtered_calls.c.name,\n ).subquery('latest_calls')" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.query" ], [ "LOAD_FAST", "filtered_calls" ], [ "CALL_METHOD", "session.query(filtered_calls)" ], [ "LOOKUP_METHOD", "session.query(filtered_calls).join" ], [ "LOAD_FAST", "latest_calls" ], [ "LOAD_GLOBAL", "sqlalchemy" ], [ "LOOKUP_METHOD", "sqlalchemy.and_" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.name" ], [ "LOAD_FAST", "latest_calls" ], [ "LOAD_ATTR", "latest_calls.c" ], [ "LOAD_ATTR", "latest_calls.c.name" ], [ "COMPARE_OP", "filtered_calls.c.name == latest_calls.c.name" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.start_time" ], [ "LOAD_FAST", "latest_calls" ], [ "LOAD_ATTR", "latest_calls.c" ], [ "LOAD_ATTR", "latest_calls.c.maxtime" ], [ "COMPARE_OP", "filtered_calls.c.start_time == latest_calls.c.maxtime" ], [ "CALL_METHOD", "sqlalchemy.and_(\n filtered_calls.c.name == latest_calls.c.name,\n filtered_calls.c.start_time == latest_calls.c.maxtime,\n )" ], [ "CALL_METHOD", "session.query(filtered_calls).join(\n latest_calls,\n sqlalchemy.and_(\n filtered_calls.c.name == latest_calls.c.name,\n filtered_calls.c.start_time == latest_calls.c.maxtime,\n )\n )" ], [ "LOOKUP_METHOD", "session.query(filtered_calls).join(\n latest_calls,\n sqlalchemy.and_(\n filtered_calls.c.name == latest_calls.c.name,\n filtered_calls.c.start_time == latest_calls.c.maxtime,\n )\n ).order_by" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.start_time" ], [ "LOOKUP_METHOD", "filtered_calls.c.start_time.desc" ], [ "CALL_METHOD", "filtered_calls.c.start_time.desc()" ], [ "CALL_METHOD", "session.query(filtered_calls).join(\n latest_calls,\n sqlalchemy.and_(\n filtered_calls.c.name == latest_calls.c.name,\n filtered_calls.c.start_time == latest_calls.c.maxtime,\n )\n ).order_by(filtered_calls.c.start_time.desc())" ], [ "LOAD_GLOBAL", "group_by_attr" ], [ "LOAD_FAST", "query" ], [ "CALL_FUNCTION", "group_by_attr(query, 'type')" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.query" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.name" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.type" ], [ "CALL_METHOD", "session.query(Function.name, Function.type)" ], [ "LOOKUP_METHOD", "session.query(Function.name, Function.type)\n .filter_by" ], [ "LOAD_FAST", "path" ], [ "CALL_METHOD", "session.query(Function.name, Function.type)\n .filter_by(file=path)" ], [ "LOOKUP_METHOD", "session.query(Function.name, Function.type)\n .filter_by(file=path)\n .distinct" ], [ "CALL_METHOD", "session.query(Function.name, Function.type)\n .filter_by(file=path)\n .distinct()" ], [ "CALL_FUNCTION", "sorted(session.query(Function.name, Function.type)\n .filter_by(file=path)\n .distinct())" ], [ "LOAD_FAST", "query" ], [ "LOAD_FAST", "all_funcs" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.name" ], [ "LOAD_FAST", "func_names" ], [ "COMPARE_OP", "func.name not in func_names" ], [ "LOAD_FAST", "funcs" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.type" ], [ "BINARY_SUBSCR", "funcs[func.type]" ], [ "LOOKUP_METHOD", "funcs[func.type].append" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "funcs[func.type].append(func)" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "funcs" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "COMPARE_OP", "path == IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "basename" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "basename(path)" ], [ "CALL_FUNCTION", "render_template('file.html',\n funcs=funcs,\n is_ipython=path == IPYTHON_FILE_PATH,\n full_path=path,\n short_path=basename(path))" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.name" ], [ "LOAD_GLOBAL", "fix_abs_path" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "fix_abs_path(path)" ], [ "LOAD_GLOBAL", "get_calls" ], [ "LOAD_FAST", "session" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "func_name" ], [ "CALL_FUNCTION", "get_calls(session, path, func_name, 200)" ], [ "LOAD_FAST", "query" ], [ "LOAD_FAST", "query" ], [ "BINARY_SUBSCR", "query[0]" ], [ "LOAD_FAST", "query" ], [ "LOAD_GLOBAL", "withattrs" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_FUNCTION", "Call()" ], [ "LOAD_FAST", "row" ], [ "LOOKUP_METHOD", "row._asdict" ], [ "CALL_METHOD", "row._asdict()" ], [ "CALL_FUNCTION_KW", "withattrs(Call(), **row._asdict())" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.query" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_METHOD", "session.query(Function)" ], [ "LOOKUP_METHOD", "session.query(Function).filter_by" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "func_name" ], [ "CALL_METHOD", "session.query(Function).filter_by(file=path, name=func_name)" ], [ "BINARY_SUBSCR", "session.query(Function).filter_by(file=path, name=func_name)[0]" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "func" ], [ "LOAD_GLOBAL", "basename" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "basename(path)" ], [ "LOAD_FAST", "calls" ], [ "CALL_FUNCTION", "render_template('function.html',\n func=func,\n short_path=basename(path),\n calls=calls)" ], [ "LOAD_GLOBAL", "fix_abs_path" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "fix_abs_path(path)" ], [ "LOAD_GLOBAL", "get_calls" ], [ "LOAD_FAST", "session" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "func_name" ], [ "CALL_FUNCTION", "get_calls(session, path, func_name, 1)" ], [ "BINARY_SUBSCR", "get_calls(session, path, func_name, 1)[0]" ], [ "LOAD_GLOBAL", "jsonify" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.id" ], [ "LOAD_GLOBAL", "url_for" ], [ "LOAD_GLOBAL", "call_view" ], [ "LOAD_ATTR", "call_view.__name__" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.id" ], [ "CALL_FUNCTION", "url_for(call_view.__name__,\n call_id=call.id)" ], [ "CALL_FUNCTION", "dict(\n id=call.id,\n url=url_for(call_view.__name__,\n call_id=call.id),\n )" ], [ "CALL_FUNCTION", "jsonify(dict(\n id=call.id,\n url=url_for(call_view.__name__,\n call_id=call.id),\n ))" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_columns" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.basic_columns" ], [ "BINARY_ADD", "Call.basic_columns + Function.basic_columns" ], [ "CALL_FUNCTION_VAR", "session.query(*(Call.basic_columns + Function.basic_columns))" ], [ "LOOKUP_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)" ], [ "LOOKUP_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "func_name" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path, name=func_name)" ], [ "LOOKUP_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path, name=func_name)\n .order_by" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.start_time" ], [ "LOOKUP_METHOD", "Call.start_time.desc" ], [ "CALL_METHOD", "Call.start_time.desc()" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path, name=func_name)\n .order_by(Call.start_time.desc())" ], [ "LOAD_FAST", "limit" ], [ "SLICE+2", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path, name=func_name)\n .order_by(Call.start_time.desc())[:limit]" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_METHOD", "session.query(Call)" ], [ "LOOKUP_METHOD", "session.query(Call).filter_by" ], [ "LOAD_FAST", "call_id" ], [ "CALL_METHOD", "session.query(Call).filter_by(id=call_id)" ], [ "LOOKUP_METHOD", "session.query(Call).filter_by(id=call_id).one" ], [ "CALL_METHOD", "session.query(Call).filter_by(id=call_id).one()" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.function" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "template" ], [ "LOAD_GLOBAL", "basename" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.file" ], [ "CALL_FUNCTION", "basename(func.file)" ], [ "LOAD_FAST", "call" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "render_template(template,\n short_path=basename(func.file),\n call=call,\n func=func)" ], [ "LOAD_GLOBAL", "base_call_view" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION", "base_call_view(call_id, 'call.html')" ], [ "LOAD_GLOBAL", "base_call_view" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION", "base_call_view(call_id, 'ipython_call.html')" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION", "render_template('ipython_iframe.html',\n container_id='1234',\n port=7777,\n call_id=call_id)" ], [ "LOAD_GLOBAL", "request" ], [ "LOAD_ATTR", "request.environ" ], [ "LOOKUP_METHOD", "request.environ.get" ], [ "CALL_METHOD", "request.environ.get('werkzeug.server.shutdown')" ], [ "LOAD_FAST", "func" ], [ "COMPARE_OP", "func is None" ], [ "LOAD_GLOBAL", "RuntimeError" ], [ "CALL_FUNCTION", "RuntimeError('Not running with the Werkzeug Server')" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "func()" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_METHOD", "session.query(Call)" ], [ "LOOKUP_METHOD", "session.query(Call).filter_by" ], [ "LOAD_FAST", "call_id" ], [ "CALL_METHOD", "session.query(Call).filter_by(id=call_id)" ], [ "LOOKUP_METHOD", "session.query(Call).filter_by(id=call_id).one" ], [ "CALL_METHOD", "session.query(Call).filter_by(id=call_id).one()" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.function" ], [ "LOAD_GLOBAL", "DecentJSONEncoder" ], [ "CALL_FUNCTION", "DecentJSONEncoder()" ], [ "LOOKUP_METHOD", "DecentJSONEncoder().encode" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.parsed_data" ], [ "LOAD_GLOBAL", "Call" ], [ "LOOKUP_METHOD", "Call.basic_dict" ], [ "LOAD_FAST", "call" ], [ "CALL_METHOD", "Call.basic_dict(call)" ], [ "CALL_FUNCTION_KW", "dict(data=call.parsed_data, **Call.basic_dict(call))" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.parsed_data" ], [ "LOAD_GLOBAL", "Function" ], [ "LOOKUP_METHOD", "Function.basic_dict" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "Function.basic_dict(func)" ], [ "CALL_FUNCTION_KW", "dict(data=func.parsed_data, **Function.basic_dict(func))" ], [ "CALL_FUNCTION", "dict(\n call=dict(data=call.parsed_data, **Call.basic_dict(call)),\n function=dict(data=func.parsed_data, **Function.basic_dict(func)))" ], [ "CALL_METHOD", "DecentJSONEncoder().encode(dict(\n call=dict(data=call.parsed_data, **Call.basic_dict(call)),\n function=dict(data=func.parsed_data, **Function.basic_dict(func))))" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_columns" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.data" ], [ "BINARY_ADD", "Call.basic_columns + (Function.data,)" ], [ "CALL_FUNCTION_VAR", "session.query(*Call.basic_columns + (Function.data,))" ], [ "LOOKUP_METHOD", "session.query(*Call.basic_columns + (Function.data,))\n .join" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_METHOD", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)" ], [ "LOOKUP_METHOD", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by" ], [ "LOAD_FAST", "body_hash" ], [ "CALL_METHOD", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by(body_hash=body_hash)" ], [ "LOOKUP_METHOD", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by(body_hash=body_hash)\n .order_by" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.start_time" ], [ "LOOKUP_METHOD", "Call.start_time.desc" ], [ "CALL_METHOD", "Call.start_time.desc()" ], [ "CALL_METHOD", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by(body_hash=body_hash)\n .order_by(Call.start_time.desc())" ], [ "SLICE+2", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by(body_hash=body_hash)\n .order_by(Call.start_time.desc())[:200]" ], [ "LOAD_FAST", "query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOOKUP_METHOD", "Call.basic_dict" ], [ "LOAD_GLOBAL", "withattrs" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_FUNCTION", "Call()" ], [ "LOAD_FAST", "row" ], [ "LOOKUP_METHOD", "row._asdict" ], [ "CALL_METHOD", "row._asdict()" ], [ "CALL_FUNCTION_KW", "withattrs(Call(), **row._asdict())" ], [ "CALL_METHOD", "Call.basic_dict(withattrs(Call(), **row._asdict()))" ], [ "LOAD_FAST", "query" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "function_data_set" ], [ "LOAD_GLOBAL", "json" ], [ "LOOKUP_METHOD", "json.loads" ], [ "LOAD_DEREF", "function_data" ], [ "CALL_METHOD", "json.loads(function_data)" ], [ "LOAD_FAST", "add" ], [ "LOAD_FAST", "ranges" ], [ "CALL_FUNCTION", "add('node_ranges', ranges)" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "add" ], [ "LOAD_FAST", "current_loop_ranges" ], [ "CALL_FUNCTION", "add('loop_ranges', current_loop_ranges)" ], [ "LOAD_FAST", "loop_ranges" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "current_loop_ranges" ], [ "COMPARE_OP", "loop_ranges in (set(), current_loop_ranges)" ], [ "LOAD_FAST", "current_loop_ranges" ], [ "LOAD_FAST", "ranges" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "CALL_FUNCTION", "dict(start=start, end=end)" ], [ "LOAD_FAST", "loop_ranges" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "CALL_FUNCTION", "dict(start=start, end=end)" ], [ "LOAD_GLOBAL", "DecentJSONEncoder" ], [ "CALL_FUNCTION", "DecentJSONEncoder()" ], [ "LOOKUP_METHOD", "DecentJSONEncoder().encode" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "calls" ], [ "LOAD_FAST", "ranges" ], [ "LOAD_FAST", "loop_ranges" ], [ "CALL_FUNCTION", "dict(\n calls=calls, ranges=ranges, loop_ranges=loop_ranges)" ], [ "CALL_METHOD", "DecentJSONEncoder().encode(dict(\n calls=calls, ranges=ranges, loop_ranges=loop_ranges))" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.data" ], [ "LOAD_DEREF", "function_data" ], [ "LOAD_FAST", "key" ], [ "BINARY_SUBSCR", "function_data[key]" ], [ "LOAD_FAST", "ranges_set" ], [ "LOOKUP_METHOD", "ranges_set.add" ], [ "LOAD_FAST", "node" ], [ "BINARY_SUBSCR", "node['start']" ], [ "LOAD_FAST", "node" ], [ "BINARY_SUBSCR", "node['end']" ], [ "CALL_METHOD", "ranges_set.add((node['start'], node['end']))" ], [ "LOAD_GLOBAL", "request" ], [ "LOOKUP_METHOD", "request.get_json" ], [ "CALL_METHOD", "request.get_json()" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.query" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.body_hash" ], [ "LOAD_GLOBAL", "sqlalchemy" ], [ "LOAD_ATTR", "sqlalchemy.func" ], [ "LOOKUP_METHOD", "sqlalchemy.func.count" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.id" ], [ "CALL_METHOD", "sqlalchemy.func.count(Call.id)" ], [ "CALL_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))" ], [ "LOOKUP_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)" ], [ "LOOKUP_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)\n .filter" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.body_hash" ], [ "LOOKUP_METHOD", "Function.body_hash.in_" ], [ "LOAD_FAST", "hashes" ], [ "CALL_METHOD", "Function.body_hash.in_(hashes)" ], [ "CALL_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)\n .filter(Function.body_hash.in_(hashes))" ], [ "LOOKUP_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)\n .filter(Function.body_hash.in_(hashes))\n .group_by" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.body_hash" ], [ "CALL_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)\n .filter(Function.body_hash.in_(hashes))\n .group_by(Function.body_hash)" ], [ "LOAD_GLOBAL", "DecentJSONEncoder" ], [ "CALL_FUNCTION", "DecentJSONEncoder()" ], [ "LOOKUP_METHOD", "DecentJSONEncoder().encode" ], [ "LOAD_FAST", "query" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "h" ], [ "LOAD_FAST", "count" ], [ "CALL_FUNCTION", "dict(hash=h, count=count)" ], [ "CALL_METHOD", "DecentJSONEncoder().encode([\n dict(hash=h, count=count)\n for h, count in query\n ])" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "argv" ], [ "CALL_FUNCTION", "len(argv)" ], [ "COMPARE_OP", "len(argv) == 1" ], [ "LOAD_FAST", "argv" ], [ "BINARY_SUBSCR", "argv[0]" ], [ "LOOKUP_METHOD", "argv[0].isdigit" ], [ "CALL_METHOD", "argv[0].isdigit()" ], [ "LOAD_FAST", "argv" ], [ "LOOKUP_METHOD", "argv.insert" ], [ "CALL_METHOD", "argv.insert(0, '--port')" ], [ "LOAD_GLOBAL", "argparse" ], [ "LOOKUP_METHOD", "argparse.ArgumentParser" ], [ "CALL_METHOD", "argparse.ArgumentParser(description=\"Bird's Eye: A graphical Python debugger\")" ], [ "LOAD_FAST", "parser" ], [ "LOOKUP_METHOD", "parser.add_argument" ], [ "LOAD_GLOBAL", "int" ], [ "CALL_METHOD", "parser.add_argument('-p', '--port', help='HTTP port, default is 7777', default=7777, type=int)" ], [ "LOAD_FAST", "parser" ], [ "LOOKUP_METHOD", "parser.add_argument" ], [ "CALL_METHOD", "parser.add_argument('--host', help=\"HTTP host, default is 'localhost'\", default='localhost')" ], [ "LOAD_FAST", "parser" ], [ "LOOKUP_METHOD", "parser.parse_args" ], [ "LOAD_FAST", "argv" ], [ "CALL_METHOD", "parser.parse_args(argv)" ], [ "LOAD_GLOBAL", "app" ], [ "LOOKUP_METHOD", "app.run" ], [ "LOAD_FAST", "args" ], [ "LOAD_ATTR", "args.port" ], [ "LOAD_FAST", "args" ], [ "LOAD_ATTR", "args.host" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.environ" ], [ "LOOKUP_METHOD", "os.environ.get" ], [ "CALL_METHOD", "os.environ.get('BIRDSEYE_RELOADER')" ], [ "COMPARE_OP", "os.environ.get('BIRDSEYE_RELOADER') == '1'" ], [ "CALL_METHOD", "app.run(\n port=args.port,\n host=args.host,\n use_reloader=os.environ.get('BIRDSEYE_RELOADER') == '1',\n )" ] ], "tests.py": [ [ "LOAD_NAME", "unittest" ], [ "LOAD_ATTR", "unittest.TestCase" ], [ "LOAD_NAME", "unittest" ], [ "LOAD_ATTR", "unittest.TestCase" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "TestFile" ], [ "CALL_FUNCTION", "TestFile()" ], [ "LOOKUP_METHOD", "TestFile().test_file" ], [ "CALL_METHOD", "TestFile().test_file()" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "Tester" ], [ "CALL_FUNCTION", "Tester()" ], [ "LOAD_NAME", "tester" ], [ "CALL_FUNCTION", "tester([1, 2, 3])" ], [ "COMPARE_OP", "tester([1, 2, 3]) == [1, 2, 3]" ], [ "LOAD_NAME", "tester" ], [ "LOAD_ATTR", "tester.asd" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester.asd is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_SUBSCR", "tester[19]" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester[19] is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_POWER", "tester ** 4" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester ** 4 is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_MULTIPLY", "tester * 3" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester * 3 is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_SUBTRACT", "tester - 2" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester - 2 is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_ADD", "tester + 1" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester + 1 is tester" ], [ "LOAD_NAME", "tester" ], [ "UNARY_NEGATIVE", "-tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "-tester is tester" ], [ "LOAD_NAME", "tester" ], [ "UNARY_POSITIVE", "+tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "+tester is tester" ], [ "LOAD_NAME", "tester" ], [ "UNARY_INVERT", "~tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "~tester is tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester < 7" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "(tester < 7) is tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester >= 78" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "(tester >= 78) is tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester != 79" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "(tester != 79) is tester" ], [ "LOAD_NAME", "tester" ], [ "LOOKUP_METHOD", "tester.foo" ], [ "LOAD_NAME", "False" ], [ "CALL_METHOD", "tester.foo(45, False)" ], [ "COMPARE_OP", "tester.foo(45, False) == 45" ], [ "LOAD_NAME", "__name__" ], [ "COMPARE_OP", "__name__ == '__main__'" ], [ "LOAD_NAME", "unittest" ], [ "LOOKUP_METHOD", "unittest.main" ], [ "CALL_METHOD", "unittest.main()" ], [ "LOAD_NAME", "True" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(1)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(2)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(3)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(9\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n 8)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n 99\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(33)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([4,\n 5, 6, [\n 7]])" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "LOAD_GLOBAL", "decorator_with_args" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('123')" ], [ "LOAD_GLOBAL", "int" ], [ "CALL_FUNCTION", "int()" ], [ "CALL_FUNCTION", "decorator_with_args(tester('123'), x=int())" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "tuple([1, 2])" ], [ "CALL_FUNCTION", "list(tuple([1, 2]))" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "CALL_FUNCTION", "tester(list(tuple([1, 2])), returns=empty_decorator)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "tuple(\n [3, 4])" ], [ "CALL_FUNCTION", "list(\n tuple(\n [3, 4]))" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "CALL_FUNCTION", "tester(\n list(\n tuple(\n [3, 4])),\n returns=empty_decorator)" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "LOAD_GLOBAL", "decorator_with_args" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "str()" ], [ "LOAD_GLOBAL", "int" ], [ "CALL_FUNCTION", "int()" ], [ "CALL_FUNCTION", "decorator_with_args(\n str(),\n x=int())" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "tuple([5, 6])" ], [ "CALL_FUNCTION", "list(tuple([5, 6]))" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "CALL_FUNCTION", "tester(list(tuple([5, 6])), returns=empty_decorator)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "tuple([7, 8])" ], [ "CALL_FUNCTION", "list(tuple([7, 8]))" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "CALL_FUNCTION", "tester(list(tuple([7, 8])), returns=empty_decorator)" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "LOAD_GLOBAL", "decorator_with_args" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('sdf')" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('123234')" ], [ "CALL_FUNCTION", "decorator_with_args(tester('sdf'), x=tester('123234'))" ], [ "CALL_FUNCTION", "decorator_with_args(tester('sdf'), x=tester('123234'))" ], [ "CALL_FUNCTION", "empty_decorator" ], [ "CALL_FUNCTION", "tester(list(tuple([7, 8])), returns=empty_decorator)" ], [ "CALL_FUNCTION", "tester(list(tuple([5, 6])), returns=empty_decorator)" ], [ "CALL_FUNCTION", "decorator_with_args(\n str(),\n x=int())" ], [ "CALL_FUNCTION", "empty_decorator" ], [ "CALL_FUNCTION", "tester(\n list(\n tuple(\n [3, 4])),\n returns=empty_decorator)" ], [ "CALL_FUNCTION", "tester(list(tuple([1, 2])), returns=empty_decorator)" ], [ "CALL_FUNCTION", "decorator_with_args(tester('123'), x=int())" ], [ "CALL_FUNCTION", "empty_decorator" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "str([{tester(x) for x in [1]}, {tester(y) for y in [1]}])" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "str([{tester(x) for x in [1]},\n {tester(x) for x in [1]}])" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "list(tester(x) for x in [1])" ], [ "CALL_FUNCTION", "str([{tester(x) for x in [1]}, list(tester(x) for x in [1])])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "y" ], [ "CALL_FUNCTION", "tester(y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertEqual" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(3)" ], [ "CALL_FUNCTION", "(lambda x: (tester(x), tester(x)))(tester(3))" ], [ "CALL_METHOD", "self.assertEqual(\n (lambda x: (tester(x), tester(x)))(tester(3)),\n (3, 3),\n )" ], [ "CALL_FUNCTION", "(lambda: (lambda: tester(1))())()" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertEqual" ], [ "CALL_FUNCTION", "(lambda: [tester(x) for x in tester([1, 2])])()" ], [ "CALL_METHOD", "self.assertEqual(\n (lambda: [tester(x) for x in tester([1, 2])])(),\n [1, 2],\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "CALL_FUNCTION", "(lambda: tester(1))()" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(1)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x): {tester(b+x): {tester(c+x) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_FAST", "foo" ], [ "CALL_FUNCTION", "foo()" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "CALL_FUNCTION", "tester(a+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "CALL_FUNCTION", "tester(b+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "CALL_FUNCTION", "tester(c+x)" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x): {tester(b+x): {tester(c+x) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+y): {tester(b+y): {tester(c+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x+y): {tester(b+x+y): {tester(c+x+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_FAST", "bar" ], [ "CALL_FUNCTION", "bar()" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "CALL_FUNCTION", "tester(a+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "CALL_FUNCTION", "tester(b+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "CALL_FUNCTION", "tester(c+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+y" ], [ "CALL_FUNCTION", "tester(a+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+y" ], [ "CALL_FUNCTION", "tester(b+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+y" ], [ "CALL_FUNCTION", "tester(c+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+x+y" ], [ "CALL_FUNCTION", "tester(a+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+x+y" ], [ "CALL_FUNCTION", "tester(b+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+x+y" ], [ "CALL_FUNCTION", "tester(c+x+y)" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x): {tester(b+x): {tester(c+x) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+y): {tester(b+y): {tester(c+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x+y): {tester(b+x+y): {tester(c+x+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x+y+z): {tester(b+x+y+z): {tester(c+x+y+z) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "CALL_FUNCTION", "tester(a+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "CALL_FUNCTION", "tester(b+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "CALL_FUNCTION", "tester(c+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+y" ], [ "CALL_FUNCTION", "tester(a+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+y" ], [ "CALL_FUNCTION", "tester(b+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+y" ], [ "CALL_FUNCTION", "tester(c+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+x+y" ], [ "CALL_FUNCTION", "tester(a+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+x+y" ], [ "CALL_FUNCTION", "tester(b+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+x+y" ], [ "CALL_FUNCTION", "tester(c+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+x+y" ], [ "LOAD_DEREF", "z" ], [ "BINARY_ADD", "a+x+y+z" ], [ "CALL_FUNCTION", "tester(a+x+y+z)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+x+y" ], [ "LOAD_DEREF", "z" ], [ "BINARY_ADD", "b+x+y+z" ], [ "CALL_FUNCTION", "tester(b+x+y+z)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+x+y" ], [ "LOAD_DEREF", "z" ], [ "BINARY_ADD", "c+x+y+z" ], [ "CALL_FUNCTION", "tester(c+x+y+z)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "dict(x=tester)" ], [ "BINARY_SUBSCR", "dict(x=tester)['x']" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "dict(x=tester)['x'](tester)" ], [ "LOAD_GLOBAL", "False" ], [ "CALL_FUNCTION", "dict(x=tester)['x'](tester)(3, check_func=False)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertRaises" ], [ "LOAD_GLOBAL", "TypeError" ], [ "CALL_METHOD", "self.assertRaises(TypeError)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2, 3])" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(0)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(4)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(5)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "tester(ValueError)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(9)" ], [ "LOAD_GLOBAL", "TypeError" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(10)" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "str()" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertRaises" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "Exception" ], [ "CALL_FUNCTION", "tester(Exception)" ], [ "CALL_METHOD", "self.assertRaises(tester(Exception))" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(0)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(0)" ], [ "LOAD_GLOBAL", "tester" ], [ "BINARY_TRUE_DIVIDE", "1 / 0" ], [ "CALL_FUNCTION", "tester(1 / 0)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "gen" ], [ "CALL_FUNCTION", "gen()" ], [ "CALL_FUNCTION", "list(gen())" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "gen2" ], [ "CALL_FUNCTION", "list(gen2)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(4)" ], [ "LOAD_GLOBAL", "time" ], [ "LOOKUP_METHOD", "time.time" ], [ "CALL_METHOD", "time.time()" ], [ "LOAD_GLOBAL", "range" ], [ "CALL_FUNCTION", "range(10000)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOOKUP_METHOD", "Source.executing" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.currentframe" ], [ "CALL_METHOD", "inspect.currentframe()" ], [ "CALL_METHOD", "Source.executing(inspect.currentframe())" ], [ "LOAD_ATTR", "Source.executing(inspect.currentframe()).node" ], [ "LOAD_FAST", "node" ], [ "COMPARE_OP", "node is None" ], [ "LOAD_FAST", "new_node" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertIs" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "new_node" ], [ "CALL_METHOD", "self.assertIs(node, new_node)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertLess" ], [ "LOAD_GLOBAL", "time" ], [ "LOOKUP_METHOD", "time.time" ], [ "CALL_METHOD", "time.time()" ], [ "LOAD_FAST", "start" ], [ "BINARY_SUBTRACT", "time.time() - start" ], [ "CALL_METHOD", "self.assertLess(time.time() - start, 1)" ], [ "LOAD_GLOBAL", "True" ], [ "LOAD_FAST", "check" ], [ "CALL_FUNCTION", "check(u'# coding=utf8\\n\u00e9', 'utf8')" ], [ "LOAD_FAST", "check" ], [ "CALL_FUNCTION", "check(u'# coding=gbk\\n\u00e9', 'gbk')" ], [ "LOAD_FAST", "check" ], [ "LOAD_GLOBAL", "UnicodeDecodeError" ], [ "CALL_FUNCTION", "check(u'# coding=utf8\\n\u00e9', 'gbk', exception=UnicodeDecodeError)" ], [ "LOAD_FAST", "check" ], [ "LOAD_GLOBAL", "False" ], [ "CALL_FUNCTION", "check(u'# coding=gbk\\n\u00e9', 'utf8', matches=False)" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_FAST", "check" ], [ "CALL_FUNCTION", "check(u'\u00e9', 'utf8')" ], [ "LOAD_FAST", "check" ], [ "LOAD_GLOBAL", "SyntaxError" ], [ "CALL_FUNCTION", "check(u'\u00e9', 'gbk', exception=SyntaxError)" ], [ "LOAD_FAST", "source" ], [ "LOOKUP_METHOD", "source.encode" ], [ "LOAD_FAST", "encoding" ], [ "CALL_METHOD", "source.encode(encoding)" ], [ "LOAD_FAST", "exception" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self.assertRaises" ], [ "LOAD_FAST", "exception" ], [ "CALL_METHOD", "self.assertRaises(exception)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOOKUP_METHOD", "Source.decode_source" ], [ "LOAD_FAST", "encoded" ], [ "CALL_METHOD", "Source.decode_source(encoded)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOOKUP_METHOD", "Source.decode_source" ], [ "LOAD_FAST", "encoded" ], [ "CALL_METHOD", "Source.decode_source(encoded)" ], [ "LOAD_FAST", "matches" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self.assertEqual" ], [ "LOAD_FAST", "decoded" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "self.assertEqual(decoded, source)" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self.assertNotEqual" ], [ "LOAD_FAST", "decoded" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "self.assertNotEqual(decoded, source)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('a')" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('''\n ab''')" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('''\n abc\n def\n '''\n )" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n '''\n 123\n 456\n '''\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n '''\n 345\n 456786\n '''\n )" ], [ "CALL_FUNCTION", "str([\n tester(\n '''\n 123\n 456\n '''\n ),\n tester(\n '''\n 345\n 456786\n '''\n ),\n ])" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n [\n '''\n 123\n 456\n '''\n '''\n 345\n 456786\n '''\n ,\n '''\n 123\n 456\n ''',\n '''\n 345\n 456786\n '''\n ]\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(1)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(2)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(3)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOOKUP_METHOD", "Source.for_filename" ], [ "LOAD_GLOBAL", "__file__" ], [ "CALL_METHOD", "Source.for_filename(__file__)" ], [ "LOOKUP_METHOD", "Source.for_filename(__file__).code_qualname" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.__code__" ], [ "CALL_METHOD", "Source.for_filename(__file__).code_qualname(func.__code__)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertEqual" ], [ "LOAD_FAST", "qn" ], [ "LOAD_FAST", "qualname" ], [ "CALL_METHOD", "self.assertEqual(qn, qualname)" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_FAST", "check_actual_qualname" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertEqual" ], [ "LOAD_FAST", "qn" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.__qualname__" ], [ "CALL_METHOD", "self.assertEqual(qn, func.__qualname__)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertTrue" ], [ "LOAD_FAST", "qn" ], [ "LOOKUP_METHOD", "qn.endswith" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.__name__" ], [ "CALL_METHOD", "qn.endswith(func.__name__)" ], [ "CALL_METHOD", "self.assertTrue(qn.endswith(func.__name__))" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assert_qualname" ], [ "LOAD_GLOBAL", "C" ], [ "LOAD_ATTR", "C.f" ], [ "CALL_METHOD", "self.assert_qualname(C.f, 'C.f')" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assert_qualname" ], [ "LOAD_GLOBAL", "C" ], [ "LOAD_ATTR", "C.D" ], [ "LOAD_ATTR", "C.D.g" ], [ "CALL_METHOD", "self.assert_qualname(C.D.g, 'C.D.g')" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assert_qualname" ], [ "LOAD_GLOBAL", "f" ], [ "CALL_METHOD", "self.assert_qualname(f, 'f')" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assert_qualname" ], [ "LOAD_GLOBAL", "f" ], [ "CALL_FUNCTION", "f()" ], [ "CALL_METHOD", "self.assert_qualname(f(), 'f..g')" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assert_qualname" ], [ "LOAD_GLOBAL", "C" ], [ "LOAD_ATTR", "C.D" ], [ "LOOKUP_METHOD", "C.D.h" ], [ "CALL_METHOD", "C.D.h()" ], [ "CALL_METHOD", "self.assert_qualname(C.D.h(), 'C.D.h..i..j')" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assert_qualname" ], [ "LOAD_GLOBAL", "lamb" ], [ "CALL_METHOD", "self.assert_qualname(lamb, '')" ], [ "LOAD_GLOBAL", "lambda_maker" ], [ "CALL_FUNCTION", "lambda_maker()" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assert_qualname" ], [ "LOAD_FAST", "foo" ], [ "CALL_METHOD", "self.assert_qualname(foo, 'lambda_maker..foo')" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assert_qualname" ], [ "LOAD_FAST", "foo" ], [ "LOAD_ATTR", "foo.x" ], [ "CALL_METHOD", "self.assert_qualname(foo.x, 'lambda_maker..')" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assert_qualname" ], [ "LOAD_FAST", "foo" ], [ "CALL_FUNCTION", "foo()" ], [ "CALL_METHOD", "self.assert_qualname(foo(), 'lambda_maker..foo..')" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assert_qualname" ], [ "LOAD_FAST", "foo" ], [ "CALL_FUNCTION", "foo()" ], [ "CALL_FUNCTION", "foo()()" ], [ "LOAD_GLOBAL", "False" ], [ "CALL_METHOD", "self.assert_qualname(foo()(), 'lambda_maker..foo..', check_actual_qualname=False)" ], [ "LOAD_NAME", "list" ], [ "LOAD_NAME", "range" ], [ "CALL_FUNCTION", "range(66000)" ], [ "CALL_FUNCTION", "list(range(66000))" ], [ "BINARY_MODULO", "'tester(6)\\n%s\\ntester(9)' % list(range(66000))" ], [ "LOAD_NAME", "tempfile" ], [ "LOOKUP_METHOD", "tempfile.mkstemp" ], [ "CALL_METHOD", "tempfile.mkstemp()" ], [ "LOAD_NAME", "compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "compile(source, filename, 'exec')" ], [ "LOAD_NAME", "open" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "open(filename, 'w')" ], [ "LOAD_FAST", "outfile" ], [ "LOOKUP_METHOD", "outfile.write" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "outfile.write(source)" ], [ "LOAD_FAST", "code" ], [ "LOAD_GLOBAL", "range" ], [ "CALL_FUNCTION", "range(5)" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "n" ], [ "CALL_FUNCTION", "range(n)" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "n == 1" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertEqual" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_FAST", "gen" ], [ "CALL_FUNCTION", "only(gen)" ], [ "CALL_METHOD", "self.assertEqual(only(gen), 0)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertRaises" ], [ "LOAD_GLOBAL", "NotOneValueFound" ], [ "CALL_METHOD", "self.assertRaises(NotOneValueFound)" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_FAST", "gen" ], [ "CALL_FUNCTION", "only(gen)" ], [ "LOAD_FAST", "i" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOOKUP_METHOD", "os.path.join" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOOKUP_METHOD", "os.path.dirname" ], [ "LOAD_GLOBAL", "__file__" ], [ "CALL_METHOD", "os.path.dirname(__file__)" ], [ "CALL_METHOD", "os.path.join(os.path.dirname(__file__), 'not_code.txt', )" ], [ "LOAD_GLOBAL", "Source" ], [ "LOOKUP_METHOD", "Source.for_filename" ], [ "LOAD_FAST", "path" ], [ "CALL_METHOD", "Source.for_filename(path)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertIsNone" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.tree" ], [ "CALL_METHOD", "self.assertIsNone(source.tree)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.currentframe" ], [ "CALL_METHOD", "inspect.currentframe()" ], [ "LOAD_GLOBAL", "Source" ], [ "LOOKUP_METHOD", "Source.executing" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "Source.executing(frame)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertEqual" ], [ "LOAD_FAST", "executing" ], [ "LOOKUP_METHOD", "executing.code_qualname" ], [ "CALL_METHOD", "executing.code_qualname()" ], [ "CALL_METHOD", "self.assertEqual(executing.code_qualname(), 'TestStuff.test_executing_methods')" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.version" ], [ "LOOKUP_METHOD", "sys.version.lower" ], [ "CALL_METHOD", "sys.version.lower()" ], [ "COMPARE_OP", "'pypy' not in sys.version.lower()" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertEqual" ], [ "LOAD_FAST", "executing" ], [ "LOOKUP_METHOD", "executing.text" ], [ "CALL_METHOD", "executing.text()" ], [ "LOAD_FAST", "text" ], [ "CALL_METHOD", "self.assertEqual(executing.text(), text)" ], [ "LOAD_FAST", "executing" ], [ "LOOKUP_METHOD", "executing.text_range" ], [ "CALL_METHOD", "executing.text_range()" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertEqual" ], [ "LOAD_FAST", "executing" ], [ "LOAD_ATTR", "executing.source" ], [ "LOAD_ATTR", "executing.source.text" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "SLICE+3", "executing.source.text[start:end]" ], [ "LOAD_FAST", "text" ], [ "CALL_METHOD", "self.assertEqual(executing.source.text[start:end], text)" ], [ "LOAD_GLOBAL", "C" ], [ "CALL_FUNCTION", "C()" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_FAST", "c" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.x" ], [ "LOAD_ATTR", "c.x.x" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.x" ], [ "LOAD_ATTR", "c.x.y" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.y" ], [ "LOAD_ATTR", "c.y.x" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.y" ], [ "LOAD_ATTR", "c.y.y" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.x" ], [ "LOAD_ATTR", "c.x.asd" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.y" ], [ "LOAD_ATTR", "c.y.qwe" ], [ "CALL_FUNCTION", "str((c.x.x, c.x.y, c.y.x, c.y.y, c.x.asd, c.y.qwe))" ], [ "LOAD_GLOBAL", "Source" ], [ "LOOKUP_METHOD", "Source.for_frame" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.currentframe" ], [ "CALL_METHOD", "inspect.currentframe()" ], [ "CALL_METHOD", "Source.for_frame(inspect.currentframe())" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.text" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.filename" ], [ "CALL_FUNCTION", "compile(source.text, source.filename, 'exec')" ], [ "LOAD_GLOBAL", "get_instructions" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "get_instructions(code)" ], [ "LOAD_FAST", "instructions" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.starts_line" ], [ "COMPARE_OP", "inst.starts_line is not None" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.starts_line" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.opname" ], [ "LOOKUP_METHOD", "inst.opname.startswith" ], [ "CALL_METHOD", "inst.opname.startswith(\n ('BINARY_', 'UNARY_', 'LOAD_ATTR', 'LOAD_METHOD', 'LOOKUP_METHOD', 'COMPARE_OP'))" ], [ "LOAD_GLOBAL", "C" ], [ "CALL_FUNCTION", "C()" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.offset" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "frame" ], [ "LOAD_GLOBAL", "globals" ], [ "CALL_FUNCTION", "globals()" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "lineno" ], [ "LOAD_FAST", "frame" ], [ "LOAD_GLOBAL", "print" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.opname" ], [ "CALL_FUNCTION", "print(inst.opname)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOOKUP_METHOD", "Source.executing" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "Source.executing(frame)" ], [ "LOAD_ATTR", "Source.executing(frame).node" ], [ "COMPARE_OP", "Source.executing(frame).node is not None" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_FAST", "i" ], [ "CALL_FUNCTION", "i()" ], [ "LOAD_FAST", "j" ], [ "LOAD_FAST", "g" ], [ "LOAD_FAST", "assign" ], [ "CALL_FUNCTION", "assign(lambda: 1)" ], [ "CALL_FUNCTION", "assign(lambda: 1)" ], [ "LOAD_FAST", "foo" ], [ "LOAD_FAST", "decorator" ], [ "LOAD_DEREF", "x" ], [ "LOAD_FAST", "func" ], [ "LOAD_FAST", "func" ], [ "LOAD_NAME", "True" ], [ "LOAD_NAME", "__add__" ], [ "LOAD_NAME", "__invert__" ], [ "LOAD_NAME", "__lt__" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.currentframe" ], [ "CALL_METHOD", "inspect.currentframe()" ], [ "LOAD_ATTR", "inspect.currentframe().f_back" ], [ "LOAD_ATTR", "inspect.currentframe().f_back.f_back" ], [ "LOAD_GLOBAL", "Source" ], [ "LOOKUP_METHOD", "Source.lazycache" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "Source.lazycache(frame)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOOKUP_METHOD", "Source.executing" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "Source.executing(frame)" ], [ "LOAD_ATTR", "Source.executing(frame).node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "typ" ], [ "CALL_FUNCTION", "isinstance(node, typ)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "typ" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.currentframe" ], [ "CALL_METHOD", "inspect.currentframe()" ], [ "LOAD_ATTR", "inspect.currentframe().f_back" ], [ "LOAD_ATTR", "inspect.currentframe().f_back.f_back" ], [ "LOAD_GLOBAL", "eval" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.Expression" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.Expression(node)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_filename" ], [ "CALL_FUNCTION", "compile(ast.Expression(node), frame.f_code.co_filename, 'eval')" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "CALL_FUNCTION", "eval(\n compile(ast.Expression(node), frame.f_code.co_filename, 'eval'),\n frame.f_globals,\n frame.f_locals,\n )" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "value" ], [ "COMPARE_OP", "result == value" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Call" ], [ "CALL_METHOD", "self.get_node(ast.Call)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.check" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.args" ], [ "BINARY_SUBSCR", "call.args[0]" ], [ "LOAD_FAST", "arg" ], [ "CALL_METHOD", "self.check(call.args[0], arg)" ], [ "LOAD_FAST", "check_func" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.check" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.func" ], [ "LOAD_FAST", "self" ], [ "CALL_METHOD", "self.check(call.func, self)" ], [ "LOAD_FAST", "returns" ], [ "COMPARE_OP", "returns is None" ], [ "LOAD_FAST", "arg" ], [ "LOAD_FAST", "returns" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Attribute" ], [ "CALL_METHOD", "self.get_node(ast.Attribute)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.value" ], [ "LOAD_FAST", "self" ], [ "CALL_METHOD", "self.check(node.value, self)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.attr" ], [ "LOAD_FAST", "item" ], [ "COMPARE_OP", "node.attr == item" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Subscript" ], [ "CALL_METHOD", "self.get_node(ast.Subscript)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.value" ], [ "LOAD_FAST", "self" ], [ "CALL_METHOD", "self.check(node.value, self)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.slice" ], [ "LOAD_ATTR", "node.slice.value" ], [ "LOAD_FAST", "item" ], [ "CALL_METHOD", "self.check(node.slice.value, item)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.BinOp" ], [ "CALL_METHOD", "self.get_node(ast.BinOp)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.left" ], [ "LOAD_FAST", "self" ], [ "CALL_METHOD", "self.check(node.left, self)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.right" ], [ "LOAD_FAST", "other" ], [ "CALL_METHOD", "self.check(node.right, other)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.UnaryOp" ], [ "CALL_METHOD", "self.get_node(ast.UnaryOp)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.operand" ], [ "LOAD_FAST", "self" ], [ "CALL_METHOD", "self.check(node.operand, self)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Compare" ], [ "CALL_METHOD", "self.get_node(ast.Compare)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.left" ], [ "LOAD_FAST", "self" ], [ "CALL_METHOD", "self.check(node.left, self)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.comparators" ], [ "BINARY_SUBSCR", "node.comparators[0]" ], [ "LOAD_FAST", "other" ], [ "CALL_METHOD", "self.check(node.comparators[0], other)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "func" ], [ "LOAD_GLOBAL", "empty_decorator" ] ], "tracer.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOOKUP_METHOD", "standard_library.install_aliases" ], [ "CALL_METHOD", "standard_library.install_aliases()" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "NamedTuple" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "Union" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "BINARY_SUBSCR", "Union[ast.expr, ast.stmt]" ], [ "BINARY_SUBSCR", "Optional[Union[ast.expr, ast.stmt]]" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.AST" ], [ "LOAD_NAME", "FrameType" ], [ "LOAD_NAME", "FrameType" ], [ "CALL_FUNCTION", "NamedTuple('EnterCallInfo', [\n\n # Node from where the call was made\n ('call_node', Optional[Union[ast.expr, ast.stmt]]),\n\n # Node where the call begins\n ('enter_node', ast.AST),\n\n # Frame from which the call was made\n ('caller_frame', FrameType),\n\n # Frame of the call\n ('current_frame', FrameType)])" ], [ "LOAD_NAME", "NamedTuple" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "Union" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "BINARY_SUBSCR", "Union[ast.expr, ast.stmt]" ], [ "BINARY_SUBSCR", "Optional[Union[ast.expr, ast.stmt]]" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.Return" ], [ "BINARY_SUBSCR", "Optional[ast.Return]" ], [ "LOAD_NAME", "FrameType" ], [ "LOAD_NAME", "FrameType" ], [ "LOAD_NAME", "Any" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "Exception" ], [ "BINARY_SUBSCR", "Optional[Exception]" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "TracebackType" ], [ "BINARY_SUBSCR", "Optional[TracebackType]" ], [ "CALL_FUNCTION", "NamedTuple('ExitCallInfo', [\n\n # Node from where the call was made\n ('call_node', Optional[Union[ast.expr, ast.stmt]]),\n\n # Node where the call explicitly returned\n ('return_node', Optional[ast.Return]),\n\n # Frame from which the call was made\n ('caller_frame', FrameType),\n\n # Frame of the call\n ('current_frame', FrameType),\n\n # Node where the call explicitly returned\n ('return_value', Any),\n\n # Exception raised in the call causing it to end,\n # will propagate to the caller\n ('exc_value', Optional[Exception]),\n\n # Traceback corresponding to exc_value\n ('exc_tb', Optional[TracebackType])])" ], [ "LOAD_NAME", "namedtuple" ], [ "CALL_FUNCTION", "namedtuple('ChangeValue', 'value')" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.NodeTransformer" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "Union" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "BINARY_SUBSCR", "Union[ast.For, ast.While, ast.comprehension]" ], [ "LOAD_NAME", "False" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.PyCF_ONLY_AST" ], [ "LOAD_FAST", "flags" ], [ "BINARY_OR", "ast.PyCF_ONLY_AST | flags" ], [ "LOAD_GLOBAL", "True" ], [ "CALL_FUNCTION", "compile(source, filename, 'exec', ast.PyCF_ONLY_AST | flags, dont_inherit=True)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.set_basic_node_attributes" ], [ "CALL_METHOD", "self.set_basic_node_attributes()" ], [ "LOAD_FAST", "tracer" ], [ "LOOKUP_METHOD", "tracer.parse_extra" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "CALL_METHOD", "tracer.parse_extra(self.root, source, filename)" ], [ "LOAD_FAST", "new_root" ], [ "COMPARE_OP", "new_root is not None" ], [ "LOAD_FAST", "new_root" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.set_basic_node_attributes" ], [ "CALL_METHOD", "self.set_basic_node_attributes()" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.set_enter_call_nodes" ], [ "CALL_METHOD", "self.set_enter_call_nodes()" ], [ "LOAD_GLOBAL", "deepcopy" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "CALL_FUNCTION", "deepcopy(self.root)" ], [ "LOAD_GLOBAL", "_NodeVisitor" ], [ "CALL_FUNCTION", "_NodeVisitor()" ], [ "LOOKUP_METHOD", "_NodeVisitor().visit" ], [ "LOAD_FAST", "new_root" ], [ "CALL_METHOD", "_NodeVisitor().visit(new_root)" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "new_root" ], [ "LOAD_FAST", "filename" ], [ "LOAD_GLOBAL", "True" ], [ "LOAD_FAST", "flags" ], [ "CALL_FUNCTION", "compile(new_root, filename, \"exec\", dont_inherit=True, flags=flags)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.walk" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "CALL_METHOD", "ast.walk(self.root)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.iter_child_nodes" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.iter_child_nodes(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.nodes" ], [ "CALL_FUNCTION", "len(self.nodes)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.nodes" ], [ "LOOKUP_METHOD", "self.nodes.append" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self.nodes.append(node)" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "LOAD_ATTR", "self.root.body" ], [ "CALL_FUNCTION", "enumerate(self.root.body)" ], [ "LOAD_GLOBAL", "is_future_import" ], [ "LOAD_FAST", "stmt" ], [ "CALL_FUNCTION", "is_future_import(stmt)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "LOAD_ATTR", "self.root.body" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "SLICE+2", "self.root.body[:i + 1]" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.walk" ], [ "LOAD_FAST", "s" ], [ "CALL_METHOD", "ast.walk(s)" ], [ "LOAD_GLOBAL", "True" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.nodes" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Module" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(node, (ast.Module, ast.FunctionDef))" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.body" ], [ "LOAD_GLOBAL", "is_future_import" ], [ "LOAD_FAST", "stmt" ], [ "CALL_FUNCTION", "is_future_import(stmt)" ], [ "LOAD_GLOBAL", "True" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_NAME", "lru_cache" ], [ "CALL_FUNCTION", "lru_cache()" ], [ "CALL_FUNCTION", "lru_cache()" ], [ "LOAD_NAME", "False" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "defaultdict(list)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "TracedFile" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "flags" ], [ "CALL_FUNCTION", "TracedFile(self, source, filename, flags)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._treetrace_hidden_with_stmt" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._treetrace_hidden_before_expr" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._treetrace_hidden_after_expr" ], [ "LOAD_GLOBAL", "partial" ], [ "LOAD_FAST", "f" ], [ "LOAD_DEREF", "traced_file" ], [ "CALL_FUNCTION", "partial(f, traced_file)" ], [ "LOAD_FAST", "f" ], [ "LOAD_ATTR", "f.__name__" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_DEREF", "func" ], [ "LOAD_GLOBAL", "FunctionType" ], [ "CALL_FUNCTION", "isinstance(func, FunctionType)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError('You can only trace user-defined functions. '\n 'The birdseye decorator must be applied first, '\n 'at the bottom of the list.')" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.iscoroutinefunction" ], [ "LOAD_DEREF", "func" ], [ "CALL_METHOD", "inspect.iscoroutinefunction(func)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.isasyncgenfunction" ], [ "LOAD_DEREF", "func" ], [ "CALL_METHOD", "inspect.isasyncgenfunction(func)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError('You cannot trace async functions')" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_GLOBAL", "is_lambda" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "is_lambda(func)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError('You cannot trace lambdas')" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.getsourcefile" ], [ "LOAD_DEREF", "func" ], [ "CALL_METHOD", "inspect.getsourcefile(func)" ], [ "LOAD_GLOBAL", "is_ipython_cell" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "is_ipython_cell(filename)" ], [ "LOAD_FAST", "get_ipython" ], [ "CALL_FUNCTION", "get_ipython()" ], [ "LOAD_ATTR", "get_ipython().compile" ], [ "LOAD_ATTR", "get_ipython().compile.flags" ], [ "LOOKUP_METHOD", "''.join" ], [ "LOAD_FAST", "linecache" ], [ "LOAD_ATTR", "linecache.cache" ], [ "LOAD_FAST", "filename" ], [ "BINARY_SUBSCR", "linecache.cache[filename]" ], [ "BINARY_SUBSCR", "linecache.cache[filename][2]" ], [ "CALL_METHOD", "''.join(linecache.cache[filename][2])" ], [ "LOAD_GLOBAL", "read_source_file" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "read_source_file(filename)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "flags" ], [ "CALL_METHOD", "self.compile(source, filename, flags)" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__dict__" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError('The birdseye decorator must be applied first, '\n 'at the bottom of the list.')" ], [ "LOAD_DEREF", "find_code" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.code" ], [ "CALL_FUNCTION", "find_code(traced_file.code)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_DEREF", "code_options" ], [ "CALL_FUNCTION", "len(code_options)" ], [ "COMPARE_OP", "len(code_options) > 1" ], [ "LOAD_GLOBAL", "is_lambda" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "is_lambda(func)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError(\"Failed to trace lambda. Convert the function to a def.\")" ], [ "LOAD_DEREF", "code_options" ], [ "BINARY_SUBSCR", "code_options[0]" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__globals__" ], [ "LOOKUP_METHOD", "func.__globals__.update" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._trace_methods_dict" ], [ "LOAD_FAST", "traced_file" ], [ "CALL_METHOD", "self._trace_methods_dict(traced_file)" ], [ "CALL_METHOD", "func.__globals__.update(self._trace_methods_dict(traced_file))" ], [ "LOAD_GLOBAL", "FunctionType" ], [ "LOAD_FAST", "new_func_code" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__globals__" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__name__" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__defaults__" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__closure__" ], [ "CALL_FUNCTION", "FunctionType(new_func_code, func.__globals__, func.__name__, func.__defaults__, func.__closure__)" ], [ "LOAD_GLOBAL", "update_wrapper" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "update_wrapper(new_func, func)" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "getattr(func, '__kwdefaults__', None)" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_FAST", "root_code" ], [ "LOAD_ATTR", "root_code.co_consts" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.iscode" ], [ "LOAD_FAST", "const" ], [ "CALL_METHOD", "inspect.iscode(const)" ], [ "LOAD_FAST", "const" ], [ "LOAD_ATTR", "const.co_firstlineno" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__code__" ], [ "LOAD_ATTR", "func.__code__.co_firstlineno" ], [ "COMPARE_OP", "const.co_firstlineno == func.__code__.co_firstlineno" ], [ "LOAD_FAST", "const" ], [ "LOAD_ATTR", "const.co_name" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__code__" ], [ "LOAD_ATTR", "func.__code__.co_name" ], [ "COMPARE_OP", "const.co_name == func.__code__.co_name" ], [ "LOAD_FAST", "matches" ], [ "LOAD_DEREF", "code_options" ], [ "LOOKUP_METHOD", "code_options.append" ], [ "LOAD_FAST", "const" ], [ "CALL_METHOD", "code_options.append(const)" ], [ "LOAD_DEREF", "find_code" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "find_code(const)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.isclass" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "inspect.isclass(func)" ], [ "LOAD_GLOBAL", "TypeError" ], [ "CALL_FUNCTION", "TypeError('Decorating classes is no longer supported')" ], [ "LOAD_FAST", "func" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self.trace_function" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "self.trace_function(func)" ], [ "LOAD_FAST", "optional" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.trace_function" ], [ "LOAD_FAST", "decorator" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self.trace_function" ], [ "LOAD_DEREF", "actual_func" ], [ "CALL_METHOD", "self.trace_function(actual_func)" ], [ "LOAD_GLOBAL", "wraps" ], [ "LOAD_DEREF", "actual_func" ], [ "CALL_FUNCTION", "wraps(actual_func)" ], [ "CALL_FUNCTION", "wraps(actual_func)" ], [ "LOAD_FAST", "wrapper" ], [ "LOAD_FAST", "kwargs" ], [ "LOOKUP_METHOD", "kwargs.pop" ], [ "LOAD_GLOBAL", "False" ], [ "CALL_METHOD", "kwargs.pop('trace_call', False)" ], [ "LOAD_FAST", "trace_call" ], [ "LOAD_DEREF", "traced" ], [ "LOAD_DEREF", "actual_func" ], [ "LOAD_FAST", "f" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "f(*args, **kwargs)" ], [ "LOAD_GLOBAL", "sys" ], [ "LOOKUP_METHOD", "sys._getframe" ], [ "CALL_METHOD", "sys._getframe(2)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.secondary_to_main_frames" ], [ "LOOKUP_METHOD", "self.secondary_to_main_frames.get" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self.secondary_to_main_frames.get(frame)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "COMPARE_OP", "frame.f_code.co_name in ('', '', '')" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_GLOBAL", "ancestors" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ancestors(node)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Lambda" ], [ "CALL_FUNCTION", "isinstance(node, (ast.FunctionDef, ast.Lambda))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.ClassDef" ], [ "CALL_FUNCTION", "isinstance(node, ast.ClassDef)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "COMPARE_OP", "frame.f_code.co_name in ('', '')" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.secondary_to_main_frames" ], [ "LOAD_FAST", "original_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.main_to_secondary_frames" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.main_to_secondary_frames[frame]" ], [ "LOOKUP_METHOD", "self.main_to_secondary_frames[frame].append" ], [ "LOAD_FAST", "original_frame" ], [ "CALL_METHOD", "self.main_to_secondary_frames[frame].append(original_frame)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.nodes" ], [ "LOAD_FAST", "_tree_index" ], [ "BINARY_SUBSCR", "traced_file.nodes[_tree_index]" ], [ "LOAD_GLOBAL", "cast" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "cast(ast.stmt, node)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._main_frame" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self._main_frame(node)" ], [ "LOAD_GLOBAL", "_StmtContext" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "_StmtContext(self, node, frame)" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.nodes" ], [ "LOAD_FAST", "_tree_index" ], [ "BINARY_SUBSCR", "traced_file.nodes[_tree_index]" ], [ "LOAD_GLOBAL", "cast" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "cast(ast.expr, node)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._main_frame" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self._main_frame(node)" ], [ "LOAD_FAST", "frame" ], [ "COMPARE_OP", "frame is None" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_stack" ], [ "LOOKUP_METHOD", "frame_info.expression_stack.append" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "frame_info.expression_stack.append(node)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.before_expr" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self.before_expr(node, frame)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._main_frame" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self._main_frame(node)" ], [ "LOAD_FAST", "frame" ], [ "COMPARE_OP", "frame is None" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._after_expr" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "value" ], [ "CALL_METHOD", "self._after_expr(node, frame, value, None, None)" ], [ "LOAD_FAST", "result" ], [ "COMPARE_OP", "result is not None" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "ChangeValue" ], [ "CALL_FUNCTION", "isinstance(result, ChangeValue)" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.value" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_stack" ], [ "LOOKUP_METHOD", "frame_info.expression_stack.pop" ], [ "CALL_METHOD", "frame_info.expression_stack.pop()" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_values" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.after_expr" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "exc_value" ], [ "LOAD_FAST", "exc_tb" ], [ "CALL_METHOD", "self.after_expr(node, frame, value, exc_value, exc_tb)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._get_caller_stuff" ], [ "LOAD_FAST", "current_frame" ], [ "CALL_METHOD", "self._get_caller_stuff(current_frame)" ], [ "LOAD_GLOBAL", "FrameInfo" ], [ "CALL_FUNCTION", "FrameInfo()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "current_frame" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.enter_call" ], [ "LOAD_GLOBAL", "EnterCallInfo" ], [ "LOAD_FAST", "call_node" ], [ "LOAD_FAST", "enter_node" ], [ "LOAD_FAST", "caller_frame" ], [ "LOAD_FAST", "current_frame" ], [ "CALL_FUNCTION", "EnterCallInfo(call_node, enter_node, caller_frame, current_frame)" ], [ "CALL_METHOD", "self.enter_call(EnterCallInfo(call_node, enter_node, caller_frame, current_frame))" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.secondary_to_main_frames" ], [ "LOOKUP_METHOD", "self.secondary_to_main_frames.get" ], [ "LOAD_FAST", "caller_frame" ], [ "CALL_METHOD", "self.secondary_to_main_frames.get(caller_frame)" ], [ "LOAD_FAST", "main_frame" ], [ "LOAD_FAST", "main_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "caller_frame" ], [ "BINARY_SUBSCR", "self.stack[caller_frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_stack" ], [ "LOAD_FAST", "expression_stack" ], [ "LOAD_FAST", "expression_stack" ], [ "BINARY_SUBSCR", "expression_stack[-1]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.statement_stack" ], [ "BINARY_SUBSCR", "frame_info.statement_stack[-1]" ], [ "LOAD_FAST", "caller_frame" ], [ "LOAD_FAST", "call_node" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "False" ], [ "CALL_FUNCTION", "getattr(node, '_visit_ignore', False)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "CALL_FUNCTION", "isinstance(node, ast.expr)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "hasattr(node, \"ctx\")" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.ctx" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Load" ], [ "CALL_FUNCTION", "isinstance(node.ctx, ast.Load)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "ast" ], [ "CALL_FUNCTION", "getattr(ast, 'Starred', ())" ], [ "CALL_FUNCTION", "isinstance(node, getattr(ast, 'Starred', ()))" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.visit_expr" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self.visit_expr(node)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "CALL_FUNCTION", "isinstance(node, ast.stmt)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.visit_stmt" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self.visit_stmt(node)" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "_NodeVisitor" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self)" ], [ "LOOKUP_METHOD", "super(_NodeVisitor, self).generic_visit" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "super(_NodeVisitor, self).generic_visit(node)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._create_simple_marker_call" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "TreeTracerBase" ], [ "LOAD_ATTR", "TreeTracerBase._treetrace_hidden_before_expr" ], [ "CALL_METHOD", "self._create_simple_marker_call(node, TreeTracerBase._treetrace_hidden_before_expr)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.copy_location" ], [ "LOAD_FAST", "before_marker" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.copy_location(before_marker, node)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.Call" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.Name" ], [ "LOAD_GLOBAL", "TreeTracerBase" ], [ "LOAD_ATTR", "TreeTracerBase._treetrace_hidden_after_expr" ], [ "LOAD_ATTR", "TreeTracerBase._treetrace_hidden_after_expr.__name__" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.Load" ], [ "CALL_METHOD", "ast.Load()" ], [ "CALL_METHOD", "ast.Name(id=TreeTracerBase._treetrace_hidden_after_expr.__name__,\n ctx=ast.Load())" ], [ "LOAD_FAST", "before_marker" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "_NodeVisitor" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self)" ], [ "LOOKUP_METHOD", "super(_NodeVisitor, self).generic_visit" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "super(_NodeVisitor, self).generic_visit(node)" ], [ "CALL_METHOD", "ast.Call(\n func=ast.Name(id=TreeTracerBase._treetrace_hidden_after_expr.__name__,\n ctx=ast.Load()),\n args=[\n before_marker,\n super(_NodeVisitor, self).generic_visit(node),\n ],\n keywords=[],\n )" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.copy_location" ], [ "LOAD_FAST", "after_marker" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.copy_location(after_marker, node)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.fix_missing_locations" ], [ "LOAD_FAST", "after_marker" ], [ "CALL_METHOD", "ast.fix_missing_locations(after_marker)" ], [ "LOAD_FAST", "after_marker" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._create_simple_marker_call" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "_NodeVisitor" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self)" ], [ "LOOKUP_METHOD", "super(_NodeVisitor, self).generic_visit" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "super(_NodeVisitor, self).generic_visit(node)" ], [ "LOAD_GLOBAL", "TreeTracerBase" ], [ "LOAD_ATTR", "TreeTracerBase._treetrace_hidden_with_stmt" ], [ "CALL_METHOD", "self._create_simple_marker_call(\n super(_NodeVisitor, self).generic_visit(node),\n TreeTracerBase._treetrace_hidden_with_stmt)" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.With" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.withitem" ], [ "LOAD_FAST", "context_expr" ], [ "CALL_METHOD", "ast.withitem(context_expr=context_expr)" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.With(\n items=[ast.withitem(context_expr=context_expr)],\n body=[node],\n )" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.With" ], [ "LOAD_FAST", "context_expr" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.With(\n context_expr=context_expr,\n body=[node],\n )" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.copy_location" ], [ "LOAD_FAST", "wrapped" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.copy_location(wrapped, node)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.fix_missing_locations" ], [ "LOAD_FAST", "wrapped" ], [ "CALL_METHOD", "ast.fix_missing_locations(wrapped)" ], [ "LOAD_FAST", "wrapped" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.Call" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.Name" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.__name__" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.Load" ], [ "CALL_METHOD", "ast.Load()" ], [ "CALL_METHOD", "ast.Name(id=func.__name__,\n ctx=ast.Load())" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.Num" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "CALL_METHOD", "ast.Num(node._tree_index)" ], [ "CALL_METHOD", "ast.Call(\n func=ast.Name(id=func.__name__,\n ctx=ast.Load()),\n args=[ast.Num(node._tree_index)],\n keywords=[],\n )" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tracer" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "False" ], [ "CALL_FUNCTION", "getattr(node, '_enter_call_node', False)" ], [ "LOAD_FAST", "tracer" ], [ "LOOKUP_METHOD", "tracer._enter_call" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "tracer._enter_call(node, frame)" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "tracer.stack[frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.statement_stack" ], [ "LOOKUP_METHOD", "frame_info.statement_stack.append" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "frame_info.statement_stack.append(node)" ], [ "LOAD_FAST", "tracer" ], [ "LOOKUP_METHOD", "tracer.before_stmt" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "tracer.before_stmt(node, frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tracer" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "tracer.stack[frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.statement_stack" ], [ "LOOKUP_METHOD", "frame_info.statement_stack.pop" ], [ "CALL_METHOD", "frame_info.statement_stack.pop()" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.exc_value" ], [ "COMPARE_OP", "exc_val is not frame_info.exc_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_stack" ], [ "LOAD_FAST", "expression_stack" ], [ "LOAD_FAST", "expression_stack" ], [ "BINARY_SUBSCR", "expression_stack[-1]" ], [ "LOAD_FAST", "tracer" ], [ "LOOKUP_METHOD", "tracer._after_expr" ], [ "LOAD_FAST", "exc_node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "exc_tb" ], [ "CALL_METHOD", "tracer._after_expr(exc_node, frame, None, exc_val, exc_tb)" ], [ "LOAD_FAST", "tracer" ], [ "LOOKUP_METHOD", "tracer.after_stmt" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "exc_tb" ], [ "LOAD_FAST", "exc_node" ], [ "CALL_METHOD", "tracer.after_stmt(node, frame, exc_val, exc_tb, exc_node)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Return" ], [ "CALL_FUNCTION", "isinstance(node, ast.Return)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.return_node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Module" ], [ "CALL_FUNCTION", "isinstance(parent, (ast.FunctionDef, ast.Module))" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.body" ], [ "BINARY_SUBSCR", "parent.body[-1]" ], [ "COMPARE_OP", "node is parent.body[-1]" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_FAST", "exiting" ], [ "LOAD_FAST", "tracer" ], [ "LOOKUP_METHOD", "tracer._get_caller_stuff" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "tracer._get_caller_stuff(frame)" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_ATTR", "return_node.value" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_values" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_ATTR", "return_node.value" ], [ "BINARY_SUBSCR", "frame_info.expression_values[return_node.value]" ], [ "LOAD_FAST", "tracer" ], [ "LOOKUP_METHOD", "tracer.exit_call" ], [ "LOAD_GLOBAL", "ExitCallInfo" ], [ "LOAD_FAST", "call_node" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_FAST", "caller_frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "return_value" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "exc_tb" ], [ "CALL_FUNCTION", "ExitCallInfo(call_node,\n return_node,\n caller_frame,\n frame,\n return_value,\n exc_val,\n exc_tb\n )" ], [ "CALL_METHOD", "tracer.exit_call(ExitCallInfo(call_node,\n return_node,\n caller_frame,\n frame,\n return_value,\n exc_val,\n exc_tb\n ))" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.stack" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tracer" ], [ "LOAD_ATTR", "self.tracer.main_to_secondary_frames" ], [ "LOOKUP_METHOD", "self.tracer.main_to_secondary_frames.pop" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self.tracer.main_to_secondary_frames.pop(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tracer" ], [ "LOAD_ATTR", "self.tracer.secondary_to_main_frames" ], [ "LOAD_FAST", "secondary_frame" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "True" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "True" ], [ "LOAD_DEREF", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(parent, ast.FunctionDef)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "CALL_FUNCTION", "isinstance(parent, ast.For)" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.iter" ], [ "LOAD_DEREF", "node" ], [ "COMPARE_OP", "parent.iter is not node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "CALL_FUNCTION", "isinstance(parent, ast.While)" ], [ "LOAD_DEREF", "node" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.orelse" ], [ "COMPARE_OP", "node not in parent.orelse" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "CALL_FUNCTION", "isinstance(parent, ast.comprehension)" ], [ "LOAD_DEREF", "node" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.ifs" ], [ "COMPARE_OP", "node in parent.ifs" ], [ "LOAD_FAST", "is_containing_loop" ], [ "LOAD_FAST", "result" ], [ "LOOKUP_METHOD", "result.append" ], [ "LOAD_FAST", "parent" ], [ "CALL_METHOD", "result.append(parent)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.ListComp" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.GeneratorExp" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.DictComp" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.SetComp" ], [ "CALL_FUNCTION", "isinstance(parent, (ast.ListComp,\n ast.GeneratorExp,\n ast.DictComp,\n ast.SetComp))" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.generators" ], [ "LOAD_DEREF", "node" ], [ "LOAD_FAST", "generators" ], [ "COMPARE_OP", "node in generators" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "takewhile" ], [ "LOAD_FAST", "generators" ], [ "CALL_FUNCTION", "takewhile(lambda n: n != node, generators)" ], [ "CALL_FUNCTION", "list(takewhile(lambda n: n != node, generators))" ], [ "LOAD_FAST", "result" ], [ "LOOKUP_METHOD", "result.extend" ], [ "LOAD_GLOBAL", "reversed" ], [ "LOAD_FAST", "generators" ], [ "CALL_FUNCTION", "reversed(generators)" ], [ "CALL_METHOD", "result.extend(reversed(generators))" ], [ "LOAD_FAST", "parent" ], [ "LOAD_FAST", "result" ], [ "LOOKUP_METHOD", "result.reverse" ], [ "CALL_METHOD", "result.reverse()" ], [ "LOAD_GLOBAL", "tuple" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "tuple(result)" ], [ "LOAD_FAST", "n" ], [ "LOAD_DEREF", "node" ], [ "COMPARE_OP", "n != node" ] ], "tracer2.py": [ [ "LOAD_NAME", "find_repr_function" ], [ "LOAD_NAME", "six" ], [ "LOAD_ATTR", "six.text_type" ], [ "CALL_FUNCTION", "find_repr_function(six.text_type)" ], [ "LOAD_NAME", "find_repr_function" ], [ "LOAD_NAME", "six" ], [ "LOAD_ATTR", "six.binary_type" ], [ "CALL_FUNCTION", "find_repr_function(six.binary_type)" ], [ "LOAD_NAME", "find_repr_function" ], [ "LOAD_NAME", "object" ], [ "CALL_FUNCTION", "find_repr_function(object)" ], [ "LOAD_NAME", "find_repr_function" ], [ "LOAD_NAME", "int" ], [ "CALL_FUNCTION", "find_repr_function(int)" ], [ "LOAD_NAME", "cheap_repr" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "threading" ], [ "LOOKUP_METHOD", "threading.local" ], [ "CALL_METHOD", "threading.local()" ], [ "LOAD_NAME", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOOKUP_METHOD", "os.path.dirname" ], [ "LOAD_ATTR", "(lambda: 0).__code__" ], [ "LOAD_ATTR", "(lambda: 0).__code__.co_filename" ], [ "CALL_METHOD", "os.path.dirname((lambda: 0).__code__.co_filename)" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOOKUP_METHOD", "os.path.dirname" ], [ "LOAD_NAME", "birdseye" ], [ "LOAD_ATTR", "birdseye.__file__" ], [ "CALL_METHOD", "os.path.dirname(birdseye.__file__)" ], [ "LOAD_NAME", "type" ], [ "LOAD_NAME", "six" ], [ "LOOKUP_METHOD", "six.add_metaclass" ], [ "LOAD_NAME", "TracerMeta" ], [ "CALL_METHOD", "six.add_metaclass(TracerMeta)" ], [ "LOAD_NAME", "object" ], [ "CALL_FUNCTION", "six.add_metaclass(TracerMeta)" ], [ "LOAD_NAME", "object" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lineno" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "CALL_FUNCTION", "OrderedDict()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "Source" ], [ "LOOKUP_METHOD", "Source.for_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "Source.for_frame(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_flags" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.CO_GENERATOR" ], [ "BINARY_AND", "frame.f_code.co_flags & inspect.CO_GENERATOR" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "False" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "is_comprehension_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "is_comprehension_frame(frame)" ], [ "LOAD_GLOBAL", "re" ], [ "LOOKUP_METHOD", "re.match" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "CALL_METHOD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name)" ], [ "LOOKUP_METHOD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group" ], [ "CALL_METHOD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group(1)" ], [ "LOOKUP_METHOD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group(1).title" ], [ "CALL_METHOD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group(1).title()" ], [ "BINARY_ADD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group(1).title()\n + u' comprehension'" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_lineno" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.local_reprs" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.get_local_reprs" ], [ "LOAD_FAST", "watch" ], [ "LOAD_FAST", "watch_extras" ], [ "CALL_METHOD", "self.get_local_reprs(watch, watch_extras)" ], [ "CALL_FUNCTION", "OrderedDict(\n (source, my_cheap_repr(value))\n for source, value in\n self.get_local_reprs(watch, watch_extras)\n )" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.comprehension_type" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.local_reprs" ], [ "LOOKUP_METHOD", "self.local_reprs.items" ], [ "CALL_METHOD", "self.local_reprs.items()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.comprehension_variables" ], [ "LOOKUP_METHOD", "self.comprehension_variables.setdefault" ], [ "LOAD_FAST", "name" ], [ "CALL_METHOD", "self.comprehension_variables.setdefault(name, [])" ], [ "LOAD_FAST", "values" ], [ "LOAD_FAST", "values" ], [ "BINARY_SUBSCR", "values[-1]" ], [ "LOAD_FAST", "value_repr" ], [ "COMPARE_OP", "values[-1] != value_repr" ], [ "LOAD_FAST", "values" ], [ "LOOKUP_METHOD", "values.append" ], [ "LOAD_FAST", "value_repr" ], [ "CALL_METHOD", "values.append(value_repr)" ], [ "LOAD_GLOBAL", "truncate_list" ], [ "LOAD_FAST", "values" ], [ "CALL_FUNCTION", "truncate_list(values, 11)" ], [ "LOAD_FAST", "values" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event in ('return', 'exception')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.comprehension_variables" ], [ "LOOKUP_METHOD", "self.comprehension_variables.items" ], [ "CALL_METHOD", "self.comprehension_variables.items()" ], [ "LOAD_FAST", "name" ], [ "LOOKUP_METHOD", "', '.join" ], [ "LOAD_FAST", "values" ], [ "CALL_METHOD", "', '.join(values)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.local_reprs" ], [ "LOOKUP_METHOD", "self.local_reprs.items" ], [ "CALL_METHOD", "self.local_reprs.items()" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "old_local_reprs" ], [ "COMPARE_OP", "name not in old_local_reprs" ], [ "LOAD_FAST", "old_local_reprs" ], [ "LOAD_FAST", "name" ], [ "BINARY_SUBSCR", "old_local_reprs[name]" ], [ "LOAD_FAST", "value_repr" ], [ "COMPARE_OP", "old_local_reprs[name] != value_repr" ], [ "LOAD_FAST", "variables" ], [ "LOOKUP_METHOD", "variables.append" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "value_repr" ], [ "CALL_METHOD", "variables.append((name, value_repr))" ], [ "LOAD_FAST", "variables" ], [ "LOAD_FAST", "source" ], [ "LOAD_GLOBAL", "my_cheap_repr" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "my_cheap_repr(value)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_varnames" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_cellvars" ], [ "BINARY_ADD", "code.co_varnames + code.co_cellvars" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_freevars" ], [ "BINARY_ADD", "code.co_varnames + code.co_cellvars + code.co_freevars" ], [ "LOAD_GLOBAL", "tuple" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "LOOKUP_METHOD", "frame.f_locals.keys" ], [ "CALL_METHOD", "frame.f_locals.keys()" ], [ "CALL_FUNCTION", "tuple(frame.f_locals.keys())" ], [ "BINARY_ADD", "code.co_varnames + code.co_cellvars + code.co_freevars + tuple(frame.f_locals.keys())" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "LOOKUP_METHOD", "frame.f_locals.items" ], [ "CALL_METHOD", "frame.f_locals.items()" ], [ "CALL_FUNCTION", "sorted(\n frame.f_locals.items(),\n key=lambda key_value: vars_order.index(key_value[0])\n )" ], [ "LOAD_FAST", "watch" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_FAST", "variable" ], [ "LOOKUP_METHOD", "variable.items" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "variable.items(frame)" ], [ "CALL_FUNCTION", "sorted(variable.items(frame))" ], [ "LOAD_FAST", "result_items" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "watch_extras" ], [ "LOAD_FAST", "extra" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "extra(source, value)" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_FAST", "pair" ], [ "COMPARE_OP", "pair is not None" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "pair" ], [ "CALL_FUNCTION", "len(pair)" ], [ "COMPARE_OP", "len(pair) == 2" ], [ "LOAD_FAST", "pair" ], [ "LOAD_DEREF", "vars_order" ], [ "LOOKUP_METHOD", "vars_order.index" ], [ "LOAD_FAST", "key_value" ], [ "BINARY_SUBSCR", "key_value[0]" ], [ "CALL_METHOD", "vars_order.index(key_value[0])" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "TracerMeta" ], [ "LOAD_FAST", "mcs" ], [ "CALL_FUNCTION", "super(TracerMeta, mcs)" ], [ "LOAD_ATTR", "super(TracerMeta, mcs).__new__" ], [ "LOAD_FAST", "mcs" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "super(TracerMeta, mcs).__new__(mcs, *args, **kwargs)" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "result()" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "no_args_decorator" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION", "no_args_decorator(args, kwargs)" ], [ "LOAD_FAST", "cls" ], [ "LOOKUP_METHOD", "cls.default" ], [ "LOAD_FAST", "args" ], [ "BINARY_SUBSCR", "args[0]" ], [ "CALL_METHOD", "cls.default(args[0])" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "TracerMeta" ], [ "LOAD_FAST", "cls" ], [ "CALL_FUNCTION", "super(TracerMeta, cls)" ], [ "LOAD_ATTR", "super(TracerMeta, cls).__call__" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "super(TracerMeta, cls).__call__(*args, **kwargs)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.default" ], [ "LOOKUP_METHOD", "self.default.__enter__" ], [ "CALL_METHOD", "self.default.__enter__(context=1)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.default" ], [ "LOAD_ATTR", "self.default.__exit__" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION_VAR", "self.default.__exit__(*args, context=1)" ], [ "LOAD_GLOBAL", "ensure_tuple" ], [ "LOAD_FAST", "watch" ], [ "CALL_FUNCTION", "ensure_tuple(watch)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "BaseVariable" ], [ "CALL_FUNCTION", "isinstance(v, BaseVariable)" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "CommonVariable" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "CommonVariable(v)" ], [ "LOAD_GLOBAL", "ensure_tuple" ], [ "LOAD_FAST", "watch_explode" ], [ "CALL_FUNCTION", "ensure_tuple(watch_explode)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "BaseVariable" ], [ "CALL_FUNCTION", "isinstance(v, BaseVariable)" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "Exploding" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "Exploding(v)" ], [ "BINARY_ADD", "[\n v if isinstance(v, BaseVariable) else CommonVariable(v)\n for v in ensure_tuple(watch)\n ] + [\n v if isinstance(v, BaseVariable) else Exploding(v)\n for v in ensure_tuple(watch_explode)\n ]" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "ArgDefaultDict" ], [ "LOAD_GLOBAL", "FrameInfo" ], [ "CALL_FUNCTION", "ArgDefaultDict(FrameInfo)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "depth" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.depth" ], [ "COMPARE_OP", "self.depth >= 1" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "iscoroutinefunction" ], [ "LOAD_DEREF", "function" ], [ "CALL_FUNCTION", "iscoroutinefunction(function)" ], [ "LOAD_GLOBAL", "NotImplementedError" ], [ "CALL_FUNCTION", "NotImplementedError(\"coroutines are not supported, sorry!\")" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.target_codes" ], [ "LOOKUP_METHOD", "self.target_codes.add" ], [ "LOAD_DEREF", "function" ], [ "LOAD_ATTR", "function.__code__" ], [ "CALL_METHOD", "self.target_codes.add(function.__code__)" ], [ "LOAD_GLOBAL", "functools" ], [ "LOOKUP_METHOD", "functools.wraps" ], [ "LOAD_DEREF", "function" ], [ "CALL_METHOD", "functools.wraps(function)" ], [ "CALL_FUNCTION", "functools.wraps(function)" ], [ "LOAD_GLOBAL", "functools" ], [ "LOOKUP_METHOD", "functools.wraps" ], [ "LOAD_DEREF", "function" ], [ "CALL_METHOD", "functools.wraps(function)" ], [ "CALL_FUNCTION", "functools.wraps(function)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.isgeneratorfunction" ], [ "LOAD_DEREF", "function" ], [ "CALL_METHOD", "inspect.isgeneratorfunction(function)" ], [ "LOAD_FAST", "generator_wrapper" ], [ "LOAD_FAST", "simple_wrapper" ], [ "LOAD_DEREF", "self" ], [ "LOAD_DEREF", "function" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "function(*args, **kwargs)" ], [ "LOAD_DEREF", "function" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "function(*args, **kwargs)" ], [ "LOAD_FAST", "gen" ], [ "LOAD_ATTR", "gen.send" ], [ "LOAD_GLOBAL", "True" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "method" ], [ "LOAD_FAST", "incoming" ], [ "CALL_FUNCTION", "method(incoming)" ], [ "LOAD_GLOBAL", "StopIteration" ], [ "LOAD_FAST", "gen" ], [ "LOAD_ATTR", "gen.send" ], [ "LOAD_FAST", "outgoing" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_FAST", "gen" ], [ "LOAD_ATTR", "gen.throw" ], [ "LOAD_FAST", "e" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.enabled" ], [ "LOAD_GLOBAL", "sys" ], [ "LOOKUP_METHOD", "sys._getframe" ], [ "LOAD_FAST", "context" ], [ "BINARY_ADD", "context + 1" ], [ "CALL_METHOD", "sys._getframe(context + 1)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._is_internal_frame" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_METHOD", "self._is_internal_frame(calling_frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.trace" ], [ "LOAD_FAST", "calling_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.target_frames" ], [ "LOOKUP_METHOD", "self.target_frames.add" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_METHOD", "self.target_frames.add(calling_frame)" ], [ "LOAD_FAST", "calling_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.trace" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_METHOD", "self.trace(calling_frame, 'enter', None)" ], [ "LOAD_GLOBAL", "thread_global" ], [ "LOAD_ATTR", "thread_global.__dict__" ], [ "LOOKUP_METHOD", "thread_global.__dict__.setdefault" ], [ "CALL_METHOD", "thread_global.__dict__.setdefault('original_trace_functions', [])" ], [ "LOAD_FAST", "stack" ], [ "LOOKUP_METHOD", "stack.append" ], [ "LOAD_GLOBAL", "sys" ], [ "LOOKUP_METHOD", "sys.gettrace" ], [ "CALL_METHOD", "sys.gettrace()" ], [ "CALL_METHOD", "stack.append(sys.gettrace())" ], [ "LOAD_GLOBAL", "sys" ], [ "LOOKUP_METHOD", "sys.settrace" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.trace" ], [ "CALL_METHOD", "sys.settrace(self.trace)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.enabled" ], [ "LOAD_GLOBAL", "thread_global" ], [ "LOAD_ATTR", "thread_global.original_trace_functions" ], [ "LOAD_GLOBAL", "sys" ], [ "LOOKUP_METHOD", "sys.settrace" ], [ "LOAD_FAST", "stack" ], [ "LOOKUP_METHOD", "stack.pop" ], [ "CALL_METHOD", "stack.pop()" ], [ "CALL_METHOD", "sys.settrace(stack.pop())" ], [ "LOAD_GLOBAL", "sys" ], [ "LOOKUP_METHOD", "sys._getframe" ], [ "LOAD_FAST", "context" ], [ "BINARY_ADD", "context + 1" ], [ "CALL_METHOD", "sys._getframe(context + 1)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.trace" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_METHOD", "self.trace(calling_frame, 'exit', None)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.target_frames" ], [ "LOOKUP_METHOD", "self.target_frames.discard" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_METHOD", "self.target_frames.discard(calling_frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame_infos" ], [ "LOOKUP_METHOD", "self.frame_infos.pop" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_METHOD", "self.frame_infos.pop(calling_frame, None)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_filename" ], [ "LOOKUP_METHOD", "frame.f_code.co_filename.startswith" ], [ "LOAD_GLOBAL", "internal_directories" ], [ "CALL_METHOD", "frame.f_code.co_filename.startswith(internal_directories)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.target_codes" ], [ "COMPARE_OP", "frame.f_code in self.target_codes" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.target_frames" ], [ "COMPARE_OP", "frame in self.target_frames" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._is_traced_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self._is_traced_frame(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.depth" ], [ "COMPARE_OP", "self.depth == 1" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._is_internal_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self._is_internal_frame(frame)" ], [ "LOAD_GLOBAL", "is_comprehension_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "is_comprehension_frame(frame)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_GLOBAL", "True" ], [ "LOAD_GLOBAL", "is_comprehension_frame" ], [ "LOAD_FAST", "candidate" ], [ "CALL_FUNCTION", "is_comprehension_frame(candidate)" ], [ "LOAD_FAST", "candidate" ], [ "LOAD_ATTR", "candidate.f_back" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._is_traced_frame" ], [ "LOAD_FAST", "candidate" ], [ "CALL_METHOD", "self._is_traced_frame(candidate)" ], [ "LOAD_FAST", "candidate" ], [ "LOAD_ATTR", "candidate.f_back" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.depth" ], [ "COMPARE_OP", "i >= self.depth" ], [ "LOAD_FAST", "candidate" ], [ "COMPARE_OP", "candidate is None" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._is_internal_frame" ], [ "LOAD_FAST", "candidate" ], [ "CALL_METHOD", "self._is_internal_frame(candidate)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.thread_local" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_ATTR", "thread_local.__dict__" ], [ "LOOKUP_METHOD", "thread_local.__dict__.setdefault" ], [ "CALL_METHOD", "thread_local.__dict__.setdefault('depth', -1)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame_infos" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.frame_infos[frame]" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event in ('call', 'enter')" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.last_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.last_frame" ], [ "LOAD_FAST", "frame" ], [ "COMPARE_OP", "self.config.last_frame is not frame" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.last_line_no" ], [ "LOAD_GLOBAL", "Event" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "event" ], [ "LOAD_FAST", "arg" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_ATTR", "thread_local.depth" ], [ "LOAD_FAST", "line_no" ], [ "CALL_FUNCTION", "Event(frame_info, event, arg, thread_local.depth, line_no=line_no)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.formatter" ], [ "LOOKUP_METHOD", "self.config.formatter.format_line_only" ], [ "LOAD_FAST", "trace_event" ], [ "CALL_METHOD", "self.config.formatter.format_line_only(trace_event)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOOKUP_METHOD", "self.config.write" ], [ "LOAD_FAST", "line" ], [ "CALL_METHOD", "self.config.write(line)" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event == 'exception'" ], [ "LOAD_GLOBAL", "True" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_GLOBAL", "Event" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "event" ], [ "LOAD_FAST", "arg" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_ATTR", "thread_local.depth" ], [ "CALL_FUNCTION", "Event(frame_info, event, arg, thread_local.depth)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "COMPARE_OP", "frame.f_code.co_name == ''" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event not in ('return', 'exception')" ], [ "LOAD_FAST", "frame_info" ], [ "LOOKUP_METHOD", "frame_info.update_variables" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.watch" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.watch_extras" ], [ "LOAD_FAST", "event" ], [ "CALL_METHOD", "frame_info.update_variables(\n self.watch,\n self.config.watch_extras,\n event,\n )" ], [ "LOAD_FAST", "trace_event" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event in ('return', 'exit')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame_infos" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.formatter" ], [ "LOOKUP_METHOD", "self.config.formatter.format" ], [ "LOAD_FAST", "trace_event" ], [ "CALL_METHOD", "self.config.formatter.format(trace_event)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOOKUP_METHOD", "self.config.write" ], [ "LOAD_FAST", "formatted" ], [ "CALL_METHOD", "self.config.write(formatted)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.trace" ], [ "LOAD_FAST", "config" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "NO_ASTTOKENS" ], [ "LOAD_GLOBAL", "Exception" ], [ "CALL_FUNCTION", "Exception(\"birdseye doesn't support this version of Python\")" ], [ "LOAD_GLOBAL", "ImportError" ], [ "LOAD_GLOBAL", "Exception" ], [ "CALL_FUNCTION", "Exception(\"You must install birdseye separately to use spy: pip install birdseye\")" ], [ "LOAD_GLOBAL", "no_args_decorator" ], [ "LOAD_DEREF", "args" ], [ "LOAD_DEREF", "kwargs" ], [ "CALL_FUNCTION", "no_args_decorator(args, kwargs)" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self._trace" ], [ "LOAD_DEREF", "args" ], [ "BINARY_SUBSCR", "args[0]" ], [ "CALL_METHOD", "self._trace(args[0])" ], [ "LOAD_FAST", "decorator" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._trace" ], [ "LOAD_FAST", "func" ], [ "LOAD_DEREF", "args" ], [ "LOAD_DEREF", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "self._trace(func, *args, **kwargs)" ], [ "LOAD_FAST", "eye" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "eye(func)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.snoop" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "self.config.snoop(*args, **kwargs)" ], [ "LOAD_DEREF", "traced" ], [ "CALL_FUNCTION", "self.config.snoop(*args, **kwargs)(traced)" ], [ "LOAD_GLOBAL", "functools" ], [ "LOOKUP_METHOD", "functools.wraps" ], [ "LOAD_DEREF", "func" ], [ "CALL_METHOD", "functools.wraps(func)" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "LOAD_FAST", "wrapper" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.enabled" ], [ "LOAD_DEREF", "traced" ], [ "LOAD_DEREF", "func" ], [ "LOAD_FAST", "final_func" ], [ "LOAD_FAST", "func_args" ], [ "LOAD_FAST", "func_kwargs" ], [ "CALL_FUNCTION_VAR_KW", "final_func(*func_args, **func_kwargs)" ] ], "utils.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOOKUP_METHOD", "standard_library.install_aliases" ], [ "CALL_METHOD", "standard_library.install_aliases()" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "type" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "version_info" ], [ "LOAD_ATTR", "version_info.major" ], [ "COMPARE_OP", "version_info.major == 2" ], [ "LOAD_NAME", "PY2" ], [ "UNARY_NOT", "not PY2" ], [ "LOAD_NAME", "TypeVar" ], [ "CALL_FUNCTION", "TypeVar('T')" ], [ "LOAD_NAME", "TypeVar" ], [ "CALL_FUNCTION", "TypeVar('RT')" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "unicode" ], [ "LOAD_NAME", "str" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "type" ], [ "LOAD_NAME", "json" ], [ "LOAD_ATTR", "json.JSONEncoder" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_GLOBAL", "ntpath" ], [ "LOOKUP_METHOD", "ntpath.split" ], [ "LOAD_FAST", "path" ], [ "CALL_METHOD", "ntpath.split(path)" ], [ "LOAD_FAST", "tail" ], [ "LOAD_GLOBAL", "ntpath" ], [ "LOOKUP_METHOD", "ntpath.basename" ], [ "LOAD_FAST", "head" ], [ "CALL_METHOD", "ntpath.basename(head)" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOOKUP_METHOD", "os.path.commonprefix" ], [ "LOAD_FAST", "paths" ], [ "CALL_METHOD", "os.path.commonprefix(paths)" ], [ "LOAD_GLOBAL", "ntpath" ], [ "LOOKUP_METHOD", "ntpath.split" ], [ "LOAD_FAST", "prefix" ], [ "CALL_METHOD", "ntpath.split(prefix)" ], [ "BINARY_SUBSCR", "ntpath.split(prefix)[0]" ], [ "LOAD_FAST", "paths" ], [ "BINARY_SUBSCR", "paths[0]" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "prefix" ], [ "CALL_FUNCTION", "len(prefix)" ], [ "BINARY_SUBSCR", "paths[0][len(prefix)]" ], [ "LOAD_FAST", "first_char_after" ], [ "COMPARE_OP", "first_char_after in r'\\/'" ], [ "LOAD_FAST", "first_char_after" ], [ "LOAD_FAST", "prefix" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "COMPARE_OP", "path == IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "all_paths" ], [ "LOAD_FAST", "f" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "COMPARE_OP", "f != IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "f" ], [ "LOAD_GLOBAL", "common_ancestor" ], [ "LOAD_FAST", "all_paths" ], [ "CALL_FUNCTION", "common_ancestor(all_paths)" ], [ "LOAD_FAST", "prefix" ], [ "COMPARE_OP", "prefix in r'\\/'" ], [ "LOAD_GLOBAL", "strip_required_prefix" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "prefix" ], [ "CALL_FUNCTION", "strip_required_prefix(path, prefix)" ], [ "LOAD_GLOBAL", "path_leaf" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "path_leaf(path)" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "COMPARE_OP", "path == IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.sep" ], [ "COMPARE_OP", "os.path.sep == '/'" ], [ "LOAD_FAST", "path" ], [ "LOOKUP_METHOD", "path.startswith" ], [ "CALL_METHOD", "path.startswith('/')" ], [ "LOAD_FAST", "path" ], [ "BINARY_ADD", "'/' + path" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "type" ], [ "LOAD_FAST", "obj" ], [ "CALL_FUNCTION", "type(obj)" ], [ "LOAD_FAST", "t" ], [ "LOAD_GLOBAL", "types" ], [ "LOAD_ATTR", "types.InstanceType" ], [ "COMPARE_OP", "t is types.InstanceType" ], [ "LOAD_FAST", "obj" ], [ "LOAD_ATTR", "obj.__class__" ], [ "LOAD_FAST", "t" ], [ "LOAD_FAST", "iterable" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_DEREF", "type_or_tuple" ], [ "CALL_FUNCTION", "isinstance(x, type_or_tuple)" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "next" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "next(it)" ], [ "LOAD_GLOBAL", "StopIteration" ], [ "LOAD_GLOBAL", "raise_from" ], [ "LOAD_GLOBAL", "RuntimeError" ], [ "LOAD_FAST", "e" ], [ "CALL_FUNCTION", "raise_from(RuntimeError, e)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "expression" ], [ "CALL_FUNCTION", "hasattr(expression, 'one_or_none')" ], [ "LOAD_FAST", "expression" ], [ "LOOKUP_METHOD", "expression.one_or_none" ], [ "CALL_METHOD", "expression.one_or_none()" ], [ "LOAD_FAST", "expression" ], [ "LOOKUP_METHOD", "expression.all" ], [ "CALL_METHOD", "expression.all()" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "len(result)" ], [ "COMPARE_OP", "len(result) == 0" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "len(result)" ], [ "COMPARE_OP", "len(result) == 1" ], [ "LOAD_FAST", "result" ], [ "BINARY_SUBSCR", "result[0]" ], [ "LOAD_GLOBAL", "Exception" ], [ "CALL_FUNCTION", "Exception(\"There is more than one item returned for the supplied filter\")" ], [ "LOAD_FAST", "lst" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "isinstance(x, list)" ], [ "LOAD_FAST", "result" ], [ "LOOKUP_METHOD", "result.extend" ], [ "LOAD_GLOBAL", "flatten_list" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "flatten_list(x)" ], [ "CALL_METHOD", "result.extend(flatten_list(x))" ], [ "LOAD_FAST", "result" ], [ "LOOKUP_METHOD", "result.append" ], [ "LOAD_FAST", "x" ], [ "CALL_METHOD", "result.append(x)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "f" ], [ "LOAD_ATTR", "f.__code__" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_GLOBAL", "False" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "LOAD_ATTR", "(lambda: 0).__code__" ], [ "LOAD_ATTR", "(lambda: 0).__code__.co_name" ], [ "COMPARE_OP", "code.co_name == (lambda: 0).__code__.co_name" ], [ "LOAD_FAST", "o" ], [ "LOAD_ATTR", "o.as_json" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "ProtocolEncoder" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(ProtocolEncoder, self)" ], [ "LOOKUP_METHOD", "super(ProtocolEncoder, self).default" ], [ "LOAD_FAST", "o" ], [ "CALL_METHOD", "super(ProtocolEncoder, self).default(o)" ], [ "LOAD_FAST", "method" ], [ "CALL_FUNCTION", "method()" ], [ "LOAD_GLOBAL", "io" ], [ "LOOKUP_METHOD", "io.open" ], [ "LOAD_FAST", "filename" ], [ "CALL_METHOD", "io.open(filename, 'rb')" ], [ "LOAD_GLOBAL", "detect_encoding" ], [ "LOAD_FAST", "fp" ], [ "LOAD_ATTR", "fp.readline" ], [ "CALL_FUNCTION", "detect_encoding(fp.readline)" ], [ "LOAD_FAST", "fp" ], [ "LOOKUP_METHOD", "fp.seek" ], [ "CALL_METHOD", "fp.seek(0)" ], [ "LOAD_GLOBAL", "io" ], [ "LOOKUP_METHOD", "io.TextIOWrapper" ], [ "LOAD_FAST", "fp" ], [ "LOAD_FAST", "encoding" ], [ "LOAD_GLOBAL", "True" ], [ "CALL_METHOD", "io.TextIOWrapper(fp, encoding, line_buffering=True)" ], [ "LOAD_FAST", "text" ], [ "LOAD_FAST", "text" ], [ "LOAD_FAST", "fp" ], [ "LOOKUP_METHOD", "fp.close" ], [ "CALL_METHOD", "fp.close()" ], [ "LOAD_FAST", "filename" ], [ "LOOKUP_METHOD", "filename.endswith" ], [ "CALL_METHOD", "filename.endswith('.pyc')" ], [ "LOAD_FAST", "filename" ], [ "SLICE+2", "filename[:-1]" ], [ "LOAD_GLOBAL", "open_with_encoding_check" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "open_with_encoding_check(filename)" ], [ "LOOKUP_METHOD", "''.join" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "f" ], [ "CALL_FUNCTION", "enumerate(f)" ], [ "LOAD_FAST", "i" ], [ "COMPARE_OP", "i < 2" ], [ "LOAD_FAST", "cookie_re" ], [ "LOOKUP_METHOD", "cookie_re.match" ], [ "LOAD_FAST", "line" ], [ "CALL_METHOD", "cookie_re.match(line)" ], [ "LOAD_FAST", "line" ], [ "CALL_METHOD", "''.join([\n '\\n' if i < 2 and cookie_re.match(line)\n else line\n for i, line in enumerate(f)\n ])" ], [ "LOAD_GLOBAL", "safe_next" ], [ "LOAD_FAST", "tokens" ], [ "LOOKUP_METHOD", "tokens.get_tokens" ], [ "LOAD_FAST", "function_node" ], [ "CALL_METHOD", "tokens.get_tokens(function_node)" ], [ "CALL_FUNCTION", "safe_next(t for t in tokens.get_tokens(function_node)\n if t.string == 'def' and t.type == token.NAME)" ], [ "LOAD_FAST", "def_token" ], [ "LOAD_ATTR", "def_token.startpos" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_ATTR", "tokens.text" ], [ "LOAD_FAST", "startpos" ], [ "LOAD_FAST", "function_node" ], [ "LOAD_ATTR", "function_node.last_token" ], [ "LOAD_ATTR", "function_node.last_token.endpos" ], [ "SLICE+3", "tokens.text[startpos:function_node.last_token.endpos]" ], [ "LOOKUP_METHOD", "tokens.text[startpos:function_node.last_token.endpos].rstrip" ], [ "CALL_METHOD", "tokens.text[startpos:function_node.last_token.endpos].rstrip()" ], [ "LOAD_FAST", "source" ], [ "LOOKUP_METHOD", "source.startswith" ], [ "CALL_METHOD", "source.startswith('def')" ], [ "LOAD_FAST", "startpos" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "t" ], [ "LOAD_ATTR", "t.string" ], [ "COMPARE_OP", "t.string == 'def'" ], [ "LOAD_FAST", "t" ], [ "LOAD_ATTR", "t.type" ], [ "LOAD_GLOBAL", "token" ], [ "LOAD_ATTR", "token.NAME" ], [ "COMPARE_OP", "t.type == token.NAME" ], [ "LOAD_FAST", "t" ], [ "LOAD_FAST", "args" ], [ "LOAD_GLOBAL", "print" ], [ "LOAD_FAST", "arg" ], [ "CALL_FUNCTION", "print(arg)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION", "len(args)" ], [ "COMPARE_OP", "len(args) == 1" ], [ "LOAD_FAST", "args" ], [ "BINARY_SUBSCR", "args[0]" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "filename" ], [ "LOOKUP_METHOD", "filename.startswith" ], [ "CALL_METHOD", "filename.startswith(' max_length" ], [ "LOAD_FAST", "max_length" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "middle" ], [ "CALL_FUNCTION", "len(middle)" ], [ "BINARY_SUBTRACT", "max_length - len(middle)" ], [ "BINARY_FLOOR_DIVIDE", "(max_length - len(middle)) // 2" ], [ "LOAD_FAST", "max_length" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "middle" ], [ "CALL_FUNCTION", "len(middle)" ], [ "BINARY_SUBTRACT", "max_length - len(middle)" ], [ "LOAD_FAST", "left" ], [ "BINARY_SUBTRACT", "max_length - len(middle) - left" ], [ "LOAD_FAST", "seq" ], [ "LOAD_FAST", "left" ], [ "SLICE+2", "seq[:left]" ], [ "LOAD_FAST", "middle" ], [ "BINARY_ADD", "seq[:left] + middle" ], [ "LOAD_FAST", "seq" ], [ "LOAD_FAST", "right" ], [ "UNARY_NEGATIVE", "-right" ], [ "SLICE+1", "seq[-right:]" ], [ "BINARY_ADD", "seq[:left] + middle + seq[-right:]" ], [ "LOAD_FAST", "seq" ], [ "LOAD_GLOBAL", "truncate" ], [ "LOAD_FAST", "string" ], [ "LOAD_FAST", "max_length" ], [ "CALL_FUNCTION", "truncate(string, max_length, '...')" ], [ "LOAD_GLOBAL", "truncate" ], [ "LOAD_FAST", "lst" ], [ "LOAD_FAST", "max_length" ], [ "CALL_FUNCTION", "truncate(lst, max_length, ['...'])" ], [ "LOAD_FAST", "split" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "six" ], [ "LOAD_ATTR", "six.string_types" ], [ "CALL_FUNCTION", "isinstance(x, six.string_types)" ], [ "LOAD_FAST", "x" ], [ "LOOKUP_METHOD", "x.replace" ], [ "CALL_METHOD", "x.replace(',', ' ')" ], [ "LOOKUP_METHOD", "x.replace(',', ' ').split" ], [ "CALL_METHOD", "x.replace(',', ' ').split()" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "set" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "isinstance(x, (list, set, tuple))" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "tuple" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tuple(x)" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOOKUP_METHOD", "os.path.basename" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_filename" ], [ "CALL_METHOD", "os.path.basename(code.co_filename)" ], [ "LOAD_FAST", "result" ], [ "LOOKUP_METHOD", "result.endswith" ], [ "CALL_METHOD", "result.endswith('.pyc')" ], [ "LOAD_FAST", "result" ], [ "SLICE+2", "result[:-1]" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "COMPARE_OP", "frame.f_code.co_name in ('', '', '')" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "code('{}.x')" ], [ "LOAD_GLOBAL", "SyntaxError" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "code('({})')" ], [ "LOAD_GLOBAL", "True" ], [ "LOAD_FAST", "without_parens" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "code('({}).x')" ], [ "COMPARE_OP", "without_parens != code('({}).x')" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "s" ], [ "LOOKUP_METHOD", "s.format" ], [ "LOAD_DEREF", "source" ], [ "CALL_METHOD", "s.format(source)" ], [ "CALL_FUNCTION", "compile(s.format(source), '', 'eval')" ], [ "LOAD_ATTR", "compile(s.format(source), '', 'eval').co_code" ], [ "LOAD_GLOBAL", "needs_parentheses" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "needs_parentheses(source)" ], [ "LOOKUP_METHOD", "'({})'.format" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "'({})'.format(source)" ], [ "LOAD_FAST", "source" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "REPR_TARGET_LENGTH" ], [ "CALL_FUNCTION", "cheap_repr(x, target_length=REPR_TARGET_LENGTH)" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "ArgDefaultDict" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(ArgDefaultDict, self)" ], [ "LOOKUP_METHOD", "super(ArgDefaultDict, self).__init__" ], [ "CALL_METHOD", "super(ArgDefaultDict, self).__init__()" ], [ "LOAD_FAST", "factory" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.factory" ], [ "LOAD_FAST", "key" ], [ "CALL_METHOD", "self.factory(key)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "key" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "lst" ], [ "CALL_FUNCTION", "len(lst)" ], [ "COMPARE_OP", "len(lst) == 1" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "CALL_FUNCTION", "str(i + 1)" ], [ "BINARY_ADD", "' ' + str(i + 1)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_GLOBAL", "os" ], [ "CALL_FUNCTION", "hasattr(os, 'PathLike')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.PathLike" ], [ "CALL_FUNCTION", "isinstance(x, os.PathLike)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "hasattr(x, '__fspath__')" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "hasattr(x, 'open')" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.__class__" ], [ "LOAD_ATTR", "x.__class__.__name__" ], [ "LOOKUP_METHOD", "x.__class__.__name__.lower" ], [ "CALL_METHOD", "x.__class__.__name__.lower()" ], [ "COMPARE_OP", "'path' in x.__class__.__name__.lower()" ], [ "LOAD_GLOBAL", "False" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION", "len(args)" ], [ "COMPARE_OP", "len(args) == 1" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.isfunction" ], [ "LOAD_FAST", "args" ], [ "BINARY_SUBSCR", "args[0]" ], [ "CALL_METHOD", "inspect.isfunction(args[0])" ], [ "LOAD_FAST", "kwargs" ], [ "UNARY_NOT", "not kwargs" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_ADD", "max_length + 2" ], [ "COMPARE_OP", "length <= max_length + 2" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "range(length)" ], [ "LOAD_GLOBAL", "chain" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_FLOOR_DIVIDE", "max_length // 2" ], [ "CALL_FUNCTION", "range(max_length // 2)" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_FLOOR_DIVIDE", "max_length // 2" ], [ "BINARY_SUBTRACT", "length - max_length // 2" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "range(length - max_length // 2,\n length)" ], [ "CALL_FUNCTION", "chain(range(max_length // 2),\n range(length - max_length // 2,\n length))" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "len(x)" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "n == 0" ], [ "LOAD_GLOBAL", "repr" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "repr(x)" ], [ "LOAD_FAST", "helper" ], [ "LOAD_ATTR", "helper.level" ], [ "BINARY_SUBTRACT", "helper.level - 1" ], [ "LOAD_GLOBAL", "_repr_series_one_line" ], [ "LOAD_ATTR", "_repr_series_one_line.maxparts" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "n" ], [ "LOAD_FAST", "maxparts" ], [ "CALL_FUNCTION", "_sample_indices(n, maxparts)" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.index" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "SLICE+3", "x.index[i:i + 1]" ], [ "LOOKUP_METHOD", "x.index[i:i + 1].format" ], [ "LOAD_GLOBAL", "False" ], [ "CALL_METHOD", "x.index[i:i + 1].format(sparsify=False)" ], [ "BINARY_SUBSCR", "x.index[i:i + 1].format(sparsify=False)[0]" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.iloc" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "x.iloc[i]" ], [ "LOAD_FAST", "pieces" ], [ "LOOKUP_METHOD", "pieces.append" ], [ "LOAD_FAST", "k" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "v" ], [ "LOAD_FAST", "newlevel" ], [ "CALL_FUNCTION", "cheap_repr(v, newlevel)" ], [ "BINARY_MODULO", "'%s = %s' % (k, cheap_repr(v, newlevel))" ], [ "CALL_METHOD", "pieces.append('%s = %s' % (k, cheap_repr(v, newlevel)))" ], [ "LOAD_FAST", "n" ], [ "LOAD_FAST", "maxparts" ], [ "BINARY_ADD", "maxparts + 2" ], [ "COMPARE_OP", "n > maxparts + 2" ], [ "LOAD_FAST", "pieces" ], [ "LOOKUP_METHOD", "pieces.insert" ], [ "LOAD_FAST", "maxparts" ], [ "BINARY_FLOOR_DIVIDE", "maxparts // 2" ], [ "CALL_METHOD", "pieces.insert(maxparts // 2, '...')" ], [ "LOOKUP_METHOD", "'; '.join" ], [ "LOAD_FAST", "pieces" ], [ "CALL_METHOD", "'; '.join(pieces)" ] ] }executing-0.8.0/tests/sample_results/pypy3.5.json000066400000000000000000021434021410133640400220420ustar00rootroot00000000000000{ "bird.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOOKUP_METHOD", "standard_library.install_aliases" ], [ "CALL_METHOD", "standard_library.install_aliases()" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "warn_if_outdated" ], [ "LOAD_NAME", "__version__" ], [ "CALL_FUNCTION", "warn_if_outdated('birdseye', __version__)" ], [ "LOAD_NAME", "namedtuple" ], [ "CALL_FUNCTION", "namedtuple('CodeInfo', 'db_func traced_file arg_names')" ], [ "LOAD_NAME", "TreeTracerBase" ], [ "LOAD_NAME", "BirdsEye" ], [ "CALL_FUNCTION", "BirdsEye()" ], [ "LOAD_NAME", "NamedTuple" ], [ "LOAD_NAME", "int" ], [ "LOAD_NAME", "bool" ], [ "LOAD_NAME", "int" ], [ "LOAD_NAME", "str" ], [ "CALL_FUNCTION", "NamedTuple('HTMLPosition', [\n ('index', int),\n ('is_start', bool),\n ('depth', int),\n ('html', str),\n])" ], [ "LOAD_NAME", "eye" ], [ "LOAD_ATTR", "eye.enter_call" ], [ "LOAD_ATTR", "eye.enter_call.__code__" ], [ "LOAD_NAME", "eye" ], [ "LOAD_ATTR", "eye.exit_call" ], [ "LOAD_ATTR", "eye.exit_call.__code__" ], [ "LOAD_NAME", "eye" ], [ "LOAD_ATTR", "eye.after_expr" ], [ "LOAD_ATTR", "eye.after_expr.__code__" ], [ "LOAD_NAME", "eye" ], [ "LOAD_ATTR", "eye.after_stmt" ], [ "LOAD_ATTR", "eye.after_stmt.__code__" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "Iterable" ], [ "LOAD_NAME", "Iteration" ], [ "BINARY_SUBSCR", "Iterable[Iteration]" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "TypeRegistry" ], [ "CALL_FUNCTION", "TypeRegistry()" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "try_register_repr" ], [ "CALL_FUNCTION", "try_register_repr('pandas', 'Series')" ], [ "CALL_FUNCTION", "try_register_repr('pandas', 'Series')" ], [ "LOAD_NAME", "cached_property" ], [ "CALL_FUNCTION", "cached_property" ], [ "LOAD_NAME", "lru_cache" ], [ "CALL_FUNCTION", "lru_cache()" ], [ "CALL_FUNCTION", "lru_cache()" ], [ "LOAD_NAME", "retry_db" ], [ "CALL_FUNCTION", "retry_db" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "BirdsEye" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(BirdsEye, self)" ], [ "LOOKUP_METHOD", "super(BirdsEye, self).__init__" ], [ "CALL_METHOD", "super(BirdsEye, self).__init__()" ], [ "LOAD_FAST", "db_uri" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "num_samples" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "dict" ], [ "CALL_FUNCTION", "dict(\n attributes=50,\n dict=50,\n list=30,\n set=30,\n pandas_rows=20,\n pandas_cols=100,\n )" ], [ "LOAD_GLOBAL", "dict" ], [ "CALL_FUNCTION", "dict(\n attributes=50,\n dict=10,\n list=6,\n set=6,\n pandas_rows=6,\n pandas_cols=10,\n )" ], [ "CALL_FUNCTION", "dict(\n big=dict(\n attributes=50,\n dict=50,\n list=30,\n set=30,\n pandas_rows=20,\n pandas_cols=100,\n ),\n small=dict(\n attributes=50,\n dict=10,\n list=6,\n set=6,\n pandas_rows=6,\n pandas_cols=10,\n ),\n )" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "Database" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._db_uri" ], [ "CALL_FUNCTION", "Database(self._db_uri)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.walk" ], [ "LOAD_FAST", "root" ], [ "CALL_METHOD", "ast.walk(root)" ], [ "LOAD_GLOBAL", "tracer" ], [ "LOOKUP_METHOD", "tracer.loops" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "tracer.loops(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "CALL_FUNCTION", "isinstance(node, ast.expr)" ], [ "LOAD_GLOBAL", "is_interesting_expression" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "is_interesting_expression(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "BirdsEye" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(BirdsEye, self)" ], [ "LOOKUP_METHOD", "super(BirdsEye, self).compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "flags" ], [ "CALL_METHOD", "super(BirdsEye, self).compile(source, filename, flags)" ], [ "LOAD_GLOBAL", "ASTTokens" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.root" ], [ "CALL_FUNCTION", "ASTTokens(source, tree=traced_file.root)" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.For)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.body" ], [ "BINARY_SUBSCR", "node.parent.body[0]" ], [ "COMPARE_OP", "node is node.parent.body[0]" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._add_iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self._add_iteration(node._loops, frame)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.While)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.test" ], [ "COMPARE_OP", "node is node.parent.test" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._add_iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self._add_iteration(node._loops, frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_ATTR", "self.stack[frame].iteration" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "loops" ], [ "CALL_FUNCTION", "enumerate(loops)" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.loops" ], [ "LOAD_FAST", "loop_node" ], [ "LOAD_ATTR", "loop_node._tree_index" ], [ "BINARY_SUBSCR", "iteration.loops[loop_node._tree_index]" ], [ "LOAD_FAST", "i" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "loops" ], [ "CALL_FUNCTION", "len(loops)" ], [ "BINARY_SUBTRACT", "len(loops) - 1" ], [ "COMPARE_OP", "i == len(loops) - 1" ], [ "LOAD_FAST", "loop" ], [ "LOOKUP_METHOD", "loop.append" ], [ "LOAD_GLOBAL", "Iteration" ], [ "CALL_FUNCTION", "Iteration()" ], [ "CALL_METHOD", "loop.append(Iteration())" ], [ "LOAD_FAST", "loop" ], [ "LOOKUP_METHOD", "loop.last" ], [ "CALL_METHOD", "loop.last()" ], [ "LOAD_GLOBAL", "_tracing_recursively" ], [ "LOAD_DEREF", "frame" ], [ "CALL_FUNCTION", "_tracing_recursively(frame)" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._is_interesting_expression" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "BINARY_SUBSCR", "self._code_infos[frame.f_code]" ], [ "LOAD_ATTR", "self._code_infos[frame.f_code].traced_file" ], [ "LOAD_ATTR", "self._code_infos[frame.f_code].traced_file.is_ipython_cell" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Expr" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.Expr)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.parent" ], [ "LOAD_ATTR", "node.parent.parent.body" ], [ "BINARY_SUBSCR", "node.parent.parent.body[-1]" ], [ "COMPARE_OP", "node.parent is node.parent.parent.body[-1]" ], [ "LOAD_DEREF", "value" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "is_obvious_builtin" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_DEREF", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_ATTR", "self.stack[frame].expression_values" ], [ "LOAD_FAST", "node" ], [ "BINARY_SUBSCR", "self.stack[frame].expression_values[node]" ], [ "CALL_FUNCTION", "is_obvious_builtin(node, self.stack[frame].expression_values[node])" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_DEREF", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_FAST", "exc_value" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self._exception_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_FAST", "exc_value" ], [ "CALL_METHOD", "self._exception_value(node, frame, exc_value)" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOOKUP_METHOD", "NodeValue.expression" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.num_samples" ], [ "LOAD_DEREF", "value" ], [ "LOAD_GLOBAL", "max" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "CALL_FUNCTION", "len(node._loops)" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self._is_first_loop_iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "frame" ], [ "CALL_METHOD", "self._is_first_loop_iteration(node, frame)" ], [ "UNARY_NOT", "not self._is_first_loop_iteration(node, frame)" ], [ "BINARY_MULTIPLY", "len(node._loops) * (not self._is_first_loop_iteration(node, frame))" ], [ "BINARY_SUBTRACT", "3 - len(node._loops) * (not self._is_first_loop_iteration(node, frame))" ], [ "CALL_FUNCTION", "max(1, 3 - len(node._loops) * (not self._is_first_loop_iteration(node, frame)))" ], [ "CALL_METHOD", "NodeValue.expression(\n self.num_samples,\n value,\n level=max(1, 3 - len(node._loops) * (not self._is_first_loop_iteration(node, frame))),\n )" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self._set_node_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_FAST", "node_value" ], [ "CALL_METHOD", "self._set_node_value(node, frame, node_value)" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self._check_inner_call" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node_value" ], [ "CALL_METHOD", "self._check_inner_call(frame_info, node, node_value)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.comprehension)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.iter" ], [ "COMPARE_OP", "node is node.parent.iter" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.GeneratorExp" ], [ "CALL_FUNCTION", "isinstance(node.parent.parent, ast.GeneratorExp)" ], [ "UNARY_NOT", "not isinstance(node.parent.parent, ast.GeneratorExp)" ], [ "LOAD_FAST", "is_special_comprehension_iter" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self._set_node_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOOKUP_METHOD", "NodeValue.covered" ], [ "CALL_METHOD", "NodeValue.covered()" ], [ "CALL_METHOD", "self._set_node_value(node.parent, frame, NodeValue.covered())" ], [ "LOAD_FAST", "exc_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "BINARY_ADD", "node._loops + (node.parent,)" ], [ "LOAD_GLOBAL", "ChangeValue" ], [ "LOAD_FAST", "comprehension_iter_proxy" ], [ "CALL_FUNCTION", "comprehension_iter_proxy()" ], [ "CALL_FUNCTION", "ChangeValue(comprehension_iter_proxy())" ], [ "LOAD_DEREF", "value" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self._add_iteration" ], [ "LOAD_DEREF", "loops" ], [ "LOAD_DEREF", "frame" ], [ "CALL_METHOD", "self._add_iteration(loops, frame)" ], [ "LOAD_FAST", "item" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.inner_calls" ], [ "LOOKUP_METHOD", "frame_info.inner_calls.pop" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "frame_info.inner_calls.pop(node, None)" ], [ "LOAD_FAST", "inner_calls" ], [ "LOAD_FAST", "node_value" ], [ "LOOKUP_METHOD", "node_value.set_meta" ], [ "LOAD_FAST", "inner_calls" ], [ "CALL_METHOD", "node_value.set_meta('inner_calls', inner_calls)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_ATTR", "self.stack[frame].iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.loops" ], [ "LOAD_FAST", "loop_node" ], [ "LOAD_ATTR", "loop_node._tree_index" ], [ "BINARY_SUBSCR", "iteration.loops[loop_node._tree_index]" ], [ "LOAD_FAST", "loop" ], [ "LOOKUP_METHOD", "loop.last" ], [ "CALL_METHOD", "loop.last()" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.index" ], [ "COMPARE_OP", "iteration.index > 0" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_ATTR", "self.stack[frame].iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.loops" ], [ "LOAD_FAST", "loop_node" ], [ "LOAD_ATTR", "loop_node._tree_index" ], [ "BINARY_SUBSCR", "iteration.loops[loop_node._tree_index]" ], [ "LOAD_FAST", "loop" ], [ "LOOKUP_METHOD", "loop.recorded_node" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "loop.recorded_node(node)" ], [ "LOAD_FAST", "loop" ], [ "LOOKUP_METHOD", "loop.last" ], [ "CALL_METHOD", "loop.last()" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.vals" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOOKUP_METHOD", "NodeValue.exception" ], [ "LOAD_FAST", "exc_value" ], [ "CALL_METHOD", "NodeValue.exception(exc_value)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._set_node_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "value" ], [ "CALL_METHOD", "self._set_node_value(node, frame, value)" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_GLOBAL", "_tracing_recursively" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "_tracing_recursively(frame)" ], [ "LOAD_FAST", "exc_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "exc_node" ], [ "COMPARE_OP", "node is exc_node" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._exception_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "exc_value" ], [ "CALL_METHOD", "self._exception_value(node, frame, exc_value)" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOOKUP_METHOD", "NodeValue.covered" ], [ "CALL_METHOD", "NodeValue.covered()" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._set_node_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "value" ], [ "CALL_METHOD", "self._set_node_value(node, frame, value)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._check_inner_call" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "value" ], [ "CALL_METHOD", "self._check_inner_call(self.stack[frame], node, value)" ], [ "LOAD_FAST", "enter_info" ], [ "LOAD_ATTR", "enter_info.current_frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_GLOBAL", "_tracing_recursively" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "_tracing_recursively(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_GLOBAL", "get_unfrozen_datetime" ], [ "CALL_FUNCTION", "get_unfrozen_datetime()" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_GLOBAL", "Iteration" ], [ "CALL_FUNCTION", "Iteration()" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "BINARY_SUBSCR", "self._code_infos[frame.f_code]" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "enter_info" ], [ "LOAD_ATTR", "enter_info.enter_node" ], [ "LOAD_ATTR", "enter_info.enter_node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Module" ], [ "CALL_FUNCTION", "isinstance(enter_info.enter_node.parent, ast.Module)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "LOOKUP_METHOD", "frame.f_locals.copy" ], [ "CALL_METHOD", "frame.f_locals.copy()" ], [ "LOAD_FAST", "code_info" ], [ "LOAD_ATTR", "code_info.arg_names" ], [ "LOAD_DEREF", "f_locals" ], [ "LOOKUP_METHOD", "f_locals.items" ], [ "CALL_METHOD", "f_locals.items()" ], [ "BINARY_ADD", "[(name, f_locals.pop(name))\n for name in code_info.arg_names\n if name] + [\n\n # Local variables other than actual arguments. These are variables from\n # the enclosing scope. It's handy to treat them like arguments in the UI\n it for it in f_locals.items()\n if it[0][0] != '.' # Appears when using nested tuple arguments\n ]" ], [ "LOAD_GLOBAL", "json" ], [ "LOOKUP_METHOD", "json.dumps" ], [ "LOAD_FAST", "arguments" ], [ "CALL_METHOD", "json.dumps([[k, cheap_repr(v)] for k, v in arguments])" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._call_id" ], [ "CALL_METHOD", "self._call_id()" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "defaultdict(list)" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOOKUP_METHOD", "self.stack.get" ], [ "LOAD_FAST", "enter_info" ], [ "LOAD_ATTR", "enter_info.caller_frame" ], [ "CALL_METHOD", "self.stack.get(enter_info.caller_frame)" ], [ "LOAD_FAST", "prev" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "prev" ], [ "CALL_FUNCTION", "getattr(prev, 'inner_calls', None)" ], [ "LOAD_FAST", "inner_calls" ], [ "COMPARE_OP", "inner_calls is not None" ], [ "LOAD_FAST", "inner_calls" ], [ "LOAD_FAST", "enter_info" ], [ "LOAD_ATTR", "enter_info.call_node" ], [ "BINARY_SUBSCR", "inner_calls[enter_info.call_node]" ], [ "LOOKUP_METHOD", "inner_calls[enter_info.call_node].append" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.call_id" ], [ "CALL_METHOD", "inner_calls[enter_info.call_node].append(frame_info.call_id)" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "name" ], [ "LOAD_DEREF", "f_locals" ], [ "LOOKUP_METHOD", "f_locals.pop" ], [ "LOAD_FAST", "name" ], [ "CALL_METHOD", "f_locals.pop(name)" ], [ "LOAD_FAST", "it" ], [ "BINARY_SUBSCR", "it[0]" ], [ "BINARY_SUBSCR", "it[0][0]" ], [ "COMPARE_OP", "it[0][0] != '.'" ], [ "LOAD_FAST", "it" ], [ "LOAD_FAST", "k" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "cheap_repr(v)" ], [ "LOAD_GLOBAL", "uuid4" ], [ "CALL_FUNCTION", "uuid4()" ], [ "LOAD_ATTR", "uuid4().hex" ], [ "LOAD_DEREF", "exit_info" ], [ "LOAD_ATTR", "exit_info.current_frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_GLOBAL", "_tracing_recursively" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "_tracing_recursively(frame)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.iteration" ], [ "LOAD_GLOBAL", "_deep_dict" ], [ "CALL_FUNCTION", "_deep_dict()" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self._extract_node_values" ], [ "LOAD_DEREF", "top_iteration" ], [ "LOAD_DEREF", "node_values" ], [ "CALL_METHOD", "self._extract_node_values(top_iteration, (), node_values)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "BINARY_SUBSCR", "self._code_infos[frame.f_code]" ], [ "LOAD_ATTR", "self._code_infos[frame.f_code].db_func" ], [ "LOAD_DEREF", "exit_info" ], [ "LOAD_ATTR", "exit_info.exc_value" ], [ "LOAD_FAST", "exc" ], [ "LOOKUP_METHOD", "''.join" ], [ "LOAD_GLOBAL", "traceback" ], [ "LOOKUP_METHOD", "traceback.format_exception" ], [ "LOAD_GLOBAL", "type" ], [ "LOAD_FAST", "exc" ], [ "CALL_FUNCTION", "type(exc)" ], [ "LOAD_FAST", "exc" ], [ "LOAD_DEREF", "exit_info" ], [ "LOAD_ATTR", "exit_info.exc_tb" ], [ "CALL_METHOD", "traceback.format_exception(type(exc), exc, exit_info.exc_tb)" ], [ "CALL_METHOD", "''.join(traceback.format_exception(type(exc), exc, exit_info.exc_tb))" ], [ "LOAD_GLOBAL", "exception_string" ], [ "LOAD_FAST", "exc" ], [ "CALL_FUNCTION", "exception_string(exc)" ], [ "LOAD_GLOBAL", "retry_db" ], [ "CALL_FUNCTION", "retry_db" ], [ "LOAD_FAST", "add_call" ], [ "CALL_FUNCTION", "add_call()" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.call_id" ], [ "LOAD_DEREF", "self" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.db" ], [ "LOAD_ATTR", "self.db.Call" ], [ "LOAD_FAST", "Call" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.call_id" ], [ "LOAD_DEREF", "db_func" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.arguments" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_DEREF", "exit_info" ], [ "LOAD_ATTR", "exit_info.return_value" ], [ "CALL_FUNCTION", "cheap_repr(exit_info.return_value)" ], [ "LOAD_DEREF", "exception" ], [ "LOAD_DEREF", "traceback_str" ], [ "LOAD_GLOBAL", "json" ], [ "LOOKUP_METHOD", "json.dumps" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_DEREF", "node_values" ], [ "LOAD_DEREF", "top_iteration" ], [ "LOOKUP_METHOD", "top_iteration.extract_iterations" ], [ "CALL_METHOD", "top_iteration.extract_iterations()" ], [ "BINARY_SUBSCR", "top_iteration.extract_iterations()['loops']" ], [ "LOAD_GLOBAL", "type_registry" ], [ "LOOKUP_METHOD", "type_registry.names" ], [ "CALL_METHOD", "type_registry.names()" ], [ "LOAD_GLOBAL", "type_registry" ], [ "LOAD_ATTR", "type_registry.num_special_types" ], [ "CALL_FUNCTION", "dict(\n node_values=node_values,\n loop_iterations=top_iteration.extract_iterations()['loops'],\n type_names=type_registry.names(),\n num_special_types=type_registry.num_special_types,\n )" ], [ "LOAD_GLOBAL", "ProtocolEncoder" ], [ "CALL_METHOD", "json.dumps(\n dict(\n node_values=node_values,\n loop_iterations=top_iteration.extract_iterations()['loops'],\n type_names=type_registry.names(),\n num_special_types=type_registry.num_special_types,\n ),\n cls=ProtocolEncoder,\n separators=(',', ':')\n )" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.start_time" ], [ "CALL_FUNCTION", "Call(id=frame_info.call_id,\n function_id=db_func,\n arguments=frame_info.arguments,\n return_value=cheap_repr(exit_info.return_value),\n exception=exception,\n traceback=traceback_str,\n data=json.dumps(\n dict(\n node_values=node_values,\n loop_iterations=top_iteration.extract_iterations()['loops'],\n type_names=type_registry.names(),\n num_special_types=type_registry.num_special_types,\n ),\n cls=ProtocolEncoder,\n separators=(',', ':')\n ),\n start_time=frame_info.start_time)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.db" ], [ "LOOKUP_METHOD", "self.db.session_scope" ], [ "CALL_METHOD", "self.db.session_scope()" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.add" ], [ "LOAD_FAST", "call" ], [ "CALL_METHOD", "session.add(call)" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.vals" ], [ "LOOKUP_METHOD", "iteration.vals.items" ], [ "CALL_METHOD", "iteration.vals.items()" ], [ "LOAD_FAST", "tree_index" ], [ "LOAD_FAST", "path" ], [ "BINARY_ADD", "(tree_index,) + path" ], [ "LOAD_FAST", "node_values" ], [ "LOAD_FAST", "full_path" ], [ "BINARY_SUBSCR", "full_path[:-1]" ], [ "LOAD_FAST", "d" ], [ "LOAD_FAST", "path_k" ], [ "BINARY_SUBSCR", "d[path_k]" ], [ "LOAD_FAST", "node_value" ], [ "LOAD_FAST", "d" ], [ "LOAD_FAST", "full_path" ], [ "BINARY_SUBSCR", "full_path[-1]" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.loops" ], [ "LOOKUP_METHOD", "iteration.loops.values" ], [ "CALL_METHOD", "iteration.loops.values()" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "loop" ], [ "CALL_FUNCTION", "enumerate(loop)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._extract_node_values" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "path + (i,)" ], [ "LOAD_FAST", "node_values" ], [ "CALL_METHOD", "self._extract_node_values(iteration, path + (i,), node_values)" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "BirdsEye" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(BirdsEye, self)" ], [ "LOOKUP_METHOD", "super(BirdsEye, self).trace_function" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "super(BirdsEye, self).trace_function(func)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOOKUP_METHOD", "self._code_infos.get" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_ATTR", "new_func.__code__" ], [ "CALL_METHOD", "self._code_infos.get(new_func.__code__)" ], [ "LOAD_FAST", "code_info" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.getsourcelines" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "inspect.getsourcelines(func)" ], [ "LOAD_FAST", "start_lineno" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "lines" ], [ "CALL_FUNCTION", "len(lines)" ], [ "BINARY_ADD", "start_lineno + len(lines)" ], [ "LOAD_GLOBAL", "safe_qualname" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "safe_qualname(func)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.getsourcefile" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "inspect.getsourcefile(func)" ], [ "LOAD_FAST", "source_file" ], [ "LOOKUP_METHOD", "source_file.startswith" ], [ "CALL_METHOD", "source_file.startswith('= 0" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.getsourcefile" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "inspect.getsourcefile(frame)" ], [ "LOAD_FAST", "filename" ], [ "COMPARE_OP", "filename is not None" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOOKUP_METHOD", "os.path.abspath" ], [ "LOAD_FAST", "filename" ], [ "CALL_METHOD", "os.path.abspath(filename)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "LOOKUP_METHOD", "frame.f_globals.get" ], [ "CALL_METHOD", "frame.f_globals.get('__name__')" ], [ "COMPARE_OP", "frame.f_globals.get('__name__') != '__main__'" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._treetrace_hidden_with_stmt" ], [ "LOAD_ATTR", "self._treetrace_hidden_with_stmt.__name__" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "COMPARE_OP", "self._treetrace_hidden_with_stmt.__name__ not in frame.f_globals" ], [ "LOAD_GLOBAL", "RuntimeError" ], [ "CALL_FUNCTION", "RuntimeError(\n 'To trace an imported module, you must import birdseye before '\n 'importing that module.')" ], [ "LOAD_GLOBAL", "read_source_file" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "read_source_file(filename)" ], [ "LOOKUP_METHOD", "read_source_file(filename).splitlines" ], [ "CALL_METHOD", "read_source_file(filename).splitlines()" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lineno" ], [ "BINARY_MULTIPLY", "[''] * frame.f_lineno" ], [ "LOAD_FAST", "lines" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lineno" ], [ "LOOKUP_METHOD", "'\\n'.join" ], [ "LOAD_FAST", "lines" ], [ "CALL_METHOD", "'\\n'.join(lines)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.exec_string" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "LOAD_FAST", "deep" ], [ "CALL_METHOD", "self.exec_string(source, filename, frame.f_globals, frame.f_locals, deep)" ], [ "LOAD_GLOBAL", "sys" ], [ "LOOKUP_METHOD", "sys.exit" ], [ "CALL_METHOD", "sys.exit(0)" ], [ "LOAD_FAST", "globs" ], [ "LOAD_FAST", "locs" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self.compile" ], [ "LOAD_DEREF", "source" ], [ "LOAD_DEREF", "filename" ], [ "CALL_METHOD", "self.compile(source, filename)" ], [ "LOAD_FAST", "globs" ], [ "LOOKUP_METHOD", "globs.update" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self._trace_methods_dict" ], [ "LOAD_DEREF", "traced_file" ], [ "CALL_METHOD", "self._trace_methods_dict(traced_file)" ], [ "CALL_METHOD", "globs.update(self._trace_methods_dict(traced_file))" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self._trace" ], [ "LOAD_GLOBAL", "FILE_SENTINEL_NAME" ], [ "LOAD_DEREF", "filename" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.code" ], [ "LOAD_DEREF", "source" ], [ "CALL_METHOD", "self._trace(FILE_SENTINEL_NAME, filename, traced_file, traced_file.code, 'module', source)" ], [ "LOAD_FAST", "deep" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.nodes" ], [ "LOAD_DEREF", "find_code" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.code" ], [ "CALL_FUNCTION", "find_code(traced_file.code)" ], [ "LOAD_GLOBAL", "exec" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.code" ], [ "LOAD_FAST", "globs" ], [ "LOAD_FAST", "locs" ], [ "CALL_FUNCTION", "exec(traced_file.code, globs, locs)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(node, ast.FunctionDef)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.lineno" ], [ "LOAD_FAST", "root_code" ], [ "LOAD_ATTR", "root_code.co_consts" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.iscode" ], [ "LOAD_FAST", "code" ], [ "CALL_METHOD", "inspect.iscode(code)" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "LOOKUP_METHOD", "code.co_name.startswith" ], [ "CALL_METHOD", "code.co_name.startswith('<')" ], [ "LOAD_DEREF", "find_code" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "find_code(code)" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_firstlineno" ], [ "LOAD_DEREF", "nodes_by_lineno" ], [ "LOOKUP_METHOD", "nodes_by_lineno.get" ], [ "LOAD_FAST", "lineno" ], [ "CALL_METHOD", "nodes_by_lineno.get(lineno)" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self._trace" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "LOAD_DEREF", "filename" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_FAST", "code" ], [ "LOAD_DEREF", "source" ], [ "LOAD_FAST", "lineno" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.last_token" ], [ "LOAD_ATTR", "node.last_token.end" ], [ "BINARY_SUBSCR", "node.last_token.end[0]" ], [ "BINARY_ADD", "node.last_token.end[0] + 1" ], [ "CALL_METHOD", "self._trace(\n code.co_name, filename, traced_file, code,\n typ='function',\n source=source,\n start_lineno=lineno,\n end_lineno=node.last_token.end[0] + 1,\n )" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_DEREF", "start_lineno" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "source" ], [ "LOOKUP_METHOD", "source.splitlines" ], [ "CALL_METHOD", "source.splitlines()" ], [ "CALL_FUNCTION", "len(source.splitlines())" ], [ "BINARY_ADD", "start_lineno + len(source.splitlines())" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._nodes_of_interest" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_DEREF", "start_lineno" ], [ "LOAD_FAST", "end_lineno" ], [ "CALL_METHOD", "self._nodes_of_interest(traced_file, start_lineno, end_lineno)" ], [ "CALL_FUNCTION", "list(self._nodes_of_interest(traced_file, start_lineno, end_lineno))" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._nodes_html" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_DEREF", "start_lineno" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_FAST", "traced_file" ], [ "CALL_METHOD", "self._nodes_html(nodes, start_lineno, end_lineno, traced_file)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "nodes" ], [ "CALL_FUNCTION", "dict(\n # This maps each node to the loops enclosing that node\n node_loops={\n node._tree_index: [n._tree_index for n in node._loops]\n for node, _ in nodes\n if node._loops\n },\n )" ], [ "LOAD_FAST", "typ" ], [ "COMPARE_OP", "typ == 'function'" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.tokens" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_FAST", "nodes" ], [ "CALL_FUNCTION", "only(node\n for node, _ in nodes\n if isinstance(node, ast.FunctionDef)\n and node.first_token.start[0] == start_lineno)" ], [ "LOAD_GLOBAL", "source_without_decorators" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_FAST", "func_node" ], [ "CALL_FUNCTION", "source_without_decorators(tokens, func_node)" ], [ "LOAD_FAST", "data_dict" ], [ "LOOKUP_METHOD", "data_dict.update" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._node_ranges" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_FAST", "func_startpos" ], [ "CALL_METHOD", "self._node_ranges(nodes, tokens, func_startpos)" ], [ "CALL_FUNCTION", "list(self._node_ranges(nodes, tokens, func_startpos))" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._loop_ranges" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_FAST", "func_startpos" ], [ "CALL_METHOD", "self._loop_ranges(nodes, tokens, func_startpos)" ], [ "CALL_FUNCTION", "list(self._loop_ranges(nodes, tokens, func_startpos))" ], [ "CALL_METHOD", "data_dict.update(\n node_ranges=list(self._node_ranges(nodes, tokens, func_startpos)),\n loop_ranges=list(self._loop_ranges(nodes, tokens, func_startpos)),\n )" ], [ "LOAD_GLOBAL", "json" ], [ "LOOKUP_METHOD", "json.dumps" ], [ "LOAD_FAST", "data_dict" ], [ "CALL_METHOD", "json.dumps(data_dict, sort_keys=True)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._db_func" ], [ "LOAD_FAST", "data" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "html_body" ], [ "LOAD_FAST", "name" ], [ "LOAD_DEREF", "start_lineno" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "typ" ], [ "CALL_METHOD", "self._db_func(data, filename, html_body, name, start_lineno, source, typ)" ], [ "LOAD_GLOBAL", "CodeInfo" ], [ "LOAD_FAST", "db_func" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_FAST", "arg_names" ], [ "CALL_FUNCTION", "CodeInfo(db_func, traced_file, arg_names)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_FAST", "n" ], [ "LOAD_ATTR", "n._tree_index" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(node, ast.FunctionDef)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.first_token" ], [ "LOAD_ATTR", "node.first_token.start" ], [ "BINARY_SUBSCR", "node.first_token.start[0]" ], [ "LOAD_DEREF", "start_lineno" ], [ "COMPARE_OP", "node.first_token.start[0] == start_lineno" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "classes" ], [ "COMPARE_OP", "'loop' not in classes" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.target" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.test" ], [ "LOAD_FAST", "tokens" ], [ "LOOKUP_METHOD", "tokens.get_text_range" ], [ "LOAD_FAST", "target" ], [ "CALL_METHOD", "tokens.get_text_range(target)" ], [ "LOAD_FAST", "func_start" ], [ "LOAD_FAST", "func_start" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "CALL_FUNCTION", "dict(\n tree_index=node._tree_index,\n start=start,\n end=end\n )" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "tokens" ], [ "LOOKUP_METHOD", "tokens.get_text_range" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "tokens.get_text_range(node)" ], [ "LOAD_FAST", "func_start" ], [ "LOAD_FAST", "func_start" ], [ "LOAD_FAST", "start" ], [ "COMPARE_OP", "start < 0" ], [ "LOAD_FAST", "end" ], [ "COMPARE_OP", "end < 0" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(node, ast.FunctionDef)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._depth" ], [ "LOAD_FAST", "classes" ], [ "CALL_FUNCTION", "dict(\n tree_index=node._tree_index,\n start=start,\n end=end,\n depth=node._depth,\n classes=classes,\n )" ], [ "LOAD_FAST", "h" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "name" ], [ "BINARY_ADD", "filename + name" ], [ "LOAD_FAST", "html_body" ], [ "BINARY_ADD", "filename + name + html_body" ], [ "LOAD_FAST", "data" ], [ "BINARY_ADD", "filename + name + html_body + data" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "start_lineno" ], [ "CALL_FUNCTION", "str(start_lineno)" ], [ "BINARY_ADD", "filename + name + html_body + data + str(start_lineno)" ], [ "CALL_FUNCTION", "h(filename + name + html_body + data + str(start_lineno))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.db" ], [ "LOAD_ATTR", "self.db.Function" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.db" ], [ "LOOKUP_METHOD", "self.db.session_scope" ], [ "CALL_METHOD", "self.db.session_scope()" ], [ "LOAD_GLOBAL", "one_or_none" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.query" ], [ "LOAD_FAST", "Function" ], [ "CALL_METHOD", "session.query(Function)" ], [ "LOOKUP_METHOD", "session.query(Function).filter_by" ], [ "LOAD_FAST", "function_hash" ], [ "CALL_METHOD", "session.query(Function).filter_by(hash=function_hash)" ], [ "CALL_FUNCTION", "one_or_none(session.query(Function).filter_by(hash=function_hash))" ], [ "LOAD_FAST", "db_func" ], [ "LOAD_FAST", "Function" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "typ" ], [ "LOAD_FAST", "html_body" ], [ "LOAD_FAST", "start_lineno" ], [ "LOAD_FAST", "data" ], [ "LOAD_FAST", "h" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "h(source)" ], [ "LOAD_FAST", "function_hash" ], [ "CALL_FUNCTION", "Function(file=filename,\n name=name,\n type=typ,\n html_body=html_body,\n lineno=start_lineno,\n data=data,\n body_hash=h(source),\n hash=function_hash)" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.add" ], [ "LOAD_FAST", "db_func" ], [ "CALL_METHOD", "session.add(db_func)" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.commit" ], [ "CALL_METHOD", "session.commit()" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "db_func" ], [ "LOAD_ATTR", "db_func.id" ], [ "LOAD_GLOBAL", "int" ], [ "CALL_FUNCTION", "isinstance(db_func.id, int)" ], [ "LOAD_FAST", "db_func" ], [ "LOAD_ATTR", "db_func.id" ], [ "LOAD_GLOBAL", "hashlib" ], [ "LOOKUP_METHOD", "hashlib.sha256" ], [ "LOAD_FAST", "s" ], [ "LOOKUP_METHOD", "s.encode" ], [ "CALL_METHOD", "s.encode('utf8')" ], [ "CALL_METHOD", "hashlib.sha256(s.encode('utf8'))" ], [ "LOOKUP_METHOD", "hashlib.sha256(s.encode('utf8')).hexdigest" ], [ "CALL_METHOD", "hashlib.sha256(s.encode('utf8')).hexdigest()" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.nodes" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "CALL_FUNCTION", "isinstance(node, (ast.While, ast.For, ast.comprehension))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.GeneratorExp" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.GeneratorExp)" ], [ "LOAD_FAST", "classes" ], [ "LOOKUP_METHOD", "classes.append" ], [ "CALL_METHOD", "classes.append('loop')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "CALL_FUNCTION", "isinstance(node, ast.stmt)" ], [ "LOAD_FAST", "classes" ], [ "LOOKUP_METHOD", "classes.append" ], [ "CALL_METHOD", "classes.append('stmt')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "CALL_FUNCTION", "isinstance(node, ast.expr)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._is_interesting_expression" ], [ "LOAD_FAST", "classes" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.AST" ], [ "CALL_FUNCTION", "isinstance(node, ast.AST)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "hasattr(node, 'first_token')" ], [ "LOAD_FAST", "start_lineno" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.first_token" ], [ "LOAD_ATTR", "node.first_token.start" ], [ "BINARY_SUBSCR", "node.first_token.start[0]" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.tokens" ], [ "LOOKUP_METHOD", "traced_file.tokens.get_text_range" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "traced_file.tokens.get_text_range(node)" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "classes" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.root" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.walk" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.root" ], [ "CALL_METHOD", "ast.walk(traced_file.root)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.iter_child_nodes" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.iter_child_nodes(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._depth" ], [ "BINARY_ADD", "node._depth + 1" ], [ "LOAD_FAST", "child" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "positions" ], [ "LOOKUP_METHOD", "positions.extend" ], [ "LOAD_GLOBAL", "map" ], [ "LOAD_GLOBAL", "HTMLPosition" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._depth" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._depth" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOOKUP_METHOD", "' '.join" ], [ "LOAD_FAST", "classes" ], [ "CALL_METHOD", "' '.join(classes)" ], [ "BINARY_MODULO", "'' % (node._tree_index, ' '.join(classes))" ], [ "CALL_FUNCTION", "map(\n HTMLPosition,\n [start, end],\n [True, False], # is_start\n [node._depth, node._depth],\n ['' % (node._tree_index, ' '.join(classes)),\n ''])" ], [ "CALL_METHOD", "positions.extend(map(\n HTMLPosition,\n [start, end],\n [True, False], # is_start\n [node._depth, node._depth],\n ['' % (node._tree_index, ' '.join(classes)),\n '']))" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._separate_comprehensions" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_FAST", "positions" ], [ "LOAD_FAST", "traced_file" ], [ "CALL_METHOD", "self._separate_comprehensions(\n [n[0] for n in nodes],\n end_lineno, positions, traced_file)" ], [ "LOAD_FAST", "positions" ], [ "LOOKUP_METHOD", "positions.append" ], [ "LOAD_GLOBAL", "HTMLPosition" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.source" ], [ "CALL_FUNCTION", "len(traced_file.source)" ], [ "CALL_FUNCTION", "HTMLPosition(len(traced_file.source), False, 0, '')" ], [ "CALL_METHOD", "positions.append(HTMLPosition(len(traced_file.source), False, 0, ''))" ], [ "LOAD_FAST", "positions" ], [ "LOOKUP_METHOD", "positions.sort" ], [ "CALL_METHOD", "positions.sort()" ], [ "LOAD_FAST", "positions" ], [ "LOAD_FAST", "html_parts" ], [ "LOOKUP_METHOD", "html_parts.append" ], [ "LOAD_GLOBAL", "html" ], [ "LOOKUP_METHOD", "html.escape" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.source" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "position" ], [ "LOAD_ATTR", "position.index" ], [ "BINARY_SUBSCR", "traced_file.source[start:position.index]" ], [ "CALL_METHOD", "html.escape(traced_file.source[start:position.index])" ], [ "CALL_METHOD", "html_parts.append(html.escape(traced_file.source[start:position.index]))" ], [ "LOAD_FAST", "html_parts" ], [ "LOOKUP_METHOD", "html_parts.append" ], [ "LOAD_FAST", "position" ], [ "LOAD_ATTR", "position.html" ], [ "CALL_METHOD", "html_parts.append(position.html)" ], [ "LOAD_FAST", "position" ], [ "LOAD_ATTR", "position.index" ], [ "LOOKUP_METHOD", "''.join" ], [ "LOAD_FAST", "html_parts" ], [ "CALL_METHOD", "''.join(html_parts)" ], [ "LOOKUP_METHOD", "'\\n'.join" ], [ "LOAD_FAST", "html_body" ], [ "LOOKUP_METHOD", "html_body.split" ], [ "CALL_METHOD", "html_body.split('\\n')" ], [ "LOAD_FAST", "start_lineno" ], [ "BINARY_SUBTRACT", "start_lineno - 1" ], [ "LOAD_FAST", "end_lineno" ], [ "BINARY_SUBTRACT", "end_lineno - 1" ], [ "BINARY_SUBSCR", "html_body.split('\\n')[start_lineno - 1:end_lineno - 1]" ], [ "CALL_METHOD", "'\\n'.join(html_body.split('\\n')[start_lineno - 1:end_lineno - 1])" ], [ "LOAD_FAST", "html_body" ], [ "LOOKUP_METHOD", "html_body.strip" ], [ "CALL_METHOD", "html_body.strip('\\n')" ], [ "LOAD_FAST", "n" ], [ "BINARY_SUBSCR", "n[0]" ], [ "LOAD_GLOBAL", "group_by_key_func" ], [ "LOAD_GLOBAL", "of_type" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "LOAD_FAST", "nodes" ], [ "CALL_FUNCTION", "of_type((ast.comprehension, ast.While, ast.For), nodes)" ], [ "CALL_FUNCTION", "group_by_key_func(of_type((ast.comprehension, ast.While, ast.For), nodes),\n lambda c: c.first_token.start[0]\n )" ], [ "LOAD_FAST", "comprehensions" ], [ "LOOKUP_METHOD", "comprehensions.values" ], [ "CALL_METHOD", "comprehensions.values()" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_FAST", "comp_list" ], [ "CALL_FUNCTION", "sorted(comp_list, key=lambda c: c.first_token.startpos)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "comp" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "CALL_FUNCTION", "isinstance(comp, ast.comprehension)" ], [ "LOAD_FAST", "comp" ], [ "LOAD_FAST", "comp" ], [ "LOAD_ATTR", "comp.parent" ], [ "LOAD_ATTR", "comp.parent.generators" ], [ "BINARY_SUBSCR", "comp.parent.generators[0]" ], [ "COMPARE_OP", "comp is comp.parent.generators[0]" ], [ "LOAD_FAST", "get_start" ], [ "LOAD_FAST", "comp" ], [ "LOAD_ATTR", "comp.parent" ], [ "CALL_FUNCTION", "get_start(comp.parent)" ], [ "LOAD_FAST", "prev_start" ], [ "COMPARE_OP", "prev_start is not None" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "prev_start" ], [ "COMPARE_OP", "start < prev_start" ], [ "LOAD_FAST", "get_start" ], [ "LOAD_FAST", "comp" ], [ "CALL_FUNCTION", "get_start(comp)" ], [ "LOAD_FAST", "get_start" ], [ "LOAD_FAST", "comp" ], [ "CALL_FUNCTION", "get_start(comp)" ], [ "LOAD_FAST", "prev_start" ], [ "COMPARE_OP", "prev_start is not None" ], [ "LOAD_FAST", "positions" ], [ "LOOKUP_METHOD", "positions.append" ], [ "LOAD_GLOBAL", "HTMLPosition" ], [ "LOAD_FAST", "start" ], [ "CALL_FUNCTION", "HTMLPosition(start, True, 0, '\\n ')" ], [ "CALL_METHOD", "positions.append(HTMLPosition(start, True, 0, '\\n '))" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.first_token" ], [ "LOAD_ATTR", "c.first_token.start" ], [ "BINARY_SUBSCR", "c.first_token.start[0]" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.tokens" ], [ "LOOKUP_METHOD", "traced_file.tokens.get_text_range" ], [ "LOAD_FAST", "n" ], [ "CALL_METHOD", "traced_file.tokens.get_text_range(n)" ], [ "BINARY_SUBSCR", "traced_file.tokens.get_text_range(n)[0]" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.first_token" ], [ "LOAD_ATTR", "c.first_token.startpos" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "_deep_dict" ], [ "CALL_FUNCTION", "defaultdict(_deep_dict)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_GLOBAL", "_bad_codes" ], [ "COMPARE_OP", "frame.f_code in _bad_codes" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "IterationList" ], [ "CALL_FUNCTION", "defaultdict(IterationList)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.index" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.loops" ], [ "LOOKUP_METHOD", "self.loops.items" ], [ "CALL_METHOD", "self.loops.items()" ], [ "LOAD_FAST", "iteration_list" ], [ "LOAD_FAST", "tree_index" ], [ "LOAD_FAST", "iteration" ], [ "LOOKUP_METHOD", "iteration.extract_iterations" ], [ "CALL_METHOD", "iteration.extract_iterations()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "deque" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.side_len" ], [ "CALL_FUNCTION", "deque(maxlen=self.side_len)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "Counter" ], [ "CALL_FUNCTION", "Counter()" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.length" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.side_len" ], [ "COMPARE_OP", "self.length < self.side_len" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start" ], [ "LOOKUP_METHOD", "self.start.append" ], [ "LOAD_FAST", "iteration" ], [ "CALL_METHOD", "self.start.append(iteration)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "CALL_FUNCTION", "len(self.end)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.side_len" ], [ "COMPARE_OP", "len(self.end) >= self.side_len" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "BINARY_SUBSCR", "self.end[0]" ], [ "LOAD_ATTR", "self.end[0].keep" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start" ], [ "LOOKUP_METHOD", "self.start.append" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "BINARY_SUBSCR", "self.end[0]" ], [ "CALL_METHOD", "self.start.append(self.end[0])" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "LOOKUP_METHOD", "self.end.append" ], [ "LOAD_FAST", "iteration" ], [ "CALL_METHOD", "self.end.append(iteration)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.length" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "chain" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "CALL_FUNCTION", "chain(self.start, self.end)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "BINARY_SUBSCR", "self.end[-1]" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start" ], [ "BINARY_SUBSCR", "self.start[-1]" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.recorded" ], [ "LOAD_FAST", "node" ], [ "BINARY_SUBSCR", "self.recorded[node]" ], [ "COMPARE_OP", "self.recorded[node] >= 2" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.last" ], [ "CALL_METHOD", "self.last()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.recorded" ], [ "LOAD_FAST", "node" ], [ "LOAD_NAME", "type" ], [ "CALL_FUNCTION", "type(None)" ], [ "LOAD_NAME", "bool" ], [ "LOAD_NAME", "int" ], [ "LOAD_NAME", "float" ], [ "LOAD_NAME", "complex" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "long" ], [ "LOAD_NAME", "basic_types" ], [ "LOAD_NAME", "list" ], [ "LOAD_NAME", "dict" ], [ "LOAD_NAME", "tuple" ], [ "LOAD_NAME", "set" ], [ "LOAD_NAME", "frozenset" ], [ "LOAD_NAME", "str" ], [ "BINARY_ADD", "basic_types + (list, dict, tuple, set, frozenset, str)" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "unicode" ], [ "LOAD_NAME", "bytes" ], [ "LOAD_NAME", "len" ], [ "LOAD_NAME", "special_types" ], [ "CALL_FUNCTION", "len(special_types)" ], [ "LOAD_GLOBAL", "Lock" ], [ "CALL_FUNCTION", "Lock()" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "CALL_FUNCTION", "defaultdict(lambda: len(self.data))" ], [ "LOAD_DEREF", "self" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.special_types" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.data" ], [ "LOAD_FAST", "t" ], [ "BINARY_SUBSCR", "self.data[t]" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.data" ], [ "CALL_FUNCTION", "len(self.data)" ], [ "LOAD_GLOBAL", "correct_type" ], [ "LOAD_FAST", "item" ], [ "CALL_FUNCTION", "correct_type(item)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.lock" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.data" ], [ "LOAD_FAST", "t" ], [ "BINARY_SUBSCR", "self.data[t]" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.data" ], [ "LOOKUP_METHOD", "self.data.items" ], [ "CALL_METHOD", "self.data.items()" ], [ "CALL_FUNCTION", "dict((v, k) for k, v in self.data.items())" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_DEREF", "rev" ], [ "CALL_FUNCTION", "len(rev)" ], [ "CALL_FUNCTION", "range(len(rev))" ], [ "LOAD_FAST", "v" ], [ "LOAD_FAST", "k" ], [ "LOAD_GLOBAL", "safe_qualname" ], [ "LOAD_DEREF", "rev" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "rev[i]" ], [ "CALL_FUNCTION", "safe_qualname(rev[i])" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_FAST", "val_repr" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "type_index" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.meta" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.meta" ], [ "LOAD_FAST", "key" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.children" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.children" ], [ "LOOKUP_METHOD", "self.children.append" ], [ "LOAD_FAST", "key" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOOKUP_METHOD", "NodeValue.expression" ], [ "LOAD_FAST", "samples" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "level" ], [ "CALL_METHOD", "NodeValue.expression(samples, value, level)" ], [ "CALL_METHOD", "self.children.append((key, NodeValue.expression(samples, value, level)))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.val_repr" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.type_index" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.meta" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.children" ], [ "LOAD_FAST", "result" ], [ "LOOKUP_METHOD", "result.extend" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.children" ], [ "CALL_METHOD", "result.extend(self.children)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "cls" ], [ "CALL_FUNCTION", "cls('', -2)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_GLOBAL", "exception_string" ], [ "LOAD_FAST", "exc_value" ], [ "CALL_FUNCTION", "exception_string(exc_value)" ], [ "CALL_FUNCTION", "cls(exception_string(exc_value), -1)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "cheap_repr(val)" ], [ "LOAD_GLOBAL", "type_registry" ], [ "LOAD_FAST", "val" ], [ "BINARY_SUBSCR", "type_registry[val]" ], [ "CALL_FUNCTION", "cls(cheap_repr(val), type_registry[val])" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "TypeRegistry" ], [ "LOAD_ATTR", "TypeRegistry.basic_types" ], [ "LOAD_GLOBAL", "BirdsEye" ], [ "CALL_FUNCTION", "isinstance(val, (TypeRegistry.basic_types, BirdsEye))" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "QuerySet" ], [ "CALL_FUNCTION", "isinstance(val, QuerySet)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "len(val)" ], [ "LOAD_FAST", "result" ], [ "LOOKUP_METHOD", "result.set_meta" ], [ "LOAD_FAST", "length" ], [ "CALL_METHOD", "result.set_meta('len', length)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "ModuleType" ], [ "CALL_FUNCTION", "isinstance(val, ModuleType)" ], [ "LOAD_GLOBAL", "min" ], [ "LOAD_FAST", "level" ], [ "CALL_FUNCTION", "min(level, 2)" ], [ "LOAD_GLOBAL", "partial" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.add_child" ], [ "LOAD_FAST", "samples" ], [ "LOAD_FAST", "level" ], [ "BINARY_SUBTRACT", "level - 1" ], [ "CALL_FUNCTION", "partial(result.add_child, samples, level - 1)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Series" ], [ "LOAD_GLOBAL", "ndarray" ], [ "CALL_FUNCTION", "isinstance(val, (Series, ndarray))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "ndarray" ], [ "CALL_FUNCTION", "isinstance(val, ndarray)" ], [ "LOAD_FAST", "attrs" ], [ "LOOKUP_METHOD", "attrs.append" ], [ "CALL_METHOD", "attrs.append('shape')" ], [ "LOAD_FAST", "attrs" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "val" ], [ "LOAD_FAST", "name" ], [ "CALL_FUNCTION", "getattr(val, name)" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "attr" ], [ "CALL_FUNCTION", "add_child(name, attr)" ], [ "LOAD_FAST", "level" ], [ "COMPARE_OP", "level >= 3" ], [ "LOAD_FAST", "level" ], [ "COMPARE_OP", "level >= 2" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Series" ], [ "CALL_FUNCTION", "isinstance(val, Series)" ], [ "LOAD_FAST", "samples" ], [ "LOAD_FAST", "sample_type" ], [ "BINARY_SUBSCR", "samples[sample_type]" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "DataFrame" ], [ "CALL_FUNCTION", "isinstance(val, DataFrame)" ], [ "LOAD_FAST", "result" ], [ "LOOKUP_METHOD", "result.set_meta" ], [ "LOAD_FAST", "meta" ], [ "CALL_METHOD", "result.set_meta('dataframe', meta)" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['pandas_rows']" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['pandas_cols']" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_rows" ], [ "BINARY_ADD", "max_rows + 2" ], [ "COMPARE_OP", "length > max_rows + 2" ], [ "LOAD_FAST", "max_rows" ], [ "BINARY_FLOOR_DIVIDE", "max_rows // 2" ], [ "LOAD_FAST", "meta" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.columns" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "columns" ], [ "CALL_FUNCTION", "len(columns)" ], [ "LOAD_FAST", "num_cols" ], [ "LOAD_FAST", "max_cols" ], [ "BINARY_ADD", "max_cols + 2" ], [ "COMPARE_OP", "num_cols > max_cols + 2" ], [ "LOAD_FAST", "max_cols" ], [ "BINARY_FLOOR_DIVIDE", "max_cols // 2" ], [ "LOAD_FAST", "meta" ], [ "LOAD_GLOBAL", "set" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "num_cols" ], [ "LOAD_FAST", "max_cols" ], [ "CALL_FUNCTION", "_sample_indices(num_cols, max_cols)" ], [ "CALL_FUNCTION", "set(_sample_indices(num_cols, max_cols))" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_GLOBAL", "zip" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.columns" ], [ "LOOKUP_METHOD", "val.columns.format" ], [ "CALL_METHOD", "val.columns.format(sparsify=False)" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.columns" ], [ "CALL_FUNCTION", "zip(val.columns.format(sparsify=False),\n val.columns)" ], [ "CALL_FUNCTION", "enumerate(zip(val.columns.format(sparsify=False),\n val.columns))" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "indices" ], [ "COMPARE_OP", "i in indices" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_FAST", "formatted_name" ], [ "LOAD_FAST", "val" ], [ "LOAD_FAST", "label" ], [ "BINARY_SUBSCR", "val[label]" ], [ "CALL_FUNCTION", "add_child(formatted_name, val[label])" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Series" ], [ "CALL_FUNCTION", "isinstance(val, Series)" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['pandas_rows']" ], [ "CALL_FUNCTION", "_sample_indices(length, samples['pandas_rows'])" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.index" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "val.index[i:i + 1]" ], [ "LOOKUP_METHOD", "val.index[i:i + 1].format" ], [ "CALL_METHOD", "val.index[i:i + 1].format(sparsify=False)" ], [ "BINARY_SUBSCR", "val.index[i:i + 1].format(sparsify=False)[0]" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.iloc" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "val.iloc[i]" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_FAST", "k" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child(k, v)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "level" ], [ "COMPARE_OP", "level <= 0" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "bytes" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "unicode" ], [ "LOAD_GLOBAL", "xrange" ], [ "CALL_FUNCTION", "isinstance(val,\n (str, bytes, range)\n if PY3 else\n (str, unicode, xrange))" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Sequence" ], [ "LOAD_GLOBAL", "ndarray" ], [ "CALL_FUNCTION", "isinstance(val, (Sequence, ndarray))" ], [ "LOAD_FAST", "length" ], [ "COMPARE_OP", "length is not None" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['list']" ], [ "CALL_FUNCTION", "_sample_indices(length, samples['list'])" ], [ "LOAD_FAST", "val" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "val[i]" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "i" ], [ "CALL_FUNCTION", "str(i)" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child(str(i), v)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Mapping" ], [ "CALL_FUNCTION", "isinstance(val, Mapping)" ], [ "LOAD_GLOBAL", "islice" ], [ "LOAD_GLOBAL", "_safe_iter" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "iteritems" ], [ "CALL_FUNCTION", "_safe_iter(val, iteritems)" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['dict']" ], [ "CALL_FUNCTION", "islice(_safe_iter(val, iteritems), samples['dict'])" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "k" ], [ "CALL_FUNCTION", "cheap_repr(k)" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child(cheap_repr(k), v)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Set" ], [ "CALL_FUNCTION", "isinstance(val, Set)" ], [ "LOAD_GLOBAL", "_safe_iter" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "_safe_iter(val)" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['set']" ], [ "LOAD_FAST", "length" ], [ "COMPARE_OP", "length is None" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "num_items" ], [ "BINARY_ADD", "num_items + 2" ], [ "COMPARE_OP", "length > num_items + 2" ], [ "LOAD_GLOBAL", "islice" ], [ "LOAD_FAST", "vals" ], [ "LOAD_FAST", "num_items" ], [ "CALL_FUNCTION", "islice(vals, num_items)" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "vals" ], [ "CALL_FUNCTION", "enumerate(vals)" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_FAST", "i" ], [ "BINARY_MODULO", "'<%s>' % i" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child('<%s>' % i, v)" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "getattr(val, '__dict__', None)" ], [ "LOAD_FAST", "d" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_GLOBAL", "islice" ], [ "LOAD_GLOBAL", "_safe_iter" ], [ "LOAD_FAST", "d" ], [ "CALL_FUNCTION", "_safe_iter(d)" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['attributes']" ], [ "CALL_FUNCTION", "islice(_safe_iter(d),\n samples['attributes'])" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "sorted(islice(_safe_iter(d),\n samples['attributes']),\n key=str)" ], [ "LOAD_FAST", "d" ], [ "LOAD_FAST", "k" ], [ "BINARY_SUBSCR", "d[k]" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "TracedFile" ], [ "CALL_FUNCTION", "isinstance(v, TracedFile)" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "k" ], [ "CALL_FUNCTION", "str(k)" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child(str(k), v)" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "type" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "type(val)" ], [ "CALL_FUNCTION", "getattr(type(val), '__slots__', None)" ], [ "CALL_FUNCTION", "sorted(getattr(type(val), '__slots__', None) or ())" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "val" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "getattr(val, s)" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "str(s)" ], [ "LOAD_FAST", "attr" ], [ "CALL_FUNCTION", "add_child(str(s), attr)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "x" ], [ "LOAD_FAST", "f" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "f(val)" ], [ "LOAD_FAST", "x" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_ADD", "max_length + 2" ], [ "COMPARE_OP", "length <= max_length + 2" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "range(length)" ], [ "LOAD_GLOBAL", "chain" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_FLOOR_DIVIDE", "max_length // 2" ], [ "CALL_FUNCTION", "range(max_length // 2)" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_FLOOR_DIVIDE", "max_length // 2" ], [ "BINARY_SUBTRACT", "length - max_length // 2" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "range(length - max_length // 2,\n length)" ], [ "CALL_FUNCTION", "chain(range(max_length // 2),\n range(length - max_length // 2,\n length))" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "len(x)" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "n == 0" ], [ "LOAD_GLOBAL", "repr" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "repr(x)" ], [ "LOAD_FAST", "helper" ], [ "LOAD_ATTR", "helper.level" ], [ "BINARY_SUBTRACT", "helper.level - 1" ], [ "LOAD_GLOBAL", "_repr_series_one_line" ], [ "LOAD_ATTR", "_repr_series_one_line.maxparts" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "n" ], [ "LOAD_FAST", "maxparts" ], [ "CALL_FUNCTION", "_sample_indices(n, maxparts)" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.index" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "x.index[i:i + 1]" ], [ "LOOKUP_METHOD", "x.index[i:i + 1].format" ], [ "CALL_METHOD", "x.index[i:i + 1].format(sparsify=False)" ], [ "BINARY_SUBSCR", "x.index[i:i + 1].format(sparsify=False)[0]" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.iloc" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "x.iloc[i]" ], [ "LOAD_FAST", "pieces" ], [ "LOOKUP_METHOD", "pieces.append" ], [ "LOAD_FAST", "k" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "v" ], [ "LOAD_FAST", "newlevel" ], [ "CALL_FUNCTION", "cheap_repr(v, newlevel)" ], [ "BINARY_MODULO", "'%s = %s' % (k, cheap_repr(v, newlevel))" ], [ "CALL_METHOD", "pieces.append('%s = %s' % (k, cheap_repr(v, newlevel)))" ], [ "LOAD_FAST", "n" ], [ "LOAD_FAST", "maxparts" ], [ "BINARY_ADD", "maxparts + 2" ], [ "COMPARE_OP", "n > maxparts + 2" ], [ "LOAD_FAST", "pieces" ], [ "LOOKUP_METHOD", "pieces.insert" ], [ "LOAD_FAST", "maxparts" ], [ "BINARY_FLOOR_DIVIDE", "maxparts // 2" ], [ "CALL_METHOD", "pieces.insert(maxparts // 2, '...')" ], [ "LOOKUP_METHOD", "'; '.join" ], [ "LOAD_FAST", "pieces" ], [ "CALL_METHOD", "'; '.join(pieces)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "CALL_FUNCTION", "isinstance(node, ast.expr)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Num" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Str" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "ast" ], [ "CALL_FUNCTION", "getattr(ast, 'NameConstant', ())" ], [ "CALL_FUNCTION", "isinstance(node, (ast.Num, ast.Str, getattr(ast, 'NameConstant', ())))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "getattr(node, 'ctx', None)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Store" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Del" ], [ "CALL_FUNCTION", "isinstance(getattr(node, 'ctx', None),\n (ast.Store, ast.Del))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.UnaryOp" ], [ "CALL_FUNCTION", "isinstance(node, ast.UnaryOp)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.op" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.UAdd" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.USub" ], [ "CALL_FUNCTION", "isinstance(node.op, (ast.UAdd, ast.USub))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.operand" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Num" ], [ "CALL_FUNCTION", "isinstance(node.operand, ast.Num)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.List" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Tuple" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Dict" ], [ "CALL_FUNCTION", "isinstance(node, (ast.List, ast.Tuple, ast.Dict))" ], [ "LOAD_GLOBAL", "any" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.iter_child_nodes" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.iter_child_nodes(node)" ], [ "CALL_FUNCTION", "any(is_interesting_expression(n) for n in ast.iter_child_nodes(node))" ], [ "UNARY_NOT", "not any(is_interesting_expression(n) for n in ast.iter_child_nodes(node))" ], [ "UNARY_NOT", "not (isinstance(node, (ast.Num, ast.Str, getattr(ast, 'NameConstant', ()))) or\n isinstance(getattr(node, 'ctx', None),\n (ast.Store, ast.Del)) or\n (isinstance(node, ast.UnaryOp) and\n isinstance(node.op, (ast.UAdd, ast.USub)) and\n isinstance(node.operand, ast.Num)) or\n (isinstance(node, (ast.List, ast.Tuple, ast.Dict)) and\n not any(is_interesting_expression(n) for n in ast.iter_child_nodes(node))))" ], [ "LOAD_GLOBAL", "is_interesting_expression" ], [ "LOAD_FAST", "n" ], [ "CALL_FUNCTION", "is_interesting_expression(n)" ], [ "LOAD_GLOBAL", "cast" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "__builtins__" ], [ "CALL_FUNCTION", "cast(dict, __builtins__)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Name" ], [ "CALL_FUNCTION", "isinstance(node, ast.Name)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.id" ], [ "LOAD_FAST", "builtins" ], [ "COMPARE_OP", "node.id in builtins" ], [ "LOAD_FAST", "builtins" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.id" ], [ "BINARY_SUBSCR", "builtins[node.id]" ], [ "LOAD_FAST", "value" ], [ "COMPARE_OP", "builtins[node.id] is value" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "ast" ], [ "CALL_FUNCTION", "getattr(ast, 'NameConstant', ())" ], [ "CALL_FUNCTION", "isinstance(node, getattr(ast, 'NameConstant', ()))" ] ], "configuration.py": [ [ "LOAD_NAME", "ctypes" ], [ "LOAD_ATTR", "ctypes.windll" ], [ "LOAD_ATTR", "ctypes.windll.kernel32" ], [ "LOAD_NAME", "kernel32" ], [ "LOOKUP_METHOD", "kernel32.SetConsoleMode" ], [ "LOAD_NAME", "kernel32" ], [ "LOOKUP_METHOD", "kernel32.GetStdHandle" ], [ "CALL_METHOD", "kernel32.GetStdHandle(-11)" ], [ "CALL_METHOD", "kernel32.SetConsoleMode(kernel32.GetStdHandle(-11), 7)" ], [ "LOAD_NAME", "Exception" ], [ "LOAD_NAME", "os" ], [ "LOAD_ATTR", "os.name" ], [ "COMPARE_OP", "os.name != 'nt'" ], [ "LOAD_NAME", "DefaultFormatter" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "object" ], [ "LOAD_FAST", "builtins" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_GLOBAL", "builtins_module" ], [ "LOAD_FAST", "snoop" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.snoop" ], [ "CALL_FUNCTION", "setattr(builtins_module, snoop, package.snoop)" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_GLOBAL", "builtins_module" ], [ "LOAD_FAST", "pp" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.pp" ], [ "CALL_FUNCTION", "setattr(builtins_module, pp, package.pp)" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_GLOBAL", "builtins_module" ], [ "LOAD_FAST", "spy" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.spy" ], [ "CALL_FUNCTION", "setattr(builtins_module, spy, package.spy)" ], [ "LOAD_GLOBAL", "Config" ], [ "LOAD_FAST", "out" ], [ "LOAD_FAST", "prefix" ], [ "LOAD_FAST", "columns" ], [ "LOAD_FAST", "overwrite" ], [ "LOAD_FAST", "color" ], [ "LOAD_FAST", "enabled" ], [ "LOAD_FAST", "watch_extras" ], [ "LOAD_FAST", "replace_watch_extras" ], [ "LOAD_FAST", "formatter_class" ], [ "CALL_FUNCTION", "Config(\n out=out,\n prefix=prefix,\n columns=columns,\n overwrite=overwrite,\n color=color,\n enabled=enabled,\n watch_extras=watch_extras,\n replace_watch_extras=replace_watch_extras,\n formatter_class=formatter_class,\n )" ], [ "LOAD_FAST", "config" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.snoop" ], [ "LOAD_FAST", "config" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.pp" ], [ "LOAD_FAST", "config" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.spy" ], [ "LOAD_NAME", "DefaultFormatter" ], [ "LOAD_GLOBAL", "can_color" ], [ "LOAD_FAST", "color" ], [ "COMPARE_OP", "color is None" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "out" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.stderr" ], [ "CALL_FUNCTION", "getattr(out or sys.stderr, 'isatty', lambda: False)" ], [ "LOAD_GLOBAL", "bool" ], [ "LOAD_FAST", "isatty" ], [ "CALL_FUNCTION", "isatty()" ], [ "CALL_FUNCTION", "bool(isatty())" ], [ "LOAD_GLOBAL", "get_write_function" ], [ "LOAD_FAST", "out" ], [ "LOAD_FAST", "overwrite" ], [ "CALL_FUNCTION", "get_write_function(out, overwrite)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "formatter_class" ], [ "LOAD_FAST", "prefix" ], [ "LOAD_FAST", "columns" ], [ "LOAD_FAST", "color" ], [ "CALL_FUNCTION", "formatter_class(prefix, columns, color)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "enabled" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "PP" ], [ "LOAD_DEREF", "self" ], [ "CALL_FUNCTION", "PP(self)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "Tracer" ], [ "LOAD_FAST", "ConfiguredTracer" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "Spy" ], [ "LOAD_DEREF", "self" ], [ "CALL_FUNCTION", "Spy(self)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "threading" ], [ "LOOKUP_METHOD", "threading.local" ], [ "CALL_METHOD", "threading.local()" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "replace_watch_extras" ], [ "COMPARE_OP", "replace_watch_extras is not None" ], [ "LOAD_GLOBAL", "ensure_tuple" ], [ "LOAD_FAST", "replace_watch_extras" ], [ "CALL_FUNCTION", "ensure_tuple(replace_watch_extras)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "len_shape_watch" ], [ "LOAD_GLOBAL", "dtype_watch" ], [ "LOAD_GLOBAL", "ensure_tuple" ], [ "LOAD_FAST", "watch_extras" ], [ "CALL_FUNCTION", "ensure_tuple(watch_extras)" ], [ "BINARY_ADD", "(len_shape_watch, dtype_watch) + ensure_tuple(watch_extras)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_CLASSDEREF", "self" ], [ "LOAD_FAST", "value" ], [ "LOAD_ATTR", "value.shape" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.ismethod" ], [ "LOAD_FAST", "shape" ], [ "CALL_METHOD", "inspect.ismethod(shape)" ], [ "LOOKUP_METHOD", "'{}.shape'.format" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "'{}.shape'.format(source)" ], [ "LOAD_FAST", "shape" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "value" ], [ "LOAD_GLOBAL", "QuerySet" ], [ "CALL_FUNCTION", "isinstance(value, QuerySet)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "len(value)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "value" ], [ "LOAD_GLOBAL", "six" ], [ "LOAD_ATTR", "six.string_types" ], [ "CALL_FUNCTION", "isinstance(value, six.string_types)" ], [ "LOAD_FAST", "length" ], [ "COMPARE_OP", "length < 50" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "value" ], [ "LOAD_GLOBAL", "Mapping" ], [ "LOAD_GLOBAL", "Set" ], [ "LOAD_GLOBAL", "Sequence" ], [ "CALL_FUNCTION", "isinstance(value, (Mapping, Set, Sequence))" ], [ "LOAD_FAST", "length" ], [ "COMPARE_OP", "length == 0" ], [ "LOOKUP_METHOD", "'len({})'.format" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "'len({})'.format(source)" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "value" ], [ "LOAD_ATTR", "value.dtype" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.ismethod" ], [ "LOAD_FAST", "dtype" ], [ "CALL_METHOD", "inspect.ismethod(dtype)" ], [ "LOOKUP_METHOD", "'{}.dtype'.format" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "'{}.dtype'.format(source)" ], [ "LOAD_FAST", "dtype" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_DEREF", "output" ], [ "LOAD_GLOBAL", "six" ], [ "LOAD_ATTR", "six.string_types" ], [ "CALL_FUNCTION", "isinstance(output, six.string_types)" ], [ "LOAD_GLOBAL", "is_pathlike" ], [ "LOAD_DEREF", "output" ], [ "CALL_FUNCTION", "is_pathlike(output)" ], [ "LOAD_FAST", "is_path" ], [ "LOAD_GLOBAL", "FileWriter" ], [ "LOAD_DEREF", "output" ], [ "LOAD_FAST", "overwrite" ], [ "CALL_FUNCTION", "FileWriter(output, overwrite)" ], [ "LOAD_ATTR", "FileWriter(output, overwrite).write" ], [ "LOAD_GLOBAL", "callable" ], [ "LOAD_DEREF", "output" ], [ "CALL_FUNCTION", "callable(output)" ], [ "LOAD_DEREF", "output" ], [ "LOAD_FAST", "write" ], [ "LOAD_DEREF", "output" ], [ "LOAD_FAST", "stream" ], [ "COMPARE_OP", "stream is None" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.stderr" ], [ "LOAD_FAST", "stream" ], [ "LOOKUP_METHOD", "stream.write" ], [ "LOAD_FAST", "s" ], [ "CALL_METHOD", "stream.write(s)" ], [ "LOAD_GLOBAL", "UnicodeEncodeError" ], [ "LOAD_FAST", "stream" ], [ "LOOKUP_METHOD", "stream.write" ], [ "LOAD_GLOBAL", "shitcode" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "shitcode(s)" ], [ "CALL_METHOD", "stream.write(shitcode(s))" ], [ "LOAD_GLOBAL", "six" ], [ "LOOKUP_METHOD", "six.text_type" ], [ "LOAD_FAST", "path" ], [ "CALL_METHOD", "six.text_type(path)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "overwrite" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "open" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.path" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.overwrite" ], [ "CALL_FUNCTION", "open(self.path, 'w' if self.overwrite else 'a', encoding='utf-8')" ], [ "LOAD_FAST", "f" ], [ "LOOKUP_METHOD", "f.write" ], [ "LOAD_FAST", "s" ], [ "CALL_METHOD", "f.write(s)" ], [ "LOAD_FAST", "self" ] ], "db.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOOKUP_METHOD", "standard_library.install_aliases" ], [ "CALL_METHOD", "standard_library.install_aliases()" ], [ "LOAD_NAME", "RESERVED_WORDS" ], [ "LOOKUP_METHOD", "RESERVED_WORDS.add" ], [ "CALL_METHOD", "RESERVED_WORDS.add('function')" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "retry" ], [ "LOAD_NAME", "InterfaceError" ], [ "LOAD_NAME", "OperationalError" ], [ "LOAD_NAME", "InternalError" ], [ "LOAD_NAME", "ProgrammingError" ], [ "CALL_FUNCTION", "retry(3, (InterfaceError, OperationalError, InternalError, ProgrammingError))" ], [ "LOAD_NAME", "contextmanager" ], [ "CALL_FUNCTION", "contextmanager" ], [ "LOAD_FAST", "db_uri" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.environ" ], [ "LOOKUP_METHOD", "os.environ.get" ], [ "CALL_METHOD", "os.environ.get('BIRDSEYE_DB')" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOOKUP_METHOD", "os.path.join" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOOKUP_METHOD", "os.path.expanduser" ], [ "CALL_METHOD", "os.path.expanduser('~')" ], [ "CALL_METHOD", "os.path.join(os.path.expanduser('~'),\n '.birdseye.db')" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "dict" ], [ "CALL_FUNCTION", "dict(\n pool_recycle=280,\n echo=False, # for convenience when debugging\n )" ], [ "LOAD_GLOBAL", "create_engine" ], [ "LOAD_FAST", "db_uri" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_KW", "create_engine(db_uri, **kwargs)" ], [ "LOAD_GLOBAL", "ArgumentError" ], [ "LOAD_FAST", "db_uri" ], [ "BINARY_ADD", "'sqlite:///' + db_uri" ], [ "LOAD_GLOBAL", "create_engine" ], [ "LOAD_FAST", "db_uri" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_KW", "create_engine(db_uri, **kwargs)" ], [ "LOAD_FAST", "engine" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "sessionmaker" ], [ "LOAD_FAST", "engine" ], [ "CALL_FUNCTION", "sessionmaker(bind=engine)" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "object" ], [ "LOAD_GLOBAL", "declarative_base" ], [ "LOAD_FAST", "Base" ], [ "CALL_FUNCTION", "declarative_base(cls=Base)" ], [ "LOAD_FAST", "Base" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "object" ], [ "LOAD_FAST", "engine" ], [ "LOAD_ATTR", "engine.name" ], [ "COMPARE_OP", "engine.name == 'mysql'" ], [ "LOAD_GLOBAL", "LONGTEXT" ], [ "LOAD_GLOBAL", "Text" ], [ "LOAD_FAST", "Base" ], [ "LOAD_FAST", "Base" ], [ "LOAD_FAST", "Call" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "Function" ], [ "LOAD_FAST", "self" ], [ "LOAD_DEREF", "KeyValue" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "KeyValueStore" ], [ "CALL_FUNCTION", "KeyValueStore()" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "_skip_version_check" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.table_exists" ], [ "LOAD_FAST", "Function" ], [ "CALL_METHOD", "self.table_exists(Function)" ], [ "LOAD_FAST", "Base" ], [ "LOAD_ATTR", "Base.metadata" ], [ "LOOKUP_METHOD", "Base.metadata.create_all" ], [ "LOAD_FAST", "engine" ], [ "CALL_METHOD", "Base.metadata.create_all(engine)" ], [ "LOAD_GLOBAL", "DB_VERSION" ], [ "LOAD_FAST", "kv" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.table_exists" ], [ "LOAD_DEREF", "KeyValue" ], [ "CALL_METHOD", "self.table_exists(KeyValue)" ], [ "LOAD_GLOBAL", "int" ], [ "LOAD_FAST", "kv" ], [ "LOAD_ATTR", "kv.version" ], [ "CALL_FUNCTION", "int(kv.version)" ], [ "LOAD_GLOBAL", "DB_VERSION" ], [ "COMPARE_OP", "int(kv.version) < DB_VERSION" ], [ "LOAD_GLOBAL", "sys" ], [ "LOOKUP_METHOD", "sys.exit" ], [ "CALL_METHOD", "sys.exit('The birdseye database schema is out of date. '\n 'Run \"python -m birdseye.clear_db\" to delete the existing tables.')" ], [ "LOAD_NAME", "declared_attr" ], [ "CALL_FUNCTION", "declared_attr" ], [ "LOAD_FAST", "cls" ], [ "LOAD_ATTR", "cls.__name__" ], [ "LOOKUP_METHOD", "cls.__name__.lower" ], [ "CALL_METHOD", "cls.__name__.lower()" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "String" ], [ "CALL_FUNCTION", "String(50)" ], [ "CALL_FUNCTION", "Column(String(50), primary_key=True)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "__getitem__" ], [ "LOAD_NAME", "__setitem__" ], [ "LOAD_DEREF", "db_self" ], [ "LOOKUP_METHOD", "db_self.session_scope" ], [ "CALL_METHOD", "db_self.session_scope()" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session\n .query" ], [ "LOAD_DEREF", "KeyValue" ], [ "LOAD_ATTR", "KeyValue.value" ], [ "CALL_METHOD", "session\n .query(KeyValue.value)" ], [ "LOOKUP_METHOD", "session\n .query(KeyValue.value)\n .filter_by" ], [ "LOAD_FAST", "item" ], [ "CALL_METHOD", "session\n .query(KeyValue.value)\n .filter_by(key=item)" ], [ "LOOKUP_METHOD", "session\n .query(KeyValue.value)\n .filter_by(key=item)\n .scalar" ], [ "CALL_METHOD", "session\n .query(KeyValue.value)\n .filter_by(key=item)\n .scalar()" ], [ "LOAD_DEREF", "db_self" ], [ "LOOKUP_METHOD", "db_self.session_scope" ], [ "CALL_METHOD", "db_self.session_scope()" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.query" ], [ "LOAD_DEREF", "KeyValue" ], [ "CALL_METHOD", "session.query(KeyValue)" ], [ "LOOKUP_METHOD", "session.query(KeyValue).filter_by" ], [ "LOAD_FAST", "key" ], [ "CALL_METHOD", "session.query(KeyValue).filter_by(key=key)" ], [ "LOOKUP_METHOD", "session.query(KeyValue).filter_by(key=key).delete" ], [ "CALL_METHOD", "session.query(KeyValue).filter_by(key=key).delete()" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.add" ], [ "LOAD_DEREF", "KeyValue" ], [ "LOAD_FAST", "key" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "str(value)" ], [ "CALL_FUNCTION", "KeyValue(key=key, value=str(value))" ], [ "CALL_METHOD", "session.add(KeyValue(key=key, value=str(value)))" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "String" ], [ "CALL_FUNCTION", "String(length=32)" ], [ "CALL_FUNCTION", "Column(String(length=32), primary_key=True)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Integer" ], [ "LOAD_NAME", "ForeignKey" ], [ "CALL_FUNCTION", "ForeignKey('function.id')" ], [ "CALL_FUNCTION", "Column(Integer, ForeignKey('function.id'), index=True)" ], [ "LOAD_NAME", "relationship" ], [ "LOAD_NAME", "backref" ], [ "CALL_FUNCTION", "backref('calls', lazy='dynamic')" ], [ "CALL_FUNCTION", "relationship('Function', backref=backref('calls', lazy='dynamic'))" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_CLASSDEREF", "LongText" ], [ "CALL_FUNCTION", "Column(LongText)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "DateTime" ], [ "CALL_FUNCTION", "Column(DateTime, index=True)" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "id" ], [ "LOAD_NAME", "function_id" ], [ "LOAD_NAME", "return_value" ], [ "LOAD_NAME", "traceback" ], [ "LOAD_NAME", "exception" ], [ "LOAD_NAME", "start_time" ], [ "LOAD_NAME", "arguments" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._pretty_time" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start_time" ], [ "CALL_METHOD", "self._pretty_time(self.start_time)" ], [ "LOAD_FAST", "dt" ], [ "LOAD_GLOBAL", "Markup" ], [ "LOAD_FAST", "dt" ], [ "LOOKUP_METHOD", "dt.strftime" ], [ "CALL_METHOD", "dt.strftime('%Y-%m-%d %H:%M:%S')" ], [ "LOAD_GLOBAL", "naturaltime" ], [ "LOAD_FAST", "dt" ], [ "CALL_FUNCTION", "naturaltime(dt)" ], [ "BINARY_MODULO", "'%s (%s)' % (\n dt.strftime('%Y-%m-%d %H:%M:%S'),\n naturaltime(dt))" ], [ "CALL_FUNCTION", "Markup('%s (%s)' % (\n dt.strftime('%Y-%m-%d %H:%M:%S'),\n naturaltime(dt)))" ], [ "LOAD_GLOBAL", "Markup" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.success" ], [ "BINARY_MODULO", "'' % (\n ('ok', 'green') if self.success else\n ('remove', 'red'))" ], [ "CALL_FUNCTION", "Markup('' % (\n ('ok', 'green') if self.success else\n ('remove', 'red')))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.exception" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.traceback" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.return_value" ], [ "COMPARE_OP", "self.return_value == 'None'" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.traceback" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.success" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.return_value" ], [ "CALL_FUNCTION", "str(self.return_value)" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.exception" ], [ "CALL_FUNCTION", "str(self.exception)" ], [ "LOAD_GLOBAL", "json" ], [ "LOOKUP_METHOD", "json.loads" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.arguments" ], [ "CALL_METHOD", "json.loads(self.arguments)" ], [ "LOAD_GLOBAL", "json" ], [ "LOOKUP_METHOD", "json.loads" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.data" ], [ "CALL_METHOD", "json.loads(self.data)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.arguments_list" ], [ "LOAD_GLOBAL", "select_attrs" ], [ "LOAD_FAST", "call" ], [ "CALL_FUNCTION", "select_attrs(call, 'id function_id return_value traceback '\n 'exception start_time')" ], [ "CALL_FUNCTION_KW", "dict(arguments=call.arguments_list,\n **select_attrs(call, 'id function_id return_value traceback '\n 'exception start_time'))" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Integer" ], [ "LOAD_NAME", "Sequence" ], [ "CALL_FUNCTION", "Sequence('function_id_seq')" ], [ "CALL_FUNCTION", "Column(Integer, Sequence('function_id_seq'), primary_key=True)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_CLASSDEREF", "LongText" ], [ "CALL_FUNCTION", "Column(LongText)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Integer" ], [ "CALL_FUNCTION", "Column(Integer)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_CLASSDEREF", "LongText" ], [ "CALL_FUNCTION", "Column(LongText)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "String" ], [ "CALL_FUNCTION", "String(length=64)" ], [ "CALL_FUNCTION", "Column(String(length=64), index=True)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "String" ], [ "CALL_FUNCTION", "String(length=64)" ], [ "CALL_FUNCTION", "Column(String(length=64), index=True)" ], [ "LOAD_NAME", "UniqueConstraint" ], [ "CALL_FUNCTION", "UniqueConstraint('hash',\n name='everything_unique')" ], [ "LOAD_NAME", "Index" ], [ "CALL_FUNCTION", "Index('idx_file', 'file', mysql_length=256)" ], [ "LOAD_NAME", "Index" ], [ "CALL_FUNCTION", "Index('idx_name', 'name', mysql_length=32)" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "file" ], [ "LOAD_NAME", "name" ], [ "LOAD_NAME", "lineno" ], [ "LOAD_NAME", "hash" ], [ "LOAD_NAME", "body_hash" ], [ "LOAD_NAME", "type" ], [ "LOAD_GLOBAL", "json" ], [ "LOOKUP_METHOD", "json.loads" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.data" ], [ "CALL_METHOD", "json.loads(self.data)" ], [ "LOAD_GLOBAL", "select_attrs" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "select_attrs(func, 'file name lineno hash body_hash type')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.engine" ], [ "LOAD_ATTR", "self.engine.dialect" ], [ "LOOKUP_METHOD", "self.engine.dialect.has_table" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.engine" ], [ "LOAD_FAST", "table" ], [ "LOAD_ATTR", "table.__name__" ], [ "CALL_METHOD", "self.engine.dialect.has_table(self.engine, table.__name__)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.session_scope" ], [ "CALL_METHOD", "self.session_scope()" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.query" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.Function" ], [ "LOAD_ATTR", "self.Function.file" ], [ "CALL_METHOD", "session.query(self.Function.file)" ], [ "LOOKUP_METHOD", "session.query(self.Function.file).distinct" ], [ "CALL_METHOD", "session.query(self.Function.file).distinct()" ], [ "LOAD_FAST", "paths" ], [ "LOOKUP_METHOD", "paths.sort" ], [ "CALL_METHOD", "paths.sort()" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "paths" ], [ "COMPARE_OP", "IPYTHON_FILE_PATH in paths" ], [ "LOAD_FAST", "paths" ], [ "LOOKUP_METHOD", "paths.remove" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "CALL_METHOD", "paths.remove(IPYTHON_FILE_PATH)" ], [ "LOAD_FAST", "paths" ], [ "LOOKUP_METHOD", "paths.insert" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "CALL_METHOD", "paths.insert(0, IPYTHON_FILE_PATH)" ], [ "LOAD_FAST", "paths" ], [ "LOAD_GLOBAL", "is_ipython_cell" ], [ "LOAD_FAST", "f" ], [ "BINARY_SUBSCR", "f[0]" ], [ "CALL_FUNCTION", "is_ipython_cell(f[0])" ], [ "LOAD_FAST", "f" ], [ "BINARY_SUBSCR", "f[0]" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.Call" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.Function" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._KeyValue" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.table_exists" ], [ "LOAD_FAST", "model" ], [ "CALL_METHOD", "self.table_exists(model)" ], [ "LOAD_FAST", "model" ], [ "LOAD_ATTR", "model.__table__" ], [ "LOOKUP_METHOD", "model.__table__.drop" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.engine" ], [ "CALL_METHOD", "model.__table__.drop(self.engine)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.Session" ], [ "CALL_METHOD", "self.Session()" ], [ "LOAD_FAST", "session" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.commit" ], [ "CALL_METHOD", "session.commit()" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.rollback" ], [ "CALL_METHOD", "session.rollback()" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.close" ], [ "CALL_METHOD", "session.close()" ], [ "LOAD_GLOBAL", "functools" ], [ "LOOKUP_METHOD", "functools.wraps" ], [ "LOAD_DEREF", "func" ], [ "CALL_METHOD", "functools.wraps(func)" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "LOAD_GLOBAL", "retry_db" ], [ "LOAD_FAST", "wrapper" ], [ "CALL_FUNCTION", "retry_db(wrapper)" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self.session_scope" ], [ "CALL_METHOD", "self.session_scope()" ], [ "LOAD_DEREF", "func" ], [ "LOAD_FAST", "session" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "func(session, *args, **kwargs)" ] ], "executing.py": [ [ "LOAD_NAME", "sys" ], [ "LOAD_ATTR", "sys.version_info" ], [ "BINARY_SUBSCR", "sys.version_info[0]" ], [ "COMPARE_OP", "sys.version_info[0] == 3" ], [ "LOAD_NAME", "PY3" ], [ "LOAD_NAME", "lru_cache" ], [ "CALL_FUNCTION", "lru_cache(maxsize=None)" ], [ "LOAD_NAME", "str" ], [ "LOAD_NAME", "unicode" ], [ "LOAD_NAME", "dis" ], [ "LOAD_ATTR", "dis.get_instructions" ], [ "LOAD_NAME", "AttributeError" ], [ "LOAD_NAME", "namedtuple" ], [ "CALL_FUNCTION", "namedtuple('Instruction', 'offset argval opname')" ], [ "LOAD_NAME", "Exception" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.NodeVisitor" ], [ "LOAD_NAME", "sum" ], [ "LOAD_NAME", "__future__" ], [ "LOAD_ATTR", "__future__.all_feature_names" ], [ "CALL_FUNCTION", "sum(\n getattr(__future__, fname).compiler_flag\n for fname in __future__.all_feature_names\n)" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "RLock" ], [ "CALL_FUNCTION", "RLock()" ], [ "LOAD_NAME", "cache" ], [ "CALL_FUNCTION", "cache" ], [ "LOAD_GLOBAL", "functools" ], [ "LOOKUP_METHOD", "functools.wraps" ], [ "LOAD_DEREF", "func" ], [ "CALL_METHOD", "functools.wraps(func)" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "LOAD_FAST", "wrapper" ], [ "LOAD_FAST", "args" ], [ "LOAD_DEREF", "d" ], [ "COMPARE_OP", "args in d" ], [ "LOAD_DEREF", "d" ], [ "LOAD_FAST", "args" ], [ "BINARY_SUBSCR", "d[args]" ], [ "LOAD_DEREF", "func" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION_VAR", "func(*args)" ], [ "LOAD_DEREF", "d" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "co" ], [ "LOAD_ATTR", "co.co_code" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "len(code)" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "i < n" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "code[i]" ], [ "LOAD_GLOBAL", "ord" ], [ "LOAD_FAST", "c" ], [ "CALL_FUNCTION", "ord(c)" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "LOAD_FAST", "op" ], [ "LOAD_GLOBAL", "HAVE_ARGUMENT" ], [ "COMPARE_OP", "op >= HAVE_ARGUMENT" ], [ "LOAD_GLOBAL", "ord" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "code[i]" ], [ "CALL_FUNCTION", "ord(code[i])" ], [ "LOAD_GLOBAL", "ord" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "code[i + 1]" ], [ "CALL_FUNCTION", "ord(code[i + 1])" ], [ "BINARY_MULTIPLY", "ord(code[i + 1]) * 256" ], [ "BINARY_ADD", "ord(code[i]) + ord(code[i + 1]) * 256" ], [ "LOAD_FAST", "extended_arg" ], [ "BINARY_ADD", "ord(code[i]) + ord(code[i + 1]) * 256 + extended_arg" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 2" ], [ "LOAD_FAST", "op" ], [ "LOAD_GLOBAL", "EXTENDED_ARG" ], [ "COMPARE_OP", "op == EXTENDED_ARG" ], [ "LOAD_FAST", "oparg" ], [ "BINARY_MULTIPLY", "oparg * 65536" ], [ "LOAD_FAST", "op" ], [ "LOAD_GLOBAL", "hasconst" ], [ "COMPARE_OP", "op in hasconst" ], [ "LOAD_FAST", "co" ], [ "LOAD_ATTR", "co.co_consts" ], [ "LOAD_FAST", "oparg" ], [ "BINARY_SUBSCR", "co.co_consts[oparg]" ], [ "LOAD_GLOBAL", "Instruction" ], [ "LOAD_FAST", "offset" ], [ "LOAD_FAST", "argval" ], [ "LOAD_GLOBAL", "opname" ], [ "LOAD_FAST", "op" ], [ "BINARY_SUBSCR", "opname[op]" ], [ "CALL_FUNCTION", "Instruction(offset, argval, opname[op])" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "it" ], [ "LOAD_GLOBAL", "Sized" ], [ "CALL_FUNCTION", "isinstance(it, Sized)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "len(it)" ], [ "COMPARE_OP", "len(it) != 1" ], [ "LOAD_GLOBAL", "NotOneValueFound" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "len(it)" ], [ "BINARY_MODULO", "'Expected one value, found %s' % len(it)" ], [ "CALL_FUNCTION", "NotOneValueFound('Expected one value, found %s' % len(it))" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "list(it)" ], [ "BINARY_SUBSCR", "list(it)[0]" ], [ "LOAD_GLOBAL", "tuple" ], [ "LOAD_GLOBAL", "islice" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "islice(it, 2)" ], [ "CALL_FUNCTION", "tuple(islice(it, 2))" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "lst" ], [ "CALL_FUNCTION", "len(lst)" ], [ "COMPARE_OP", "len(lst) == 0" ], [ "LOAD_GLOBAL", "NotOneValueFound" ], [ "CALL_FUNCTION", "NotOneValueFound('Expected one value, found 0')" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "lst" ], [ "CALL_FUNCTION", "len(lst)" ], [ "COMPARE_OP", "len(lst) > 1" ], [ "LOAD_GLOBAL", "NotOneValueFound" ], [ "CALL_FUNCTION", "NotOneValueFound('Expected one value, found several')" ], [ "LOAD_FAST", "lst" ], [ "BINARY_SUBSCR", "lst[0]" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "cache" ], [ "CALL_FUNCTION", "cache" ], [ "LOAD_NAME", "cache" ], [ "CALL_FUNCTION", "cache" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "text" ], [ "LOAD_GLOBAL", "text_type" ], [ "CALL_FUNCTION", "isinstance(text, text_type)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.decode_source" ], [ "LOAD_FAST", "text" ], [ "CALL_METHOD", "self.decode_source(text)" ], [ "LOAD_FAST", "text" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_FAST", "text" ], [ "LOOKUP_METHOD", "''.join" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "text" ], [ "LOOKUP_METHOD", "text.splitlines" ], [ "CALL_METHOD", "text.splitlines(True)" ], [ "CALL_FUNCTION", "enumerate(text.splitlines(True))" ], [ "CALL_METHOD", "''.join([\n '\\n' if i < 2 and encoding_pattern.match(line)\n else line\n for i, line in enumerate(text.splitlines(True))\n ])" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "defaultdict(list)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "text" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.parse" ], [ "LOAD_FAST", "ast_text" ], [ "LOAD_FAST", "filename" ], [ "CALL_METHOD", "ast.parse(ast_text, filename=filename)" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "SyntaxError" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.walk" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tree" ], [ "CALL_METHOD", "ast.walk(self.tree)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.iter_child_nodes" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.iter_child_nodes(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "hasattr(node, 'lineno')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._nodes_by_line" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.lineno" ], [ "BINARY_SUBSCR", "self._nodes_by_line[node.lineno]" ], [ "LOOKUP_METHOD", "self._nodes_by_line[node.lineno].append" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self._nodes_by_line[node.lineno].append(node)" ], [ "LOAD_GLOBAL", "QualnameVisitor" ], [ "CALL_FUNCTION", "QualnameVisitor()" ], [ "LOAD_FAST", "visitor" ], [ "LOOKUP_METHOD", "visitor.visit" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tree" ], [ "CALL_METHOD", "visitor.visit(self.tree)" ], [ "LOAD_FAST", "visitor" ], [ "LOAD_ATTR", "visitor.qualnames" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "i" ], [ "COMPARE_OP", "i < 2" ], [ "LOAD_GLOBAL", "encoding_pattern" ], [ "LOOKUP_METHOD", "encoding_pattern.match" ], [ "LOAD_FAST", "line" ], [ "CALL_METHOD", "encoding_pattern.match(line)" ], [ "LOAD_FAST", "line" ], [ "LOAD_FAST", "cls" ], [ "LOOKUP_METHOD", "cls.for_filename" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_filename" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "CALL_METHOD", "cls.for_filename(frame.f_code.co_filename, frame.f_globals or {})" ], [ "LOAD_FAST", "cls" ], [ "LOOKUP_METHOD", "cls._class_local" ], [ "CALL_METHOD", "cls._class_local('__source_cache', {})" ], [ "LOAD_FAST", "source_cache" ], [ "LOAD_FAST", "filename" ], [ "BINARY_SUBSCR", "source_cache[filename]" ], [ "LOAD_GLOBAL", "KeyError" ], [ "LOAD_GLOBAL", "linecache" ], [ "LOOKUP_METHOD", "linecache.getlines" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "module_globals" ], [ "CALL_METHOD", "linecache.getlines(filename, module_globals)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_FAST", "filename" ], [ "LOOKUP_METHOD", "''.join" ], [ "LOAD_FAST", "lines" ], [ "CALL_METHOD", "''.join(lines)" ], [ "CALL_FUNCTION", "cls(filename, ''.join(lines))" ], [ "LOAD_FAST", "source_cache" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_GLOBAL", "linecache" ], [ "CALL_FUNCTION", "hasattr(linecache, 'lazycache')" ], [ "LOAD_GLOBAL", "linecache" ], [ "LOOKUP_METHOD", "linecache.lazycache" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_filename" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "CALL_METHOD", "linecache.lazycache(frame.f_code.co_filename, frame.f_globals)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lasti" ], [ "LOAD_FAST", "cls" ], [ "LOOKUP_METHOD", "cls._class_local" ], [ "CALL_METHOD", "cls._class_local('__executing_cache', {})" ], [ "LOAD_FAST", "executing_cache" ], [ "LOAD_FAST", "key" ], [ "BINARY_SUBSCR", "executing_cache[key]" ], [ "LOAD_GLOBAL", "KeyError" ], [ "LOAD_FAST", "cls" ], [ "LOOKUP_METHOD", "cls.for_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "cls.for_frame(frame)" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.tree" ], [ "LOAD_FAST", "source" ], [ "LOOKUP_METHOD", "source.statements_at_line" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lineno" ], [ "CALL_METHOD", "source.statements_at_line(frame.f_lineno)" ], [ "LOAD_GLOBAL", "NodeFinder" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "stmts" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.tree" ], [ "CALL_FUNCTION", "NodeFinder(frame, stmts, source.tree)" ], [ "LOAD_ATTR", "NodeFinder(frame, stmts, source.tree).result" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_GLOBAL", "statement_containing_node" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "statement_containing_node(node)" ], [ "LOAD_FAST", "new_stmts" ], [ "LOAD_FAST", "stmts" ], [ "COMPARE_OP", "new_stmts <= stmts" ], [ "LOAD_FAST", "new_stmts" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "stmts" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "executing_cache" ], [ "LOAD_FAST", "key" ], [ "LOAD_GLOBAL", "Executing" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION_VAR", "Executing(frame, *args)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_ATTR", "cls.__dict__" ], [ "LOOKUP_METHOD", "cls.__dict__.get" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "default" ], [ "CALL_METHOD", "cls.__dict__.get(name, default)" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_FAST", "cls" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "setattr(cls, name, result)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._nodes_by_line" ], [ "LOAD_FAST", "lineno" ], [ "BINARY_SUBSCR", "self._nodes_by_line[lineno]" ], [ "LOAD_GLOBAL", "statement_containing_node" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "statement_containing_node(node)" ], [ "LOAD_FAST", "ASTTokens" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.text" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tree" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.filename" ], [ "CALL_FUNCTION", "ASTTokens(\n self.text,\n tree=self.tree,\n filename=self.filename,\n )" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "source" ], [ "LOAD_GLOBAL", "bytes" ], [ "CALL_FUNCTION", "isinstance(source, bytes)" ], [ "LOAD_GLOBAL", "detect_encoding" ], [ "LOAD_GLOBAL", "io" ], [ "LOOKUP_METHOD", "io.BytesIO" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "io.BytesIO(source)" ], [ "LOAD_ATTR", "io.BytesIO(source).readline" ], [ "CALL_FUNCTION", "detect_encoding(io.BytesIO(source).readline)" ], [ "LOAD_FAST", "source" ], [ "LOOKUP_METHOD", "source.decode" ], [ "LOAD_FAST", "encoding" ], [ "CALL_METHOD", "source.decode(encoding)" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_filename" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.filename" ], [ "COMPARE_OP", "code.co_filename == self.filename" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._qualnames" ], [ "LOOKUP_METHOD", "self._qualnames.get" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_firstlineno" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "CALL_METHOD", "self._qualnames.get((code.co_name, code.co_firstlineno), code.co_name)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "stmts" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.source" ], [ "LOOKUP_METHOD", "self.source.code_qualname" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_code" ], [ "CALL_METHOD", "self.source.code_qualname(self.frame.f_code)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.source" ], [ "LOOKUP_METHOD", "self.source.asttokens" ], [ "CALL_METHOD", "self.source.asttokens()" ], [ "LOOKUP_METHOD", "self.source.asttokens().get_text" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.node" ], [ "CALL_METHOD", "self.source.asttokens().get_text(self.node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.source" ], [ "LOOKUP_METHOD", "self.source.asttokens" ], [ "CALL_METHOD", "self.source.asttokens()" ], [ "LOOKUP_METHOD", "self.source.asttokens().get_text_range" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.node" ], [ "CALL_METHOD", "self.source.asttokens().get_text_range(self.node)" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "QualnameVisitor" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(QualnameVisitor, self)" ], [ "LOOKUP_METHOD", "super(QualnameVisitor, self).__init__" ], [ "CALL_METHOD", "super(QualnameVisitor, self).__init__()" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.name" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOOKUP_METHOD", "self.stack.append" ], [ "LOAD_FAST", "name" ], [ "CALL_METHOD", "self.stack.append(name)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.qualnames" ], [ "LOOKUP_METHOD", "self.qualnames.setdefault" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.lineno" ], [ "LOOKUP_METHOD", "\".\".join" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "CALL_METHOD", "\".\".join(self.stack)" ], [ "CALL_METHOD", "self.qualnames.setdefault((name, node.lineno), \".\".join(self.stack))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOOKUP_METHOD", "self.stack.append" ], [ "CALL_METHOD", "self.stack.append('')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Lambda" ], [ "CALL_FUNCTION", "isinstance(node, ast.Lambda)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.body" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.body" ], [ "LOAD_FAST", "children" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.visit" ], [ "LOAD_FAST", "child" ], [ "CALL_METHOD", "self.visit(child)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOOKUP_METHOD", "self.stack.pop" ], [ "CALL_METHOD", "self.stack.pop()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOOKUP_METHOD", "self.stack.pop" ], [ "CALL_METHOD", "self.stack.pop()" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.iter_fields" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.iter_fields(node)" ], [ "LOAD_FAST", "field" ], [ "COMPARE_OP", "field == 'body'" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.AST" ], [ "CALL_FUNCTION", "isinstance(child, ast.AST)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.visit" ], [ "LOAD_FAST", "child" ], [ "CALL_METHOD", "self.visit(child)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "isinstance(child, list)" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "grandchild" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.AST" ], [ "CALL_FUNCTION", "isinstance(grandchild, ast.AST)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.visit" ], [ "LOAD_FAST", "grandchild" ], [ "CALL_METHOD", "self.visit(grandchild)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.visit_FunctionDef" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self.visit_FunctionDef(node, '')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOOKUP_METHOD", "self.stack.append" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.name" ], [ "CALL_METHOD", "self.stack.append(node.name)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.generic_visit" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self.generic_visit(node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOOKUP_METHOD", "self.stack.pop" ], [ "CALL_METHOD", "self.stack.pop()" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "__future__" ], [ "LOAD_FAST", "fname" ], [ "CALL_FUNCTION", "getattr(__future__, fname)" ], [ "LOAD_ATTR", "getattr(__future__, fname).compiler_flag" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "matching_code" ], [ "LOAD_ATTR", "matching_code.co_filename" ], [ "LOAD_GLOBAL", "future_flags" ], [ "LOAD_FAST", "matching_code" ], [ "LOAD_ATTR", "matching_code.co_flags" ], [ "BINARY_AND", "future_flags & matching_code.co_flags" ], [ "CALL_FUNCTION", "compile(\n source,\n matching_code.co_filename,\n 'exec',\n flags=future_flags & matching_code.co_flags,\n dont_inherit=True,\n )" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "tree" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_code" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lasti" ], [ "BINARY_SUBSCR", "frame.f_code.co_code[frame.f_lasti]" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_GLOBAL", "ord" ], [ "LOAD_FAST", "b" ], [ "CALL_FUNCTION", "ord(b)" ], [ "LOAD_GLOBAL", "dis" ], [ "LOAD_ATTR", "dis.opname" ], [ "LOAD_FAST", "b" ], [ "BINARY_SUBSCR", "dis.opname[b]" ], [ "LOAD_FAST", "op_name" ], [ "LOOKUP_METHOD", "op_name.startswith" ], [ "CALL_METHOD", "op_name.startswith('CALL_')" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Call" ], [ "LOAD_FAST", "op_name" ], [ "COMPARE_OP", "op_name == 'BINARY_SUBSCR'" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Subscript" ], [ "LOAD_FAST", "op_name" ], [ "LOOKUP_METHOD", "op_name.startswith" ], [ "CALL_METHOD", "op_name.startswith('BINARY_')" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.BinOp" ], [ "LOAD_FAST", "op_name" ], [ "LOOKUP_METHOD", "op_name.startswith" ], [ "CALL_METHOD", "op_name.startswith('UNARY_')" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.UnaryOp" ], [ "LOAD_FAST", "op_name" ], [ "COMPARE_OP", "op_name in ('LOAD_ATTR', 'LOAD_METHOD', 'LOOKUP_METHOD')" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Attribute" ], [ "LOAD_FAST", "op_name" ], [ "COMPARE_OP", "op_name == 'COMPARE_OP'" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Compare" ], [ "LOAD_GLOBAL", "RuntimeError" ], [ "LOAD_FAST", "op_name" ], [ "CALL_FUNCTION", "RuntimeError(op_name)" ], [ "LOAD_GLOBAL", "lock" ], [ "LOAD_FAST", "stmts" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.matching_nodes" ], [ "LOAD_FAST", "exprs" ], [ "CALL_METHOD", "self.matching_nodes(exprs)" ], [ "CALL_FUNCTION", "list(self.matching_nodes(exprs))" ], [ "CALL_FUNCTION", "only(list(self.matching_nodes(exprs)))" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.walk" ], [ "LOAD_FAST", "stmt" ], [ "CALL_METHOD", "ast.walk(stmt)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "typ" ], [ "CALL_FUNCTION", "isinstance(node, typ)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "hasattr(node, \"ctx\")" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.ctx" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Load" ], [ "CALL_FUNCTION", "isinstance(node.ctx, ast.Load)" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "exprs" ], [ "CALL_FUNCTION", "enumerate(exprs)" ], [ "LOAD_GLOBAL", "get_setter" ], [ "LOAD_FAST", "expr" ], [ "CALL_FUNCTION", "get_setter(expr)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.BinOp" ], [ "LOAD_FAST", "expr" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.Pow" ], [ "CALL_METHOD", "ast.Pow()" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.Str" ], [ "LOAD_GLOBAL", "sentinel" ], [ "CALL_METHOD", "ast.Str(s=sentinel)" ], [ "CALL_METHOD", "ast.BinOp(\n left=expr,\n op=ast.Pow(),\n right=ast.Str(s=sentinel),\n )" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.fix_missing_locations" ], [ "LOAD_FAST", "replacement" ], [ "CALL_METHOD", "ast.fix_missing_locations(replacement)" ], [ "LOAD_FAST", "setter" ], [ "LOAD_FAST", "replacement" ], [ "CALL_FUNCTION", "setter(replacement)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.compile_instructions" ], [ "CALL_METHOD", "self.compile_instructions()" ], [ "LOAD_GLOBAL", "SyntaxError" ], [ "LOAD_FAST", "setter" ], [ "LOAD_FAST", "expr" ], [ "CALL_FUNCTION", "setter(expr)" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "instructions" ], [ "CALL_FUNCTION", "enumerate(instructions)" ], [ "LOAD_FAST", "indices" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_FAST", "indices" ], [ "CALL_FUNCTION", "only(indices)" ], [ "BINARY_SUBTRACT", "only(indices) - 1" ], [ "LOAD_FAST", "instructions" ], [ "LOAD_FAST", "arg_index" ], [ "BINARY_SUBSCR", "instructions[arg_index]" ], [ "LOAD_ATTR", "instructions[arg_index].opname" ], [ "COMPARE_OP", "instructions[arg_index].opname == 'EXTENDED_ARG'" ], [ "LOAD_FAST", "instructions" ], [ "LOAD_FAST", "arg_index" ], [ "BINARY_SUBSCR", "instructions[arg_index]" ], [ "LOAD_ATTR", "instructions[arg_index].offset" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_lasti" ], [ "COMPARE_OP", "instructions[arg_index].offset == self.frame.f_lasti" ], [ "LOAD_FAST", "expr" ], [ "LOAD_FAST", "instruction" ], [ "LOAD_ATTR", "instruction.argval" ], [ "LOAD_GLOBAL", "sentinel" ], [ "COMPARE_OP", "instruction.argval == sentinel" ], [ "LOAD_FAST", "i" ], [ "LOAD_GLOBAL", "compile_similar_to" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tree" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_code" ], [ "CALL_FUNCTION", "compile_similar_to(self.tree, self.frame.f_code)" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_GLOBAL", "find_codes" ], [ "LOAD_FAST", "module_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_code" ], [ "CALL_FUNCTION", "find_codes(module_code, self.frame.f_code)" ], [ "CALL_FUNCTION", "only(find_codes(module_code, self.frame.f_code))" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "get_instructions" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "get_instructions(code)" ], [ "CALL_FUNCTION", "list(get_instructions(code))" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.iter_fields" ], [ "LOAD_DEREF", "parent" ], [ "CALL_METHOD", "ast.iter_fields(parent)" ], [ "LOAD_DEREF", "field" ], [ "LOAD_FAST", "node" ], [ "COMPARE_OP", "field is node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_DEREF", "field" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "isinstance(field, list)" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_DEREF", "field" ], [ "CALL_FUNCTION", "enumerate(field)" ], [ "LOAD_FAST", "item" ], [ "LOAD_FAST", "node" ], [ "COMPARE_OP", "item is node" ], [ "LOAD_FAST", "setter" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_DEREF", "parent" ], [ "LOAD_DEREF", "name" ], [ "LOAD_FAST", "new_node" ], [ "CALL_FUNCTION", "setattr(parent, name, new_node)" ], [ "LOAD_FAST", "new_node" ], [ "LOAD_DEREF", "field" ], [ "LOAD_DEREF", "i" ], [ "LOAD_DEREF", "matches" ], [ "LOAD_FAST", "root_code" ], [ "CALL_FUNCTION", "matches(root_code)" ], [ "LOAD_DEREF", "code_options" ], [ "LOOKUP_METHOD", "code_options.append" ], [ "LOAD_FAST", "root_code" ], [ "CALL_METHOD", "code_options.append(root_code)" ], [ "LOAD_DEREF", "finder" ], [ "LOAD_FAST", "root_code" ], [ "CALL_FUNCTION", "finder(root_code)" ], [ "LOAD_DEREF", "code_options" ], [ "LOAD_GLOBAL", "all" ], [ "LOAD_GLOBAL", "attrgetter" ], [ "CALL_FUNCTION", "attrgetter('co_firstlineno')" ], [ "LOAD_GLOBAL", "attrgetter" ], [ "CALL_FUNCTION", "attrgetter('co_name')" ], [ "LOAD_GLOBAL", "code_names" ], [ "CALL_FUNCTION", "all(\n f(c) == f(matching)\n for f in [\n attrgetter('co_firstlineno'),\n attrgetter('co_name'),\n code_names,\n ]\n )" ], [ "LOAD_FAST", "f" ], [ "LOAD_DEREF", "c" ], [ "CALL_FUNCTION", "f(c)" ], [ "LOAD_FAST", "f" ], [ "LOAD_DEREF", "matching" ], [ "CALL_FUNCTION", "f(matching)" ], [ "COMPARE_OP", "f(c) == f(matching)" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_consts" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.iscode" ], [ "LOAD_FAST", "const" ], [ "CALL_METHOD", "inspect.iscode(const)" ], [ "LOAD_DEREF", "matches" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "matches(const)" ], [ "LOAD_DEREF", "code_options" ], [ "LOOKUP_METHOD", "code_options.append" ], [ "LOAD_FAST", "const" ], [ "CALL_METHOD", "code_options.append(const)" ], [ "LOAD_DEREF", "finder" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "finder(const)" ], [ "LOAD_GLOBAL", "frozenset" ], [ "CALL_FUNCTION", "frozenset()" ], [ "LOOKUP_METHOD", "frozenset().union" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_names" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_varnames" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_freevars" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_cellvars" ], [ "CALL_METHOD", "frozenset().union(\n code.co_names,\n code.co_varnames,\n code.co_freevars,\n code.co_cellvars,\n )" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "CALL_FUNCTION", "isinstance(node, ast.stmt)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_FAST", "node" ] ], "import_hook.py": [ [ "LOAD_NAME", "object" ], [ "LOAD_FAST", "spec" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "deep" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "eye" ], [ "LOOKUP_METHOD", "eye.exec_string" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.source" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._spec" ], [ "LOAD_ATTR", "self._spec.origin" ], [ "LOAD_FAST", "module" ], [ "LOAD_ATTR", "module.__dict__" ], [ "LOAD_FAST", "module" ], [ "LOAD_ATTR", "module.__dict__" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.deep" ], [ "CALL_METHOD", "eye.exec_string(\n source=self.source,\n filename=self._spec.origin,\n globs=module.__dict__,\n locs=module.__dict__,\n deep=self.deep,\n )" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._spec" ], [ "LOAD_ATTR", "self._spec.loader" ], [ "LOOKUP_METHOD", "self._spec.loader.get_filename" ], [ "LOAD_FAST", "fullname" ], [ "CALL_METHOD", "self._spec.loader.get_filename(fullname)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._spec" ], [ "LOAD_ATTR", "self._spec.loader" ], [ "LOOKUP_METHOD", "self._spec.loader.is_package" ], [ "LOAD_FAST", "fullname" ], [ "CALL_METHOD", "self._spec.loader.is_package(fullname)" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.meta_path" ], [ "LOAD_FAST", "finder" ], [ "LOAD_FAST", "self" ], [ "COMPARE_OP", "finder is self" ], [ "LOAD_FAST", "finder" ], [ "LOAD_ATTR", "finder.__module__" ], [ "COMPARE_OP", "'pytest' in finder.__module__" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "finder" ], [ "CALL_FUNCTION", "hasattr(finder, 'find_spec')" ], [ "LOAD_FAST", "finder" ], [ "LOOKUP_METHOD", "finder.find_spec" ], [ "LOAD_FAST", "fullname" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "target" ], [ "CALL_METHOD", "finder.find_spec(fullname, path, target=target)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "finder" ], [ "CALL_FUNCTION", "hasattr(finder, 'load_module')" ], [ "LOAD_GLOBAL", "spec_from_loader" ], [ "LOAD_FAST", "fullname" ], [ "LOAD_FAST", "finder" ], [ "CALL_FUNCTION", "spec_from_loader(fullname, finder)" ], [ "LOAD_FAST", "spec" ], [ "COMPARE_OP", "spec is not None" ], [ "LOAD_FAST", "spec" ], [ "LOAD_ATTR", "spec.origin" ], [ "COMPARE_OP", "spec.origin != 'builtin'" ], [ "LOAD_FAST", "spec" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._find_plain_spec" ], [ "LOAD_FAST", "fullname" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "target" ], [ "CALL_METHOD", "self._find_plain_spec(fullname, path, target)" ], [ "LOAD_FAST", "spec" ], [ "COMPARE_OP", "spec is None" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "spec" ], [ "LOAD_ATTR", "spec.loader" ], [ "CALL_FUNCTION", "hasattr(spec.loader, 'get_source')" ], [ "LOAD_GLOBAL", "callable" ], [ "LOAD_FAST", "spec" ], [ "LOAD_ATTR", "spec.loader" ], [ "LOAD_ATTR", "spec.loader.get_source" ], [ "CALL_FUNCTION", "callable(spec.loader.get_source)" ], [ "LOAD_FAST", "fullname" ], [ "COMPARE_OP", "fullname != 'org'" ], [ "LOAD_GLOBAL", "logging" ], [ "LOOKUP_METHOD", "logging.debug" ], [ "LOAD_FAST", "fullname" ], [ "CALL_METHOD", "logging.debug('Failed finding spec for %s', fullname)" ], [ "LOAD_FAST", "spec" ], [ "LOAD_ATTR", "spec.loader" ], [ "LOOKUP_METHOD", "spec.loader.get_source" ], [ "LOAD_FAST", "fullname" ], [ "CALL_METHOD", "spec.loader.get_source(fullname)" ], [ "LOAD_GLOBAL", "ImportError" ], [ "LOAD_GLOBAL", "logging" ], [ "LOOKUP_METHOD", "logging.debug" ], [ "LOAD_FAST", "fullname" ], [ "CALL_METHOD", "logging.debug('Loader for %s was unable to find the sources',\n fullname)" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_GLOBAL", "logging" ], [ "LOOKUP_METHOD", "logging.exception" ], [ "LOAD_FAST", "fullname" ], [ "CALL_METHOD", "logging.exception('Loader for %s raised an error', fullname)" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "source" ], [ "COMPARE_OP", "'birdseye' not in source" ], [ "LOAD_GLOBAL", "should_trace" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "should_trace(source)" ], [ "LOAD_FAST", "trace_stmt" ], [ "LOAD_GLOBAL", "BirdsEyeLoader" ], [ "LOAD_FAST", "spec" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "deep" ], [ "CALL_FUNCTION", "BirdsEyeLoader(spec, source, deep)" ], [ "LOAD_GLOBAL", "spec_from_loader" ], [ "LOAD_FAST", "fullname" ], [ "LOAD_FAST", "loader" ], [ "CALL_FUNCTION", "spec_from_loader(fullname, loader)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.parse" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "ast.parse(source)" ], [ "LOAD_ATTR", "ast.parse(source).body" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Import" ], [ "CALL_FUNCTION", "isinstance(stmt, ast.Import)" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_ATTR", "stmt.names" ], [ "LOAD_FAST", "alias" ], [ "LOAD_ATTR", "alias.name" ], [ "LOOKUP_METHOD", "alias.name.startswith" ], [ "CALL_METHOD", "alias.name.startswith('birdseye.trace_module')" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_FAST", "alias" ], [ "LOAD_ATTR", "alias.name" ], [ "LOOKUP_METHOD", "alias.name.endswith" ], [ "CALL_METHOD", "alias.name.endswith('deep')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.ImportFrom" ], [ "CALL_FUNCTION", "isinstance(stmt, ast.ImportFrom)" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_ATTR", "stmt.module" ], [ "COMPARE_OP", "stmt.module == 'birdseye'" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_ATTR", "stmt.names" ], [ "LOAD_FAST", "alias" ], [ "LOAD_ATTR", "alias.name" ], [ "LOOKUP_METHOD", "alias.name.startswith" ], [ "CALL_METHOD", "alias.name.startswith('trace_module')" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_FAST", "alias" ], [ "LOAD_ATTR", "alias.name" ], [ "LOOKUP_METHOD", "alias.name.endswith" ], [ "CALL_METHOD", "alias.name.endswith('deep')" ], [ "LOAD_FAST", "deep" ], [ "LOAD_FAST", "trace_stmt" ] ], "ipython.py": [ [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "BytesIO" ], [ "LOAD_NAME", "StringIO" ], [ "LOAD_NAME", "stream_proxy" ], [ "LOAD_NAME", "sys" ], [ "LOAD_ATTR", "sys.stderr" ], [ "CALL_FUNCTION", "stream_proxy(sys.stderr)" ], [ "LOAD_NAME", "sys" ], [ "LOAD_NAME", "stream_proxy" ], [ "LOAD_NAME", "sys" ], [ "LOAD_ATTR", "sys.stdout" ], [ "CALL_FUNCTION", "stream_proxy(sys.stdout)" ], [ "LOAD_NAME", "sys" ], [ "LOAD_NAME", "Environment" ], [ "LOAD_NAME", "PackageLoader" ], [ "CALL_FUNCTION", "PackageLoader('birdseye', 'templates')" ], [ "LOAD_NAME", "select_autoescape" ], [ "CALL_FUNCTION", "select_autoescape(['html', 'xml'])" ], [ "CALL_FUNCTION", "Environment(\n loader=PackageLoader('birdseye', 'templates'),\n autoescape=select_autoescape(['html', 'xml'])\n)" ], [ "LOAD_NAME", "magics_class" ], [ "LOAD_NAME", "Magics" ], [ "CALL_FUNCTION", "magics_class" ], [ "LOAD_GLOBAL", "LocalProxy" ], [ "LOAD_FAST", "p" ], [ "CALL_FUNCTION", "LocalProxy(p)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.currentframe" ], [ "CALL_METHOD", "inspect.currentframe()" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_GLOBAL", "ThreadingMixIn" ], [ "LOAD_ATTR", "ThreadingMixIn.process_request_thread" ], [ "LOAD_ATTR", "ThreadingMixIn.process_request_thread.__code__" ], [ "COMPARE_OP", "frame.f_code == ThreadingMixIn.process_request_thread.__code__" ], [ "LOAD_GLOBAL", "fake_stream" ], [ "CALL_FUNCTION", "fake_stream()" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_GLOBAL", "thread_proxies" ], [ "LOOKUP_METHOD", "thread_proxies.get" ], [ "LOAD_GLOBAL", "currentThread" ], [ "CALL_FUNCTION", "currentThread()" ], [ "LOAD_ATTR", "currentThread().ident" ], [ "LOAD_DEREF", "original" ], [ "CALL_METHOD", "thread_proxies.get(currentThread().ident,\n original)" ], [ "LOAD_FAST", "show_server_output" ], [ "LOAD_GLOBAL", "fake_stream" ], [ "CALL_FUNCTION", "fake_stream()" ], [ "LOAD_GLOBAL", "thread_proxies" ], [ "LOAD_GLOBAL", "currentThread" ], [ "CALL_FUNCTION", "currentThread()" ], [ "LOAD_ATTR", "currentThread().ident" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_ATTR", "server.app" ], [ "LOOKUP_METHOD", "server.app.run" ], [ "LOAD_FAST", "port" ], [ "LOAD_FAST", "bind_host" ], [ "CALL_METHOD", "server.app.run(\n debug=True,\n port=port,\n host=bind_host,\n use_reloader=False,\n )" ], [ "LOAD_GLOBAL", "socket" ], [ "LOAD_ATTR", "socket.error" ], [ "LOAD_NAME", "Unicode" ], [ "CALL_FUNCTION", "Unicode(\n u'', config=True,\n help='If set, a server will not be automatically started by %%eye. '\n 'The iframe containing birdseye output will use this value as the base '\n 'of its URL.'\n )" ], [ "LOAD_NAME", "Int" ], [ "CALL_FUNCTION", "Int(\n 7777, config=True,\n help='Port number for the server started by %%eye.'\n )" ], [ "LOAD_NAME", "Unicode" ], [ "CALL_FUNCTION", "Unicode(\n '127.0.0.1', config=True,\n help='Host that the server started by %%eye listens on. '\n 'Set to 0.0.0.0 to make it accessible anywhere.'\n )" ], [ "LOAD_NAME", "Bool" ], [ "CALL_FUNCTION", "Bool(\n False, config=True,\n help='Set to True to show stdout and stderr from the server started by %%eye.'\n )" ], [ "LOAD_NAME", "Unicode" ], [ "CALL_FUNCTION", "Unicode(\n u'', config=True,\n help='The database URL that the server started by %%eye reads from. '\n 'Equivalent to the environment variable BIRDSEYE_DB.'\n )" ], [ "LOAD_NAME", "cell_magic" ], [ "CALL_FUNCTION", "cell_magic" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.server_url" ], [ "LOAD_GLOBAL", "Database" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.db_url" ], [ "CALL_FUNCTION", "Database(self.db_url)" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_ATTR", "server.db" ], [ "LOAD_ATTR", "server.db.Function" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_ATTR", "server.db" ], [ "LOAD_ATTR", "server.db.Call" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_ATTR", "server.db" ], [ "LOAD_ATTR", "server.db.Session" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_GLOBAL", "Thread" ], [ "LOAD_GLOBAL", "run_server" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.port" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.bind_host" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.show_server_output" ], [ "CALL_FUNCTION", "Thread(\n target=run_server,\n args=(\n self.port,\n self.bind_host,\n self.show_server_output,\n ),\n )" ], [ "LOOKUP_METHOD", "Thread(\n target=run_server,\n args=(\n self.port,\n self.bind_host,\n self.show_server_output,\n ),\n ).start" ], [ "CALL_METHOD", "Thread(\n target=run_server,\n args=(\n self.port,\n self.bind_host,\n self.show_server_output,\n ),\n ).start()" ], [ "LOAD_GLOBAL", "Database" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.db_url" ], [ "CALL_FUNCTION", "Database(self.db_url)" ], [ "LOAD_GLOBAL", "eye" ], [ "LOAD_GLOBAL", "eye" ], [ "LOOKUP_METHOD", "eye.exec_ipython_cell" ], [ "LOAD_FAST", "cell" ], [ "LOAD_FAST", "callback" ], [ "CALL_METHOD", "eye.exec_ipython_cell(cell, callback)" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "call_id" ], [ "COMPARE_OP", "call_id is None" ], [ "LOAD_GLOBAL", "HTML" ], [ "LOAD_GLOBAL", "templates_env" ], [ "LOOKUP_METHOD", "templates_env.get_template" ], [ "CALL_METHOD", "templates_env.get_template('ipython_iframe.html')" ], [ "LOOKUP_METHOD", "templates_env.get_template('ipython_iframe.html').render" ], [ "LOAD_FAST", "call_id" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.server_url" ], [ "LOOKUP_METHOD", "self.server_url.rstrip" ], [ "CALL_METHOD", "self.server_url.rstrip('/')" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.port" ], [ "LOAD_GLOBAL", "uuid4" ], [ "CALL_FUNCTION", "uuid4()" ], [ "LOAD_ATTR", "uuid4().hex" ], [ "CALL_METHOD", "templates_env.get_template('ipython_iframe.html').render(\n call_id=call_id,\n url=self.server_url.rstrip('/'),\n port=self.port,\n container_id=uuid4().hex,\n )" ], [ "CALL_FUNCTION", "HTML(templates_env.get_template('ipython_iframe.html').render(\n call_id=call_id,\n url=self.server_url.rstrip('/'),\n port=self.port,\n container_id=uuid4().hex,\n ))" ], [ "LOAD_GLOBAL", "display" ], [ "LOAD_FAST", "html" ], [ "CALL_FUNCTION", "display(html)" ] ], "server.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOOKUP_METHOD", "standard_library.install_aliases" ], [ "CALL_METHOD", "standard_library.install_aliases()" ], [ "LOAD_NAME", "Flask" ], [ "CALL_FUNCTION", "Flask('birdseye')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.jinja_env" ], [ "LOAD_NAME", "Humanize" ], [ "LOAD_NAME", "app" ], [ "CALL_FUNCTION", "Humanize(app)" ], [ "LOAD_NAME", "PathConverter" ], [ "LOAD_NAME", "FileConverter" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.url_map" ], [ "LOAD_ATTR", "app.url_map.converters" ], [ "LOAD_NAME", "Database" ], [ "CALL_FUNCTION", "Database()" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.Session" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.Function" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.Call" ], [ "LOAD_NAME", "app" ], [ "LOOKUP_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/')" ], [ "LOAD_NAME", "app" ], [ "LOOKUP_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/file/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/file/')" ], [ "LOAD_NAME", "app" ], [ "LOOKUP_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/file//__function__/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/file//__function__/')" ], [ "LOAD_NAME", "app" ], [ "LOOKUP_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/api/file//__function__//latest_call/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/api/file//__function__//latest_call/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "LOAD_NAME", "app" ], [ "LOOKUP_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/call/')" ], [ "CALL_FUNCTION", "app.route('/call/')" ], [ "LOAD_NAME", "app" ], [ "LOOKUP_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/ipython_call/')" ], [ "CALL_FUNCTION", "app.route('/ipython_call/')" ], [ "LOAD_NAME", "app" ], [ "LOOKUP_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/ipython_iframe/')" ], [ "CALL_FUNCTION", "app.route('/ipython_iframe/')" ], [ "LOAD_NAME", "app" ], [ "LOOKUP_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/kill', methods=['POST'])" ], [ "CALL_FUNCTION", "app.route('/kill', methods=['POST'])" ], [ "LOAD_NAME", "app" ], [ "LOOKUP_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/api/call/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/api/call/')" ], [ "LOAD_NAME", "app" ], [ "LOOKUP_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/api/calls_by_body_hash/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/api/calls_by_body_hash/')" ], [ "LOAD_NAME", "app" ], [ "LOOKUP_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/api/body_hashes_present/', methods=['POST'])" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/api/body_hashes_present/', methods=['POST'])" ], [ "LOAD_NAME", "sys" ], [ "LOAD_ATTR", "sys.argv" ], [ "BINARY_SUBSCR", "sys.argv[1:]" ], [ "LOAD_NAME", "__name__" ], [ "COMPARE_OP", "__name__ == '__main__'" ], [ "LOAD_NAME", "main" ], [ "CALL_FUNCTION", "main()" ], [ "LOAD_GLOBAL", "db" ], [ "LOOKUP_METHOD", "db.all_file_paths" ], [ "CALL_METHOD", "db.all_file_paths()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_columns" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.basic_columns" ], [ "BINARY_ADD", "Call.basic_columns + Function.basic_columns" ], [ "CALL_FUNCTION_VAR", "session.query(*(Call.basic_columns + Function.basic_columns))" ], [ "LOOKUP_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)" ], [ "LOOKUP_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .order_by" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.start_time" ], [ "LOOKUP_METHOD", "Call.start_time.desc" ], [ "CALL_METHOD", "Call.start_time.desc()" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .order_by(Call.start_time.desc())" ], [ "BINARY_SUBSCR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .order_by(Call.start_time.desc())[:100]" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "CALL_FUNCTION", "OrderedDict()" ], [ "LOAD_FAST", "recent_calls" ], [ "LOAD_GLOBAL", "is_ipython_cell" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.file" ], [ "CALL_FUNCTION", "is_ipython_cell(row.file)" ], [ "LOAD_FAST", "files" ], [ "LOOKUP_METHOD", "files.setdefault" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.file" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "CALL_FUNCTION", "OrderedDict()" ], [ "CALL_METHOD", "files.setdefault(\n row.file, OrderedDict()\n )" ], [ "LOOKUP_METHOD", "files.setdefault(\n row.file, OrderedDict()\n ).setdefault" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.name" ], [ "LOAD_FAST", "row" ], [ "CALL_METHOD", "files.setdefault(\n row.file, OrderedDict()\n ).setdefault(\n row.name, row\n )" ], [ "LOAD_FAST", "all_paths" ], [ "LOAD_FAST", "files" ], [ "LOOKUP_METHOD", "files.setdefault" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "CALL_FUNCTION", "OrderedDict()" ], [ "CALL_METHOD", "files.setdefault(\n path, OrderedDict()\n )" ], [ "LOAD_GLOBAL", "partial" ], [ "LOAD_GLOBAL", "short_path" ], [ "LOAD_FAST", "all_paths" ], [ "CALL_FUNCTION", "partial(short_path, all_paths=all_paths)" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "short" ], [ "LOAD_FAST", "files" ], [ "CALL_FUNCTION", "render_template('index.html',\n short=short,\n files=files)" ], [ "LOAD_GLOBAL", "fix_abs_path" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "fix_abs_path(path)" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_columns" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.basic_columns" ], [ "BINARY_ADD", "Call.basic_columns + Function.basic_columns" ], [ "CALL_FUNCTION_VAR", "session.query(*(Call.basic_columns + Function.basic_columns))" ], [ "LOOKUP_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)" ], [ "LOOKUP_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by" ], [ "LOAD_FAST", "path" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path)" ], [ "LOOKUP_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path)\n .subquery" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path)\n .subquery('filtered_calls')" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.query" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.name" ], [ "LOAD_GLOBAL", "sqlalchemy" ], [ "LOAD_ATTR", "sqlalchemy.func" ], [ "LOOKUP_METHOD", "sqlalchemy.func.max" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.start_time" ], [ "CALL_METHOD", "sqlalchemy.func.max(filtered_calls.c.start_time)" ], [ "LOOKUP_METHOD", "sqlalchemy.func.max(filtered_calls.c.start_time).label" ], [ "CALL_METHOD", "sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')" ], [ "CALL_METHOD", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n )" ], [ "LOOKUP_METHOD", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n ).group_by" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.name" ], [ "CALL_METHOD", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n ).group_by(\n filtered_calls.c.name,\n )" ], [ "LOOKUP_METHOD", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n ).group_by(\n filtered_calls.c.name,\n ).subquery" ], [ "CALL_METHOD", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n ).group_by(\n filtered_calls.c.name,\n ).subquery('latest_calls')" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.query" ], [ "LOAD_FAST", "filtered_calls" ], [ "CALL_METHOD", "session.query(filtered_calls)" ], [ "LOOKUP_METHOD", "session.query(filtered_calls).join" ], [ "LOAD_FAST", "latest_calls" ], [ "LOAD_GLOBAL", "sqlalchemy" ], [ "LOOKUP_METHOD", "sqlalchemy.and_" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.name" ], [ "LOAD_FAST", "latest_calls" ], [ "LOAD_ATTR", "latest_calls.c" ], [ "LOAD_ATTR", "latest_calls.c.name" ], [ "COMPARE_OP", "filtered_calls.c.name == latest_calls.c.name" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.start_time" ], [ "LOAD_FAST", "latest_calls" ], [ "LOAD_ATTR", "latest_calls.c" ], [ "LOAD_ATTR", "latest_calls.c.maxtime" ], [ "COMPARE_OP", "filtered_calls.c.start_time == latest_calls.c.maxtime" ], [ "CALL_METHOD", "sqlalchemy.and_(\n filtered_calls.c.name == latest_calls.c.name,\n filtered_calls.c.start_time == latest_calls.c.maxtime,\n )" ], [ "CALL_METHOD", "session.query(filtered_calls).join(\n latest_calls,\n sqlalchemy.and_(\n filtered_calls.c.name == latest_calls.c.name,\n filtered_calls.c.start_time == latest_calls.c.maxtime,\n )\n )" ], [ "LOOKUP_METHOD", "session.query(filtered_calls).join(\n latest_calls,\n sqlalchemy.and_(\n filtered_calls.c.name == latest_calls.c.name,\n filtered_calls.c.start_time == latest_calls.c.maxtime,\n )\n ).order_by" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.start_time" ], [ "LOOKUP_METHOD", "filtered_calls.c.start_time.desc" ], [ "CALL_METHOD", "filtered_calls.c.start_time.desc()" ], [ "CALL_METHOD", "session.query(filtered_calls).join(\n latest_calls,\n sqlalchemy.and_(\n filtered_calls.c.name == latest_calls.c.name,\n filtered_calls.c.start_time == latest_calls.c.maxtime,\n )\n ).order_by(filtered_calls.c.start_time.desc())" ], [ "LOAD_GLOBAL", "group_by_attr" ], [ "LOAD_FAST", "query" ], [ "CALL_FUNCTION", "group_by_attr(query, 'type')" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.query" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.name" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.type" ], [ "CALL_METHOD", "session.query(Function.name, Function.type)" ], [ "LOOKUP_METHOD", "session.query(Function.name, Function.type)\n .filter_by" ], [ "LOAD_FAST", "path" ], [ "CALL_METHOD", "session.query(Function.name, Function.type)\n .filter_by(file=path)" ], [ "LOOKUP_METHOD", "session.query(Function.name, Function.type)\n .filter_by(file=path)\n .distinct" ], [ "CALL_METHOD", "session.query(Function.name, Function.type)\n .filter_by(file=path)\n .distinct()" ], [ "CALL_FUNCTION", "sorted(session.query(Function.name, Function.type)\n .filter_by(file=path)\n .distinct())" ], [ "LOAD_FAST", "query" ], [ "LOAD_FAST", "all_funcs" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.name" ], [ "LOAD_FAST", "func_names" ], [ "COMPARE_OP", "func.name not in func_names" ], [ "LOAD_FAST", "funcs" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.type" ], [ "BINARY_SUBSCR", "funcs[func.type]" ], [ "LOOKUP_METHOD", "funcs[func.type].append" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "funcs[func.type].append(func)" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "funcs" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "COMPARE_OP", "path == IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "basename" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "basename(path)" ], [ "CALL_FUNCTION", "render_template('file.html',\n funcs=funcs,\n is_ipython=path == IPYTHON_FILE_PATH,\n full_path=path,\n short_path=basename(path))" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.name" ], [ "LOAD_GLOBAL", "fix_abs_path" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "fix_abs_path(path)" ], [ "LOAD_GLOBAL", "get_calls" ], [ "LOAD_FAST", "session" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "func_name" ], [ "CALL_FUNCTION", "get_calls(session, path, func_name, 200)" ], [ "LOAD_FAST", "query" ], [ "LOAD_FAST", "query" ], [ "BINARY_SUBSCR", "query[0]" ], [ "LOAD_FAST", "query" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.query" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_METHOD", "session.query(Function)" ], [ "LOOKUP_METHOD", "session.query(Function).filter_by" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "func_name" ], [ "CALL_METHOD", "session.query(Function).filter_by(file=path, name=func_name)" ], [ "BINARY_SUBSCR", "session.query(Function).filter_by(file=path, name=func_name)[0]" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "func" ], [ "LOAD_GLOBAL", "basename" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "basename(path)" ], [ "LOAD_FAST", "calls" ], [ "CALL_FUNCTION", "render_template('function.html',\n func=func,\n short_path=basename(path),\n calls=calls)" ], [ "LOAD_GLOBAL", "withattrs" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_FUNCTION", "Call()" ], [ "LOAD_FAST", "row" ], [ "LOOKUP_METHOD", "row._asdict" ], [ "CALL_METHOD", "row._asdict()" ], [ "CALL_FUNCTION_KW", "withattrs(Call(), **row._asdict())" ], [ "LOAD_GLOBAL", "fix_abs_path" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "fix_abs_path(path)" ], [ "LOAD_GLOBAL", "get_calls" ], [ "LOAD_FAST", "session" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "func_name" ], [ "CALL_FUNCTION", "get_calls(session, path, func_name, 1)" ], [ "BINARY_SUBSCR", "get_calls(session, path, func_name, 1)[0]" ], [ "LOAD_GLOBAL", "jsonify" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.id" ], [ "LOAD_GLOBAL", "url_for" ], [ "LOAD_GLOBAL", "call_view" ], [ "LOAD_ATTR", "call_view.__name__" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.id" ], [ "CALL_FUNCTION", "url_for(call_view.__name__,\n call_id=call.id)" ], [ "CALL_FUNCTION", "dict(\n id=call.id,\n url=url_for(call_view.__name__,\n call_id=call.id),\n )" ], [ "CALL_FUNCTION", "jsonify(dict(\n id=call.id,\n url=url_for(call_view.__name__,\n call_id=call.id),\n ))" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_columns" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.basic_columns" ], [ "BINARY_ADD", "Call.basic_columns + Function.basic_columns" ], [ "CALL_FUNCTION_VAR", "session.query(*(Call.basic_columns + Function.basic_columns))" ], [ "LOOKUP_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)" ], [ "LOOKUP_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "func_name" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path, name=func_name)" ], [ "LOOKUP_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path, name=func_name)\n .order_by" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.start_time" ], [ "LOOKUP_METHOD", "Call.start_time.desc" ], [ "CALL_METHOD", "Call.start_time.desc()" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path, name=func_name)\n .order_by(Call.start_time.desc())" ], [ "LOAD_FAST", "limit" ], [ "BINARY_SUBSCR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path, name=func_name)\n .order_by(Call.start_time.desc())[:limit]" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_METHOD", "session.query(Call)" ], [ "LOOKUP_METHOD", "session.query(Call).filter_by" ], [ "LOAD_FAST", "call_id" ], [ "CALL_METHOD", "session.query(Call).filter_by(id=call_id)" ], [ "LOOKUP_METHOD", "session.query(Call).filter_by(id=call_id).one" ], [ "CALL_METHOD", "session.query(Call).filter_by(id=call_id).one()" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.function" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "template" ], [ "LOAD_GLOBAL", "basename" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.file" ], [ "CALL_FUNCTION", "basename(func.file)" ], [ "LOAD_FAST", "call" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "render_template(template,\n short_path=basename(func.file),\n call=call,\n func=func)" ], [ "LOAD_GLOBAL", "base_call_view" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION", "base_call_view(call_id, 'call.html')" ], [ "LOAD_GLOBAL", "base_call_view" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION", "base_call_view(call_id, 'ipython_call.html')" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION", "render_template('ipython_iframe.html',\n container_id='1234',\n port=7777,\n call_id=call_id)" ], [ "LOAD_GLOBAL", "request" ], [ "LOAD_ATTR", "request.environ" ], [ "LOOKUP_METHOD", "request.environ.get" ], [ "CALL_METHOD", "request.environ.get('werkzeug.server.shutdown')" ], [ "LOAD_FAST", "func" ], [ "COMPARE_OP", "func is None" ], [ "LOAD_GLOBAL", "RuntimeError" ], [ "CALL_FUNCTION", "RuntimeError('Not running with the Werkzeug Server')" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "func()" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_METHOD", "session.query(Call)" ], [ "LOOKUP_METHOD", "session.query(Call).filter_by" ], [ "LOAD_FAST", "call_id" ], [ "CALL_METHOD", "session.query(Call).filter_by(id=call_id)" ], [ "LOOKUP_METHOD", "session.query(Call).filter_by(id=call_id).one" ], [ "CALL_METHOD", "session.query(Call).filter_by(id=call_id).one()" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.function" ], [ "LOAD_GLOBAL", "DecentJSONEncoder" ], [ "CALL_FUNCTION", "DecentJSONEncoder()" ], [ "LOOKUP_METHOD", "DecentJSONEncoder().encode" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.parsed_data" ], [ "LOAD_GLOBAL", "Call" ], [ "LOOKUP_METHOD", "Call.basic_dict" ], [ "LOAD_FAST", "call" ], [ "CALL_METHOD", "Call.basic_dict(call)" ], [ "CALL_FUNCTION_KW", "dict(data=call.parsed_data, **Call.basic_dict(call))" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.parsed_data" ], [ "LOAD_GLOBAL", "Function" ], [ "LOOKUP_METHOD", "Function.basic_dict" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "Function.basic_dict(func)" ], [ "CALL_FUNCTION_KW", "dict(data=func.parsed_data, **Function.basic_dict(func))" ], [ "CALL_FUNCTION", "dict(\n call=dict(data=call.parsed_data, **Call.basic_dict(call)),\n function=dict(data=func.parsed_data, **Function.basic_dict(func)))" ], [ "CALL_METHOD", "DecentJSONEncoder().encode(dict(\n call=dict(data=call.parsed_data, **Call.basic_dict(call)),\n function=dict(data=func.parsed_data, **Function.basic_dict(func))))" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_columns" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.data" ], [ "BINARY_ADD", "Call.basic_columns + (Function.data,)" ], [ "CALL_FUNCTION_VAR", "session.query(*Call.basic_columns + (Function.data,))" ], [ "LOOKUP_METHOD", "session.query(*Call.basic_columns + (Function.data,))\n .join" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_METHOD", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)" ], [ "LOOKUP_METHOD", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by" ], [ "LOAD_FAST", "body_hash" ], [ "CALL_METHOD", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by(body_hash=body_hash)" ], [ "LOOKUP_METHOD", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by(body_hash=body_hash)\n .order_by" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.start_time" ], [ "LOOKUP_METHOD", "Call.start_time.desc" ], [ "CALL_METHOD", "Call.start_time.desc()" ], [ "CALL_METHOD", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by(body_hash=body_hash)\n .order_by(Call.start_time.desc())" ], [ "BINARY_SUBSCR", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by(body_hash=body_hash)\n .order_by(Call.start_time.desc())[:200]" ], [ "LOAD_FAST", "query" ], [ "LOAD_FAST", "query" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "function_data_set" ], [ "LOAD_GLOBAL", "json" ], [ "LOOKUP_METHOD", "json.loads" ], [ "LOAD_DEREF", "function_data" ], [ "CALL_METHOD", "json.loads(function_data)" ], [ "LOAD_FAST", "add" ], [ "LOAD_FAST", "ranges" ], [ "CALL_FUNCTION", "add('node_ranges', ranges)" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "add" ], [ "LOAD_FAST", "current_loop_ranges" ], [ "CALL_FUNCTION", "add('loop_ranges', current_loop_ranges)" ], [ "LOAD_FAST", "loop_ranges" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "current_loop_ranges" ], [ "COMPARE_OP", "loop_ranges in (set(), current_loop_ranges)" ], [ "LOAD_FAST", "current_loop_ranges" ], [ "LOAD_FAST", "ranges" ], [ "LOAD_FAST", "loop_ranges" ], [ "LOAD_GLOBAL", "DecentJSONEncoder" ], [ "CALL_FUNCTION", "DecentJSONEncoder()" ], [ "LOOKUP_METHOD", "DecentJSONEncoder().encode" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "calls" ], [ "LOAD_FAST", "ranges" ], [ "LOAD_FAST", "loop_ranges" ], [ "CALL_FUNCTION", "dict(\n calls=calls, ranges=ranges, loop_ranges=loop_ranges)" ], [ "CALL_METHOD", "DecentJSONEncoder().encode(dict(\n calls=calls, ranges=ranges, loop_ranges=loop_ranges))" ], [ "LOAD_GLOBAL", "Call" ], [ "LOOKUP_METHOD", "Call.basic_dict" ], [ "LOAD_GLOBAL", "withattrs" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_FUNCTION", "Call()" ], [ "LOAD_FAST", "row" ], [ "LOOKUP_METHOD", "row._asdict" ], [ "CALL_METHOD", "row._asdict()" ], [ "CALL_FUNCTION_KW", "withattrs(Call(), **row._asdict())" ], [ "CALL_METHOD", "Call.basic_dict(withattrs(Call(), **row._asdict()))" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.data" ], [ "LOAD_DEREF", "function_data" ], [ "LOAD_FAST", "key" ], [ "BINARY_SUBSCR", "function_data[key]" ], [ "LOAD_FAST", "ranges_set" ], [ "LOOKUP_METHOD", "ranges_set.add" ], [ "LOAD_FAST", "node" ], [ "BINARY_SUBSCR", "node['start']" ], [ "LOAD_FAST", "node" ], [ "BINARY_SUBSCR", "node['end']" ], [ "CALL_METHOD", "ranges_set.add((node['start'], node['end']))" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "CALL_FUNCTION", "dict(start=start, end=end)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "CALL_FUNCTION", "dict(start=start, end=end)" ], [ "LOAD_GLOBAL", "request" ], [ "LOOKUP_METHOD", "request.get_json" ], [ "CALL_METHOD", "request.get_json()" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.query" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.body_hash" ], [ "LOAD_GLOBAL", "sqlalchemy" ], [ "LOAD_ATTR", "sqlalchemy.func" ], [ "LOOKUP_METHOD", "sqlalchemy.func.count" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.id" ], [ "CALL_METHOD", "sqlalchemy.func.count(Call.id)" ], [ "CALL_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))" ], [ "LOOKUP_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)" ], [ "LOOKUP_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)\n .filter" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.body_hash" ], [ "LOOKUP_METHOD", "Function.body_hash.in_" ], [ "LOAD_FAST", "hashes" ], [ "CALL_METHOD", "Function.body_hash.in_(hashes)" ], [ "CALL_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)\n .filter(Function.body_hash.in_(hashes))" ], [ "LOOKUP_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)\n .filter(Function.body_hash.in_(hashes))\n .group_by" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.body_hash" ], [ "CALL_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)\n .filter(Function.body_hash.in_(hashes))\n .group_by(Function.body_hash)" ], [ "LOAD_GLOBAL", "DecentJSONEncoder" ], [ "CALL_FUNCTION", "DecentJSONEncoder()" ], [ "LOOKUP_METHOD", "DecentJSONEncoder().encode" ], [ "LOAD_FAST", "query" ], [ "CALL_METHOD", "DecentJSONEncoder().encode([\n dict(hash=h, count=count)\n for h, count in query\n ])" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "h" ], [ "LOAD_FAST", "count" ], [ "CALL_FUNCTION", "dict(hash=h, count=count)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "argv" ], [ "CALL_FUNCTION", "len(argv)" ], [ "COMPARE_OP", "len(argv) == 1" ], [ "LOAD_FAST", "argv" ], [ "BINARY_SUBSCR", "argv[0]" ], [ "LOOKUP_METHOD", "argv[0].isdigit" ], [ "CALL_METHOD", "argv[0].isdigit()" ], [ "LOAD_FAST", "argv" ], [ "LOOKUP_METHOD", "argv.insert" ], [ "CALL_METHOD", "argv.insert(0, '--port')" ], [ "LOAD_GLOBAL", "argparse" ], [ "LOOKUP_METHOD", "argparse.ArgumentParser" ], [ "CALL_METHOD", "argparse.ArgumentParser(description=\"Bird's Eye: A graphical Python debugger\")" ], [ "LOAD_FAST", "parser" ], [ "LOOKUP_METHOD", "parser.add_argument" ], [ "LOAD_GLOBAL", "int" ], [ "CALL_METHOD", "parser.add_argument('-p', '--port', help='HTTP port, default is 7777', default=7777, type=int)" ], [ "LOAD_FAST", "parser" ], [ "LOOKUP_METHOD", "parser.add_argument" ], [ "CALL_METHOD", "parser.add_argument('--host', help=\"HTTP host, default is 'localhost'\", default='localhost')" ], [ "LOAD_FAST", "parser" ], [ "LOOKUP_METHOD", "parser.parse_args" ], [ "LOAD_FAST", "argv" ], [ "CALL_METHOD", "parser.parse_args(argv)" ], [ "LOAD_GLOBAL", "app" ], [ "LOOKUP_METHOD", "app.run" ], [ "LOAD_FAST", "args" ], [ "LOAD_ATTR", "args.port" ], [ "LOAD_FAST", "args" ], [ "LOAD_ATTR", "args.host" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.environ" ], [ "LOOKUP_METHOD", "os.environ.get" ], [ "CALL_METHOD", "os.environ.get('BIRDSEYE_RELOADER')" ], [ "COMPARE_OP", "os.environ.get('BIRDSEYE_RELOADER') == '1'" ], [ "CALL_METHOD", "app.run(\n port=args.port,\n host=args.host,\n use_reloader=os.environ.get('BIRDSEYE_RELOADER') == '1',\n )" ] ], "tests.py": [ [ "LOAD_NAME", "unittest" ], [ "LOAD_ATTR", "unittest.TestCase" ], [ "LOAD_NAME", "unittest" ], [ "LOAD_ATTR", "unittest.TestCase" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "TestFile" ], [ "CALL_FUNCTION", "TestFile()" ], [ "LOOKUP_METHOD", "TestFile().test_file" ], [ "CALL_METHOD", "TestFile().test_file()" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "Tester" ], [ "CALL_FUNCTION", "Tester()" ], [ "LOAD_NAME", "tester" ], [ "CALL_FUNCTION", "tester([1, 2, 3])" ], [ "COMPARE_OP", "tester([1, 2, 3]) == [1, 2, 3]" ], [ "LOAD_NAME", "tester" ], [ "LOAD_ATTR", "tester.asd" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester.asd is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_SUBSCR", "tester[19]" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester[19] is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_POWER", "tester ** 4" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester ** 4 is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_MULTIPLY", "tester * 3" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester * 3 is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_SUBTRACT", "tester - 2" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester - 2 is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_ADD", "tester + 1" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester + 1 is tester" ], [ "LOAD_NAME", "tester" ], [ "UNARY_NEGATIVE", "-tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "-tester is tester" ], [ "LOAD_NAME", "tester" ], [ "UNARY_POSITIVE", "+tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "+tester is tester" ], [ "LOAD_NAME", "tester" ], [ "UNARY_INVERT", "~tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "~tester is tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester < 7" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "(tester < 7) is tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester >= 78" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "(tester >= 78) is tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester != 79" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "(tester != 79) is tester" ], [ "LOAD_NAME", "tester" ], [ "LOOKUP_METHOD", "tester.foo" ], [ "CALL_METHOD", "tester.foo(45, False)" ], [ "COMPARE_OP", "tester.foo(45, False) == 45" ], [ "LOAD_NAME", "__name__" ], [ "COMPARE_OP", "__name__ == '__main__'" ], [ "LOAD_NAME", "unittest" ], [ "LOOKUP_METHOD", "unittest.main" ], [ "CALL_METHOD", "unittest.main()" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(1)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(2)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(3)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(9\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n 8)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n 99\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(33)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([4,\n 5, 6, [\n 7]])" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "LOAD_GLOBAL", "decorator_with_args" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('123')" ], [ "LOAD_GLOBAL", "int" ], [ "CALL_FUNCTION", "int()" ], [ "CALL_FUNCTION", "decorator_with_args(tester('123'), x=int())" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "tuple([1, 2])" ], [ "CALL_FUNCTION", "list(tuple([1, 2]))" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "CALL_FUNCTION", "tester(list(tuple([1, 2])), returns=empty_decorator)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "tuple(\n [3, 4])" ], [ "CALL_FUNCTION", "list(\n tuple(\n [3, 4]))" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "CALL_FUNCTION", "tester(\n list(\n tuple(\n [3, 4])),\n returns=empty_decorator)" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "LOAD_GLOBAL", "decorator_with_args" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "str()" ], [ "LOAD_GLOBAL", "int" ], [ "CALL_FUNCTION", "int()" ], [ "CALL_FUNCTION", "decorator_with_args(\n str(),\n x=int())" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "tuple([5, 6])" ], [ "CALL_FUNCTION", "list(tuple([5, 6]))" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "CALL_FUNCTION", "tester(list(tuple([5, 6])), returns=empty_decorator)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "tuple([7, 8])" ], [ "CALL_FUNCTION", "list(tuple([7, 8]))" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "CALL_FUNCTION", "tester(list(tuple([7, 8])), returns=empty_decorator)" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "LOAD_GLOBAL", "decorator_with_args" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('sdf')" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('123234')" ], [ "CALL_FUNCTION", "decorator_with_args(tester('sdf'), x=tester('123234'))" ], [ "CALL_FUNCTION", "decorator_with_args(tester('sdf'), x=tester('123234'))" ], [ "CALL_FUNCTION", "empty_decorator" ], [ "CALL_FUNCTION", "tester(list(tuple([7, 8])), returns=empty_decorator)" ], [ "CALL_FUNCTION", "tester(list(tuple([5, 6])), returns=empty_decorator)" ], [ "CALL_FUNCTION", "decorator_with_args(\n str(),\n x=int())" ], [ "CALL_FUNCTION", "empty_decorator" ], [ "CALL_FUNCTION", "tester(\n list(\n tuple(\n [3, 4])),\n returns=empty_decorator)" ], [ "CALL_FUNCTION", "tester(list(tuple([1, 2])), returns=empty_decorator)" ], [ "CALL_FUNCTION", "decorator_with_args(tester('123'), x=int())" ], [ "CALL_FUNCTION", "empty_decorator" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "str([{tester(x) for x in [1]}, {tester(y) for y in [1]}])" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "str([{tester(x) for x in [1]},\n {tester(x) for x in [1]}])" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "list(tester(x) for x in [1])" ], [ "CALL_FUNCTION", "str([{tester(x) for x in [1]}, list(tester(x) for x in [1])])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "y" ], [ "CALL_FUNCTION", "tester(y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertEqual" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(3)" ], [ "CALL_FUNCTION", "(lambda x: (tester(x), tester(x)))(tester(3))" ], [ "CALL_METHOD", "self.assertEqual(\n (lambda x: (tester(x), tester(x)))(tester(3)),\n (3, 3),\n )" ], [ "CALL_FUNCTION", "(lambda: (lambda: tester(1))())()" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertEqual" ], [ "CALL_FUNCTION", "(lambda: [tester(x) for x in tester([1, 2])])()" ], [ "CALL_METHOD", "self.assertEqual(\n (lambda: [tester(x) for x in tester([1, 2])])(),\n [1, 2],\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "CALL_FUNCTION", "(lambda: tester(1))()" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(1)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x): {tester(b+x): {tester(c+x) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_FAST", "foo" ], [ "CALL_FUNCTION", "foo()" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "CALL_FUNCTION", "tester(a+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "CALL_FUNCTION", "tester(b+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "CALL_FUNCTION", "tester(c+x)" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x): {tester(b+x): {tester(c+x) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+y): {tester(b+y): {tester(c+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x+y): {tester(b+x+y): {tester(c+x+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_FAST", "bar" ], [ "CALL_FUNCTION", "bar()" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "CALL_FUNCTION", "tester(a+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "CALL_FUNCTION", "tester(b+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "CALL_FUNCTION", "tester(c+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+y" ], [ "CALL_FUNCTION", "tester(a+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+y" ], [ "CALL_FUNCTION", "tester(b+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+y" ], [ "CALL_FUNCTION", "tester(c+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+x+y" ], [ "CALL_FUNCTION", "tester(a+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+x+y" ], [ "CALL_FUNCTION", "tester(b+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+x+y" ], [ "CALL_FUNCTION", "tester(c+x+y)" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x): {tester(b+x): {tester(c+x) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+y): {tester(b+y): {tester(c+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x+y): {tester(b+x+y): {tester(c+x+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x+y+z): {tester(b+x+y+z): {tester(c+x+y+z) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "CALL_FUNCTION", "tester(a+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "CALL_FUNCTION", "tester(b+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "CALL_FUNCTION", "tester(c+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+y" ], [ "CALL_FUNCTION", "tester(a+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+y" ], [ "CALL_FUNCTION", "tester(b+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+y" ], [ "CALL_FUNCTION", "tester(c+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+x+y" ], [ "CALL_FUNCTION", "tester(a+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+x+y" ], [ "CALL_FUNCTION", "tester(b+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+x+y" ], [ "CALL_FUNCTION", "tester(c+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+x+y" ], [ "LOAD_DEREF", "z" ], [ "BINARY_ADD", "a+x+y+z" ], [ "CALL_FUNCTION", "tester(a+x+y+z)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+x+y" ], [ "LOAD_DEREF", "z" ], [ "BINARY_ADD", "b+x+y+z" ], [ "CALL_FUNCTION", "tester(b+x+y+z)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+x+y" ], [ "LOAD_DEREF", "z" ], [ "BINARY_ADD", "c+x+y+z" ], [ "CALL_FUNCTION", "tester(c+x+y+z)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "dict(x=tester)" ], [ "BINARY_SUBSCR", "dict(x=tester)['x']" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "dict(x=tester)['x'](tester)" ], [ "CALL_FUNCTION", "dict(x=tester)['x'](tester)(3, check_func=False)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertRaises" ], [ "LOAD_GLOBAL", "TypeError" ], [ "CALL_METHOD", "self.assertRaises(TypeError)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2, 3])" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(0)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(4)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(5)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "tester(ValueError)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(9)" ], [ "LOAD_GLOBAL", "TypeError" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(10)" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "str()" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertRaises" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "Exception" ], [ "CALL_FUNCTION", "tester(Exception)" ], [ "CALL_METHOD", "self.assertRaises(tester(Exception))" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(0)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(0)" ], [ "LOAD_GLOBAL", "tester" ], [ "BINARY_TRUE_DIVIDE", "1 / 0" ], [ "CALL_FUNCTION", "tester(1 / 0)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "gen" ], [ "CALL_FUNCTION", "gen()" ], [ "CALL_FUNCTION", "list(gen())" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "gen2" ], [ "CALL_FUNCTION", "list(gen2)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(4)" ], [ "LOAD_GLOBAL", "time" ], [ "LOOKUP_METHOD", "time.time" ], [ "CALL_METHOD", "time.time()" ], [ "LOAD_GLOBAL", "range" ], [ "CALL_FUNCTION", "range(10000)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOOKUP_METHOD", "Source.executing" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.currentframe" ], [ "CALL_METHOD", "inspect.currentframe()" ], [ "CALL_METHOD", "Source.executing(inspect.currentframe())" ], [ "LOAD_ATTR", "Source.executing(inspect.currentframe()).node" ], [ "LOAD_FAST", "node" ], [ "COMPARE_OP", "node is None" ], [ "LOAD_FAST", "new_node" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertIs" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "new_node" ], [ "CALL_METHOD", "self.assertIs(node, new_node)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertLess" ], [ "LOAD_GLOBAL", "time" ], [ "LOOKUP_METHOD", "time.time" ], [ "CALL_METHOD", "time.time()" ], [ "LOAD_FAST", "start" ], [ "BINARY_SUBTRACT", "time.time() - start" ], [ "CALL_METHOD", "self.assertLess(time.time() - start, 1)" ], [ "LOAD_FAST", "check" ], [ "CALL_FUNCTION", "check(u'# coding=utf8\\n\u00e9', 'utf8')" ], [ "LOAD_FAST", "check" ], [ "CALL_FUNCTION", "check(u'# coding=gbk\\n\u00e9', 'gbk')" ], [ "LOAD_FAST", "check" ], [ "LOAD_GLOBAL", "UnicodeDecodeError" ], [ "CALL_FUNCTION", "check(u'# coding=utf8\\n\u00e9', 'gbk', exception=UnicodeDecodeError)" ], [ "LOAD_FAST", "check" ], [ "CALL_FUNCTION", "check(u'# coding=gbk\\n\u00e9', 'utf8', matches=False)" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_FAST", "check" ], [ "CALL_FUNCTION", "check(u'\u00e9', 'utf8')" ], [ "LOAD_FAST", "check" ], [ "LOAD_GLOBAL", "SyntaxError" ], [ "CALL_FUNCTION", "check(u'\u00e9', 'gbk', exception=SyntaxError)" ], [ "LOAD_FAST", "source" ], [ "LOOKUP_METHOD", "source.encode" ], [ "LOAD_FAST", "encoding" ], [ "CALL_METHOD", "source.encode(encoding)" ], [ "LOAD_FAST", "exception" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self.assertRaises" ], [ "LOAD_FAST", "exception" ], [ "CALL_METHOD", "self.assertRaises(exception)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOOKUP_METHOD", "Source.decode_source" ], [ "LOAD_FAST", "encoded" ], [ "CALL_METHOD", "Source.decode_source(encoded)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOOKUP_METHOD", "Source.decode_source" ], [ "LOAD_FAST", "encoded" ], [ "CALL_METHOD", "Source.decode_source(encoded)" ], [ "LOAD_FAST", "matches" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self.assertEqual" ], [ "LOAD_FAST", "decoded" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "self.assertEqual(decoded, source)" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self.assertNotEqual" ], [ "LOAD_FAST", "decoded" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "self.assertNotEqual(decoded, source)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('a')" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('''\n ab''')" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('''\n abc\n def\n '''\n )" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n '''\n 123\n 456\n '''\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n '''\n 345\n 456786\n '''\n )" ], [ "CALL_FUNCTION", "str([\n tester(\n '''\n 123\n 456\n '''\n ),\n tester(\n '''\n 345\n 456786\n '''\n ),\n ])" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n [\n '''\n 123\n 456\n '''\n '''\n 345\n 456786\n '''\n ,\n '''\n 123\n 456\n ''',\n '''\n 345\n 456786\n '''\n ]\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(1)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(2)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(3)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOOKUP_METHOD", "Source.for_filename" ], [ "LOAD_GLOBAL", "__file__" ], [ "CALL_METHOD", "Source.for_filename(__file__)" ], [ "LOOKUP_METHOD", "Source.for_filename(__file__).code_qualname" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.__code__" ], [ "CALL_METHOD", "Source.for_filename(__file__).code_qualname(func.__code__)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertEqual" ], [ "LOAD_FAST", "qn" ], [ "LOAD_FAST", "qualname" ], [ "CALL_METHOD", "self.assertEqual(qn, qualname)" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_FAST", "check_actual_qualname" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertEqual" ], [ "LOAD_FAST", "qn" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.__qualname__" ], [ "CALL_METHOD", "self.assertEqual(qn, func.__qualname__)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertTrue" ], [ "LOAD_FAST", "qn" ], [ "LOOKUP_METHOD", "qn.endswith" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.__name__" ], [ "CALL_METHOD", "qn.endswith(func.__name__)" ], [ "CALL_METHOD", "self.assertTrue(qn.endswith(func.__name__))" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assert_qualname" ], [ "LOAD_GLOBAL", "C" ], [ "LOAD_ATTR", "C.f" ], [ "CALL_METHOD", "self.assert_qualname(C.f, 'C.f')" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assert_qualname" ], [ "LOAD_GLOBAL", "C" ], [ "LOAD_ATTR", "C.D" ], [ "LOAD_ATTR", "C.D.g" ], [ "CALL_METHOD", "self.assert_qualname(C.D.g, 'C.D.g')" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assert_qualname" ], [ "LOAD_GLOBAL", "f" ], [ "CALL_METHOD", "self.assert_qualname(f, 'f')" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assert_qualname" ], [ "LOAD_GLOBAL", "f" ], [ "CALL_FUNCTION", "f()" ], [ "CALL_METHOD", "self.assert_qualname(f(), 'f..g')" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assert_qualname" ], [ "LOAD_GLOBAL", "C" ], [ "LOAD_ATTR", "C.D" ], [ "LOOKUP_METHOD", "C.D.h" ], [ "CALL_METHOD", "C.D.h()" ], [ "CALL_METHOD", "self.assert_qualname(C.D.h(), 'C.D.h..i..j')" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assert_qualname" ], [ "LOAD_GLOBAL", "lamb" ], [ "CALL_METHOD", "self.assert_qualname(lamb, '')" ], [ "LOAD_GLOBAL", "lambda_maker" ], [ "CALL_FUNCTION", "lambda_maker()" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assert_qualname" ], [ "LOAD_FAST", "foo" ], [ "CALL_METHOD", "self.assert_qualname(foo, 'lambda_maker..foo')" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assert_qualname" ], [ "LOAD_FAST", "foo" ], [ "LOAD_ATTR", "foo.x" ], [ "CALL_METHOD", "self.assert_qualname(foo.x, 'lambda_maker..')" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assert_qualname" ], [ "LOAD_FAST", "foo" ], [ "CALL_FUNCTION", "foo()" ], [ "CALL_METHOD", "self.assert_qualname(foo(), 'lambda_maker..foo..')" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assert_qualname" ], [ "LOAD_FAST", "foo" ], [ "CALL_FUNCTION", "foo()" ], [ "CALL_FUNCTION", "foo()()" ], [ "CALL_METHOD", "self.assert_qualname(foo()(), 'lambda_maker..foo..', check_actual_qualname=False)" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "range" ], [ "CALL_FUNCTION", "range(66000)" ], [ "CALL_FUNCTION", "list(range(66000))" ], [ "BINARY_MODULO", "'tester(6)\\n%s\\ntester(9)' % list(range(66000))" ], [ "LOAD_GLOBAL", "tempfile" ], [ "LOOKUP_METHOD", "tempfile.mkstemp" ], [ "CALL_METHOD", "tempfile.mkstemp()" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "compile(source, filename, 'exec')" ], [ "LOAD_GLOBAL", "open" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "open(filename, 'w')" ], [ "LOAD_FAST", "outfile" ], [ "LOOKUP_METHOD", "outfile.write" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "outfile.write(source)" ], [ "LOAD_GLOBAL", "exec" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "exec(code)" ], [ "LOAD_GLOBAL", "range" ], [ "CALL_FUNCTION", "range(5)" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "n" ], [ "CALL_FUNCTION", "range(n)" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "n == 1" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertEqual" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_FAST", "gen" ], [ "CALL_FUNCTION", "only(gen)" ], [ "CALL_METHOD", "self.assertEqual(only(gen), 0)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertRaises" ], [ "LOAD_GLOBAL", "NotOneValueFound" ], [ "CALL_METHOD", "self.assertRaises(NotOneValueFound)" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_FAST", "gen" ], [ "CALL_FUNCTION", "only(gen)" ], [ "LOAD_FAST", "i" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOOKUP_METHOD", "os.path.join" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOOKUP_METHOD", "os.path.dirname" ], [ "LOAD_GLOBAL", "__file__" ], [ "CALL_METHOD", "os.path.dirname(__file__)" ], [ "CALL_METHOD", "os.path.join(os.path.dirname(__file__), 'not_code.txt', )" ], [ "LOAD_GLOBAL", "Source" ], [ "LOOKUP_METHOD", "Source.for_filename" ], [ "LOAD_FAST", "path" ], [ "CALL_METHOD", "Source.for_filename(path)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertIsNone" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.tree" ], [ "CALL_METHOD", "self.assertIsNone(source.tree)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.currentframe" ], [ "CALL_METHOD", "inspect.currentframe()" ], [ "LOAD_GLOBAL", "Source" ], [ "LOOKUP_METHOD", "Source.executing" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "Source.executing(frame)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertEqual" ], [ "LOAD_FAST", "executing" ], [ "LOOKUP_METHOD", "executing.code_qualname" ], [ "CALL_METHOD", "executing.code_qualname()" ], [ "CALL_METHOD", "self.assertEqual(executing.code_qualname(), 'TestStuff.test_executing_methods')" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.version" ], [ "LOOKUP_METHOD", "sys.version.lower" ], [ "CALL_METHOD", "sys.version.lower()" ], [ "COMPARE_OP", "'pypy' not in sys.version.lower()" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertEqual" ], [ "LOAD_FAST", "executing" ], [ "LOOKUP_METHOD", "executing.text" ], [ "CALL_METHOD", "executing.text()" ], [ "LOAD_FAST", "text" ], [ "CALL_METHOD", "self.assertEqual(executing.text(), text)" ], [ "LOAD_FAST", "executing" ], [ "LOOKUP_METHOD", "executing.text_range" ], [ "CALL_METHOD", "executing.text_range()" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertEqual" ], [ "LOAD_FAST", "executing" ], [ "LOAD_ATTR", "executing.source" ], [ "LOAD_ATTR", "executing.source.text" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "BINARY_SUBSCR", "executing.source.text[start:end]" ], [ "LOAD_FAST", "text" ], [ "CALL_METHOD", "self.assertEqual(executing.source.text[start:end], text)" ], [ "LOAD_GLOBAL", "C" ], [ "CALL_FUNCTION", "C()" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_FAST", "c" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.x" ], [ "LOAD_ATTR", "c.x.x" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.x" ], [ "LOAD_ATTR", "c.x.y" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.y" ], [ "LOAD_ATTR", "c.y.x" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.y" ], [ "LOAD_ATTR", "c.y.y" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.x" ], [ "LOAD_ATTR", "c.x.asd" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.y" ], [ "LOAD_ATTR", "c.y.qwe" ], [ "CALL_FUNCTION", "str((c.x.x, c.x.y, c.y.x, c.y.y, c.x.asd, c.y.qwe))" ], [ "LOAD_GLOBAL", "Source" ], [ "LOOKUP_METHOD", "Source.for_frame" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.currentframe" ], [ "CALL_METHOD", "inspect.currentframe()" ], [ "CALL_METHOD", "Source.for_frame(inspect.currentframe())" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.text" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.filename" ], [ "CALL_FUNCTION", "compile(source.text, source.filename, 'exec')" ], [ "LOAD_GLOBAL", "get_instructions" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "get_instructions(code)" ], [ "LOAD_FAST", "instructions" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.starts_line" ], [ "COMPARE_OP", "inst.starts_line is not None" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.starts_line" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.opname" ], [ "LOOKUP_METHOD", "inst.opname.startswith" ], [ "CALL_METHOD", "inst.opname.startswith(\n ('BINARY_', 'UNARY_', 'LOAD_ATTR', 'LOAD_METHOD', 'LOOKUP_METHOD', 'COMPARE_OP'))" ], [ "LOAD_GLOBAL", "C" ], [ "CALL_FUNCTION", "C()" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.offset" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "frame" ], [ "LOAD_GLOBAL", "globals" ], [ "CALL_FUNCTION", "globals()" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "lineno" ], [ "LOAD_FAST", "frame" ], [ "LOAD_GLOBAL", "print" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.opname" ], [ "CALL_FUNCTION", "print(inst.opname)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOOKUP_METHOD", "Source.executing" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "Source.executing(frame)" ], [ "LOAD_ATTR", "Source.executing(frame).node" ], [ "COMPARE_OP", "Source.executing(frame).node is not None" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_FAST", "i" ], [ "CALL_FUNCTION", "i()" ], [ "LOAD_FAST", "j" ], [ "LOAD_FAST", "g" ], [ "LOAD_FAST", "assign" ], [ "CALL_FUNCTION", "assign(lambda: 1)" ], [ "CALL_FUNCTION", "assign(lambda: 1)" ], [ "LOAD_FAST", "foo" ], [ "LOAD_FAST", "decorator" ], [ "LOAD_DEREF", "x" ], [ "LOAD_FAST", "func" ], [ "LOAD_FAST", "func" ], [ "LOAD_NAME", "__add__" ], [ "LOAD_NAME", "__invert__" ], [ "LOAD_NAME", "__lt__" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.currentframe" ], [ "CALL_METHOD", "inspect.currentframe()" ], [ "LOAD_ATTR", "inspect.currentframe().f_back" ], [ "LOAD_ATTR", "inspect.currentframe().f_back.f_back" ], [ "LOAD_GLOBAL", "Source" ], [ "LOOKUP_METHOD", "Source.lazycache" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "Source.lazycache(frame)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOOKUP_METHOD", "Source.executing" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "Source.executing(frame)" ], [ "LOAD_ATTR", "Source.executing(frame).node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "typ" ], [ "CALL_FUNCTION", "isinstance(node, typ)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "typ" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.currentframe" ], [ "CALL_METHOD", "inspect.currentframe()" ], [ "LOAD_ATTR", "inspect.currentframe().f_back" ], [ "LOAD_ATTR", "inspect.currentframe().f_back.f_back" ], [ "LOAD_GLOBAL", "eval" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.Expression" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.Expression(node)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_filename" ], [ "CALL_FUNCTION", "compile(ast.Expression(node), frame.f_code.co_filename, 'eval')" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "CALL_FUNCTION", "eval(\n compile(ast.Expression(node), frame.f_code.co_filename, 'eval'),\n frame.f_globals,\n frame.f_locals,\n )" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "value" ], [ "COMPARE_OP", "result == value" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Call" ], [ "CALL_METHOD", "self.get_node(ast.Call)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.check" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.args" ], [ "BINARY_SUBSCR", "call.args[0]" ], [ "LOAD_FAST", "arg" ], [ "CALL_METHOD", "self.check(call.args[0], arg)" ], [ "LOAD_FAST", "check_func" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.check" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.func" ], [ "LOAD_FAST", "self" ], [ "CALL_METHOD", "self.check(call.func, self)" ], [ "LOAD_FAST", "returns" ], [ "COMPARE_OP", "returns is None" ], [ "LOAD_FAST", "arg" ], [ "LOAD_FAST", "returns" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Attribute" ], [ "CALL_METHOD", "self.get_node(ast.Attribute)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.value" ], [ "LOAD_FAST", "self" ], [ "CALL_METHOD", "self.check(node.value, self)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.attr" ], [ "LOAD_FAST", "item" ], [ "COMPARE_OP", "node.attr == item" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Subscript" ], [ "CALL_METHOD", "self.get_node(ast.Subscript)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.value" ], [ "LOAD_FAST", "self" ], [ "CALL_METHOD", "self.check(node.value, self)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.slice" ], [ "LOAD_ATTR", "node.slice.value" ], [ "LOAD_FAST", "item" ], [ "CALL_METHOD", "self.check(node.slice.value, item)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.BinOp" ], [ "CALL_METHOD", "self.get_node(ast.BinOp)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.left" ], [ "LOAD_FAST", "self" ], [ "CALL_METHOD", "self.check(node.left, self)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.right" ], [ "LOAD_FAST", "other" ], [ "CALL_METHOD", "self.check(node.right, other)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.UnaryOp" ], [ "CALL_METHOD", "self.get_node(ast.UnaryOp)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.operand" ], [ "LOAD_FAST", "self" ], [ "CALL_METHOD", "self.check(node.operand, self)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Compare" ], [ "CALL_METHOD", "self.get_node(ast.Compare)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.left" ], [ "LOAD_FAST", "self" ], [ "CALL_METHOD", "self.check(node.left, self)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.comparators" ], [ "BINARY_SUBSCR", "node.comparators[0]" ], [ "LOAD_FAST", "other" ], [ "CALL_METHOD", "self.check(node.comparators[0], other)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "func" ], [ "LOAD_GLOBAL", "empty_decorator" ] ], "tracer.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOOKUP_METHOD", "standard_library.install_aliases" ], [ "CALL_METHOD", "standard_library.install_aliases()" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "NamedTuple" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "Union" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "BINARY_SUBSCR", "Union[ast.expr, ast.stmt]" ], [ "BINARY_SUBSCR", "Optional[Union[ast.expr, ast.stmt]]" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.AST" ], [ "LOAD_NAME", "FrameType" ], [ "LOAD_NAME", "FrameType" ], [ "CALL_FUNCTION", "NamedTuple('EnterCallInfo', [\n\n # Node from where the call was made\n ('call_node', Optional[Union[ast.expr, ast.stmt]]),\n\n # Node where the call begins\n ('enter_node', ast.AST),\n\n # Frame from which the call was made\n ('caller_frame', FrameType),\n\n # Frame of the call\n ('current_frame', FrameType)])" ], [ "LOAD_NAME", "NamedTuple" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "Union" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "BINARY_SUBSCR", "Union[ast.expr, ast.stmt]" ], [ "BINARY_SUBSCR", "Optional[Union[ast.expr, ast.stmt]]" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.Return" ], [ "BINARY_SUBSCR", "Optional[ast.Return]" ], [ "LOAD_NAME", "FrameType" ], [ "LOAD_NAME", "FrameType" ], [ "LOAD_NAME", "Any" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "Exception" ], [ "BINARY_SUBSCR", "Optional[Exception]" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "TracebackType" ], [ "BINARY_SUBSCR", "Optional[TracebackType]" ], [ "CALL_FUNCTION", "NamedTuple('ExitCallInfo', [\n\n # Node from where the call was made\n ('call_node', Optional[Union[ast.expr, ast.stmt]]),\n\n # Node where the call explicitly returned\n ('return_node', Optional[ast.Return]),\n\n # Frame from which the call was made\n ('caller_frame', FrameType),\n\n # Frame of the call\n ('current_frame', FrameType),\n\n # Node where the call explicitly returned\n ('return_value', Any),\n\n # Exception raised in the call causing it to end,\n # will propagate to the caller\n ('exc_value', Optional[Exception]),\n\n # Traceback corresponding to exc_value\n ('exc_tb', Optional[TracebackType])])" ], [ "LOAD_NAME", "namedtuple" ], [ "CALL_FUNCTION", "namedtuple('ChangeValue', 'value')" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.NodeTransformer" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "Union" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "BINARY_SUBSCR", "Union[ast.For, ast.While, ast.comprehension]" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.PyCF_ONLY_AST" ], [ "LOAD_FAST", "flags" ], [ "BINARY_OR", "ast.PyCF_ONLY_AST | flags" ], [ "CALL_FUNCTION", "compile(source, filename, 'exec', ast.PyCF_ONLY_AST | flags, dont_inherit=True)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.set_basic_node_attributes" ], [ "CALL_METHOD", "self.set_basic_node_attributes()" ], [ "LOAD_FAST", "tracer" ], [ "LOOKUP_METHOD", "tracer.parse_extra" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "CALL_METHOD", "tracer.parse_extra(self.root, source, filename)" ], [ "LOAD_FAST", "new_root" ], [ "COMPARE_OP", "new_root is not None" ], [ "LOAD_FAST", "new_root" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.set_basic_node_attributes" ], [ "CALL_METHOD", "self.set_basic_node_attributes()" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.set_enter_call_nodes" ], [ "CALL_METHOD", "self.set_enter_call_nodes()" ], [ "LOAD_GLOBAL", "deepcopy" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "CALL_FUNCTION", "deepcopy(self.root)" ], [ "LOAD_GLOBAL", "_NodeVisitor" ], [ "CALL_FUNCTION", "_NodeVisitor()" ], [ "LOOKUP_METHOD", "_NodeVisitor().visit" ], [ "LOAD_FAST", "new_root" ], [ "CALL_METHOD", "_NodeVisitor().visit(new_root)" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "new_root" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "flags" ], [ "CALL_FUNCTION", "compile(new_root, filename, \"exec\", dont_inherit=True, flags=flags)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.walk" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "CALL_METHOD", "ast.walk(self.root)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.iter_child_nodes" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.iter_child_nodes(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.nodes" ], [ "CALL_FUNCTION", "len(self.nodes)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.nodes" ], [ "LOOKUP_METHOD", "self.nodes.append" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self.nodes.append(node)" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "LOAD_ATTR", "self.root.body" ], [ "CALL_FUNCTION", "enumerate(self.root.body)" ], [ "LOAD_GLOBAL", "is_future_import" ], [ "LOAD_FAST", "stmt" ], [ "CALL_FUNCTION", "is_future_import(stmt)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "LOAD_ATTR", "self.root.body" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "self.root.body[:i + 1]" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.walk" ], [ "LOAD_FAST", "s" ], [ "CALL_METHOD", "ast.walk(s)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.nodes" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Module" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(node, (ast.Module, ast.FunctionDef))" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.body" ], [ "LOAD_GLOBAL", "is_future_import" ], [ "LOAD_FAST", "stmt" ], [ "CALL_FUNCTION", "is_future_import(stmt)" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_NAME", "lru_cache" ], [ "CALL_FUNCTION", "lru_cache()" ], [ "CALL_FUNCTION", "lru_cache()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "defaultdict(list)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "TracedFile" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "flags" ], [ "CALL_FUNCTION", "TracedFile(self, source, filename, flags)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._treetrace_hidden_with_stmt" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._treetrace_hidden_before_expr" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._treetrace_hidden_after_expr" ], [ "LOAD_GLOBAL", "partial" ], [ "LOAD_FAST", "f" ], [ "LOAD_DEREF", "traced_file" ], [ "CALL_FUNCTION", "partial(f, traced_file)" ], [ "LOAD_FAST", "f" ], [ "LOAD_ATTR", "f.__name__" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_DEREF", "func" ], [ "LOAD_GLOBAL", "FunctionType" ], [ "CALL_FUNCTION", "isinstance(func, FunctionType)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError('You can only trace user-defined functions. '\n 'The birdseye decorator must be applied first, '\n 'at the bottom of the list.')" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.iscoroutinefunction" ], [ "LOAD_DEREF", "func" ], [ "CALL_METHOD", "inspect.iscoroutinefunction(func)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.isasyncgenfunction" ], [ "LOAD_DEREF", "func" ], [ "CALL_METHOD", "inspect.isasyncgenfunction(func)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError('You cannot trace async functions')" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_GLOBAL", "is_lambda" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "is_lambda(func)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError('You cannot trace lambdas')" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.getsourcefile" ], [ "LOAD_DEREF", "func" ], [ "CALL_METHOD", "inspect.getsourcefile(func)" ], [ "LOAD_GLOBAL", "is_ipython_cell" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "is_ipython_cell(filename)" ], [ "LOAD_FAST", "get_ipython" ], [ "CALL_FUNCTION", "get_ipython()" ], [ "LOAD_ATTR", "get_ipython().compile" ], [ "LOAD_ATTR", "get_ipython().compile.flags" ], [ "LOOKUP_METHOD", "''.join" ], [ "LOAD_FAST", "linecache" ], [ "LOAD_ATTR", "linecache.cache" ], [ "LOAD_FAST", "filename" ], [ "BINARY_SUBSCR", "linecache.cache[filename]" ], [ "BINARY_SUBSCR", "linecache.cache[filename][2]" ], [ "CALL_METHOD", "''.join(linecache.cache[filename][2])" ], [ "LOAD_GLOBAL", "read_source_file" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "read_source_file(filename)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "flags" ], [ "CALL_METHOD", "self.compile(source, filename, flags)" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__dict__" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError('The birdseye decorator must be applied first, '\n 'at the bottom of the list.')" ], [ "LOAD_DEREF", "find_code" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.code" ], [ "CALL_FUNCTION", "find_code(traced_file.code)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_DEREF", "code_options" ], [ "CALL_FUNCTION", "len(code_options)" ], [ "COMPARE_OP", "len(code_options) > 1" ], [ "LOAD_GLOBAL", "is_lambda" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "is_lambda(func)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError(\"Failed to trace lambda. Convert the function to a def.\")" ], [ "LOAD_DEREF", "code_options" ], [ "BINARY_SUBSCR", "code_options[0]" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__globals__" ], [ "LOOKUP_METHOD", "func.__globals__.update" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._trace_methods_dict" ], [ "LOAD_FAST", "traced_file" ], [ "CALL_METHOD", "self._trace_methods_dict(traced_file)" ], [ "CALL_METHOD", "func.__globals__.update(self._trace_methods_dict(traced_file))" ], [ "LOAD_GLOBAL", "FunctionType" ], [ "LOAD_FAST", "new_func_code" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__globals__" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__name__" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__defaults__" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__closure__" ], [ "CALL_FUNCTION", "FunctionType(new_func_code, func.__globals__, func.__name__, func.__defaults__, func.__closure__)" ], [ "LOAD_GLOBAL", "update_wrapper" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "update_wrapper(new_func, func)" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "getattr(func, '__kwdefaults__', None)" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_FAST", "root_code" ], [ "LOAD_ATTR", "root_code.co_consts" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.iscode" ], [ "LOAD_FAST", "const" ], [ "CALL_METHOD", "inspect.iscode(const)" ], [ "LOAD_FAST", "const" ], [ "LOAD_ATTR", "const.co_firstlineno" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__code__" ], [ "LOAD_ATTR", "func.__code__.co_firstlineno" ], [ "COMPARE_OP", "const.co_firstlineno == func.__code__.co_firstlineno" ], [ "LOAD_FAST", "const" ], [ "LOAD_ATTR", "const.co_name" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__code__" ], [ "LOAD_ATTR", "func.__code__.co_name" ], [ "COMPARE_OP", "const.co_name == func.__code__.co_name" ], [ "LOAD_FAST", "matches" ], [ "LOAD_DEREF", "code_options" ], [ "LOOKUP_METHOD", "code_options.append" ], [ "LOAD_FAST", "const" ], [ "CALL_METHOD", "code_options.append(const)" ], [ "LOAD_DEREF", "find_code" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "find_code(const)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.isclass" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "inspect.isclass(func)" ], [ "LOAD_GLOBAL", "TypeError" ], [ "CALL_FUNCTION", "TypeError('Decorating classes is no longer supported')" ], [ "LOAD_FAST", "func" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self.trace_function" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "self.trace_function(func)" ], [ "LOAD_FAST", "optional" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.trace_function" ], [ "LOAD_FAST", "decorator" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self.trace_function" ], [ "LOAD_DEREF", "actual_func" ], [ "CALL_METHOD", "self.trace_function(actual_func)" ], [ "LOAD_GLOBAL", "wraps" ], [ "LOAD_DEREF", "actual_func" ], [ "CALL_FUNCTION", "wraps(actual_func)" ], [ "CALL_FUNCTION", "wraps(actual_func)" ], [ "LOAD_FAST", "wrapper" ], [ "LOAD_FAST", "kwargs" ], [ "LOOKUP_METHOD", "kwargs.pop" ], [ "CALL_METHOD", "kwargs.pop('trace_call', False)" ], [ "LOAD_FAST", "trace_call" ], [ "LOAD_DEREF", "traced" ], [ "LOAD_DEREF", "actual_func" ], [ "LOAD_FAST", "f" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "f(*args, **kwargs)" ], [ "LOAD_GLOBAL", "sys" ], [ "LOOKUP_METHOD", "sys._getframe" ], [ "CALL_METHOD", "sys._getframe(2)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.secondary_to_main_frames" ], [ "LOOKUP_METHOD", "self.secondary_to_main_frames.get" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self.secondary_to_main_frames.get(frame)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "COMPARE_OP", "frame.f_code.co_name in ('', '', '')" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_GLOBAL", "ancestors" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ancestors(node)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Lambda" ], [ "CALL_FUNCTION", "isinstance(node, (ast.FunctionDef, ast.Lambda))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.ClassDef" ], [ "CALL_FUNCTION", "isinstance(node, ast.ClassDef)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "COMPARE_OP", "frame.f_code.co_name in ('', '')" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.secondary_to_main_frames" ], [ "LOAD_FAST", "original_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.main_to_secondary_frames" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.main_to_secondary_frames[frame]" ], [ "LOOKUP_METHOD", "self.main_to_secondary_frames[frame].append" ], [ "LOAD_FAST", "original_frame" ], [ "CALL_METHOD", "self.main_to_secondary_frames[frame].append(original_frame)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.nodes" ], [ "LOAD_FAST", "_tree_index" ], [ "BINARY_SUBSCR", "traced_file.nodes[_tree_index]" ], [ "LOAD_GLOBAL", "cast" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "cast(ast.stmt, node)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._main_frame" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self._main_frame(node)" ], [ "LOAD_GLOBAL", "_StmtContext" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "_StmtContext(self, node, frame)" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.nodes" ], [ "LOAD_FAST", "_tree_index" ], [ "BINARY_SUBSCR", "traced_file.nodes[_tree_index]" ], [ "LOAD_GLOBAL", "cast" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "cast(ast.expr, node)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._main_frame" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self._main_frame(node)" ], [ "LOAD_FAST", "frame" ], [ "COMPARE_OP", "frame is None" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_stack" ], [ "LOOKUP_METHOD", "frame_info.expression_stack.append" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "frame_info.expression_stack.append(node)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.before_expr" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self.before_expr(node, frame)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._main_frame" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self._main_frame(node)" ], [ "LOAD_FAST", "frame" ], [ "COMPARE_OP", "frame is None" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._after_expr" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "value" ], [ "CALL_METHOD", "self._after_expr(node, frame, value, None, None)" ], [ "LOAD_FAST", "result" ], [ "COMPARE_OP", "result is not None" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "ChangeValue" ], [ "CALL_FUNCTION", "isinstance(result, ChangeValue)" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.value" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_stack" ], [ "LOOKUP_METHOD", "frame_info.expression_stack.pop" ], [ "CALL_METHOD", "frame_info.expression_stack.pop()" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_values" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.after_expr" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "exc_value" ], [ "LOAD_FAST", "exc_tb" ], [ "CALL_METHOD", "self.after_expr(node, frame, value, exc_value, exc_tb)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._get_caller_stuff" ], [ "LOAD_FAST", "current_frame" ], [ "CALL_METHOD", "self._get_caller_stuff(current_frame)" ], [ "LOAD_GLOBAL", "FrameInfo" ], [ "CALL_FUNCTION", "FrameInfo()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "current_frame" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.enter_call" ], [ "LOAD_GLOBAL", "EnterCallInfo" ], [ "LOAD_FAST", "call_node" ], [ "LOAD_FAST", "enter_node" ], [ "LOAD_FAST", "caller_frame" ], [ "LOAD_FAST", "current_frame" ], [ "CALL_FUNCTION", "EnterCallInfo(call_node, enter_node, caller_frame, current_frame)" ], [ "CALL_METHOD", "self.enter_call(EnterCallInfo(call_node, enter_node, caller_frame, current_frame))" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.secondary_to_main_frames" ], [ "LOOKUP_METHOD", "self.secondary_to_main_frames.get" ], [ "LOAD_FAST", "caller_frame" ], [ "CALL_METHOD", "self.secondary_to_main_frames.get(caller_frame)" ], [ "LOAD_FAST", "main_frame" ], [ "LOAD_FAST", "main_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "caller_frame" ], [ "BINARY_SUBSCR", "self.stack[caller_frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_stack" ], [ "LOAD_FAST", "expression_stack" ], [ "LOAD_FAST", "expression_stack" ], [ "BINARY_SUBSCR", "expression_stack[-1]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.statement_stack" ], [ "BINARY_SUBSCR", "frame_info.statement_stack[-1]" ], [ "LOAD_FAST", "caller_frame" ], [ "LOAD_FAST", "call_node" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "getattr(node, '_visit_ignore', False)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "CALL_FUNCTION", "isinstance(node, ast.expr)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "hasattr(node, \"ctx\")" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.ctx" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Load" ], [ "CALL_FUNCTION", "isinstance(node.ctx, ast.Load)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "ast" ], [ "CALL_FUNCTION", "getattr(ast, 'Starred', ())" ], [ "CALL_FUNCTION", "isinstance(node, getattr(ast, 'Starred', ()))" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.visit_expr" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self.visit_expr(node)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "CALL_FUNCTION", "isinstance(node, ast.stmt)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.visit_stmt" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self.visit_stmt(node)" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "_NodeVisitor" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self)" ], [ "LOOKUP_METHOD", "super(_NodeVisitor, self).generic_visit" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "super(_NodeVisitor, self).generic_visit(node)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._create_simple_marker_call" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "TreeTracerBase" ], [ "LOAD_ATTR", "TreeTracerBase._treetrace_hidden_before_expr" ], [ "CALL_METHOD", "self._create_simple_marker_call(node, TreeTracerBase._treetrace_hidden_before_expr)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.copy_location" ], [ "LOAD_FAST", "before_marker" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.copy_location(before_marker, node)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.Call" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.Name" ], [ "LOAD_GLOBAL", "TreeTracerBase" ], [ "LOAD_ATTR", "TreeTracerBase._treetrace_hidden_after_expr" ], [ "LOAD_ATTR", "TreeTracerBase._treetrace_hidden_after_expr.__name__" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.Load" ], [ "CALL_METHOD", "ast.Load()" ], [ "CALL_METHOD", "ast.Name(id=TreeTracerBase._treetrace_hidden_after_expr.__name__,\n ctx=ast.Load())" ], [ "LOAD_FAST", "before_marker" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "_NodeVisitor" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self)" ], [ "LOOKUP_METHOD", "super(_NodeVisitor, self).generic_visit" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "super(_NodeVisitor, self).generic_visit(node)" ], [ "CALL_METHOD", "ast.Call(\n func=ast.Name(id=TreeTracerBase._treetrace_hidden_after_expr.__name__,\n ctx=ast.Load()),\n args=[\n before_marker,\n super(_NodeVisitor, self).generic_visit(node),\n ],\n keywords=[],\n )" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.copy_location" ], [ "LOAD_FAST", "after_marker" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.copy_location(after_marker, node)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.fix_missing_locations" ], [ "LOAD_FAST", "after_marker" ], [ "CALL_METHOD", "ast.fix_missing_locations(after_marker)" ], [ "LOAD_FAST", "after_marker" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._create_simple_marker_call" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "_NodeVisitor" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self)" ], [ "LOOKUP_METHOD", "super(_NodeVisitor, self).generic_visit" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "super(_NodeVisitor, self).generic_visit(node)" ], [ "LOAD_GLOBAL", "TreeTracerBase" ], [ "LOAD_ATTR", "TreeTracerBase._treetrace_hidden_with_stmt" ], [ "CALL_METHOD", "self._create_simple_marker_call(\n super(_NodeVisitor, self).generic_visit(node),\n TreeTracerBase._treetrace_hidden_with_stmt)" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.With" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.withitem" ], [ "LOAD_FAST", "context_expr" ], [ "CALL_METHOD", "ast.withitem(context_expr=context_expr)" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.With(\n items=[ast.withitem(context_expr=context_expr)],\n body=[node],\n )" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.With" ], [ "LOAD_FAST", "context_expr" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.With(\n context_expr=context_expr,\n body=[node],\n )" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.copy_location" ], [ "LOAD_FAST", "wrapped" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.copy_location(wrapped, node)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.fix_missing_locations" ], [ "LOAD_FAST", "wrapped" ], [ "CALL_METHOD", "ast.fix_missing_locations(wrapped)" ], [ "LOAD_FAST", "wrapped" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.Call" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.Name" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.__name__" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.Load" ], [ "CALL_METHOD", "ast.Load()" ], [ "CALL_METHOD", "ast.Name(id=func.__name__,\n ctx=ast.Load())" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.Num" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "CALL_METHOD", "ast.Num(node._tree_index)" ], [ "CALL_METHOD", "ast.Call(\n func=ast.Name(id=func.__name__,\n ctx=ast.Load()),\n args=[ast.Num(node._tree_index)],\n keywords=[],\n )" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tracer" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "getattr(node, '_enter_call_node', False)" ], [ "LOAD_FAST", "tracer" ], [ "LOOKUP_METHOD", "tracer._enter_call" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "tracer._enter_call(node, frame)" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "tracer.stack[frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.statement_stack" ], [ "LOOKUP_METHOD", "frame_info.statement_stack.append" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "frame_info.statement_stack.append(node)" ], [ "LOAD_FAST", "tracer" ], [ "LOOKUP_METHOD", "tracer.before_stmt" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "tracer.before_stmt(node, frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tracer" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "tracer.stack[frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.statement_stack" ], [ "LOOKUP_METHOD", "frame_info.statement_stack.pop" ], [ "CALL_METHOD", "frame_info.statement_stack.pop()" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.exc_value" ], [ "COMPARE_OP", "exc_val is not frame_info.exc_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_stack" ], [ "LOAD_FAST", "expression_stack" ], [ "LOAD_FAST", "expression_stack" ], [ "BINARY_SUBSCR", "expression_stack[-1]" ], [ "LOAD_FAST", "tracer" ], [ "LOOKUP_METHOD", "tracer._after_expr" ], [ "LOAD_FAST", "exc_node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "exc_tb" ], [ "CALL_METHOD", "tracer._after_expr(exc_node, frame, None, exc_val, exc_tb)" ], [ "LOAD_FAST", "tracer" ], [ "LOOKUP_METHOD", "tracer.after_stmt" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "exc_tb" ], [ "LOAD_FAST", "exc_node" ], [ "CALL_METHOD", "tracer.after_stmt(node, frame, exc_val, exc_tb, exc_node)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Return" ], [ "CALL_FUNCTION", "isinstance(node, ast.Return)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.return_node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Module" ], [ "CALL_FUNCTION", "isinstance(parent, (ast.FunctionDef, ast.Module))" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.body" ], [ "BINARY_SUBSCR", "parent.body[-1]" ], [ "COMPARE_OP", "node is parent.body[-1]" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_FAST", "exiting" ], [ "LOAD_FAST", "tracer" ], [ "LOOKUP_METHOD", "tracer._get_caller_stuff" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "tracer._get_caller_stuff(frame)" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_ATTR", "return_node.value" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_values" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_ATTR", "return_node.value" ], [ "BINARY_SUBSCR", "frame_info.expression_values[return_node.value]" ], [ "LOAD_FAST", "tracer" ], [ "LOOKUP_METHOD", "tracer.exit_call" ], [ "LOAD_GLOBAL", "ExitCallInfo" ], [ "LOAD_FAST", "call_node" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_FAST", "caller_frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "return_value" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "exc_tb" ], [ "CALL_FUNCTION", "ExitCallInfo(call_node,\n return_node,\n caller_frame,\n frame,\n return_value,\n exc_val,\n exc_tb\n )" ], [ "CALL_METHOD", "tracer.exit_call(ExitCallInfo(call_node,\n return_node,\n caller_frame,\n frame,\n return_value,\n exc_val,\n exc_tb\n ))" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.stack" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tracer" ], [ "LOAD_ATTR", "self.tracer.main_to_secondary_frames" ], [ "LOOKUP_METHOD", "self.tracer.main_to_secondary_frames.pop" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self.tracer.main_to_secondary_frames.pop(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tracer" ], [ "LOAD_ATTR", "self.tracer.secondary_to_main_frames" ], [ "LOAD_FAST", "secondary_frame" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(parent, ast.FunctionDef)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "CALL_FUNCTION", "isinstance(parent, ast.For)" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.iter" ], [ "LOAD_DEREF", "node" ], [ "COMPARE_OP", "parent.iter is not node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "CALL_FUNCTION", "isinstance(parent, ast.While)" ], [ "LOAD_DEREF", "node" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.orelse" ], [ "COMPARE_OP", "node not in parent.orelse" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "CALL_FUNCTION", "isinstance(parent, ast.comprehension)" ], [ "LOAD_DEREF", "node" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.ifs" ], [ "COMPARE_OP", "node in parent.ifs" ], [ "LOAD_FAST", "is_containing_loop" ], [ "LOAD_FAST", "result" ], [ "LOOKUP_METHOD", "result.append" ], [ "LOAD_FAST", "parent" ], [ "CALL_METHOD", "result.append(parent)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.ListComp" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.GeneratorExp" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.DictComp" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.SetComp" ], [ "CALL_FUNCTION", "isinstance(parent, (ast.ListComp,\n ast.GeneratorExp,\n ast.DictComp,\n ast.SetComp))" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.generators" ], [ "LOAD_DEREF", "node" ], [ "LOAD_FAST", "generators" ], [ "COMPARE_OP", "node in generators" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "takewhile" ], [ "LOAD_FAST", "generators" ], [ "CALL_FUNCTION", "takewhile(lambda n: n != node, generators)" ], [ "CALL_FUNCTION", "list(takewhile(lambda n: n != node, generators))" ], [ "LOAD_FAST", "result" ], [ "LOOKUP_METHOD", "result.extend" ], [ "LOAD_GLOBAL", "reversed" ], [ "LOAD_FAST", "generators" ], [ "CALL_FUNCTION", "reversed(generators)" ], [ "CALL_METHOD", "result.extend(reversed(generators))" ], [ "LOAD_FAST", "parent" ], [ "LOAD_FAST", "result" ], [ "LOOKUP_METHOD", "result.reverse" ], [ "CALL_METHOD", "result.reverse()" ], [ "LOAD_GLOBAL", "tuple" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "tuple(result)" ], [ "LOAD_FAST", "n" ], [ "LOAD_DEREF", "node" ], [ "COMPARE_OP", "n != node" ] ], "tracer2.py": [ [ "LOAD_NAME", "find_repr_function" ], [ "LOAD_NAME", "six" ], [ "LOAD_ATTR", "six.text_type" ], [ "CALL_FUNCTION", "find_repr_function(six.text_type)" ], [ "LOAD_NAME", "find_repr_function" ], [ "LOAD_NAME", "six" ], [ "LOAD_ATTR", "six.binary_type" ], [ "CALL_FUNCTION", "find_repr_function(six.binary_type)" ], [ "LOAD_NAME", "find_repr_function" ], [ "LOAD_NAME", "object" ], [ "CALL_FUNCTION", "find_repr_function(object)" ], [ "LOAD_NAME", "find_repr_function" ], [ "LOAD_NAME", "int" ], [ "CALL_FUNCTION", "find_repr_function(int)" ], [ "LOAD_NAME", "cheap_repr" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "threading" ], [ "LOOKUP_METHOD", "threading.local" ], [ "CALL_METHOD", "threading.local()" ], [ "LOAD_NAME", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOOKUP_METHOD", "os.path.dirname" ], [ "LOAD_ATTR", "(lambda: 0).__code__" ], [ "LOAD_ATTR", "(lambda: 0).__code__.co_filename" ], [ "CALL_METHOD", "os.path.dirname((lambda: 0).__code__.co_filename)" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOOKUP_METHOD", "os.path.dirname" ], [ "LOAD_NAME", "birdseye" ], [ "LOAD_ATTR", "birdseye.__file__" ], [ "CALL_METHOD", "os.path.dirname(birdseye.__file__)" ], [ "LOAD_NAME", "type" ], [ "LOAD_NAME", "six" ], [ "LOOKUP_METHOD", "six.add_metaclass" ], [ "LOAD_NAME", "TracerMeta" ], [ "CALL_METHOD", "six.add_metaclass(TracerMeta)" ], [ "LOAD_NAME", "object" ], [ "CALL_FUNCTION", "six.add_metaclass(TracerMeta)" ], [ "LOAD_NAME", "object" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lineno" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "CALL_FUNCTION", "OrderedDict()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "Source" ], [ "LOOKUP_METHOD", "Source.for_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "Source.for_frame(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_flags" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.CO_GENERATOR" ], [ "BINARY_AND", "frame.f_code.co_flags & inspect.CO_GENERATOR" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "is_comprehension_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "is_comprehension_frame(frame)" ], [ "LOAD_GLOBAL", "re" ], [ "LOOKUP_METHOD", "re.match" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "CALL_METHOD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name)" ], [ "LOOKUP_METHOD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group" ], [ "CALL_METHOD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group(1)" ], [ "LOOKUP_METHOD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group(1).title" ], [ "CALL_METHOD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group(1).title()" ], [ "BINARY_ADD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group(1).title()\n + u' comprehension'" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_lineno" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.local_reprs" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.get_local_reprs" ], [ "LOAD_FAST", "watch" ], [ "LOAD_FAST", "watch_extras" ], [ "CALL_METHOD", "self.get_local_reprs(watch, watch_extras)" ], [ "CALL_FUNCTION", "OrderedDict(\n (source, my_cheap_repr(value))\n for source, value in\n self.get_local_reprs(watch, watch_extras)\n )" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.comprehension_type" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.local_reprs" ], [ "LOOKUP_METHOD", "self.local_reprs.items" ], [ "CALL_METHOD", "self.local_reprs.items()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.comprehension_variables" ], [ "LOOKUP_METHOD", "self.comprehension_variables.setdefault" ], [ "LOAD_FAST", "name" ], [ "CALL_METHOD", "self.comprehension_variables.setdefault(name, [])" ], [ "LOAD_FAST", "values" ], [ "LOAD_FAST", "values" ], [ "BINARY_SUBSCR", "values[-1]" ], [ "LOAD_FAST", "value_repr" ], [ "COMPARE_OP", "values[-1] != value_repr" ], [ "LOAD_FAST", "values" ], [ "LOOKUP_METHOD", "values.append" ], [ "LOAD_FAST", "value_repr" ], [ "CALL_METHOD", "values.append(value_repr)" ], [ "LOAD_GLOBAL", "truncate_list" ], [ "LOAD_FAST", "values" ], [ "CALL_FUNCTION", "truncate_list(values, 11)" ], [ "LOAD_FAST", "values" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event in ('return', 'exception')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.comprehension_variables" ], [ "LOOKUP_METHOD", "self.comprehension_variables.items" ], [ "CALL_METHOD", "self.comprehension_variables.items()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.local_reprs" ], [ "LOOKUP_METHOD", "self.local_reprs.items" ], [ "CALL_METHOD", "self.local_reprs.items()" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "old_local_reprs" ], [ "COMPARE_OP", "name not in old_local_reprs" ], [ "LOAD_FAST", "old_local_reprs" ], [ "LOAD_FAST", "name" ], [ "BINARY_SUBSCR", "old_local_reprs[name]" ], [ "LOAD_FAST", "value_repr" ], [ "COMPARE_OP", "old_local_reprs[name] != value_repr" ], [ "LOAD_FAST", "variables" ], [ "LOOKUP_METHOD", "variables.append" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "value_repr" ], [ "CALL_METHOD", "variables.append((name, value_repr))" ], [ "LOAD_FAST", "variables" ], [ "LOAD_FAST", "source" ], [ "LOAD_GLOBAL", "my_cheap_repr" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "my_cheap_repr(value)" ], [ "LOAD_FAST", "name" ], [ "LOOKUP_METHOD", "', '.join" ], [ "LOAD_FAST", "values" ], [ "CALL_METHOD", "', '.join(values)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_varnames" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_cellvars" ], [ "BINARY_ADD", "code.co_varnames + code.co_cellvars" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_freevars" ], [ "BINARY_ADD", "code.co_varnames + code.co_cellvars + code.co_freevars" ], [ "LOAD_GLOBAL", "tuple" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "LOOKUP_METHOD", "frame.f_locals.keys" ], [ "CALL_METHOD", "frame.f_locals.keys()" ], [ "CALL_FUNCTION", "tuple(frame.f_locals.keys())" ], [ "BINARY_ADD", "code.co_varnames + code.co_cellvars + code.co_freevars + tuple(frame.f_locals.keys())" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "LOOKUP_METHOD", "frame.f_locals.items" ], [ "CALL_METHOD", "frame.f_locals.items()" ], [ "CALL_FUNCTION", "sorted(\n frame.f_locals.items(),\n key=lambda key_value: vars_order.index(key_value[0])\n )" ], [ "LOAD_FAST", "watch" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_FAST", "variable" ], [ "LOOKUP_METHOD", "variable.items" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "variable.items(frame)" ], [ "CALL_FUNCTION", "sorted(variable.items(frame))" ], [ "LOAD_FAST", "result_items" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "watch_extras" ], [ "LOAD_FAST", "extra" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "extra(source, value)" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_FAST", "pair" ], [ "COMPARE_OP", "pair is not None" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "pair" ], [ "CALL_FUNCTION", "len(pair)" ], [ "COMPARE_OP", "len(pair) == 2" ], [ "LOAD_FAST", "pair" ], [ "LOAD_DEREF", "vars_order" ], [ "LOOKUP_METHOD", "vars_order.index" ], [ "LOAD_FAST", "key_value" ], [ "BINARY_SUBSCR", "key_value[0]" ], [ "CALL_METHOD", "vars_order.index(key_value[0])" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "TracerMeta" ], [ "LOAD_FAST", "mcs" ], [ "CALL_FUNCTION", "super(TracerMeta, mcs)" ], [ "LOAD_ATTR", "super(TracerMeta, mcs).__new__" ], [ "LOAD_FAST", "mcs" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "super(TracerMeta, mcs).__new__(mcs, *args, **kwargs)" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "result()" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "no_args_decorator" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION", "no_args_decorator(args, kwargs)" ], [ "LOAD_FAST", "cls" ], [ "LOOKUP_METHOD", "cls.default" ], [ "LOAD_FAST", "args" ], [ "BINARY_SUBSCR", "args[0]" ], [ "CALL_METHOD", "cls.default(args[0])" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "TracerMeta" ], [ "LOAD_FAST", "cls" ], [ "CALL_FUNCTION", "super(TracerMeta, cls)" ], [ "LOAD_ATTR", "super(TracerMeta, cls).__call__" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "super(TracerMeta, cls).__call__(*args, **kwargs)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.default" ], [ "LOOKUP_METHOD", "self.default.__enter__" ], [ "CALL_METHOD", "self.default.__enter__(context=1)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.default" ], [ "LOAD_ATTR", "self.default.__exit__" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION_VAR", "self.default.__exit__(*args, context=1)" ], [ "LOAD_GLOBAL", "ensure_tuple" ], [ "LOAD_FAST", "watch" ], [ "CALL_FUNCTION", "ensure_tuple(watch)" ], [ "LOAD_GLOBAL", "ensure_tuple" ], [ "LOAD_FAST", "watch_explode" ], [ "CALL_FUNCTION", "ensure_tuple(watch_explode)" ], [ "BINARY_ADD", "[\n v if isinstance(v, BaseVariable) else CommonVariable(v)\n for v in ensure_tuple(watch)\n ] + [\n v if isinstance(v, BaseVariable) else Exploding(v)\n for v in ensure_tuple(watch_explode)\n ]" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "ArgDefaultDict" ], [ "LOAD_GLOBAL", "FrameInfo" ], [ "CALL_FUNCTION", "ArgDefaultDict(FrameInfo)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "depth" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.depth" ], [ "COMPARE_OP", "self.depth >= 1" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "BaseVariable" ], [ "CALL_FUNCTION", "isinstance(v, BaseVariable)" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "CommonVariable" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "CommonVariable(v)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "BaseVariable" ], [ "CALL_FUNCTION", "isinstance(v, BaseVariable)" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "Exploding" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "Exploding(v)" ], [ "LOAD_GLOBAL", "iscoroutinefunction" ], [ "LOAD_DEREF", "function" ], [ "CALL_FUNCTION", "iscoroutinefunction(function)" ], [ "LOAD_GLOBAL", "NotImplementedError" ], [ "CALL_FUNCTION", "NotImplementedError(\"coroutines are not supported, sorry!\")" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.target_codes" ], [ "LOOKUP_METHOD", "self.target_codes.add" ], [ "LOAD_DEREF", "function" ], [ "LOAD_ATTR", "function.__code__" ], [ "CALL_METHOD", "self.target_codes.add(function.__code__)" ], [ "LOAD_GLOBAL", "functools" ], [ "LOOKUP_METHOD", "functools.wraps" ], [ "LOAD_DEREF", "function" ], [ "CALL_METHOD", "functools.wraps(function)" ], [ "CALL_FUNCTION", "functools.wraps(function)" ], [ "LOAD_GLOBAL", "functools" ], [ "LOOKUP_METHOD", "functools.wraps" ], [ "LOAD_DEREF", "function" ], [ "CALL_METHOD", "functools.wraps(function)" ], [ "CALL_FUNCTION", "functools.wraps(function)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.isgeneratorfunction" ], [ "LOAD_DEREF", "function" ], [ "CALL_METHOD", "inspect.isgeneratorfunction(function)" ], [ "LOAD_FAST", "generator_wrapper" ], [ "LOAD_FAST", "simple_wrapper" ], [ "LOAD_DEREF", "self" ], [ "LOAD_DEREF", "function" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "function(*args, **kwargs)" ], [ "LOAD_DEREF", "function" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "function(*args, **kwargs)" ], [ "LOAD_FAST", "gen" ], [ "LOAD_ATTR", "gen.send" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "method" ], [ "LOAD_FAST", "incoming" ], [ "CALL_FUNCTION", "method(incoming)" ], [ "LOAD_GLOBAL", "StopIteration" ], [ "LOAD_FAST", "gen" ], [ "LOAD_ATTR", "gen.send" ], [ "LOAD_FAST", "outgoing" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_FAST", "gen" ], [ "LOAD_ATTR", "gen.throw" ], [ "LOAD_FAST", "e" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.enabled" ], [ "LOAD_GLOBAL", "sys" ], [ "LOOKUP_METHOD", "sys._getframe" ], [ "LOAD_FAST", "context" ], [ "BINARY_ADD", "context + 1" ], [ "CALL_METHOD", "sys._getframe(context + 1)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._is_internal_frame" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_METHOD", "self._is_internal_frame(calling_frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.trace" ], [ "LOAD_FAST", "calling_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.target_frames" ], [ "LOOKUP_METHOD", "self.target_frames.add" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_METHOD", "self.target_frames.add(calling_frame)" ], [ "LOAD_FAST", "calling_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.trace" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_METHOD", "self.trace(calling_frame, 'enter', None)" ], [ "LOAD_GLOBAL", "thread_global" ], [ "LOAD_ATTR", "thread_global.__dict__" ], [ "LOOKUP_METHOD", "thread_global.__dict__.setdefault" ], [ "CALL_METHOD", "thread_global.__dict__.setdefault('original_trace_functions', [])" ], [ "LOAD_FAST", "stack" ], [ "LOOKUP_METHOD", "stack.append" ], [ "LOAD_GLOBAL", "sys" ], [ "LOOKUP_METHOD", "sys.gettrace" ], [ "CALL_METHOD", "sys.gettrace()" ], [ "CALL_METHOD", "stack.append(sys.gettrace())" ], [ "LOAD_GLOBAL", "sys" ], [ "LOOKUP_METHOD", "sys.settrace" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.trace" ], [ "CALL_METHOD", "sys.settrace(self.trace)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.enabled" ], [ "LOAD_GLOBAL", "thread_global" ], [ "LOAD_ATTR", "thread_global.original_trace_functions" ], [ "LOAD_GLOBAL", "sys" ], [ "LOOKUP_METHOD", "sys.settrace" ], [ "LOAD_FAST", "stack" ], [ "LOOKUP_METHOD", "stack.pop" ], [ "CALL_METHOD", "stack.pop()" ], [ "CALL_METHOD", "sys.settrace(stack.pop())" ], [ "LOAD_GLOBAL", "sys" ], [ "LOOKUP_METHOD", "sys._getframe" ], [ "LOAD_FAST", "context" ], [ "BINARY_ADD", "context + 1" ], [ "CALL_METHOD", "sys._getframe(context + 1)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.trace" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_METHOD", "self.trace(calling_frame, 'exit', None)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.target_frames" ], [ "LOOKUP_METHOD", "self.target_frames.discard" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_METHOD", "self.target_frames.discard(calling_frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame_infos" ], [ "LOOKUP_METHOD", "self.frame_infos.pop" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_METHOD", "self.frame_infos.pop(calling_frame, None)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_filename" ], [ "LOOKUP_METHOD", "frame.f_code.co_filename.startswith" ], [ "LOAD_GLOBAL", "internal_directories" ], [ "CALL_METHOD", "frame.f_code.co_filename.startswith(internal_directories)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.target_codes" ], [ "COMPARE_OP", "frame.f_code in self.target_codes" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.target_frames" ], [ "COMPARE_OP", "frame in self.target_frames" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._is_traced_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self._is_traced_frame(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.depth" ], [ "COMPARE_OP", "self.depth == 1" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._is_internal_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self._is_internal_frame(frame)" ], [ "LOAD_GLOBAL", "is_comprehension_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "is_comprehension_frame(frame)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_GLOBAL", "is_comprehension_frame" ], [ "LOAD_FAST", "candidate" ], [ "CALL_FUNCTION", "is_comprehension_frame(candidate)" ], [ "LOAD_FAST", "candidate" ], [ "LOAD_ATTR", "candidate.f_back" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._is_traced_frame" ], [ "LOAD_FAST", "candidate" ], [ "CALL_METHOD", "self._is_traced_frame(candidate)" ], [ "LOAD_FAST", "candidate" ], [ "LOAD_ATTR", "candidate.f_back" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.depth" ], [ "COMPARE_OP", "i >= self.depth" ], [ "LOAD_FAST", "candidate" ], [ "COMPARE_OP", "candidate is None" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._is_internal_frame" ], [ "LOAD_FAST", "candidate" ], [ "CALL_METHOD", "self._is_internal_frame(candidate)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.thread_local" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_ATTR", "thread_local.__dict__" ], [ "LOOKUP_METHOD", "thread_local.__dict__.setdefault" ], [ "CALL_METHOD", "thread_local.__dict__.setdefault('depth', -1)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame_infos" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.frame_infos[frame]" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event in ('call', 'enter')" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.last_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.last_frame" ], [ "LOAD_FAST", "frame" ], [ "COMPARE_OP", "self.config.last_frame is not frame" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.last_line_no" ], [ "LOAD_GLOBAL", "Event" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "event" ], [ "LOAD_FAST", "arg" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_ATTR", "thread_local.depth" ], [ "LOAD_FAST", "line_no" ], [ "CALL_FUNCTION", "Event(frame_info, event, arg, thread_local.depth, line_no=line_no)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.formatter" ], [ "LOOKUP_METHOD", "self.config.formatter.format_line_only" ], [ "LOAD_FAST", "trace_event" ], [ "CALL_METHOD", "self.config.formatter.format_line_only(trace_event)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOOKUP_METHOD", "self.config.write" ], [ "LOAD_FAST", "line" ], [ "CALL_METHOD", "self.config.write(line)" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event == 'exception'" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_GLOBAL", "Event" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "event" ], [ "LOAD_FAST", "arg" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_ATTR", "thread_local.depth" ], [ "CALL_FUNCTION", "Event(frame_info, event, arg, thread_local.depth)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "COMPARE_OP", "frame.f_code.co_name == ''" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event not in ('return', 'exception')" ], [ "LOAD_FAST", "frame_info" ], [ "LOOKUP_METHOD", "frame_info.update_variables" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.watch" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.watch_extras" ], [ "LOAD_FAST", "event" ], [ "CALL_METHOD", "frame_info.update_variables(\n self.watch,\n self.config.watch_extras,\n event,\n )" ], [ "LOAD_FAST", "trace_event" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event in ('return', 'exit')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame_infos" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.formatter" ], [ "LOOKUP_METHOD", "self.config.formatter.format" ], [ "LOAD_FAST", "trace_event" ], [ "CALL_METHOD", "self.config.formatter.format(trace_event)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOOKUP_METHOD", "self.config.write" ], [ "LOAD_FAST", "formatted" ], [ "CALL_METHOD", "self.config.write(formatted)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.trace" ], [ "LOAD_FAST", "config" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "NO_ASTTOKENS" ], [ "LOAD_GLOBAL", "Exception" ], [ "CALL_FUNCTION", "Exception(\"birdseye doesn't support this version of Python\")" ], [ "LOAD_GLOBAL", "ImportError" ], [ "LOAD_GLOBAL", "Exception" ], [ "CALL_FUNCTION", "Exception(\"You must install birdseye separately to use spy: pip install birdseye\")" ], [ "LOAD_GLOBAL", "no_args_decorator" ], [ "LOAD_DEREF", "args" ], [ "LOAD_DEREF", "kwargs" ], [ "CALL_FUNCTION", "no_args_decorator(args, kwargs)" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self._trace" ], [ "LOAD_DEREF", "args" ], [ "BINARY_SUBSCR", "args[0]" ], [ "CALL_METHOD", "self._trace(args[0])" ], [ "LOAD_FAST", "decorator" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._trace" ], [ "LOAD_FAST", "func" ], [ "LOAD_DEREF", "args" ], [ "LOAD_DEREF", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "self._trace(func, *args, **kwargs)" ], [ "LOAD_FAST", "eye" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "eye(func)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.snoop" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "self.config.snoop(*args, **kwargs)" ], [ "LOAD_DEREF", "traced" ], [ "CALL_FUNCTION", "self.config.snoop(*args, **kwargs)(traced)" ], [ "LOAD_GLOBAL", "functools" ], [ "LOOKUP_METHOD", "functools.wraps" ], [ "LOAD_DEREF", "func" ], [ "CALL_METHOD", "functools.wraps(func)" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "LOAD_FAST", "wrapper" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.enabled" ], [ "LOAD_DEREF", "traced" ], [ "LOAD_DEREF", "func" ], [ "LOAD_FAST", "final_func" ], [ "LOAD_FAST", "func_args" ], [ "LOAD_FAST", "func_kwargs" ], [ "CALL_FUNCTION_VAR_KW", "final_func(*func_args, **func_kwargs)" ] ], "utils.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOOKUP_METHOD", "standard_library.install_aliases" ], [ "CALL_METHOD", "standard_library.install_aliases()" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "type" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "version_info" ], [ "LOAD_ATTR", "version_info.major" ], [ "COMPARE_OP", "version_info.major == 2" ], [ "LOAD_NAME", "PY2" ], [ "UNARY_NOT", "not PY2" ], [ "LOAD_NAME", "TypeVar" ], [ "CALL_FUNCTION", "TypeVar('T')" ], [ "LOAD_NAME", "TypeVar" ], [ "CALL_FUNCTION", "TypeVar('RT')" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "unicode" ], [ "LOAD_NAME", "str" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "type" ], [ "LOAD_NAME", "json" ], [ "LOAD_ATTR", "json.JSONEncoder" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_GLOBAL", "ntpath" ], [ "LOOKUP_METHOD", "ntpath.split" ], [ "LOAD_FAST", "path" ], [ "CALL_METHOD", "ntpath.split(path)" ], [ "LOAD_FAST", "tail" ], [ "LOAD_GLOBAL", "ntpath" ], [ "LOOKUP_METHOD", "ntpath.basename" ], [ "LOAD_FAST", "head" ], [ "CALL_METHOD", "ntpath.basename(head)" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOOKUP_METHOD", "os.path.commonprefix" ], [ "LOAD_FAST", "paths" ], [ "CALL_METHOD", "os.path.commonprefix(paths)" ], [ "LOAD_GLOBAL", "ntpath" ], [ "LOOKUP_METHOD", "ntpath.split" ], [ "LOAD_FAST", "prefix" ], [ "CALL_METHOD", "ntpath.split(prefix)" ], [ "BINARY_SUBSCR", "ntpath.split(prefix)[0]" ], [ "LOAD_FAST", "paths" ], [ "BINARY_SUBSCR", "paths[0]" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "prefix" ], [ "CALL_FUNCTION", "len(prefix)" ], [ "BINARY_SUBSCR", "paths[0][len(prefix)]" ], [ "LOAD_FAST", "first_char_after" ], [ "COMPARE_OP", "first_char_after in r'\\/'" ], [ "LOAD_FAST", "first_char_after" ], [ "LOAD_FAST", "prefix" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "COMPARE_OP", "path == IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "all_paths" ], [ "LOAD_GLOBAL", "common_ancestor" ], [ "LOAD_FAST", "all_paths" ], [ "CALL_FUNCTION", "common_ancestor(all_paths)" ], [ "LOAD_FAST", "prefix" ], [ "COMPARE_OP", "prefix in r'\\/'" ], [ "LOAD_GLOBAL", "strip_required_prefix" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "prefix" ], [ "CALL_FUNCTION", "strip_required_prefix(path, prefix)" ], [ "LOAD_GLOBAL", "path_leaf" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "path_leaf(path)" ], [ "LOAD_FAST", "f" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "COMPARE_OP", "f != IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "f" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "COMPARE_OP", "path == IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.sep" ], [ "COMPARE_OP", "os.path.sep == '/'" ], [ "LOAD_FAST", "path" ], [ "LOOKUP_METHOD", "path.startswith" ], [ "CALL_METHOD", "path.startswith('/')" ], [ "LOAD_FAST", "path" ], [ "BINARY_ADD", "'/' + path" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "type" ], [ "LOAD_FAST", "obj" ], [ "CALL_FUNCTION", "type(obj)" ], [ "LOAD_FAST", "t" ], [ "LOAD_GLOBAL", "types" ], [ "LOAD_ATTR", "types.InstanceType" ], [ "COMPARE_OP", "t is types.InstanceType" ], [ "LOAD_FAST", "obj" ], [ "LOAD_ATTR", "obj.__class__" ], [ "LOAD_FAST", "t" ], [ "LOAD_FAST", "iterable" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_DEREF", "type_or_tuple" ], [ "CALL_FUNCTION", "isinstance(x, type_or_tuple)" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "next" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "next(it)" ], [ "LOAD_GLOBAL", "StopIteration" ], [ "LOAD_GLOBAL", "raise_from" ], [ "LOAD_GLOBAL", "RuntimeError" ], [ "LOAD_FAST", "e" ], [ "CALL_FUNCTION", "raise_from(RuntimeError, e)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "expression" ], [ "CALL_FUNCTION", "hasattr(expression, 'one_or_none')" ], [ "LOAD_FAST", "expression" ], [ "LOOKUP_METHOD", "expression.one_or_none" ], [ "CALL_METHOD", "expression.one_or_none()" ], [ "LOAD_FAST", "expression" ], [ "LOOKUP_METHOD", "expression.all" ], [ "CALL_METHOD", "expression.all()" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "len(result)" ], [ "COMPARE_OP", "len(result) == 0" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "len(result)" ], [ "COMPARE_OP", "len(result) == 1" ], [ "LOAD_FAST", "result" ], [ "BINARY_SUBSCR", "result[0]" ], [ "LOAD_GLOBAL", "Exception" ], [ "CALL_FUNCTION", "Exception(\"There is more than one item returned for the supplied filter\")" ], [ "LOAD_FAST", "lst" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "isinstance(x, list)" ], [ "LOAD_FAST", "result" ], [ "LOOKUP_METHOD", "result.extend" ], [ "LOAD_GLOBAL", "flatten_list" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "flatten_list(x)" ], [ "CALL_METHOD", "result.extend(flatten_list(x))" ], [ "LOAD_FAST", "result" ], [ "LOOKUP_METHOD", "result.append" ], [ "LOAD_FAST", "x" ], [ "CALL_METHOD", "result.append(x)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "f" ], [ "LOAD_ATTR", "f.__code__" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "LOAD_ATTR", "(lambda: 0).__code__" ], [ "LOAD_ATTR", "(lambda: 0).__code__.co_name" ], [ "COMPARE_OP", "code.co_name == (lambda: 0).__code__.co_name" ], [ "LOAD_FAST", "o" ], [ "LOAD_ATTR", "o.as_json" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "ProtocolEncoder" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(ProtocolEncoder, self)" ], [ "LOOKUP_METHOD", "super(ProtocolEncoder, self).default" ], [ "LOAD_FAST", "o" ], [ "CALL_METHOD", "super(ProtocolEncoder, self).default(o)" ], [ "LOAD_FAST", "method" ], [ "CALL_FUNCTION", "method()" ], [ "LOAD_GLOBAL", "io" ], [ "LOOKUP_METHOD", "io.open" ], [ "LOAD_FAST", "filename" ], [ "CALL_METHOD", "io.open(filename, 'rb')" ], [ "LOAD_GLOBAL", "detect_encoding" ], [ "LOAD_FAST", "fp" ], [ "LOAD_ATTR", "fp.readline" ], [ "CALL_FUNCTION", "detect_encoding(fp.readline)" ], [ "LOAD_FAST", "fp" ], [ "LOOKUP_METHOD", "fp.seek" ], [ "CALL_METHOD", "fp.seek(0)" ], [ "LOAD_GLOBAL", "io" ], [ "LOOKUP_METHOD", "io.TextIOWrapper" ], [ "LOAD_FAST", "fp" ], [ "LOAD_FAST", "encoding" ], [ "CALL_METHOD", "io.TextIOWrapper(fp, encoding, line_buffering=True)" ], [ "LOAD_FAST", "text" ], [ "LOAD_FAST", "text" ], [ "LOAD_FAST", "fp" ], [ "LOOKUP_METHOD", "fp.close" ], [ "CALL_METHOD", "fp.close()" ], [ "LOAD_FAST", "filename" ], [ "LOOKUP_METHOD", "filename.endswith" ], [ "CALL_METHOD", "filename.endswith('.pyc')" ], [ "LOAD_FAST", "filename" ], [ "BINARY_SUBSCR", "filename[:-1]" ], [ "LOAD_GLOBAL", "open_with_encoding_check" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "open_with_encoding_check(filename)" ], [ "LOOKUP_METHOD", "''.join" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "f" ], [ "CALL_FUNCTION", "enumerate(f)" ], [ "CALL_METHOD", "''.join([\n '\\n' if i < 2 and cookie_re.match(line)\n else line\n for i, line in enumerate(f)\n ])" ], [ "LOAD_FAST", "i" ], [ "COMPARE_OP", "i < 2" ], [ "LOAD_DEREF", "cookie_re" ], [ "LOOKUP_METHOD", "cookie_re.match" ], [ "LOAD_FAST", "line" ], [ "CALL_METHOD", "cookie_re.match(line)" ], [ "LOAD_FAST", "line" ], [ "LOAD_GLOBAL", "safe_next" ], [ "LOAD_FAST", "tokens" ], [ "LOOKUP_METHOD", "tokens.get_tokens" ], [ "LOAD_FAST", "function_node" ], [ "CALL_METHOD", "tokens.get_tokens(function_node)" ], [ "CALL_FUNCTION", "safe_next(t for t in tokens.get_tokens(function_node)\n if t.string == 'def' and t.type == token.NAME)" ], [ "LOAD_FAST", "def_token" ], [ "LOAD_ATTR", "def_token.startpos" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_ATTR", "tokens.text" ], [ "LOAD_FAST", "startpos" ], [ "LOAD_FAST", "function_node" ], [ "LOAD_ATTR", "function_node.last_token" ], [ "LOAD_ATTR", "function_node.last_token.endpos" ], [ "BINARY_SUBSCR", "tokens.text[startpos:function_node.last_token.endpos]" ], [ "LOOKUP_METHOD", "tokens.text[startpos:function_node.last_token.endpos].rstrip" ], [ "CALL_METHOD", "tokens.text[startpos:function_node.last_token.endpos].rstrip()" ], [ "LOAD_FAST", "source" ], [ "LOOKUP_METHOD", "source.startswith" ], [ "CALL_METHOD", "source.startswith('def')" ], [ "LOAD_FAST", "startpos" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "t" ], [ "LOAD_ATTR", "t.string" ], [ "COMPARE_OP", "t.string == 'def'" ], [ "LOAD_FAST", "t" ], [ "LOAD_ATTR", "t.type" ], [ "LOAD_GLOBAL", "token" ], [ "LOAD_ATTR", "token.NAME" ], [ "COMPARE_OP", "t.type == token.NAME" ], [ "LOAD_FAST", "t" ], [ "LOAD_FAST", "args" ], [ "LOAD_GLOBAL", "print" ], [ "LOAD_FAST", "arg" ], [ "CALL_FUNCTION", "print(arg)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION", "len(args)" ], [ "COMPARE_OP", "len(args) == 1" ], [ "LOAD_FAST", "args" ], [ "BINARY_SUBSCR", "args[0]" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "filename" ], [ "LOOKUP_METHOD", "filename.startswith" ], [ "CALL_METHOD", "filename.startswith(' max_length" ], [ "LOAD_FAST", "max_length" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "middle" ], [ "CALL_FUNCTION", "len(middle)" ], [ "BINARY_SUBTRACT", "max_length - len(middle)" ], [ "BINARY_FLOOR_DIVIDE", "(max_length - len(middle)) // 2" ], [ "LOAD_FAST", "max_length" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "middle" ], [ "CALL_FUNCTION", "len(middle)" ], [ "BINARY_SUBTRACT", "max_length - len(middle)" ], [ "LOAD_FAST", "left" ], [ "BINARY_SUBTRACT", "max_length - len(middle) - left" ], [ "LOAD_FAST", "seq" ], [ "LOAD_FAST", "left" ], [ "BINARY_SUBSCR", "seq[:left]" ], [ "LOAD_FAST", "middle" ], [ "BINARY_ADD", "seq[:left] + middle" ], [ "LOAD_FAST", "seq" ], [ "LOAD_FAST", "right" ], [ "UNARY_NEGATIVE", "-right" ], [ "BINARY_SUBSCR", "seq[-right:]" ], [ "BINARY_ADD", "seq[:left] + middle + seq[-right:]" ], [ "LOAD_FAST", "seq" ], [ "LOAD_GLOBAL", "truncate" ], [ "LOAD_FAST", "string" ], [ "LOAD_FAST", "max_length" ], [ "CALL_FUNCTION", "truncate(string, max_length, '...')" ], [ "LOAD_GLOBAL", "truncate" ], [ "LOAD_FAST", "lst" ], [ "LOAD_FAST", "max_length" ], [ "CALL_FUNCTION", "truncate(lst, max_length, ['...'])" ], [ "LOAD_FAST", "split" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "six" ], [ "LOAD_ATTR", "six.string_types" ], [ "CALL_FUNCTION", "isinstance(x, six.string_types)" ], [ "LOAD_FAST", "x" ], [ "LOOKUP_METHOD", "x.replace" ], [ "CALL_METHOD", "x.replace(',', ' ')" ], [ "LOOKUP_METHOD", "x.replace(',', ' ').split" ], [ "CALL_METHOD", "x.replace(',', ' ').split()" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "set" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "isinstance(x, (list, set, tuple))" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "tuple" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tuple(x)" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOOKUP_METHOD", "os.path.basename" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_filename" ], [ "CALL_METHOD", "os.path.basename(code.co_filename)" ], [ "LOAD_FAST", "result" ], [ "LOOKUP_METHOD", "result.endswith" ], [ "CALL_METHOD", "result.endswith('.pyc')" ], [ "LOAD_FAST", "result" ], [ "BINARY_SUBSCR", "result[:-1]" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "COMPARE_OP", "frame.f_code.co_name in ('', '', '')" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "code('{}.x')" ], [ "LOAD_GLOBAL", "SyntaxError" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "code('({})')" ], [ "LOAD_FAST", "without_parens" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "code('({}).x')" ], [ "COMPARE_OP", "without_parens != code('({}).x')" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "s" ], [ "LOOKUP_METHOD", "s.format" ], [ "LOAD_DEREF", "source" ], [ "CALL_METHOD", "s.format(source)" ], [ "CALL_FUNCTION", "compile(s.format(source), '', 'eval')" ], [ "LOAD_ATTR", "compile(s.format(source), '', 'eval').co_code" ], [ "LOAD_GLOBAL", "needs_parentheses" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "needs_parentheses(source)" ], [ "LOOKUP_METHOD", "'({})'.format" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "'({})'.format(source)" ], [ "LOAD_FAST", "source" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "REPR_TARGET_LENGTH" ], [ "CALL_FUNCTION", "cheap_repr(x, target_length=REPR_TARGET_LENGTH)" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "ArgDefaultDict" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(ArgDefaultDict, self)" ], [ "LOOKUP_METHOD", "super(ArgDefaultDict, self).__init__" ], [ "CALL_METHOD", "super(ArgDefaultDict, self).__init__()" ], [ "LOAD_FAST", "factory" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.factory" ], [ "LOAD_FAST", "key" ], [ "CALL_METHOD", "self.factory(key)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "key" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "lst" ], [ "CALL_FUNCTION", "len(lst)" ], [ "COMPARE_OP", "len(lst) == 1" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "CALL_FUNCTION", "str(i + 1)" ], [ "BINARY_ADD", "' ' + str(i + 1)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_GLOBAL", "os" ], [ "CALL_FUNCTION", "hasattr(os, 'PathLike')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.PathLike" ], [ "CALL_FUNCTION", "isinstance(x, os.PathLike)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "hasattr(x, '__fspath__')" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "hasattr(x, 'open')" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.__class__" ], [ "LOAD_ATTR", "x.__class__.__name__" ], [ "LOOKUP_METHOD", "x.__class__.__name__.lower" ], [ "CALL_METHOD", "x.__class__.__name__.lower()" ], [ "COMPARE_OP", "'path' in x.__class__.__name__.lower()" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION", "len(args)" ], [ "COMPARE_OP", "len(args) == 1" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.isfunction" ], [ "LOAD_FAST", "args" ], [ "BINARY_SUBSCR", "args[0]" ], [ "CALL_METHOD", "inspect.isfunction(args[0])" ], [ "LOAD_FAST", "kwargs" ], [ "UNARY_NOT", "not kwargs" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_ADD", "max_length + 2" ], [ "COMPARE_OP", "length <= max_length + 2" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "range(length)" ], [ "LOAD_GLOBAL", "chain" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_FLOOR_DIVIDE", "max_length // 2" ], [ "CALL_FUNCTION", "range(max_length // 2)" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_FLOOR_DIVIDE", "max_length // 2" ], [ "BINARY_SUBTRACT", "length - max_length // 2" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "range(length - max_length // 2,\n length)" ], [ "CALL_FUNCTION", "chain(range(max_length // 2),\n range(length - max_length // 2,\n length))" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "len(x)" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "n == 0" ], [ "LOAD_GLOBAL", "repr" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "repr(x)" ], [ "LOAD_FAST", "helper" ], [ "LOAD_ATTR", "helper.level" ], [ "BINARY_SUBTRACT", "helper.level - 1" ], [ "LOAD_GLOBAL", "_repr_series_one_line" ], [ "LOAD_ATTR", "_repr_series_one_line.maxparts" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "n" ], [ "LOAD_FAST", "maxparts" ], [ "CALL_FUNCTION", "_sample_indices(n, maxparts)" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.index" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "x.index[i:i + 1]" ], [ "LOOKUP_METHOD", "x.index[i:i + 1].format" ], [ "CALL_METHOD", "x.index[i:i + 1].format(sparsify=False)" ], [ "BINARY_SUBSCR", "x.index[i:i + 1].format(sparsify=False)[0]" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.iloc" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "x.iloc[i]" ], [ "LOAD_FAST", "pieces" ], [ "LOOKUP_METHOD", "pieces.append" ], [ "LOAD_FAST", "k" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "v" ], [ "LOAD_FAST", "newlevel" ], [ "CALL_FUNCTION", "cheap_repr(v, newlevel)" ], [ "BINARY_MODULO", "'%s = %s' % (k, cheap_repr(v, newlevel))" ], [ "CALL_METHOD", "pieces.append('%s = %s' % (k, cheap_repr(v, newlevel)))" ], [ "LOAD_FAST", "n" ], [ "LOAD_FAST", "maxparts" ], [ "BINARY_ADD", "maxparts + 2" ], [ "COMPARE_OP", "n > maxparts + 2" ], [ "LOAD_FAST", "pieces" ], [ "LOOKUP_METHOD", "pieces.insert" ], [ "LOAD_FAST", "maxparts" ], [ "BINARY_FLOOR_DIVIDE", "maxparts // 2" ], [ "CALL_METHOD", "pieces.insert(maxparts // 2, '...')" ], [ "LOOKUP_METHOD", "'; '.join" ], [ "LOAD_FAST", "pieces" ], [ "CALL_METHOD", "'; '.join(pieces)" ] ] }executing-0.8.0/tests/sample_results/pypy3.6.json000066400000000000000000021434021410133640400220430ustar00rootroot00000000000000{ "bird.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOOKUP_METHOD", "standard_library.install_aliases" ], [ "CALL_METHOD", "standard_library.install_aliases()" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "warn_if_outdated" ], [ "LOAD_NAME", "__version__" ], [ "CALL_FUNCTION", "warn_if_outdated('birdseye', __version__)" ], [ "LOAD_NAME", "namedtuple" ], [ "CALL_FUNCTION", "namedtuple('CodeInfo', 'db_func traced_file arg_names')" ], [ "LOAD_NAME", "TreeTracerBase" ], [ "LOAD_NAME", "BirdsEye" ], [ "CALL_FUNCTION", "BirdsEye()" ], [ "LOAD_NAME", "NamedTuple" ], [ "LOAD_NAME", "int" ], [ "LOAD_NAME", "bool" ], [ "LOAD_NAME", "int" ], [ "LOAD_NAME", "str" ], [ "CALL_FUNCTION", "NamedTuple('HTMLPosition', [\n ('index', int),\n ('is_start', bool),\n ('depth', int),\n ('html', str),\n])" ], [ "LOAD_NAME", "eye" ], [ "LOAD_ATTR", "eye.enter_call" ], [ "LOAD_ATTR", "eye.enter_call.__code__" ], [ "LOAD_NAME", "eye" ], [ "LOAD_ATTR", "eye.exit_call" ], [ "LOAD_ATTR", "eye.exit_call.__code__" ], [ "LOAD_NAME", "eye" ], [ "LOAD_ATTR", "eye.after_expr" ], [ "LOAD_ATTR", "eye.after_expr.__code__" ], [ "LOAD_NAME", "eye" ], [ "LOAD_ATTR", "eye.after_stmt" ], [ "LOAD_ATTR", "eye.after_stmt.__code__" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "Iterable" ], [ "LOAD_NAME", "Iteration" ], [ "BINARY_SUBSCR", "Iterable[Iteration]" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "TypeRegistry" ], [ "CALL_FUNCTION", "TypeRegistry()" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "try_register_repr" ], [ "CALL_FUNCTION", "try_register_repr('pandas', 'Series')" ], [ "CALL_FUNCTION", "try_register_repr('pandas', 'Series')" ], [ "LOAD_NAME", "cached_property" ], [ "CALL_FUNCTION", "cached_property" ], [ "LOAD_NAME", "lru_cache" ], [ "CALL_FUNCTION", "lru_cache()" ], [ "CALL_FUNCTION", "lru_cache()" ], [ "LOAD_NAME", "retry_db" ], [ "CALL_FUNCTION", "retry_db" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "BirdsEye" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(BirdsEye, self)" ], [ "LOOKUP_METHOD", "super(BirdsEye, self).__init__" ], [ "CALL_METHOD", "super(BirdsEye, self).__init__()" ], [ "LOAD_FAST", "db_uri" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "num_samples" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "dict" ], [ "CALL_FUNCTION", "dict(\n attributes=50,\n dict=50,\n list=30,\n set=30,\n pandas_rows=20,\n pandas_cols=100,\n )" ], [ "LOAD_GLOBAL", "dict" ], [ "CALL_FUNCTION", "dict(\n attributes=50,\n dict=10,\n list=6,\n set=6,\n pandas_rows=6,\n pandas_cols=10,\n )" ], [ "CALL_FUNCTION", "dict(\n big=dict(\n attributes=50,\n dict=50,\n list=30,\n set=30,\n pandas_rows=20,\n pandas_cols=100,\n ),\n small=dict(\n attributes=50,\n dict=10,\n list=6,\n set=6,\n pandas_rows=6,\n pandas_cols=10,\n ),\n )" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "Database" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._db_uri" ], [ "CALL_FUNCTION", "Database(self._db_uri)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.walk" ], [ "LOAD_FAST", "root" ], [ "CALL_METHOD", "ast.walk(root)" ], [ "LOAD_GLOBAL", "tracer" ], [ "LOOKUP_METHOD", "tracer.loops" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "tracer.loops(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "CALL_FUNCTION", "isinstance(node, ast.expr)" ], [ "LOAD_GLOBAL", "is_interesting_expression" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "is_interesting_expression(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "BirdsEye" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(BirdsEye, self)" ], [ "LOOKUP_METHOD", "super(BirdsEye, self).compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "flags" ], [ "CALL_METHOD", "super(BirdsEye, self).compile(source, filename, flags)" ], [ "LOAD_GLOBAL", "ASTTokens" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.root" ], [ "CALL_FUNCTION", "ASTTokens(source, tree=traced_file.root)" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.For)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.body" ], [ "BINARY_SUBSCR", "node.parent.body[0]" ], [ "COMPARE_OP", "node is node.parent.body[0]" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._add_iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self._add_iteration(node._loops, frame)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.While)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.test" ], [ "COMPARE_OP", "node is node.parent.test" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._add_iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self._add_iteration(node._loops, frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_ATTR", "self.stack[frame].iteration" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "loops" ], [ "CALL_FUNCTION", "enumerate(loops)" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.loops" ], [ "LOAD_FAST", "loop_node" ], [ "LOAD_ATTR", "loop_node._tree_index" ], [ "BINARY_SUBSCR", "iteration.loops[loop_node._tree_index]" ], [ "LOAD_FAST", "i" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "loops" ], [ "CALL_FUNCTION", "len(loops)" ], [ "BINARY_SUBTRACT", "len(loops) - 1" ], [ "COMPARE_OP", "i == len(loops) - 1" ], [ "LOAD_FAST", "loop" ], [ "LOOKUP_METHOD", "loop.append" ], [ "LOAD_GLOBAL", "Iteration" ], [ "CALL_FUNCTION", "Iteration()" ], [ "CALL_METHOD", "loop.append(Iteration())" ], [ "LOAD_FAST", "loop" ], [ "LOOKUP_METHOD", "loop.last" ], [ "CALL_METHOD", "loop.last()" ], [ "LOAD_GLOBAL", "_tracing_recursively" ], [ "LOAD_DEREF", "frame" ], [ "CALL_FUNCTION", "_tracing_recursively(frame)" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._is_interesting_expression" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "BINARY_SUBSCR", "self._code_infos[frame.f_code]" ], [ "LOAD_ATTR", "self._code_infos[frame.f_code].traced_file" ], [ "LOAD_ATTR", "self._code_infos[frame.f_code].traced_file.is_ipython_cell" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Expr" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.Expr)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.parent" ], [ "LOAD_ATTR", "node.parent.parent.body" ], [ "BINARY_SUBSCR", "node.parent.parent.body[-1]" ], [ "COMPARE_OP", "node.parent is node.parent.parent.body[-1]" ], [ "LOAD_DEREF", "value" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "is_obvious_builtin" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_DEREF", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_ATTR", "self.stack[frame].expression_values" ], [ "LOAD_FAST", "node" ], [ "BINARY_SUBSCR", "self.stack[frame].expression_values[node]" ], [ "CALL_FUNCTION", "is_obvious_builtin(node, self.stack[frame].expression_values[node])" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_DEREF", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_FAST", "exc_value" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self._exception_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_FAST", "exc_value" ], [ "CALL_METHOD", "self._exception_value(node, frame, exc_value)" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOOKUP_METHOD", "NodeValue.expression" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.num_samples" ], [ "LOAD_DEREF", "value" ], [ "LOAD_GLOBAL", "max" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "CALL_FUNCTION", "len(node._loops)" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self._is_first_loop_iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "frame" ], [ "CALL_METHOD", "self._is_first_loop_iteration(node, frame)" ], [ "UNARY_NOT", "not self._is_first_loop_iteration(node, frame)" ], [ "BINARY_MULTIPLY", "len(node._loops) * (not self._is_first_loop_iteration(node, frame))" ], [ "BINARY_SUBTRACT", "3 - len(node._loops) * (not self._is_first_loop_iteration(node, frame))" ], [ "CALL_FUNCTION", "max(1, 3 - len(node._loops) * (not self._is_first_loop_iteration(node, frame)))" ], [ "CALL_METHOD", "NodeValue.expression(\n self.num_samples,\n value,\n level=max(1, 3 - len(node._loops) * (not self._is_first_loop_iteration(node, frame))),\n )" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self._set_node_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_FAST", "node_value" ], [ "CALL_METHOD", "self._set_node_value(node, frame, node_value)" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self._check_inner_call" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node_value" ], [ "CALL_METHOD", "self._check_inner_call(frame_info, node, node_value)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.comprehension)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.iter" ], [ "COMPARE_OP", "node is node.parent.iter" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_ATTR", "node.parent.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.GeneratorExp" ], [ "CALL_FUNCTION", "isinstance(node.parent.parent, ast.GeneratorExp)" ], [ "UNARY_NOT", "not isinstance(node.parent.parent, ast.GeneratorExp)" ], [ "LOAD_FAST", "is_special_comprehension_iter" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self._set_node_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_DEREF", "frame" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOOKUP_METHOD", "NodeValue.covered" ], [ "CALL_METHOD", "NodeValue.covered()" ], [ "CALL_METHOD", "self._set_node_value(node.parent, frame, NodeValue.covered())" ], [ "LOAD_FAST", "exc_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "BINARY_ADD", "node._loops + (node.parent,)" ], [ "LOAD_GLOBAL", "ChangeValue" ], [ "LOAD_FAST", "comprehension_iter_proxy" ], [ "CALL_FUNCTION", "comprehension_iter_proxy()" ], [ "CALL_FUNCTION", "ChangeValue(comprehension_iter_proxy())" ], [ "LOAD_DEREF", "value" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self._add_iteration" ], [ "LOAD_DEREF", "loops" ], [ "LOAD_DEREF", "frame" ], [ "CALL_METHOD", "self._add_iteration(loops, frame)" ], [ "LOAD_FAST", "item" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.inner_calls" ], [ "LOOKUP_METHOD", "frame_info.inner_calls.pop" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "frame_info.inner_calls.pop(node, None)" ], [ "LOAD_FAST", "inner_calls" ], [ "LOAD_FAST", "node_value" ], [ "LOOKUP_METHOD", "node_value.set_meta" ], [ "LOAD_FAST", "inner_calls" ], [ "CALL_METHOD", "node_value.set_meta('inner_calls', inner_calls)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_ATTR", "self.stack[frame].iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.loops" ], [ "LOAD_FAST", "loop_node" ], [ "LOAD_ATTR", "loop_node._tree_index" ], [ "BINARY_SUBSCR", "iteration.loops[loop_node._tree_index]" ], [ "LOAD_FAST", "loop" ], [ "LOOKUP_METHOD", "loop.last" ], [ "CALL_METHOD", "loop.last()" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.index" ], [ "COMPARE_OP", "iteration.index > 0" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_ATTR", "self.stack[frame].iteration" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.loops" ], [ "LOAD_FAST", "loop_node" ], [ "LOAD_ATTR", "loop_node._tree_index" ], [ "BINARY_SUBSCR", "iteration.loops[loop_node._tree_index]" ], [ "LOAD_FAST", "loop" ], [ "LOOKUP_METHOD", "loop.recorded_node" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "loop.recorded_node(node)" ], [ "LOAD_FAST", "loop" ], [ "LOOKUP_METHOD", "loop.last" ], [ "CALL_METHOD", "loop.last()" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.vals" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOOKUP_METHOD", "NodeValue.exception" ], [ "LOAD_FAST", "exc_value" ], [ "CALL_METHOD", "NodeValue.exception(exc_value)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._set_node_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "value" ], [ "CALL_METHOD", "self._set_node_value(node, frame, value)" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_GLOBAL", "_tracing_recursively" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "_tracing_recursively(frame)" ], [ "LOAD_FAST", "exc_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "exc_node" ], [ "COMPARE_OP", "node is exc_node" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._exception_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "exc_value" ], [ "CALL_METHOD", "self._exception_value(node, frame, exc_value)" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOOKUP_METHOD", "NodeValue.covered" ], [ "CALL_METHOD", "NodeValue.covered()" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._set_node_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "value" ], [ "CALL_METHOD", "self._set_node_value(node, frame, value)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._check_inner_call" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "value" ], [ "CALL_METHOD", "self._check_inner_call(self.stack[frame], node, value)" ], [ "LOAD_FAST", "enter_info" ], [ "LOAD_ATTR", "enter_info.current_frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_GLOBAL", "_tracing_recursively" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "_tracing_recursively(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_GLOBAL", "get_unfrozen_datetime" ], [ "CALL_FUNCTION", "get_unfrozen_datetime()" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_GLOBAL", "Iteration" ], [ "CALL_FUNCTION", "Iteration()" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "BINARY_SUBSCR", "self._code_infos[frame.f_code]" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "enter_info" ], [ "LOAD_ATTR", "enter_info.enter_node" ], [ "LOAD_ATTR", "enter_info.enter_node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Module" ], [ "CALL_FUNCTION", "isinstance(enter_info.enter_node.parent, ast.Module)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "LOOKUP_METHOD", "frame.f_locals.copy" ], [ "CALL_METHOD", "frame.f_locals.copy()" ], [ "LOAD_FAST", "code_info" ], [ "LOAD_ATTR", "code_info.arg_names" ], [ "LOAD_DEREF", "f_locals" ], [ "LOOKUP_METHOD", "f_locals.items" ], [ "CALL_METHOD", "f_locals.items()" ], [ "BINARY_ADD", "[(name, f_locals.pop(name))\n for name in code_info.arg_names\n if name] + [\n\n # Local variables other than actual arguments. These are variables from\n # the enclosing scope. It's handy to treat them like arguments in the UI\n it for it in f_locals.items()\n if it[0][0] != '.' # Appears when using nested tuple arguments\n ]" ], [ "LOAD_GLOBAL", "json" ], [ "LOOKUP_METHOD", "json.dumps" ], [ "LOAD_FAST", "arguments" ], [ "CALL_METHOD", "json.dumps([[k, cheap_repr(v)] for k, v in arguments])" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._call_id" ], [ "CALL_METHOD", "self._call_id()" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "defaultdict(list)" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOOKUP_METHOD", "self.stack.get" ], [ "LOAD_FAST", "enter_info" ], [ "LOAD_ATTR", "enter_info.caller_frame" ], [ "CALL_METHOD", "self.stack.get(enter_info.caller_frame)" ], [ "LOAD_FAST", "prev" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "prev" ], [ "CALL_FUNCTION", "getattr(prev, 'inner_calls', None)" ], [ "LOAD_FAST", "inner_calls" ], [ "COMPARE_OP", "inner_calls is not None" ], [ "LOAD_FAST", "inner_calls" ], [ "LOAD_FAST", "enter_info" ], [ "LOAD_ATTR", "enter_info.call_node" ], [ "BINARY_SUBSCR", "inner_calls[enter_info.call_node]" ], [ "LOOKUP_METHOD", "inner_calls[enter_info.call_node].append" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.call_id" ], [ "CALL_METHOD", "inner_calls[enter_info.call_node].append(frame_info.call_id)" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "name" ], [ "LOAD_DEREF", "f_locals" ], [ "LOOKUP_METHOD", "f_locals.pop" ], [ "LOAD_FAST", "name" ], [ "CALL_METHOD", "f_locals.pop(name)" ], [ "LOAD_FAST", "it" ], [ "BINARY_SUBSCR", "it[0]" ], [ "BINARY_SUBSCR", "it[0][0]" ], [ "COMPARE_OP", "it[0][0] != '.'" ], [ "LOAD_FAST", "it" ], [ "LOAD_FAST", "k" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "cheap_repr(v)" ], [ "LOAD_GLOBAL", "uuid4" ], [ "CALL_FUNCTION", "uuid4()" ], [ "LOAD_ATTR", "uuid4().hex" ], [ "LOAD_DEREF", "exit_info" ], [ "LOAD_ATTR", "exit_info.current_frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "COMPARE_OP", "frame.f_code not in self._code_infos" ], [ "LOAD_GLOBAL", "_tracing_recursively" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "_tracing_recursively(frame)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.iteration" ], [ "LOAD_GLOBAL", "_deep_dict" ], [ "CALL_FUNCTION", "_deep_dict()" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self._extract_node_values" ], [ "LOAD_DEREF", "top_iteration" ], [ "LOAD_DEREF", "node_values" ], [ "CALL_METHOD", "self._extract_node_values(top_iteration, (), node_values)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "BINARY_SUBSCR", "self._code_infos[frame.f_code]" ], [ "LOAD_ATTR", "self._code_infos[frame.f_code].db_func" ], [ "LOAD_DEREF", "exit_info" ], [ "LOAD_ATTR", "exit_info.exc_value" ], [ "LOAD_FAST", "exc" ], [ "LOOKUP_METHOD", "''.join" ], [ "LOAD_GLOBAL", "traceback" ], [ "LOOKUP_METHOD", "traceback.format_exception" ], [ "LOAD_GLOBAL", "type" ], [ "LOAD_FAST", "exc" ], [ "CALL_FUNCTION", "type(exc)" ], [ "LOAD_FAST", "exc" ], [ "LOAD_DEREF", "exit_info" ], [ "LOAD_ATTR", "exit_info.exc_tb" ], [ "CALL_METHOD", "traceback.format_exception(type(exc), exc, exit_info.exc_tb)" ], [ "CALL_METHOD", "''.join(traceback.format_exception(type(exc), exc, exit_info.exc_tb))" ], [ "LOAD_GLOBAL", "exception_string" ], [ "LOAD_FAST", "exc" ], [ "CALL_FUNCTION", "exception_string(exc)" ], [ "LOAD_GLOBAL", "retry_db" ], [ "CALL_FUNCTION", "retry_db" ], [ "LOAD_FAST", "add_call" ], [ "CALL_FUNCTION", "add_call()" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.call_id" ], [ "LOAD_DEREF", "self" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.db" ], [ "LOAD_ATTR", "self.db.Call" ], [ "LOAD_FAST", "Call" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.call_id" ], [ "LOAD_DEREF", "db_func" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.arguments" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_DEREF", "exit_info" ], [ "LOAD_ATTR", "exit_info.return_value" ], [ "CALL_FUNCTION", "cheap_repr(exit_info.return_value)" ], [ "LOAD_DEREF", "exception" ], [ "LOAD_DEREF", "traceback_str" ], [ "LOAD_GLOBAL", "json" ], [ "LOOKUP_METHOD", "json.dumps" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_DEREF", "node_values" ], [ "LOAD_DEREF", "top_iteration" ], [ "LOOKUP_METHOD", "top_iteration.extract_iterations" ], [ "CALL_METHOD", "top_iteration.extract_iterations()" ], [ "BINARY_SUBSCR", "top_iteration.extract_iterations()['loops']" ], [ "LOAD_GLOBAL", "type_registry" ], [ "LOOKUP_METHOD", "type_registry.names" ], [ "CALL_METHOD", "type_registry.names()" ], [ "LOAD_GLOBAL", "type_registry" ], [ "LOAD_ATTR", "type_registry.num_special_types" ], [ "CALL_FUNCTION", "dict(\n node_values=node_values,\n loop_iterations=top_iteration.extract_iterations()['loops'],\n type_names=type_registry.names(),\n num_special_types=type_registry.num_special_types,\n )" ], [ "LOAD_GLOBAL", "ProtocolEncoder" ], [ "CALL_METHOD", "json.dumps(\n dict(\n node_values=node_values,\n loop_iterations=top_iteration.extract_iterations()['loops'],\n type_names=type_registry.names(),\n num_special_types=type_registry.num_special_types,\n ),\n cls=ProtocolEncoder,\n separators=(',', ':')\n )" ], [ "LOAD_DEREF", "frame_info" ], [ "LOAD_ATTR", "frame_info.start_time" ], [ "CALL_FUNCTION", "Call(id=frame_info.call_id,\n function_id=db_func,\n arguments=frame_info.arguments,\n return_value=cheap_repr(exit_info.return_value),\n exception=exception,\n traceback=traceback_str,\n data=json.dumps(\n dict(\n node_values=node_values,\n loop_iterations=top_iteration.extract_iterations()['loops'],\n type_names=type_registry.names(),\n num_special_types=type_registry.num_special_types,\n ),\n cls=ProtocolEncoder,\n separators=(',', ':')\n ),\n start_time=frame_info.start_time)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.db" ], [ "LOOKUP_METHOD", "self.db.session_scope" ], [ "CALL_METHOD", "self.db.session_scope()" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.add" ], [ "LOAD_FAST", "call" ], [ "CALL_METHOD", "session.add(call)" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.vals" ], [ "LOOKUP_METHOD", "iteration.vals.items" ], [ "CALL_METHOD", "iteration.vals.items()" ], [ "LOAD_FAST", "tree_index" ], [ "LOAD_FAST", "path" ], [ "BINARY_ADD", "(tree_index,) + path" ], [ "LOAD_FAST", "node_values" ], [ "LOAD_FAST", "full_path" ], [ "BINARY_SUBSCR", "full_path[:-1]" ], [ "LOAD_FAST", "d" ], [ "LOAD_FAST", "path_k" ], [ "BINARY_SUBSCR", "d[path_k]" ], [ "LOAD_FAST", "node_value" ], [ "LOAD_FAST", "d" ], [ "LOAD_FAST", "full_path" ], [ "BINARY_SUBSCR", "full_path[-1]" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_ATTR", "iteration.loops" ], [ "LOOKUP_METHOD", "iteration.loops.values" ], [ "CALL_METHOD", "iteration.loops.values()" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "loop" ], [ "CALL_FUNCTION", "enumerate(loop)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._extract_node_values" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "path + (i,)" ], [ "LOAD_FAST", "node_values" ], [ "CALL_METHOD", "self._extract_node_values(iteration, path + (i,), node_values)" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "BirdsEye" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(BirdsEye, self)" ], [ "LOOKUP_METHOD", "super(BirdsEye, self).trace_function" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "super(BirdsEye, self).trace_function(func)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOOKUP_METHOD", "self._code_infos.get" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_ATTR", "new_func.__code__" ], [ "CALL_METHOD", "self._code_infos.get(new_func.__code__)" ], [ "LOAD_FAST", "code_info" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.getsourcelines" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "inspect.getsourcelines(func)" ], [ "LOAD_FAST", "start_lineno" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "lines" ], [ "CALL_FUNCTION", "len(lines)" ], [ "BINARY_ADD", "start_lineno + len(lines)" ], [ "LOAD_GLOBAL", "safe_qualname" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "safe_qualname(func)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.getsourcefile" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "inspect.getsourcefile(func)" ], [ "LOAD_FAST", "source_file" ], [ "LOOKUP_METHOD", "source_file.startswith" ], [ "CALL_METHOD", "source_file.startswith('= 0" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.getsourcefile" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "inspect.getsourcefile(frame)" ], [ "LOAD_FAST", "filename" ], [ "COMPARE_OP", "filename is not None" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOOKUP_METHOD", "os.path.abspath" ], [ "LOAD_FAST", "filename" ], [ "CALL_METHOD", "os.path.abspath(filename)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "LOOKUP_METHOD", "frame.f_globals.get" ], [ "CALL_METHOD", "frame.f_globals.get('__name__')" ], [ "COMPARE_OP", "frame.f_globals.get('__name__') != '__main__'" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._treetrace_hidden_with_stmt" ], [ "LOAD_ATTR", "self._treetrace_hidden_with_stmt.__name__" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "COMPARE_OP", "self._treetrace_hidden_with_stmt.__name__ not in frame.f_globals" ], [ "LOAD_GLOBAL", "RuntimeError" ], [ "CALL_FUNCTION", "RuntimeError(\n 'To trace an imported module, you must import birdseye before '\n 'importing that module.')" ], [ "LOAD_GLOBAL", "read_source_file" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "read_source_file(filename)" ], [ "LOOKUP_METHOD", "read_source_file(filename).splitlines" ], [ "CALL_METHOD", "read_source_file(filename).splitlines()" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lineno" ], [ "BINARY_MULTIPLY", "[''] * frame.f_lineno" ], [ "LOAD_FAST", "lines" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lineno" ], [ "LOOKUP_METHOD", "'\\n'.join" ], [ "LOAD_FAST", "lines" ], [ "CALL_METHOD", "'\\n'.join(lines)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.exec_string" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "LOAD_FAST", "deep" ], [ "CALL_METHOD", "self.exec_string(source, filename, frame.f_globals, frame.f_locals, deep)" ], [ "LOAD_GLOBAL", "sys" ], [ "LOOKUP_METHOD", "sys.exit" ], [ "CALL_METHOD", "sys.exit(0)" ], [ "LOAD_FAST", "globs" ], [ "LOAD_FAST", "locs" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self.compile" ], [ "LOAD_DEREF", "source" ], [ "LOAD_DEREF", "filename" ], [ "CALL_METHOD", "self.compile(source, filename)" ], [ "LOAD_FAST", "globs" ], [ "LOOKUP_METHOD", "globs.update" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self._trace_methods_dict" ], [ "LOAD_DEREF", "traced_file" ], [ "CALL_METHOD", "self._trace_methods_dict(traced_file)" ], [ "CALL_METHOD", "globs.update(self._trace_methods_dict(traced_file))" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self._trace" ], [ "LOAD_GLOBAL", "FILE_SENTINEL_NAME" ], [ "LOAD_DEREF", "filename" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.code" ], [ "LOAD_DEREF", "source" ], [ "CALL_METHOD", "self._trace(FILE_SENTINEL_NAME, filename, traced_file, traced_file.code, 'module', source)" ], [ "LOAD_FAST", "deep" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.nodes" ], [ "LOAD_DEREF", "find_code" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.code" ], [ "CALL_FUNCTION", "find_code(traced_file.code)" ], [ "LOAD_GLOBAL", "exec" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.code" ], [ "LOAD_FAST", "globs" ], [ "LOAD_FAST", "locs" ], [ "CALL_FUNCTION", "exec(traced_file.code, globs, locs)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(node, ast.FunctionDef)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.lineno" ], [ "LOAD_FAST", "root_code" ], [ "LOAD_ATTR", "root_code.co_consts" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.iscode" ], [ "LOAD_FAST", "code" ], [ "CALL_METHOD", "inspect.iscode(code)" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "LOOKUP_METHOD", "code.co_name.startswith" ], [ "CALL_METHOD", "code.co_name.startswith('<')" ], [ "LOAD_DEREF", "find_code" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "find_code(code)" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_firstlineno" ], [ "LOAD_DEREF", "nodes_by_lineno" ], [ "LOOKUP_METHOD", "nodes_by_lineno.get" ], [ "LOAD_FAST", "lineno" ], [ "CALL_METHOD", "nodes_by_lineno.get(lineno)" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self._trace" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "LOAD_DEREF", "filename" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_FAST", "code" ], [ "LOAD_DEREF", "source" ], [ "LOAD_FAST", "lineno" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.last_token" ], [ "LOAD_ATTR", "node.last_token.end" ], [ "BINARY_SUBSCR", "node.last_token.end[0]" ], [ "BINARY_ADD", "node.last_token.end[0] + 1" ], [ "CALL_METHOD", "self._trace(\n code.co_name, filename, traced_file, code,\n typ='function',\n source=source,\n start_lineno=lineno,\n end_lineno=node.last_token.end[0] + 1,\n )" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_DEREF", "start_lineno" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "source" ], [ "LOOKUP_METHOD", "source.splitlines" ], [ "CALL_METHOD", "source.splitlines()" ], [ "CALL_FUNCTION", "len(source.splitlines())" ], [ "BINARY_ADD", "start_lineno + len(source.splitlines())" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._nodes_of_interest" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_DEREF", "start_lineno" ], [ "LOAD_FAST", "end_lineno" ], [ "CALL_METHOD", "self._nodes_of_interest(traced_file, start_lineno, end_lineno)" ], [ "CALL_FUNCTION", "list(self._nodes_of_interest(traced_file, start_lineno, end_lineno))" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._nodes_html" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_DEREF", "start_lineno" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_FAST", "traced_file" ], [ "CALL_METHOD", "self._nodes_html(nodes, start_lineno, end_lineno, traced_file)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "nodes" ], [ "CALL_FUNCTION", "dict(\n # This maps each node to the loops enclosing that node\n node_loops={\n node._tree_index: [n._tree_index for n in node._loops]\n for node, _ in nodes\n if node._loops\n },\n )" ], [ "LOAD_FAST", "typ" ], [ "COMPARE_OP", "typ == 'function'" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.tokens" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_FAST", "nodes" ], [ "CALL_FUNCTION", "only(node\n for node, _ in nodes\n if isinstance(node, ast.FunctionDef)\n and node.first_token.start[0] == start_lineno)" ], [ "LOAD_GLOBAL", "source_without_decorators" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_FAST", "func_node" ], [ "CALL_FUNCTION", "source_without_decorators(tokens, func_node)" ], [ "LOAD_FAST", "data_dict" ], [ "LOOKUP_METHOD", "data_dict.update" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._node_ranges" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_FAST", "func_startpos" ], [ "CALL_METHOD", "self._node_ranges(nodes, tokens, func_startpos)" ], [ "CALL_FUNCTION", "list(self._node_ranges(nodes, tokens, func_startpos))" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._loop_ranges" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_FAST", "func_startpos" ], [ "CALL_METHOD", "self._loop_ranges(nodes, tokens, func_startpos)" ], [ "CALL_FUNCTION", "list(self._loop_ranges(nodes, tokens, func_startpos))" ], [ "CALL_METHOD", "data_dict.update(\n node_ranges=list(self._node_ranges(nodes, tokens, func_startpos)),\n loop_ranges=list(self._loop_ranges(nodes, tokens, func_startpos)),\n )" ], [ "LOAD_GLOBAL", "json" ], [ "LOOKUP_METHOD", "json.dumps" ], [ "LOAD_FAST", "data_dict" ], [ "CALL_METHOD", "json.dumps(data_dict, sort_keys=True)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._db_func" ], [ "LOAD_FAST", "data" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "html_body" ], [ "LOAD_FAST", "name" ], [ "LOAD_DEREF", "start_lineno" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "typ" ], [ "CALL_METHOD", "self._db_func(data, filename, html_body, name, start_lineno, source, typ)" ], [ "LOAD_GLOBAL", "CodeInfo" ], [ "LOAD_FAST", "db_func" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_FAST", "arg_names" ], [ "CALL_FUNCTION", "CodeInfo(db_func, traced_file, arg_names)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._code_infos" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._loops" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_FAST", "n" ], [ "LOAD_ATTR", "n._tree_index" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(node, ast.FunctionDef)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.first_token" ], [ "LOAD_ATTR", "node.first_token.start" ], [ "BINARY_SUBSCR", "node.first_token.start[0]" ], [ "LOAD_DEREF", "start_lineno" ], [ "COMPARE_OP", "node.first_token.start[0] == start_lineno" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "classes" ], [ "COMPARE_OP", "'loop' not in classes" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.target" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.test" ], [ "LOAD_FAST", "tokens" ], [ "LOOKUP_METHOD", "tokens.get_text_range" ], [ "LOAD_FAST", "target" ], [ "CALL_METHOD", "tokens.get_text_range(target)" ], [ "LOAD_FAST", "func_start" ], [ "LOAD_FAST", "func_start" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "CALL_FUNCTION", "dict(\n tree_index=node._tree_index,\n start=start,\n end=end\n )" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "tokens" ], [ "LOOKUP_METHOD", "tokens.get_text_range" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "tokens.get_text_range(node)" ], [ "LOAD_FAST", "func_start" ], [ "LOAD_FAST", "func_start" ], [ "LOAD_FAST", "start" ], [ "COMPARE_OP", "start < 0" ], [ "LOAD_FAST", "end" ], [ "COMPARE_OP", "end < 0" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(node, ast.FunctionDef)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._depth" ], [ "LOAD_FAST", "classes" ], [ "CALL_FUNCTION", "dict(\n tree_index=node._tree_index,\n start=start,\n end=end,\n depth=node._depth,\n classes=classes,\n )" ], [ "LOAD_FAST", "h" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "name" ], [ "BINARY_ADD", "filename + name" ], [ "LOAD_FAST", "html_body" ], [ "BINARY_ADD", "filename + name + html_body" ], [ "LOAD_FAST", "data" ], [ "BINARY_ADD", "filename + name + html_body + data" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "start_lineno" ], [ "CALL_FUNCTION", "str(start_lineno)" ], [ "BINARY_ADD", "filename + name + html_body + data + str(start_lineno)" ], [ "CALL_FUNCTION", "h(filename + name + html_body + data + str(start_lineno))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.db" ], [ "LOAD_ATTR", "self.db.Function" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.db" ], [ "LOOKUP_METHOD", "self.db.session_scope" ], [ "CALL_METHOD", "self.db.session_scope()" ], [ "LOAD_GLOBAL", "one_or_none" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.query" ], [ "LOAD_FAST", "Function" ], [ "CALL_METHOD", "session.query(Function)" ], [ "LOOKUP_METHOD", "session.query(Function).filter_by" ], [ "LOAD_FAST", "function_hash" ], [ "CALL_METHOD", "session.query(Function).filter_by(hash=function_hash)" ], [ "CALL_FUNCTION", "one_or_none(session.query(Function).filter_by(hash=function_hash))" ], [ "LOAD_FAST", "db_func" ], [ "LOAD_FAST", "Function" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "typ" ], [ "LOAD_FAST", "html_body" ], [ "LOAD_FAST", "start_lineno" ], [ "LOAD_FAST", "data" ], [ "LOAD_FAST", "h" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "h(source)" ], [ "LOAD_FAST", "function_hash" ], [ "CALL_FUNCTION", "Function(file=filename,\n name=name,\n type=typ,\n html_body=html_body,\n lineno=start_lineno,\n data=data,\n body_hash=h(source),\n hash=function_hash)" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.add" ], [ "LOAD_FAST", "db_func" ], [ "CALL_METHOD", "session.add(db_func)" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.commit" ], [ "CALL_METHOD", "session.commit()" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "db_func" ], [ "LOAD_ATTR", "db_func.id" ], [ "LOAD_GLOBAL", "int" ], [ "CALL_FUNCTION", "isinstance(db_func.id, int)" ], [ "LOAD_FAST", "db_func" ], [ "LOAD_ATTR", "db_func.id" ], [ "LOAD_GLOBAL", "hashlib" ], [ "LOOKUP_METHOD", "hashlib.sha256" ], [ "LOAD_FAST", "s" ], [ "LOOKUP_METHOD", "s.encode" ], [ "CALL_METHOD", "s.encode('utf8')" ], [ "CALL_METHOD", "hashlib.sha256(s.encode('utf8'))" ], [ "LOOKUP_METHOD", "hashlib.sha256(s.encode('utf8')).hexdigest" ], [ "CALL_METHOD", "hashlib.sha256(s.encode('utf8')).hexdigest()" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.nodes" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "CALL_FUNCTION", "isinstance(node, (ast.While, ast.For, ast.comprehension))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.GeneratorExp" ], [ "CALL_FUNCTION", "isinstance(node.parent, ast.GeneratorExp)" ], [ "LOAD_FAST", "classes" ], [ "LOOKUP_METHOD", "classes.append" ], [ "CALL_METHOD", "classes.append('loop')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "CALL_FUNCTION", "isinstance(node, ast.stmt)" ], [ "LOAD_FAST", "classes" ], [ "LOOKUP_METHOD", "classes.append" ], [ "CALL_METHOD", "classes.append('stmt')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "CALL_FUNCTION", "isinstance(node, ast.expr)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._is_interesting_expression" ], [ "LOAD_FAST", "classes" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.AST" ], [ "CALL_FUNCTION", "isinstance(node, ast.AST)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "hasattr(node, 'first_token')" ], [ "LOAD_FAST", "start_lineno" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.first_token" ], [ "LOAD_ATTR", "node.first_token.start" ], [ "BINARY_SUBSCR", "node.first_token.start[0]" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.tokens" ], [ "LOOKUP_METHOD", "traced_file.tokens.get_text_range" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "traced_file.tokens.get_text_range(node)" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "classes" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.root" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.walk" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.root" ], [ "CALL_METHOD", "ast.walk(traced_file.root)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.iter_child_nodes" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.iter_child_nodes(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._depth" ], [ "BINARY_ADD", "node._depth + 1" ], [ "LOAD_FAST", "child" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "positions" ], [ "LOOKUP_METHOD", "positions.extend" ], [ "LOAD_GLOBAL", "map" ], [ "LOAD_GLOBAL", "HTMLPosition" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._depth" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._depth" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "LOOKUP_METHOD", "' '.join" ], [ "LOAD_FAST", "classes" ], [ "CALL_METHOD", "' '.join(classes)" ], [ "BINARY_MODULO", "'' % (node._tree_index, ' '.join(classes))" ], [ "CALL_FUNCTION", "map(\n HTMLPosition,\n [start, end],\n [True, False], # is_start\n [node._depth, node._depth],\n ['' % (node._tree_index, ' '.join(classes)),\n ''])" ], [ "CALL_METHOD", "positions.extend(map(\n HTMLPosition,\n [start, end],\n [True, False], # is_start\n [node._depth, node._depth],\n ['' % (node._tree_index, ' '.join(classes)),\n '']))" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._separate_comprehensions" ], [ "LOAD_FAST", "nodes" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_FAST", "positions" ], [ "LOAD_FAST", "traced_file" ], [ "CALL_METHOD", "self._separate_comprehensions(\n [n[0] for n in nodes],\n end_lineno, positions, traced_file)" ], [ "LOAD_FAST", "positions" ], [ "LOOKUP_METHOD", "positions.append" ], [ "LOAD_GLOBAL", "HTMLPosition" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.source" ], [ "CALL_FUNCTION", "len(traced_file.source)" ], [ "CALL_FUNCTION", "HTMLPosition(len(traced_file.source), False, 0, '')" ], [ "CALL_METHOD", "positions.append(HTMLPosition(len(traced_file.source), False, 0, ''))" ], [ "LOAD_FAST", "positions" ], [ "LOOKUP_METHOD", "positions.sort" ], [ "CALL_METHOD", "positions.sort()" ], [ "LOAD_FAST", "positions" ], [ "LOAD_FAST", "html_parts" ], [ "LOOKUP_METHOD", "html_parts.append" ], [ "LOAD_GLOBAL", "html" ], [ "LOOKUP_METHOD", "html.escape" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.source" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "position" ], [ "LOAD_ATTR", "position.index" ], [ "BINARY_SUBSCR", "traced_file.source[start:position.index]" ], [ "CALL_METHOD", "html.escape(traced_file.source[start:position.index])" ], [ "CALL_METHOD", "html_parts.append(html.escape(traced_file.source[start:position.index]))" ], [ "LOAD_FAST", "html_parts" ], [ "LOOKUP_METHOD", "html_parts.append" ], [ "LOAD_FAST", "position" ], [ "LOAD_ATTR", "position.html" ], [ "CALL_METHOD", "html_parts.append(position.html)" ], [ "LOAD_FAST", "position" ], [ "LOAD_ATTR", "position.index" ], [ "LOOKUP_METHOD", "''.join" ], [ "LOAD_FAST", "html_parts" ], [ "CALL_METHOD", "''.join(html_parts)" ], [ "LOOKUP_METHOD", "'\\n'.join" ], [ "LOAD_FAST", "html_body" ], [ "LOOKUP_METHOD", "html_body.split" ], [ "CALL_METHOD", "html_body.split('\\n')" ], [ "LOAD_FAST", "start_lineno" ], [ "BINARY_SUBTRACT", "start_lineno - 1" ], [ "LOAD_FAST", "end_lineno" ], [ "BINARY_SUBTRACT", "end_lineno - 1" ], [ "BINARY_SUBSCR", "html_body.split('\\n')[start_lineno - 1:end_lineno - 1]" ], [ "CALL_METHOD", "'\\n'.join(html_body.split('\\n')[start_lineno - 1:end_lineno - 1])" ], [ "LOAD_FAST", "html_body" ], [ "LOOKUP_METHOD", "html_body.strip" ], [ "CALL_METHOD", "html_body.strip('\\n')" ], [ "LOAD_FAST", "n" ], [ "BINARY_SUBSCR", "n[0]" ], [ "LOAD_GLOBAL", "group_by_key_func" ], [ "LOAD_GLOBAL", "of_type" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "LOAD_FAST", "nodes" ], [ "CALL_FUNCTION", "of_type((ast.comprehension, ast.While, ast.For), nodes)" ], [ "CALL_FUNCTION", "group_by_key_func(of_type((ast.comprehension, ast.While, ast.For), nodes),\n lambda c: c.first_token.start[0]\n )" ], [ "LOAD_FAST", "comprehensions" ], [ "LOOKUP_METHOD", "comprehensions.values" ], [ "CALL_METHOD", "comprehensions.values()" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_FAST", "comp_list" ], [ "CALL_FUNCTION", "sorted(comp_list, key=lambda c: c.first_token.startpos)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "comp" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "CALL_FUNCTION", "isinstance(comp, ast.comprehension)" ], [ "LOAD_FAST", "comp" ], [ "LOAD_FAST", "comp" ], [ "LOAD_ATTR", "comp.parent" ], [ "LOAD_ATTR", "comp.parent.generators" ], [ "BINARY_SUBSCR", "comp.parent.generators[0]" ], [ "COMPARE_OP", "comp is comp.parent.generators[0]" ], [ "LOAD_FAST", "get_start" ], [ "LOAD_FAST", "comp" ], [ "LOAD_ATTR", "comp.parent" ], [ "CALL_FUNCTION", "get_start(comp.parent)" ], [ "LOAD_FAST", "prev_start" ], [ "COMPARE_OP", "prev_start is not None" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "prev_start" ], [ "COMPARE_OP", "start < prev_start" ], [ "LOAD_FAST", "get_start" ], [ "LOAD_FAST", "comp" ], [ "CALL_FUNCTION", "get_start(comp)" ], [ "LOAD_FAST", "get_start" ], [ "LOAD_FAST", "comp" ], [ "CALL_FUNCTION", "get_start(comp)" ], [ "LOAD_FAST", "prev_start" ], [ "COMPARE_OP", "prev_start is not None" ], [ "LOAD_FAST", "positions" ], [ "LOOKUP_METHOD", "positions.append" ], [ "LOAD_GLOBAL", "HTMLPosition" ], [ "LOAD_FAST", "start" ], [ "CALL_FUNCTION", "HTMLPosition(start, True, 0, '\\n ')" ], [ "CALL_METHOD", "positions.append(HTMLPosition(start, True, 0, '\\n '))" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end_lineno" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.first_token" ], [ "LOAD_ATTR", "c.first_token.start" ], [ "BINARY_SUBSCR", "c.first_token.start[0]" ], [ "LOAD_DEREF", "traced_file" ], [ "LOAD_ATTR", "traced_file.tokens" ], [ "LOOKUP_METHOD", "traced_file.tokens.get_text_range" ], [ "LOAD_FAST", "n" ], [ "CALL_METHOD", "traced_file.tokens.get_text_range(n)" ], [ "BINARY_SUBSCR", "traced_file.tokens.get_text_range(n)[0]" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.first_token" ], [ "LOAD_ATTR", "c.first_token.startpos" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "_deep_dict" ], [ "CALL_FUNCTION", "defaultdict(_deep_dict)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_GLOBAL", "_bad_codes" ], [ "COMPARE_OP", "frame.f_code in _bad_codes" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "IterationList" ], [ "CALL_FUNCTION", "defaultdict(IterationList)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.index" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.loops" ], [ "LOOKUP_METHOD", "self.loops.items" ], [ "CALL_METHOD", "self.loops.items()" ], [ "LOAD_FAST", "iteration_list" ], [ "LOAD_FAST", "tree_index" ], [ "LOAD_FAST", "iteration" ], [ "LOOKUP_METHOD", "iteration.extract_iterations" ], [ "CALL_METHOD", "iteration.extract_iterations()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "deque" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.side_len" ], [ "CALL_FUNCTION", "deque(maxlen=self.side_len)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "Counter" ], [ "CALL_FUNCTION", "Counter()" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.length" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.side_len" ], [ "COMPARE_OP", "self.length < self.side_len" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start" ], [ "LOOKUP_METHOD", "self.start.append" ], [ "LOAD_FAST", "iteration" ], [ "CALL_METHOD", "self.start.append(iteration)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "CALL_FUNCTION", "len(self.end)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.side_len" ], [ "COMPARE_OP", "len(self.end) >= self.side_len" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "BINARY_SUBSCR", "self.end[0]" ], [ "LOAD_ATTR", "self.end[0].keep" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start" ], [ "LOOKUP_METHOD", "self.start.append" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "BINARY_SUBSCR", "self.end[0]" ], [ "CALL_METHOD", "self.start.append(self.end[0])" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "LOOKUP_METHOD", "self.end.append" ], [ "LOAD_FAST", "iteration" ], [ "CALL_METHOD", "self.end.append(iteration)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.length" ], [ "LOAD_FAST", "iteration" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "chain" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "CALL_FUNCTION", "chain(self.start, self.end)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.end" ], [ "BINARY_SUBSCR", "self.end[-1]" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start" ], [ "BINARY_SUBSCR", "self.start[-1]" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.recorded" ], [ "LOAD_FAST", "node" ], [ "BINARY_SUBSCR", "self.recorded[node]" ], [ "COMPARE_OP", "self.recorded[node] >= 2" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.last" ], [ "CALL_METHOD", "self.last()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.recorded" ], [ "LOAD_FAST", "node" ], [ "LOAD_NAME", "type" ], [ "CALL_FUNCTION", "type(None)" ], [ "LOAD_NAME", "bool" ], [ "LOAD_NAME", "int" ], [ "LOAD_NAME", "float" ], [ "LOAD_NAME", "complex" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "long" ], [ "LOAD_NAME", "basic_types" ], [ "LOAD_NAME", "list" ], [ "LOAD_NAME", "dict" ], [ "LOAD_NAME", "tuple" ], [ "LOAD_NAME", "set" ], [ "LOAD_NAME", "frozenset" ], [ "LOAD_NAME", "str" ], [ "BINARY_ADD", "basic_types + (list, dict, tuple, set, frozenset, str)" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "unicode" ], [ "LOAD_NAME", "bytes" ], [ "LOAD_NAME", "len" ], [ "LOAD_NAME", "special_types" ], [ "CALL_FUNCTION", "len(special_types)" ], [ "LOAD_GLOBAL", "Lock" ], [ "CALL_FUNCTION", "Lock()" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "CALL_FUNCTION", "defaultdict(lambda: len(self.data))" ], [ "LOAD_DEREF", "self" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.special_types" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.data" ], [ "LOAD_FAST", "t" ], [ "BINARY_SUBSCR", "self.data[t]" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.data" ], [ "CALL_FUNCTION", "len(self.data)" ], [ "LOAD_GLOBAL", "correct_type" ], [ "LOAD_FAST", "item" ], [ "CALL_FUNCTION", "correct_type(item)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.lock" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.data" ], [ "LOAD_FAST", "t" ], [ "BINARY_SUBSCR", "self.data[t]" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.data" ], [ "LOOKUP_METHOD", "self.data.items" ], [ "CALL_METHOD", "self.data.items()" ], [ "CALL_FUNCTION", "dict((v, k) for k, v in self.data.items())" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_DEREF", "rev" ], [ "CALL_FUNCTION", "len(rev)" ], [ "CALL_FUNCTION", "range(len(rev))" ], [ "LOAD_FAST", "v" ], [ "LOAD_FAST", "k" ], [ "LOAD_GLOBAL", "safe_qualname" ], [ "LOAD_DEREF", "rev" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "rev[i]" ], [ "CALL_FUNCTION", "safe_qualname(rev[i])" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_FAST", "val_repr" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "type_index" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.meta" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.meta" ], [ "LOAD_FAST", "key" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.children" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.children" ], [ "LOOKUP_METHOD", "self.children.append" ], [ "LOAD_FAST", "key" ], [ "LOAD_GLOBAL", "NodeValue" ], [ "LOOKUP_METHOD", "NodeValue.expression" ], [ "LOAD_FAST", "samples" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "level" ], [ "CALL_METHOD", "NodeValue.expression(samples, value, level)" ], [ "CALL_METHOD", "self.children.append((key, NodeValue.expression(samples, value, level)))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.val_repr" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.type_index" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.meta" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.children" ], [ "LOAD_FAST", "result" ], [ "LOOKUP_METHOD", "result.extend" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.children" ], [ "CALL_METHOD", "result.extend(self.children)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "cls" ], [ "CALL_FUNCTION", "cls('', -2)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_GLOBAL", "exception_string" ], [ "LOAD_FAST", "exc_value" ], [ "CALL_FUNCTION", "exception_string(exc_value)" ], [ "CALL_FUNCTION", "cls(exception_string(exc_value), -1)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "cheap_repr(val)" ], [ "LOAD_GLOBAL", "type_registry" ], [ "LOAD_FAST", "val" ], [ "BINARY_SUBSCR", "type_registry[val]" ], [ "CALL_FUNCTION", "cls(cheap_repr(val), type_registry[val])" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "TypeRegistry" ], [ "LOAD_ATTR", "TypeRegistry.basic_types" ], [ "LOAD_GLOBAL", "BirdsEye" ], [ "CALL_FUNCTION", "isinstance(val, (TypeRegistry.basic_types, BirdsEye))" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "QuerySet" ], [ "CALL_FUNCTION", "isinstance(val, QuerySet)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "len(val)" ], [ "LOAD_FAST", "result" ], [ "LOOKUP_METHOD", "result.set_meta" ], [ "LOAD_FAST", "length" ], [ "CALL_METHOD", "result.set_meta('len', length)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "ModuleType" ], [ "CALL_FUNCTION", "isinstance(val, ModuleType)" ], [ "LOAD_GLOBAL", "min" ], [ "LOAD_FAST", "level" ], [ "CALL_FUNCTION", "min(level, 2)" ], [ "LOAD_GLOBAL", "partial" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.add_child" ], [ "LOAD_FAST", "samples" ], [ "LOAD_FAST", "level" ], [ "BINARY_SUBTRACT", "level - 1" ], [ "CALL_FUNCTION", "partial(result.add_child, samples, level - 1)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Series" ], [ "LOAD_GLOBAL", "ndarray" ], [ "CALL_FUNCTION", "isinstance(val, (Series, ndarray))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "ndarray" ], [ "CALL_FUNCTION", "isinstance(val, ndarray)" ], [ "LOAD_FAST", "attrs" ], [ "LOOKUP_METHOD", "attrs.append" ], [ "CALL_METHOD", "attrs.append('shape')" ], [ "LOAD_FAST", "attrs" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "val" ], [ "LOAD_FAST", "name" ], [ "CALL_FUNCTION", "getattr(val, name)" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "attr" ], [ "CALL_FUNCTION", "add_child(name, attr)" ], [ "LOAD_FAST", "level" ], [ "COMPARE_OP", "level >= 3" ], [ "LOAD_FAST", "level" ], [ "COMPARE_OP", "level >= 2" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Series" ], [ "CALL_FUNCTION", "isinstance(val, Series)" ], [ "LOAD_FAST", "samples" ], [ "LOAD_FAST", "sample_type" ], [ "BINARY_SUBSCR", "samples[sample_type]" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "DataFrame" ], [ "CALL_FUNCTION", "isinstance(val, DataFrame)" ], [ "LOAD_FAST", "result" ], [ "LOOKUP_METHOD", "result.set_meta" ], [ "LOAD_FAST", "meta" ], [ "CALL_METHOD", "result.set_meta('dataframe', meta)" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['pandas_rows']" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['pandas_cols']" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_rows" ], [ "BINARY_ADD", "max_rows + 2" ], [ "COMPARE_OP", "length > max_rows + 2" ], [ "LOAD_FAST", "max_rows" ], [ "BINARY_FLOOR_DIVIDE", "max_rows // 2" ], [ "LOAD_FAST", "meta" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.columns" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "columns" ], [ "CALL_FUNCTION", "len(columns)" ], [ "LOAD_FAST", "num_cols" ], [ "LOAD_FAST", "max_cols" ], [ "BINARY_ADD", "max_cols + 2" ], [ "COMPARE_OP", "num_cols > max_cols + 2" ], [ "LOAD_FAST", "max_cols" ], [ "BINARY_FLOOR_DIVIDE", "max_cols // 2" ], [ "LOAD_FAST", "meta" ], [ "LOAD_GLOBAL", "set" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "num_cols" ], [ "LOAD_FAST", "max_cols" ], [ "CALL_FUNCTION", "_sample_indices(num_cols, max_cols)" ], [ "CALL_FUNCTION", "set(_sample_indices(num_cols, max_cols))" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_GLOBAL", "zip" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.columns" ], [ "LOOKUP_METHOD", "val.columns.format" ], [ "CALL_METHOD", "val.columns.format(sparsify=False)" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.columns" ], [ "CALL_FUNCTION", "zip(val.columns.format(sparsify=False),\n val.columns)" ], [ "CALL_FUNCTION", "enumerate(zip(val.columns.format(sparsify=False),\n val.columns))" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "indices" ], [ "COMPARE_OP", "i in indices" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_FAST", "formatted_name" ], [ "LOAD_FAST", "val" ], [ "LOAD_FAST", "label" ], [ "BINARY_SUBSCR", "val[label]" ], [ "CALL_FUNCTION", "add_child(formatted_name, val[label])" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Series" ], [ "CALL_FUNCTION", "isinstance(val, Series)" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['pandas_rows']" ], [ "CALL_FUNCTION", "_sample_indices(length, samples['pandas_rows'])" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.index" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "val.index[i:i + 1]" ], [ "LOOKUP_METHOD", "val.index[i:i + 1].format" ], [ "CALL_METHOD", "val.index[i:i + 1].format(sparsify=False)" ], [ "BINARY_SUBSCR", "val.index[i:i + 1].format(sparsify=False)[0]" ], [ "LOAD_FAST", "val" ], [ "LOAD_ATTR", "val.iloc" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "val.iloc[i]" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_FAST", "k" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child(k, v)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "level" ], [ "COMPARE_OP", "level <= 0" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "bytes" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "unicode" ], [ "LOAD_GLOBAL", "xrange" ], [ "CALL_FUNCTION", "isinstance(val,\n (str, bytes, range)\n if PY3 else\n (str, unicode, xrange))" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Sequence" ], [ "LOAD_GLOBAL", "ndarray" ], [ "CALL_FUNCTION", "isinstance(val, (Sequence, ndarray))" ], [ "LOAD_FAST", "length" ], [ "COMPARE_OP", "length is not None" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['list']" ], [ "CALL_FUNCTION", "_sample_indices(length, samples['list'])" ], [ "LOAD_FAST", "val" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "val[i]" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "i" ], [ "CALL_FUNCTION", "str(i)" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child(str(i), v)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Mapping" ], [ "CALL_FUNCTION", "isinstance(val, Mapping)" ], [ "LOAD_GLOBAL", "islice" ], [ "LOAD_GLOBAL", "_safe_iter" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "iteritems" ], [ "CALL_FUNCTION", "_safe_iter(val, iteritems)" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['dict']" ], [ "CALL_FUNCTION", "islice(_safe_iter(val, iteritems), samples['dict'])" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "k" ], [ "CALL_FUNCTION", "cheap_repr(k)" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child(cheap_repr(k), v)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "val" ], [ "LOAD_GLOBAL", "Set" ], [ "CALL_FUNCTION", "isinstance(val, Set)" ], [ "LOAD_GLOBAL", "_safe_iter" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "_safe_iter(val)" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['set']" ], [ "LOAD_FAST", "length" ], [ "COMPARE_OP", "length is None" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "num_items" ], [ "BINARY_ADD", "num_items + 2" ], [ "COMPARE_OP", "length > num_items + 2" ], [ "LOAD_GLOBAL", "islice" ], [ "LOAD_FAST", "vals" ], [ "LOAD_FAST", "num_items" ], [ "CALL_FUNCTION", "islice(vals, num_items)" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "vals" ], [ "CALL_FUNCTION", "enumerate(vals)" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_FAST", "i" ], [ "BINARY_MODULO", "'<%s>' % i" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child('<%s>' % i, v)" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "getattr(val, '__dict__', None)" ], [ "LOAD_FAST", "d" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_GLOBAL", "islice" ], [ "LOAD_GLOBAL", "_safe_iter" ], [ "LOAD_FAST", "d" ], [ "CALL_FUNCTION", "_safe_iter(d)" ], [ "LOAD_FAST", "samples" ], [ "BINARY_SUBSCR", "samples['attributes']" ], [ "CALL_FUNCTION", "islice(_safe_iter(d),\n samples['attributes'])" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "sorted(islice(_safe_iter(d),\n samples['attributes']),\n key=str)" ], [ "LOAD_FAST", "d" ], [ "LOAD_FAST", "k" ], [ "BINARY_SUBSCR", "d[k]" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "TracedFile" ], [ "CALL_FUNCTION", "isinstance(v, TracedFile)" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "k" ], [ "CALL_FUNCTION", "str(k)" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "add_child(str(k), v)" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "type" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "type(val)" ], [ "CALL_FUNCTION", "getattr(type(val), '__slots__', None)" ], [ "CALL_FUNCTION", "sorted(getattr(type(val), '__slots__', None) or ())" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "val" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "getattr(val, s)" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "add_child" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "str(s)" ], [ "LOAD_FAST", "attr" ], [ "CALL_FUNCTION", "add_child(str(s), attr)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "x" ], [ "LOAD_FAST", "f" ], [ "LOAD_FAST", "val" ], [ "CALL_FUNCTION", "f(val)" ], [ "LOAD_FAST", "x" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_ADD", "max_length + 2" ], [ "COMPARE_OP", "length <= max_length + 2" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "range(length)" ], [ "LOAD_GLOBAL", "chain" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_FLOOR_DIVIDE", "max_length // 2" ], [ "CALL_FUNCTION", "range(max_length // 2)" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_FLOOR_DIVIDE", "max_length // 2" ], [ "BINARY_SUBTRACT", "length - max_length // 2" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "range(length - max_length // 2,\n length)" ], [ "CALL_FUNCTION", "chain(range(max_length // 2),\n range(length - max_length // 2,\n length))" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "len(x)" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "n == 0" ], [ "LOAD_GLOBAL", "repr" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "repr(x)" ], [ "LOAD_FAST", "helper" ], [ "LOAD_ATTR", "helper.level" ], [ "BINARY_SUBTRACT", "helper.level - 1" ], [ "LOAD_GLOBAL", "_repr_series_one_line" ], [ "LOAD_ATTR", "_repr_series_one_line.maxparts" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "n" ], [ "LOAD_FAST", "maxparts" ], [ "CALL_FUNCTION", "_sample_indices(n, maxparts)" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.index" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "x.index[i:i + 1]" ], [ "LOOKUP_METHOD", "x.index[i:i + 1].format" ], [ "CALL_METHOD", "x.index[i:i + 1].format(sparsify=False)" ], [ "BINARY_SUBSCR", "x.index[i:i + 1].format(sparsify=False)[0]" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.iloc" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "x.iloc[i]" ], [ "LOAD_FAST", "pieces" ], [ "LOOKUP_METHOD", "pieces.append" ], [ "LOAD_FAST", "k" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "v" ], [ "LOAD_FAST", "newlevel" ], [ "CALL_FUNCTION", "cheap_repr(v, newlevel)" ], [ "BINARY_MODULO", "'%s = %s' % (k, cheap_repr(v, newlevel))" ], [ "CALL_METHOD", "pieces.append('%s = %s' % (k, cheap_repr(v, newlevel)))" ], [ "LOAD_FAST", "n" ], [ "LOAD_FAST", "maxparts" ], [ "BINARY_ADD", "maxparts + 2" ], [ "COMPARE_OP", "n > maxparts + 2" ], [ "LOAD_FAST", "pieces" ], [ "LOOKUP_METHOD", "pieces.insert" ], [ "LOAD_FAST", "maxparts" ], [ "BINARY_FLOOR_DIVIDE", "maxparts // 2" ], [ "CALL_METHOD", "pieces.insert(maxparts // 2, '...')" ], [ "LOOKUP_METHOD", "'; '.join" ], [ "LOAD_FAST", "pieces" ], [ "CALL_METHOD", "'; '.join(pieces)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "CALL_FUNCTION", "isinstance(node, ast.expr)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Num" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Str" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "ast" ], [ "CALL_FUNCTION", "getattr(ast, 'NameConstant', ())" ], [ "CALL_FUNCTION", "isinstance(node, (ast.Num, ast.Str, getattr(ast, 'NameConstant', ())))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "getattr(node, 'ctx', None)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Store" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Del" ], [ "CALL_FUNCTION", "isinstance(getattr(node, 'ctx', None),\n (ast.Store, ast.Del))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.UnaryOp" ], [ "CALL_FUNCTION", "isinstance(node, ast.UnaryOp)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.op" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.UAdd" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.USub" ], [ "CALL_FUNCTION", "isinstance(node.op, (ast.UAdd, ast.USub))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.operand" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Num" ], [ "CALL_FUNCTION", "isinstance(node.operand, ast.Num)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.List" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Tuple" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Dict" ], [ "CALL_FUNCTION", "isinstance(node, (ast.List, ast.Tuple, ast.Dict))" ], [ "LOAD_GLOBAL", "any" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.iter_child_nodes" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.iter_child_nodes(node)" ], [ "CALL_FUNCTION", "any(is_interesting_expression(n) for n in ast.iter_child_nodes(node))" ], [ "UNARY_NOT", "not any(is_interesting_expression(n) for n in ast.iter_child_nodes(node))" ], [ "UNARY_NOT", "not (isinstance(node, (ast.Num, ast.Str, getattr(ast, 'NameConstant', ()))) or\n isinstance(getattr(node, 'ctx', None),\n (ast.Store, ast.Del)) or\n (isinstance(node, ast.UnaryOp) and\n isinstance(node.op, (ast.UAdd, ast.USub)) and\n isinstance(node.operand, ast.Num)) or\n (isinstance(node, (ast.List, ast.Tuple, ast.Dict)) and\n not any(is_interesting_expression(n) for n in ast.iter_child_nodes(node))))" ], [ "LOAD_GLOBAL", "is_interesting_expression" ], [ "LOAD_FAST", "n" ], [ "CALL_FUNCTION", "is_interesting_expression(n)" ], [ "LOAD_GLOBAL", "cast" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "__builtins__" ], [ "CALL_FUNCTION", "cast(dict, __builtins__)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Name" ], [ "CALL_FUNCTION", "isinstance(node, ast.Name)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.id" ], [ "LOAD_FAST", "builtins" ], [ "COMPARE_OP", "node.id in builtins" ], [ "LOAD_FAST", "builtins" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.id" ], [ "BINARY_SUBSCR", "builtins[node.id]" ], [ "LOAD_FAST", "value" ], [ "COMPARE_OP", "builtins[node.id] is value" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "ast" ], [ "CALL_FUNCTION", "getattr(ast, 'NameConstant', ())" ], [ "CALL_FUNCTION", "isinstance(node, getattr(ast, 'NameConstant', ()))" ] ], "configuration.py": [ [ "LOAD_NAME", "ctypes" ], [ "LOAD_ATTR", "ctypes.windll" ], [ "LOAD_ATTR", "ctypes.windll.kernel32" ], [ "LOAD_NAME", "kernel32" ], [ "LOOKUP_METHOD", "kernel32.SetConsoleMode" ], [ "LOAD_NAME", "kernel32" ], [ "LOOKUP_METHOD", "kernel32.GetStdHandle" ], [ "CALL_METHOD", "kernel32.GetStdHandle(-11)" ], [ "CALL_METHOD", "kernel32.SetConsoleMode(kernel32.GetStdHandle(-11), 7)" ], [ "LOAD_NAME", "Exception" ], [ "LOAD_NAME", "os" ], [ "LOAD_ATTR", "os.name" ], [ "COMPARE_OP", "os.name != 'nt'" ], [ "LOAD_NAME", "DefaultFormatter" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "object" ], [ "LOAD_FAST", "builtins" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_GLOBAL", "builtins_module" ], [ "LOAD_FAST", "snoop" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.snoop" ], [ "CALL_FUNCTION", "setattr(builtins_module, snoop, package.snoop)" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_GLOBAL", "builtins_module" ], [ "LOAD_FAST", "pp" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.pp" ], [ "CALL_FUNCTION", "setattr(builtins_module, pp, package.pp)" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_GLOBAL", "builtins_module" ], [ "LOAD_FAST", "spy" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.spy" ], [ "CALL_FUNCTION", "setattr(builtins_module, spy, package.spy)" ], [ "LOAD_GLOBAL", "Config" ], [ "LOAD_FAST", "out" ], [ "LOAD_FAST", "prefix" ], [ "LOAD_FAST", "columns" ], [ "LOAD_FAST", "overwrite" ], [ "LOAD_FAST", "color" ], [ "LOAD_FAST", "enabled" ], [ "LOAD_FAST", "watch_extras" ], [ "LOAD_FAST", "replace_watch_extras" ], [ "LOAD_FAST", "formatter_class" ], [ "CALL_FUNCTION", "Config(\n out=out,\n prefix=prefix,\n columns=columns,\n overwrite=overwrite,\n color=color,\n enabled=enabled,\n watch_extras=watch_extras,\n replace_watch_extras=replace_watch_extras,\n formatter_class=formatter_class,\n )" ], [ "LOAD_FAST", "config" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.snoop" ], [ "LOAD_FAST", "config" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.pp" ], [ "LOAD_FAST", "config" ], [ "LOAD_GLOBAL", "package" ], [ "LOAD_ATTR", "package.spy" ], [ "LOAD_NAME", "DefaultFormatter" ], [ "LOAD_GLOBAL", "can_color" ], [ "LOAD_FAST", "color" ], [ "COMPARE_OP", "color is None" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "out" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.stderr" ], [ "CALL_FUNCTION", "getattr(out or sys.stderr, 'isatty', lambda: False)" ], [ "LOAD_GLOBAL", "bool" ], [ "LOAD_FAST", "isatty" ], [ "CALL_FUNCTION", "isatty()" ], [ "CALL_FUNCTION", "bool(isatty())" ], [ "LOAD_GLOBAL", "get_write_function" ], [ "LOAD_FAST", "out" ], [ "LOAD_FAST", "overwrite" ], [ "CALL_FUNCTION", "get_write_function(out, overwrite)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "formatter_class" ], [ "LOAD_FAST", "prefix" ], [ "LOAD_FAST", "columns" ], [ "LOAD_FAST", "color" ], [ "CALL_FUNCTION", "formatter_class(prefix, columns, color)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "enabled" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "PP" ], [ "LOAD_DEREF", "self" ], [ "CALL_FUNCTION", "PP(self)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "Tracer" ], [ "LOAD_FAST", "ConfiguredTracer" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "Spy" ], [ "LOAD_DEREF", "self" ], [ "CALL_FUNCTION", "Spy(self)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "threading" ], [ "LOOKUP_METHOD", "threading.local" ], [ "CALL_METHOD", "threading.local()" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "replace_watch_extras" ], [ "COMPARE_OP", "replace_watch_extras is not None" ], [ "LOAD_GLOBAL", "ensure_tuple" ], [ "LOAD_FAST", "replace_watch_extras" ], [ "CALL_FUNCTION", "ensure_tuple(replace_watch_extras)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_GLOBAL", "len_shape_watch" ], [ "LOAD_GLOBAL", "dtype_watch" ], [ "LOAD_GLOBAL", "ensure_tuple" ], [ "LOAD_FAST", "watch_extras" ], [ "CALL_FUNCTION", "ensure_tuple(watch_extras)" ], [ "BINARY_ADD", "(len_shape_watch, dtype_watch) + ensure_tuple(watch_extras)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_CLASSDEREF", "self" ], [ "LOAD_FAST", "value" ], [ "LOAD_ATTR", "value.shape" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.ismethod" ], [ "LOAD_FAST", "shape" ], [ "CALL_METHOD", "inspect.ismethod(shape)" ], [ "LOOKUP_METHOD", "'{}.shape'.format" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "'{}.shape'.format(source)" ], [ "LOAD_FAST", "shape" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "value" ], [ "LOAD_GLOBAL", "QuerySet" ], [ "CALL_FUNCTION", "isinstance(value, QuerySet)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "len(value)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "value" ], [ "LOAD_GLOBAL", "six" ], [ "LOAD_ATTR", "six.string_types" ], [ "CALL_FUNCTION", "isinstance(value, six.string_types)" ], [ "LOAD_FAST", "length" ], [ "COMPARE_OP", "length < 50" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "value" ], [ "LOAD_GLOBAL", "Mapping" ], [ "LOAD_GLOBAL", "Set" ], [ "LOAD_GLOBAL", "Sequence" ], [ "CALL_FUNCTION", "isinstance(value, (Mapping, Set, Sequence))" ], [ "LOAD_FAST", "length" ], [ "COMPARE_OP", "length == 0" ], [ "LOOKUP_METHOD", "'len({})'.format" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "'len({})'.format(source)" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "value" ], [ "LOAD_ATTR", "value.dtype" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.ismethod" ], [ "LOAD_FAST", "dtype" ], [ "CALL_METHOD", "inspect.ismethod(dtype)" ], [ "LOOKUP_METHOD", "'{}.dtype'.format" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "'{}.dtype'.format(source)" ], [ "LOAD_FAST", "dtype" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_DEREF", "output" ], [ "LOAD_GLOBAL", "six" ], [ "LOAD_ATTR", "six.string_types" ], [ "CALL_FUNCTION", "isinstance(output, six.string_types)" ], [ "LOAD_GLOBAL", "is_pathlike" ], [ "LOAD_DEREF", "output" ], [ "CALL_FUNCTION", "is_pathlike(output)" ], [ "LOAD_FAST", "is_path" ], [ "LOAD_GLOBAL", "FileWriter" ], [ "LOAD_DEREF", "output" ], [ "LOAD_FAST", "overwrite" ], [ "CALL_FUNCTION", "FileWriter(output, overwrite)" ], [ "LOAD_ATTR", "FileWriter(output, overwrite).write" ], [ "LOAD_GLOBAL", "callable" ], [ "LOAD_DEREF", "output" ], [ "CALL_FUNCTION", "callable(output)" ], [ "LOAD_DEREF", "output" ], [ "LOAD_FAST", "write" ], [ "LOAD_DEREF", "output" ], [ "LOAD_FAST", "stream" ], [ "COMPARE_OP", "stream is None" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.stderr" ], [ "LOAD_FAST", "stream" ], [ "LOOKUP_METHOD", "stream.write" ], [ "LOAD_FAST", "s" ], [ "CALL_METHOD", "stream.write(s)" ], [ "LOAD_GLOBAL", "UnicodeEncodeError" ], [ "LOAD_FAST", "stream" ], [ "LOOKUP_METHOD", "stream.write" ], [ "LOAD_GLOBAL", "shitcode" ], [ "LOAD_FAST", "s" ], [ "CALL_FUNCTION", "shitcode(s)" ], [ "CALL_METHOD", "stream.write(shitcode(s))" ], [ "LOAD_GLOBAL", "six" ], [ "LOOKUP_METHOD", "six.text_type" ], [ "LOAD_FAST", "path" ], [ "CALL_METHOD", "six.text_type(path)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "overwrite" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "open" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.path" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.overwrite" ], [ "CALL_FUNCTION", "open(self.path, 'w' if self.overwrite else 'a', encoding='utf-8')" ], [ "LOAD_FAST", "f" ], [ "LOOKUP_METHOD", "f.write" ], [ "LOAD_FAST", "s" ], [ "CALL_METHOD", "f.write(s)" ], [ "LOAD_FAST", "self" ] ], "db.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOOKUP_METHOD", "standard_library.install_aliases" ], [ "CALL_METHOD", "standard_library.install_aliases()" ], [ "LOAD_NAME", "RESERVED_WORDS" ], [ "LOOKUP_METHOD", "RESERVED_WORDS.add" ], [ "CALL_METHOD", "RESERVED_WORDS.add('function')" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "retry" ], [ "LOAD_NAME", "InterfaceError" ], [ "LOAD_NAME", "OperationalError" ], [ "LOAD_NAME", "InternalError" ], [ "LOAD_NAME", "ProgrammingError" ], [ "CALL_FUNCTION", "retry(3, (InterfaceError, OperationalError, InternalError, ProgrammingError))" ], [ "LOAD_NAME", "contextmanager" ], [ "CALL_FUNCTION", "contextmanager" ], [ "LOAD_FAST", "db_uri" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.environ" ], [ "LOOKUP_METHOD", "os.environ.get" ], [ "CALL_METHOD", "os.environ.get('BIRDSEYE_DB')" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOOKUP_METHOD", "os.path.join" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOOKUP_METHOD", "os.path.expanduser" ], [ "CALL_METHOD", "os.path.expanduser('~')" ], [ "CALL_METHOD", "os.path.join(os.path.expanduser('~'),\n '.birdseye.db')" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "dict" ], [ "CALL_FUNCTION", "dict(\n pool_recycle=280,\n echo=False, # for convenience when debugging\n )" ], [ "LOAD_GLOBAL", "create_engine" ], [ "LOAD_FAST", "db_uri" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_KW", "create_engine(db_uri, **kwargs)" ], [ "LOAD_GLOBAL", "ArgumentError" ], [ "LOAD_FAST", "db_uri" ], [ "BINARY_ADD", "'sqlite:///' + db_uri" ], [ "LOAD_GLOBAL", "create_engine" ], [ "LOAD_FAST", "db_uri" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_KW", "create_engine(db_uri, **kwargs)" ], [ "LOAD_FAST", "engine" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "sessionmaker" ], [ "LOAD_FAST", "engine" ], [ "CALL_FUNCTION", "sessionmaker(bind=engine)" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "object" ], [ "LOAD_GLOBAL", "declarative_base" ], [ "LOAD_FAST", "Base" ], [ "CALL_FUNCTION", "declarative_base(cls=Base)" ], [ "LOAD_FAST", "Base" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "object" ], [ "LOAD_FAST", "engine" ], [ "LOAD_ATTR", "engine.name" ], [ "COMPARE_OP", "engine.name == 'mysql'" ], [ "LOAD_GLOBAL", "LONGTEXT" ], [ "LOAD_GLOBAL", "Text" ], [ "LOAD_FAST", "Base" ], [ "LOAD_FAST", "Base" ], [ "LOAD_FAST", "Call" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "Function" ], [ "LOAD_FAST", "self" ], [ "LOAD_DEREF", "KeyValue" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "KeyValueStore" ], [ "CALL_FUNCTION", "KeyValueStore()" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "_skip_version_check" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.table_exists" ], [ "LOAD_FAST", "Function" ], [ "CALL_METHOD", "self.table_exists(Function)" ], [ "LOAD_FAST", "Base" ], [ "LOAD_ATTR", "Base.metadata" ], [ "LOOKUP_METHOD", "Base.metadata.create_all" ], [ "LOAD_FAST", "engine" ], [ "CALL_METHOD", "Base.metadata.create_all(engine)" ], [ "LOAD_GLOBAL", "DB_VERSION" ], [ "LOAD_FAST", "kv" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.table_exists" ], [ "LOAD_DEREF", "KeyValue" ], [ "CALL_METHOD", "self.table_exists(KeyValue)" ], [ "LOAD_GLOBAL", "int" ], [ "LOAD_FAST", "kv" ], [ "LOAD_ATTR", "kv.version" ], [ "CALL_FUNCTION", "int(kv.version)" ], [ "LOAD_GLOBAL", "DB_VERSION" ], [ "COMPARE_OP", "int(kv.version) < DB_VERSION" ], [ "LOAD_GLOBAL", "sys" ], [ "LOOKUP_METHOD", "sys.exit" ], [ "CALL_METHOD", "sys.exit('The birdseye database schema is out of date. '\n 'Run \"python -m birdseye.clear_db\" to delete the existing tables.')" ], [ "LOAD_NAME", "declared_attr" ], [ "CALL_FUNCTION", "declared_attr" ], [ "LOAD_FAST", "cls" ], [ "LOAD_ATTR", "cls.__name__" ], [ "LOOKUP_METHOD", "cls.__name__.lower" ], [ "CALL_METHOD", "cls.__name__.lower()" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "String" ], [ "CALL_FUNCTION", "String(50)" ], [ "CALL_FUNCTION", "Column(String(50), primary_key=True)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "__getitem__" ], [ "LOAD_NAME", "__setitem__" ], [ "LOAD_DEREF", "db_self" ], [ "LOOKUP_METHOD", "db_self.session_scope" ], [ "CALL_METHOD", "db_self.session_scope()" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session\n .query" ], [ "LOAD_DEREF", "KeyValue" ], [ "LOAD_ATTR", "KeyValue.value" ], [ "CALL_METHOD", "session\n .query(KeyValue.value)" ], [ "LOOKUP_METHOD", "session\n .query(KeyValue.value)\n .filter_by" ], [ "LOAD_FAST", "item" ], [ "CALL_METHOD", "session\n .query(KeyValue.value)\n .filter_by(key=item)" ], [ "LOOKUP_METHOD", "session\n .query(KeyValue.value)\n .filter_by(key=item)\n .scalar" ], [ "CALL_METHOD", "session\n .query(KeyValue.value)\n .filter_by(key=item)\n .scalar()" ], [ "LOAD_DEREF", "db_self" ], [ "LOOKUP_METHOD", "db_self.session_scope" ], [ "CALL_METHOD", "db_self.session_scope()" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.query" ], [ "LOAD_DEREF", "KeyValue" ], [ "CALL_METHOD", "session.query(KeyValue)" ], [ "LOOKUP_METHOD", "session.query(KeyValue).filter_by" ], [ "LOAD_FAST", "key" ], [ "CALL_METHOD", "session.query(KeyValue).filter_by(key=key)" ], [ "LOOKUP_METHOD", "session.query(KeyValue).filter_by(key=key).delete" ], [ "CALL_METHOD", "session.query(KeyValue).filter_by(key=key).delete()" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.add" ], [ "LOAD_DEREF", "KeyValue" ], [ "LOAD_FAST", "key" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "str(value)" ], [ "CALL_FUNCTION", "KeyValue(key=key, value=str(value))" ], [ "CALL_METHOD", "session.add(KeyValue(key=key, value=str(value)))" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "String" ], [ "CALL_FUNCTION", "String(length=32)" ], [ "CALL_FUNCTION", "Column(String(length=32), primary_key=True)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Integer" ], [ "LOAD_NAME", "ForeignKey" ], [ "CALL_FUNCTION", "ForeignKey('function.id')" ], [ "CALL_FUNCTION", "Column(Integer, ForeignKey('function.id'), index=True)" ], [ "LOAD_NAME", "relationship" ], [ "LOAD_NAME", "backref" ], [ "CALL_FUNCTION", "backref('calls', lazy='dynamic')" ], [ "CALL_FUNCTION", "relationship('Function', backref=backref('calls', lazy='dynamic'))" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_CLASSDEREF", "LongText" ], [ "CALL_FUNCTION", "Column(LongText)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "DateTime" ], [ "CALL_FUNCTION", "Column(DateTime, index=True)" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "id" ], [ "LOAD_NAME", "function_id" ], [ "LOAD_NAME", "return_value" ], [ "LOAD_NAME", "traceback" ], [ "LOAD_NAME", "exception" ], [ "LOAD_NAME", "start_time" ], [ "LOAD_NAME", "arguments" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._pretty_time" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.start_time" ], [ "CALL_METHOD", "self._pretty_time(self.start_time)" ], [ "LOAD_FAST", "dt" ], [ "LOAD_GLOBAL", "Markup" ], [ "LOAD_FAST", "dt" ], [ "LOOKUP_METHOD", "dt.strftime" ], [ "CALL_METHOD", "dt.strftime('%Y-%m-%d %H:%M:%S')" ], [ "LOAD_GLOBAL", "naturaltime" ], [ "LOAD_FAST", "dt" ], [ "CALL_FUNCTION", "naturaltime(dt)" ], [ "BINARY_MODULO", "'%s (%s)' % (\n dt.strftime('%Y-%m-%d %H:%M:%S'),\n naturaltime(dt))" ], [ "CALL_FUNCTION", "Markup('%s (%s)' % (\n dt.strftime('%Y-%m-%d %H:%M:%S'),\n naturaltime(dt)))" ], [ "LOAD_GLOBAL", "Markup" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.success" ], [ "BINARY_MODULO", "'' % (\n ('ok', 'green') if self.success else\n ('remove', 'red'))" ], [ "CALL_FUNCTION", "Markup('' % (\n ('ok', 'green') if self.success else\n ('remove', 'red')))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.exception" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.traceback" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.return_value" ], [ "COMPARE_OP", "self.return_value == 'None'" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.traceback" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.success" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.return_value" ], [ "CALL_FUNCTION", "str(self.return_value)" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.exception" ], [ "CALL_FUNCTION", "str(self.exception)" ], [ "LOAD_GLOBAL", "json" ], [ "LOOKUP_METHOD", "json.loads" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.arguments" ], [ "CALL_METHOD", "json.loads(self.arguments)" ], [ "LOAD_GLOBAL", "json" ], [ "LOOKUP_METHOD", "json.loads" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.data" ], [ "CALL_METHOD", "json.loads(self.data)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.arguments_list" ], [ "LOAD_GLOBAL", "select_attrs" ], [ "LOAD_FAST", "call" ], [ "CALL_FUNCTION", "select_attrs(call, 'id function_id return_value traceback '\n 'exception start_time')" ], [ "CALL_FUNCTION_KW", "dict(arguments=call.arguments_list,\n **select_attrs(call, 'id function_id return_value traceback '\n 'exception start_time'))" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Integer" ], [ "LOAD_NAME", "Sequence" ], [ "CALL_FUNCTION", "Sequence('function_id_seq')" ], [ "CALL_FUNCTION", "Column(Integer, Sequence('function_id_seq'), primary_key=True)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Text" ], [ "CALL_FUNCTION", "Column(Text)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_CLASSDEREF", "LongText" ], [ "CALL_FUNCTION", "Column(LongText)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "Integer" ], [ "CALL_FUNCTION", "Column(Integer)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_CLASSDEREF", "LongText" ], [ "CALL_FUNCTION", "Column(LongText)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "String" ], [ "CALL_FUNCTION", "String(length=64)" ], [ "CALL_FUNCTION", "Column(String(length=64), index=True)" ], [ "LOAD_NAME", "Column" ], [ "LOAD_NAME", "String" ], [ "CALL_FUNCTION", "String(length=64)" ], [ "CALL_FUNCTION", "Column(String(length=64), index=True)" ], [ "LOAD_NAME", "UniqueConstraint" ], [ "CALL_FUNCTION", "UniqueConstraint('hash',\n name='everything_unique')" ], [ "LOAD_NAME", "Index" ], [ "CALL_FUNCTION", "Index('idx_file', 'file', mysql_length=256)" ], [ "LOAD_NAME", "Index" ], [ "CALL_FUNCTION", "Index('idx_name', 'name', mysql_length=32)" ], [ "LOAD_NAME", "property" ], [ "CALL_FUNCTION", "property" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "file" ], [ "LOAD_NAME", "name" ], [ "LOAD_NAME", "lineno" ], [ "LOAD_NAME", "hash" ], [ "LOAD_NAME", "body_hash" ], [ "LOAD_NAME", "type" ], [ "LOAD_GLOBAL", "json" ], [ "LOOKUP_METHOD", "json.loads" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.data" ], [ "CALL_METHOD", "json.loads(self.data)" ], [ "LOAD_GLOBAL", "select_attrs" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "select_attrs(func, 'file name lineno hash body_hash type')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.engine" ], [ "LOAD_ATTR", "self.engine.dialect" ], [ "LOOKUP_METHOD", "self.engine.dialect.has_table" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.engine" ], [ "LOAD_FAST", "table" ], [ "LOAD_ATTR", "table.__name__" ], [ "CALL_METHOD", "self.engine.dialect.has_table(self.engine, table.__name__)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.session_scope" ], [ "CALL_METHOD", "self.session_scope()" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.query" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.Function" ], [ "LOAD_ATTR", "self.Function.file" ], [ "CALL_METHOD", "session.query(self.Function.file)" ], [ "LOOKUP_METHOD", "session.query(self.Function.file).distinct" ], [ "CALL_METHOD", "session.query(self.Function.file).distinct()" ], [ "LOAD_FAST", "paths" ], [ "LOOKUP_METHOD", "paths.sort" ], [ "CALL_METHOD", "paths.sort()" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "paths" ], [ "COMPARE_OP", "IPYTHON_FILE_PATH in paths" ], [ "LOAD_FAST", "paths" ], [ "LOOKUP_METHOD", "paths.remove" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "CALL_METHOD", "paths.remove(IPYTHON_FILE_PATH)" ], [ "LOAD_FAST", "paths" ], [ "LOOKUP_METHOD", "paths.insert" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "CALL_METHOD", "paths.insert(0, IPYTHON_FILE_PATH)" ], [ "LOAD_FAST", "paths" ], [ "LOAD_GLOBAL", "is_ipython_cell" ], [ "LOAD_FAST", "f" ], [ "BINARY_SUBSCR", "f[0]" ], [ "CALL_FUNCTION", "is_ipython_cell(f[0])" ], [ "LOAD_FAST", "f" ], [ "BINARY_SUBSCR", "f[0]" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.Call" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.Function" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._KeyValue" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.table_exists" ], [ "LOAD_FAST", "model" ], [ "CALL_METHOD", "self.table_exists(model)" ], [ "LOAD_FAST", "model" ], [ "LOAD_ATTR", "model.__table__" ], [ "LOOKUP_METHOD", "model.__table__.drop" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.engine" ], [ "CALL_METHOD", "model.__table__.drop(self.engine)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.Session" ], [ "CALL_METHOD", "self.Session()" ], [ "LOAD_FAST", "session" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.commit" ], [ "CALL_METHOD", "session.commit()" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.rollback" ], [ "CALL_METHOD", "session.rollback()" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.close" ], [ "CALL_METHOD", "session.close()" ], [ "LOAD_GLOBAL", "functools" ], [ "LOOKUP_METHOD", "functools.wraps" ], [ "LOAD_DEREF", "func" ], [ "CALL_METHOD", "functools.wraps(func)" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "LOAD_GLOBAL", "retry_db" ], [ "LOAD_FAST", "wrapper" ], [ "CALL_FUNCTION", "retry_db(wrapper)" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self.session_scope" ], [ "CALL_METHOD", "self.session_scope()" ], [ "LOAD_DEREF", "func" ], [ "LOAD_FAST", "session" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "func(session, *args, **kwargs)" ] ], "executing.py": [ [ "LOAD_NAME", "sys" ], [ "LOAD_ATTR", "sys.version_info" ], [ "BINARY_SUBSCR", "sys.version_info[0]" ], [ "COMPARE_OP", "sys.version_info[0] == 3" ], [ "LOAD_NAME", "PY3" ], [ "LOAD_NAME", "lru_cache" ], [ "CALL_FUNCTION", "lru_cache(maxsize=None)" ], [ "LOAD_NAME", "str" ], [ "LOAD_NAME", "unicode" ], [ "LOAD_NAME", "dis" ], [ "LOAD_ATTR", "dis.get_instructions" ], [ "LOAD_NAME", "AttributeError" ], [ "LOAD_NAME", "namedtuple" ], [ "CALL_FUNCTION", "namedtuple('Instruction', 'offset argval opname')" ], [ "LOAD_NAME", "Exception" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.NodeVisitor" ], [ "LOAD_NAME", "sum" ], [ "LOAD_NAME", "__future__" ], [ "LOAD_ATTR", "__future__.all_feature_names" ], [ "CALL_FUNCTION", "sum(\n getattr(__future__, fname).compiler_flag\n for fname in __future__.all_feature_names\n)" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "RLock" ], [ "CALL_FUNCTION", "RLock()" ], [ "LOAD_NAME", "cache" ], [ "CALL_FUNCTION", "cache" ], [ "LOAD_GLOBAL", "functools" ], [ "LOOKUP_METHOD", "functools.wraps" ], [ "LOAD_DEREF", "func" ], [ "CALL_METHOD", "functools.wraps(func)" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "LOAD_FAST", "wrapper" ], [ "LOAD_FAST", "args" ], [ "LOAD_DEREF", "d" ], [ "COMPARE_OP", "args in d" ], [ "LOAD_DEREF", "d" ], [ "LOAD_FAST", "args" ], [ "BINARY_SUBSCR", "d[args]" ], [ "LOAD_DEREF", "func" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION_VAR", "func(*args)" ], [ "LOAD_DEREF", "d" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "co" ], [ "LOAD_ATTR", "co.co_code" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "len(code)" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "i < n" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "code[i]" ], [ "LOAD_GLOBAL", "ord" ], [ "LOAD_FAST", "c" ], [ "CALL_FUNCTION", "ord(c)" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "LOAD_FAST", "op" ], [ "LOAD_GLOBAL", "HAVE_ARGUMENT" ], [ "COMPARE_OP", "op >= HAVE_ARGUMENT" ], [ "LOAD_GLOBAL", "ord" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "code[i]" ], [ "CALL_FUNCTION", "ord(code[i])" ], [ "LOAD_GLOBAL", "ord" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "code[i + 1]" ], [ "CALL_FUNCTION", "ord(code[i + 1])" ], [ "BINARY_MULTIPLY", "ord(code[i + 1]) * 256" ], [ "BINARY_ADD", "ord(code[i]) + ord(code[i + 1]) * 256" ], [ "LOAD_FAST", "extended_arg" ], [ "BINARY_ADD", "ord(code[i]) + ord(code[i + 1]) * 256 + extended_arg" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 2" ], [ "LOAD_FAST", "op" ], [ "LOAD_GLOBAL", "EXTENDED_ARG" ], [ "COMPARE_OP", "op == EXTENDED_ARG" ], [ "LOAD_FAST", "oparg" ], [ "BINARY_MULTIPLY", "oparg * 65536" ], [ "LOAD_FAST", "op" ], [ "LOAD_GLOBAL", "hasconst" ], [ "COMPARE_OP", "op in hasconst" ], [ "LOAD_FAST", "co" ], [ "LOAD_ATTR", "co.co_consts" ], [ "LOAD_FAST", "oparg" ], [ "BINARY_SUBSCR", "co.co_consts[oparg]" ], [ "LOAD_GLOBAL", "Instruction" ], [ "LOAD_FAST", "offset" ], [ "LOAD_FAST", "argval" ], [ "LOAD_GLOBAL", "opname" ], [ "LOAD_FAST", "op" ], [ "BINARY_SUBSCR", "opname[op]" ], [ "CALL_FUNCTION", "Instruction(offset, argval, opname[op])" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "it" ], [ "LOAD_GLOBAL", "Sized" ], [ "CALL_FUNCTION", "isinstance(it, Sized)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "len(it)" ], [ "COMPARE_OP", "len(it) != 1" ], [ "LOAD_GLOBAL", "NotOneValueFound" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "len(it)" ], [ "BINARY_MODULO", "'Expected one value, found %s' % len(it)" ], [ "CALL_FUNCTION", "NotOneValueFound('Expected one value, found %s' % len(it))" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "list(it)" ], [ "BINARY_SUBSCR", "list(it)[0]" ], [ "LOAD_GLOBAL", "tuple" ], [ "LOAD_GLOBAL", "islice" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "islice(it, 2)" ], [ "CALL_FUNCTION", "tuple(islice(it, 2))" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "lst" ], [ "CALL_FUNCTION", "len(lst)" ], [ "COMPARE_OP", "len(lst) == 0" ], [ "LOAD_GLOBAL", "NotOneValueFound" ], [ "CALL_FUNCTION", "NotOneValueFound('Expected one value, found 0')" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "lst" ], [ "CALL_FUNCTION", "len(lst)" ], [ "COMPARE_OP", "len(lst) > 1" ], [ "LOAD_GLOBAL", "NotOneValueFound" ], [ "CALL_FUNCTION", "NotOneValueFound('Expected one value, found several')" ], [ "LOAD_FAST", "lst" ], [ "BINARY_SUBSCR", "lst[0]" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "classmethod" ], [ "CALL_FUNCTION", "classmethod" ], [ "LOAD_NAME", "cache" ], [ "CALL_FUNCTION", "cache" ], [ "LOAD_NAME", "cache" ], [ "CALL_FUNCTION", "cache" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "text" ], [ "LOAD_GLOBAL", "text_type" ], [ "CALL_FUNCTION", "isinstance(text, text_type)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.decode_source" ], [ "LOAD_FAST", "text" ], [ "CALL_METHOD", "self.decode_source(text)" ], [ "LOAD_FAST", "text" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_FAST", "text" ], [ "LOOKUP_METHOD", "''.join" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "text" ], [ "LOOKUP_METHOD", "text.splitlines" ], [ "CALL_METHOD", "text.splitlines(True)" ], [ "CALL_FUNCTION", "enumerate(text.splitlines(True))" ], [ "CALL_METHOD", "''.join([\n '\\n' if i < 2 and encoding_pattern.match(line)\n else line\n for i, line in enumerate(text.splitlines(True))\n ])" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "defaultdict(list)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "text" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.parse" ], [ "LOAD_FAST", "ast_text" ], [ "LOAD_FAST", "filename" ], [ "CALL_METHOD", "ast.parse(ast_text, filename=filename)" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "SyntaxError" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.walk" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tree" ], [ "CALL_METHOD", "ast.walk(self.tree)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.iter_child_nodes" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.iter_child_nodes(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "hasattr(node, 'lineno')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._nodes_by_line" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.lineno" ], [ "BINARY_SUBSCR", "self._nodes_by_line[node.lineno]" ], [ "LOOKUP_METHOD", "self._nodes_by_line[node.lineno].append" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self._nodes_by_line[node.lineno].append(node)" ], [ "LOAD_GLOBAL", "QualnameVisitor" ], [ "CALL_FUNCTION", "QualnameVisitor()" ], [ "LOAD_FAST", "visitor" ], [ "LOOKUP_METHOD", "visitor.visit" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tree" ], [ "CALL_METHOD", "visitor.visit(self.tree)" ], [ "LOAD_FAST", "visitor" ], [ "LOAD_ATTR", "visitor.qualnames" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "i" ], [ "COMPARE_OP", "i < 2" ], [ "LOAD_GLOBAL", "encoding_pattern" ], [ "LOOKUP_METHOD", "encoding_pattern.match" ], [ "LOAD_FAST", "line" ], [ "CALL_METHOD", "encoding_pattern.match(line)" ], [ "LOAD_FAST", "line" ], [ "LOAD_FAST", "cls" ], [ "LOOKUP_METHOD", "cls.for_filename" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_filename" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "CALL_METHOD", "cls.for_filename(frame.f_code.co_filename, frame.f_globals or {})" ], [ "LOAD_FAST", "cls" ], [ "LOOKUP_METHOD", "cls._class_local" ], [ "CALL_METHOD", "cls._class_local('__source_cache', {})" ], [ "LOAD_FAST", "source_cache" ], [ "LOAD_FAST", "filename" ], [ "BINARY_SUBSCR", "source_cache[filename]" ], [ "LOAD_GLOBAL", "KeyError" ], [ "LOAD_GLOBAL", "linecache" ], [ "LOOKUP_METHOD", "linecache.getlines" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "module_globals" ], [ "CALL_METHOD", "linecache.getlines(filename, module_globals)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_FAST", "filename" ], [ "LOOKUP_METHOD", "''.join" ], [ "LOAD_FAST", "lines" ], [ "CALL_METHOD", "''.join(lines)" ], [ "CALL_FUNCTION", "cls(filename, ''.join(lines))" ], [ "LOAD_FAST", "source_cache" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_GLOBAL", "linecache" ], [ "CALL_FUNCTION", "hasattr(linecache, 'lazycache')" ], [ "LOAD_GLOBAL", "linecache" ], [ "LOOKUP_METHOD", "linecache.lazycache" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_filename" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "CALL_METHOD", "linecache.lazycache(frame.f_code.co_filename, frame.f_globals)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lasti" ], [ "LOAD_FAST", "cls" ], [ "LOOKUP_METHOD", "cls._class_local" ], [ "CALL_METHOD", "cls._class_local('__executing_cache', {})" ], [ "LOAD_FAST", "executing_cache" ], [ "LOAD_FAST", "key" ], [ "BINARY_SUBSCR", "executing_cache[key]" ], [ "LOAD_GLOBAL", "KeyError" ], [ "LOAD_FAST", "cls" ], [ "LOOKUP_METHOD", "cls.for_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "cls.for_frame(frame)" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.tree" ], [ "LOAD_FAST", "source" ], [ "LOOKUP_METHOD", "source.statements_at_line" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lineno" ], [ "CALL_METHOD", "source.statements_at_line(frame.f_lineno)" ], [ "LOAD_GLOBAL", "NodeFinder" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "stmts" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.tree" ], [ "CALL_FUNCTION", "NodeFinder(frame, stmts, source.tree)" ], [ "LOAD_ATTR", "NodeFinder(frame, stmts, source.tree).result" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_GLOBAL", "statement_containing_node" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "statement_containing_node(node)" ], [ "LOAD_FAST", "new_stmts" ], [ "LOAD_FAST", "stmts" ], [ "COMPARE_OP", "new_stmts <= stmts" ], [ "LOAD_FAST", "new_stmts" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "stmts" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "executing_cache" ], [ "LOAD_FAST", "key" ], [ "LOAD_GLOBAL", "Executing" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION_VAR", "Executing(frame, *args)" ], [ "LOAD_FAST", "cls" ], [ "LOAD_ATTR", "cls.__dict__" ], [ "LOOKUP_METHOD", "cls.__dict__.get" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "default" ], [ "CALL_METHOD", "cls.__dict__.get(name, default)" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_FAST", "cls" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "setattr(cls, name, result)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._nodes_by_line" ], [ "LOAD_FAST", "lineno" ], [ "BINARY_SUBSCR", "self._nodes_by_line[lineno]" ], [ "LOAD_GLOBAL", "statement_containing_node" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "statement_containing_node(node)" ], [ "LOAD_FAST", "ASTTokens" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.text" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tree" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.filename" ], [ "CALL_FUNCTION", "ASTTokens(\n self.text,\n tree=self.tree,\n filename=self.filename,\n )" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "source" ], [ "LOAD_GLOBAL", "bytes" ], [ "CALL_FUNCTION", "isinstance(source, bytes)" ], [ "LOAD_GLOBAL", "detect_encoding" ], [ "LOAD_GLOBAL", "io" ], [ "LOOKUP_METHOD", "io.BytesIO" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "io.BytesIO(source)" ], [ "LOAD_ATTR", "io.BytesIO(source).readline" ], [ "CALL_FUNCTION", "detect_encoding(io.BytesIO(source).readline)" ], [ "LOAD_FAST", "source" ], [ "LOOKUP_METHOD", "source.decode" ], [ "LOAD_FAST", "encoding" ], [ "CALL_METHOD", "source.decode(encoding)" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_filename" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.filename" ], [ "COMPARE_OP", "code.co_filename == self.filename" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._qualnames" ], [ "LOOKUP_METHOD", "self._qualnames.get" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_firstlineno" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "CALL_METHOD", "self._qualnames.get((code.co_name, code.co_firstlineno), code.co_name)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "stmts" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.source" ], [ "LOOKUP_METHOD", "self.source.code_qualname" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_code" ], [ "CALL_METHOD", "self.source.code_qualname(self.frame.f_code)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.source" ], [ "LOOKUP_METHOD", "self.source.asttokens" ], [ "CALL_METHOD", "self.source.asttokens()" ], [ "LOOKUP_METHOD", "self.source.asttokens().get_text" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.node" ], [ "CALL_METHOD", "self.source.asttokens().get_text(self.node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.source" ], [ "LOOKUP_METHOD", "self.source.asttokens" ], [ "CALL_METHOD", "self.source.asttokens()" ], [ "LOOKUP_METHOD", "self.source.asttokens().get_text_range" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.node" ], [ "CALL_METHOD", "self.source.asttokens().get_text_range(self.node)" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "QualnameVisitor" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(QualnameVisitor, self)" ], [ "LOOKUP_METHOD", "super(QualnameVisitor, self).__init__" ], [ "CALL_METHOD", "super(QualnameVisitor, self).__init__()" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.name" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOOKUP_METHOD", "self.stack.append" ], [ "LOAD_FAST", "name" ], [ "CALL_METHOD", "self.stack.append(name)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.qualnames" ], [ "LOOKUP_METHOD", "self.qualnames.setdefault" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.lineno" ], [ "LOOKUP_METHOD", "\".\".join" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "CALL_METHOD", "\".\".join(self.stack)" ], [ "CALL_METHOD", "self.qualnames.setdefault((name, node.lineno), \".\".join(self.stack))" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOOKUP_METHOD", "self.stack.append" ], [ "CALL_METHOD", "self.stack.append('')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Lambda" ], [ "CALL_FUNCTION", "isinstance(node, ast.Lambda)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.body" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.body" ], [ "LOAD_FAST", "children" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.visit" ], [ "LOAD_FAST", "child" ], [ "CALL_METHOD", "self.visit(child)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOOKUP_METHOD", "self.stack.pop" ], [ "CALL_METHOD", "self.stack.pop()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOOKUP_METHOD", "self.stack.pop" ], [ "CALL_METHOD", "self.stack.pop()" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.iter_fields" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.iter_fields(node)" ], [ "LOAD_FAST", "field" ], [ "COMPARE_OP", "field == 'body'" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.AST" ], [ "CALL_FUNCTION", "isinstance(child, ast.AST)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.visit" ], [ "LOAD_FAST", "child" ], [ "CALL_METHOD", "self.visit(child)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "isinstance(child, list)" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "grandchild" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.AST" ], [ "CALL_FUNCTION", "isinstance(grandchild, ast.AST)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.visit" ], [ "LOAD_FAST", "grandchild" ], [ "CALL_METHOD", "self.visit(grandchild)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.visit_FunctionDef" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self.visit_FunctionDef(node, '')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOOKUP_METHOD", "self.stack.append" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.name" ], [ "CALL_METHOD", "self.stack.append(node.name)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.generic_visit" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self.generic_visit(node)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOOKUP_METHOD", "self.stack.pop" ], [ "CALL_METHOD", "self.stack.pop()" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "__future__" ], [ "LOAD_FAST", "fname" ], [ "CALL_FUNCTION", "getattr(__future__, fname)" ], [ "LOAD_ATTR", "getattr(__future__, fname).compiler_flag" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "matching_code" ], [ "LOAD_ATTR", "matching_code.co_filename" ], [ "LOAD_GLOBAL", "future_flags" ], [ "LOAD_FAST", "matching_code" ], [ "LOAD_ATTR", "matching_code.co_flags" ], [ "BINARY_AND", "future_flags & matching_code.co_flags" ], [ "CALL_FUNCTION", "compile(\n source,\n matching_code.co_filename,\n 'exec',\n flags=future_flags & matching_code.co_flags,\n dont_inherit=True,\n )" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "tree" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_code" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lasti" ], [ "BINARY_SUBSCR", "frame.f_code.co_code[frame.f_lasti]" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_GLOBAL", "ord" ], [ "LOAD_FAST", "b" ], [ "CALL_FUNCTION", "ord(b)" ], [ "LOAD_GLOBAL", "dis" ], [ "LOAD_ATTR", "dis.opname" ], [ "LOAD_FAST", "b" ], [ "BINARY_SUBSCR", "dis.opname[b]" ], [ "LOAD_FAST", "op_name" ], [ "LOOKUP_METHOD", "op_name.startswith" ], [ "CALL_METHOD", "op_name.startswith('CALL_')" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Call" ], [ "LOAD_FAST", "op_name" ], [ "COMPARE_OP", "op_name == 'BINARY_SUBSCR'" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Subscript" ], [ "LOAD_FAST", "op_name" ], [ "LOOKUP_METHOD", "op_name.startswith" ], [ "CALL_METHOD", "op_name.startswith('BINARY_')" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.BinOp" ], [ "LOAD_FAST", "op_name" ], [ "LOOKUP_METHOD", "op_name.startswith" ], [ "CALL_METHOD", "op_name.startswith('UNARY_')" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.UnaryOp" ], [ "LOAD_FAST", "op_name" ], [ "COMPARE_OP", "op_name in ('LOAD_ATTR', 'LOAD_METHOD', 'LOOKUP_METHOD')" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Attribute" ], [ "LOAD_FAST", "op_name" ], [ "COMPARE_OP", "op_name == 'COMPARE_OP'" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Compare" ], [ "LOAD_GLOBAL", "RuntimeError" ], [ "LOAD_FAST", "op_name" ], [ "CALL_FUNCTION", "RuntimeError(op_name)" ], [ "LOAD_GLOBAL", "lock" ], [ "LOAD_FAST", "stmts" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.matching_nodes" ], [ "LOAD_FAST", "exprs" ], [ "CALL_METHOD", "self.matching_nodes(exprs)" ], [ "CALL_FUNCTION", "list(self.matching_nodes(exprs))" ], [ "CALL_FUNCTION", "only(list(self.matching_nodes(exprs)))" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.walk" ], [ "LOAD_FAST", "stmt" ], [ "CALL_METHOD", "ast.walk(stmt)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "typ" ], [ "CALL_FUNCTION", "isinstance(node, typ)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "hasattr(node, \"ctx\")" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.ctx" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Load" ], [ "CALL_FUNCTION", "isinstance(node.ctx, ast.Load)" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "exprs" ], [ "CALL_FUNCTION", "enumerate(exprs)" ], [ "LOAD_GLOBAL", "get_setter" ], [ "LOAD_FAST", "expr" ], [ "CALL_FUNCTION", "get_setter(expr)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.BinOp" ], [ "LOAD_FAST", "expr" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.Pow" ], [ "CALL_METHOD", "ast.Pow()" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.Str" ], [ "LOAD_GLOBAL", "sentinel" ], [ "CALL_METHOD", "ast.Str(s=sentinel)" ], [ "CALL_METHOD", "ast.BinOp(\n left=expr,\n op=ast.Pow(),\n right=ast.Str(s=sentinel),\n )" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.fix_missing_locations" ], [ "LOAD_FAST", "replacement" ], [ "CALL_METHOD", "ast.fix_missing_locations(replacement)" ], [ "LOAD_FAST", "setter" ], [ "LOAD_FAST", "replacement" ], [ "CALL_FUNCTION", "setter(replacement)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.compile_instructions" ], [ "CALL_METHOD", "self.compile_instructions()" ], [ "LOAD_GLOBAL", "SyntaxError" ], [ "LOAD_FAST", "setter" ], [ "LOAD_FAST", "expr" ], [ "CALL_FUNCTION", "setter(expr)" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "instructions" ], [ "CALL_FUNCTION", "enumerate(instructions)" ], [ "LOAD_FAST", "indices" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_FAST", "indices" ], [ "CALL_FUNCTION", "only(indices)" ], [ "BINARY_SUBTRACT", "only(indices) - 1" ], [ "LOAD_FAST", "instructions" ], [ "LOAD_FAST", "arg_index" ], [ "BINARY_SUBSCR", "instructions[arg_index]" ], [ "LOAD_ATTR", "instructions[arg_index].opname" ], [ "COMPARE_OP", "instructions[arg_index].opname == 'EXTENDED_ARG'" ], [ "LOAD_FAST", "instructions" ], [ "LOAD_FAST", "arg_index" ], [ "BINARY_SUBSCR", "instructions[arg_index]" ], [ "LOAD_ATTR", "instructions[arg_index].offset" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_lasti" ], [ "COMPARE_OP", "instructions[arg_index].offset == self.frame.f_lasti" ], [ "LOAD_FAST", "expr" ], [ "LOAD_FAST", "instruction" ], [ "LOAD_ATTR", "instruction.argval" ], [ "LOAD_GLOBAL", "sentinel" ], [ "COMPARE_OP", "instruction.argval == sentinel" ], [ "LOAD_FAST", "i" ], [ "LOAD_GLOBAL", "compile_similar_to" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tree" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_code" ], [ "CALL_FUNCTION", "compile_similar_to(self.tree, self.frame.f_code)" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_GLOBAL", "find_codes" ], [ "LOAD_FAST", "module_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_code" ], [ "CALL_FUNCTION", "find_codes(module_code, self.frame.f_code)" ], [ "CALL_FUNCTION", "only(find_codes(module_code, self.frame.f_code))" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "get_instructions" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "get_instructions(code)" ], [ "CALL_FUNCTION", "list(get_instructions(code))" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.iter_fields" ], [ "LOAD_DEREF", "parent" ], [ "CALL_METHOD", "ast.iter_fields(parent)" ], [ "LOAD_DEREF", "field" ], [ "LOAD_FAST", "node" ], [ "COMPARE_OP", "field is node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_DEREF", "field" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "isinstance(field, list)" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_DEREF", "field" ], [ "CALL_FUNCTION", "enumerate(field)" ], [ "LOAD_FAST", "item" ], [ "LOAD_FAST", "node" ], [ "COMPARE_OP", "item is node" ], [ "LOAD_FAST", "setter" ], [ "LOAD_GLOBAL", "setattr" ], [ "LOAD_DEREF", "parent" ], [ "LOAD_DEREF", "name" ], [ "LOAD_FAST", "new_node" ], [ "CALL_FUNCTION", "setattr(parent, name, new_node)" ], [ "LOAD_FAST", "new_node" ], [ "LOAD_DEREF", "field" ], [ "LOAD_DEREF", "i" ], [ "LOAD_DEREF", "matches" ], [ "LOAD_FAST", "root_code" ], [ "CALL_FUNCTION", "matches(root_code)" ], [ "LOAD_DEREF", "code_options" ], [ "LOOKUP_METHOD", "code_options.append" ], [ "LOAD_FAST", "root_code" ], [ "CALL_METHOD", "code_options.append(root_code)" ], [ "LOAD_DEREF", "finder" ], [ "LOAD_FAST", "root_code" ], [ "CALL_FUNCTION", "finder(root_code)" ], [ "LOAD_DEREF", "code_options" ], [ "LOAD_GLOBAL", "all" ], [ "LOAD_GLOBAL", "attrgetter" ], [ "CALL_FUNCTION", "attrgetter('co_firstlineno')" ], [ "LOAD_GLOBAL", "attrgetter" ], [ "CALL_FUNCTION", "attrgetter('co_name')" ], [ "LOAD_GLOBAL", "code_names" ], [ "CALL_FUNCTION", "all(\n f(c) == f(matching)\n for f in [\n attrgetter('co_firstlineno'),\n attrgetter('co_name'),\n code_names,\n ]\n )" ], [ "LOAD_FAST", "f" ], [ "LOAD_DEREF", "c" ], [ "CALL_FUNCTION", "f(c)" ], [ "LOAD_FAST", "f" ], [ "LOAD_DEREF", "matching" ], [ "CALL_FUNCTION", "f(matching)" ], [ "COMPARE_OP", "f(c) == f(matching)" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_consts" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.iscode" ], [ "LOAD_FAST", "const" ], [ "CALL_METHOD", "inspect.iscode(const)" ], [ "LOAD_DEREF", "matches" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "matches(const)" ], [ "LOAD_DEREF", "code_options" ], [ "LOOKUP_METHOD", "code_options.append" ], [ "LOAD_FAST", "const" ], [ "CALL_METHOD", "code_options.append(const)" ], [ "LOAD_DEREF", "finder" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "finder(const)" ], [ "LOAD_GLOBAL", "frozenset" ], [ "CALL_FUNCTION", "frozenset()" ], [ "LOOKUP_METHOD", "frozenset().union" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_names" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_varnames" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_freevars" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_cellvars" ], [ "CALL_METHOD", "frozenset().union(\n code.co_names,\n code.co_varnames,\n code.co_freevars,\n code.co_cellvars,\n )" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "CALL_FUNCTION", "isinstance(node, ast.stmt)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_FAST", "node" ] ], "import_hook.py": [ [ "LOAD_NAME", "object" ], [ "LOAD_FAST", "spec" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "deep" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "eye" ], [ "LOOKUP_METHOD", "eye.exec_string" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.source" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._spec" ], [ "LOAD_ATTR", "self._spec.origin" ], [ "LOAD_FAST", "module" ], [ "LOAD_ATTR", "module.__dict__" ], [ "LOAD_FAST", "module" ], [ "LOAD_ATTR", "module.__dict__" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.deep" ], [ "CALL_METHOD", "eye.exec_string(\n source=self.source,\n filename=self._spec.origin,\n globs=module.__dict__,\n locs=module.__dict__,\n deep=self.deep,\n )" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._spec" ], [ "LOAD_ATTR", "self._spec.loader" ], [ "LOOKUP_METHOD", "self._spec.loader.get_filename" ], [ "LOAD_FAST", "fullname" ], [ "CALL_METHOD", "self._spec.loader.get_filename(fullname)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._spec" ], [ "LOAD_ATTR", "self._spec.loader" ], [ "LOOKUP_METHOD", "self._spec.loader.is_package" ], [ "LOAD_FAST", "fullname" ], [ "CALL_METHOD", "self._spec.loader.is_package(fullname)" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.meta_path" ], [ "LOAD_FAST", "finder" ], [ "LOAD_FAST", "self" ], [ "COMPARE_OP", "finder is self" ], [ "LOAD_FAST", "finder" ], [ "LOAD_ATTR", "finder.__module__" ], [ "COMPARE_OP", "'pytest' in finder.__module__" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "finder" ], [ "CALL_FUNCTION", "hasattr(finder, 'find_spec')" ], [ "LOAD_FAST", "finder" ], [ "LOOKUP_METHOD", "finder.find_spec" ], [ "LOAD_FAST", "fullname" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "target" ], [ "CALL_METHOD", "finder.find_spec(fullname, path, target=target)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "finder" ], [ "CALL_FUNCTION", "hasattr(finder, 'load_module')" ], [ "LOAD_GLOBAL", "spec_from_loader" ], [ "LOAD_FAST", "fullname" ], [ "LOAD_FAST", "finder" ], [ "CALL_FUNCTION", "spec_from_loader(fullname, finder)" ], [ "LOAD_FAST", "spec" ], [ "COMPARE_OP", "spec is not None" ], [ "LOAD_FAST", "spec" ], [ "LOAD_ATTR", "spec.origin" ], [ "COMPARE_OP", "spec.origin != 'builtin'" ], [ "LOAD_FAST", "spec" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._find_plain_spec" ], [ "LOAD_FAST", "fullname" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "target" ], [ "CALL_METHOD", "self._find_plain_spec(fullname, path, target)" ], [ "LOAD_FAST", "spec" ], [ "COMPARE_OP", "spec is None" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "spec" ], [ "LOAD_ATTR", "spec.loader" ], [ "CALL_FUNCTION", "hasattr(spec.loader, 'get_source')" ], [ "LOAD_GLOBAL", "callable" ], [ "LOAD_FAST", "spec" ], [ "LOAD_ATTR", "spec.loader" ], [ "LOAD_ATTR", "spec.loader.get_source" ], [ "CALL_FUNCTION", "callable(spec.loader.get_source)" ], [ "LOAD_FAST", "fullname" ], [ "COMPARE_OP", "fullname != 'org'" ], [ "LOAD_GLOBAL", "logging" ], [ "LOOKUP_METHOD", "logging.debug" ], [ "LOAD_FAST", "fullname" ], [ "CALL_METHOD", "logging.debug('Failed finding spec for %s', fullname)" ], [ "LOAD_FAST", "spec" ], [ "LOAD_ATTR", "spec.loader" ], [ "LOOKUP_METHOD", "spec.loader.get_source" ], [ "LOAD_FAST", "fullname" ], [ "CALL_METHOD", "spec.loader.get_source(fullname)" ], [ "LOAD_GLOBAL", "ImportError" ], [ "LOAD_GLOBAL", "logging" ], [ "LOOKUP_METHOD", "logging.debug" ], [ "LOAD_FAST", "fullname" ], [ "CALL_METHOD", "logging.debug('Loader for %s was unable to find the sources',\n fullname)" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_GLOBAL", "logging" ], [ "LOOKUP_METHOD", "logging.exception" ], [ "LOAD_FAST", "fullname" ], [ "CALL_METHOD", "logging.exception('Loader for %s raised an error', fullname)" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "source" ], [ "COMPARE_OP", "'birdseye' not in source" ], [ "LOAD_GLOBAL", "should_trace" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "should_trace(source)" ], [ "LOAD_FAST", "trace_stmt" ], [ "LOAD_GLOBAL", "BirdsEyeLoader" ], [ "LOAD_FAST", "spec" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "deep" ], [ "CALL_FUNCTION", "BirdsEyeLoader(spec, source, deep)" ], [ "LOAD_GLOBAL", "spec_from_loader" ], [ "LOAD_FAST", "fullname" ], [ "LOAD_FAST", "loader" ], [ "CALL_FUNCTION", "spec_from_loader(fullname, loader)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.parse" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "ast.parse(source)" ], [ "LOAD_ATTR", "ast.parse(source).body" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Import" ], [ "CALL_FUNCTION", "isinstance(stmt, ast.Import)" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_ATTR", "stmt.names" ], [ "LOAD_FAST", "alias" ], [ "LOAD_ATTR", "alias.name" ], [ "LOOKUP_METHOD", "alias.name.startswith" ], [ "CALL_METHOD", "alias.name.startswith('birdseye.trace_module')" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_FAST", "alias" ], [ "LOAD_ATTR", "alias.name" ], [ "LOOKUP_METHOD", "alias.name.endswith" ], [ "CALL_METHOD", "alias.name.endswith('deep')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.ImportFrom" ], [ "CALL_FUNCTION", "isinstance(stmt, ast.ImportFrom)" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_ATTR", "stmt.module" ], [ "COMPARE_OP", "stmt.module == 'birdseye'" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_ATTR", "stmt.names" ], [ "LOAD_FAST", "alias" ], [ "LOAD_ATTR", "alias.name" ], [ "LOOKUP_METHOD", "alias.name.startswith" ], [ "CALL_METHOD", "alias.name.startswith('trace_module')" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_FAST", "alias" ], [ "LOAD_ATTR", "alias.name" ], [ "LOOKUP_METHOD", "alias.name.endswith" ], [ "CALL_METHOD", "alias.name.endswith('deep')" ], [ "LOAD_FAST", "deep" ], [ "LOAD_FAST", "trace_stmt" ] ], "ipython.py": [ [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "BytesIO" ], [ "LOAD_NAME", "StringIO" ], [ "LOAD_NAME", "stream_proxy" ], [ "LOAD_NAME", "sys" ], [ "LOAD_ATTR", "sys.stderr" ], [ "CALL_FUNCTION", "stream_proxy(sys.stderr)" ], [ "LOAD_NAME", "sys" ], [ "LOAD_NAME", "stream_proxy" ], [ "LOAD_NAME", "sys" ], [ "LOAD_ATTR", "sys.stdout" ], [ "CALL_FUNCTION", "stream_proxy(sys.stdout)" ], [ "LOAD_NAME", "sys" ], [ "LOAD_NAME", "Environment" ], [ "LOAD_NAME", "PackageLoader" ], [ "CALL_FUNCTION", "PackageLoader('birdseye', 'templates')" ], [ "LOAD_NAME", "select_autoescape" ], [ "CALL_FUNCTION", "select_autoescape(['html', 'xml'])" ], [ "CALL_FUNCTION", "Environment(\n loader=PackageLoader('birdseye', 'templates'),\n autoescape=select_autoescape(['html', 'xml'])\n)" ], [ "LOAD_NAME", "magics_class" ], [ "LOAD_NAME", "Magics" ], [ "CALL_FUNCTION", "magics_class" ], [ "LOAD_GLOBAL", "LocalProxy" ], [ "LOAD_FAST", "p" ], [ "CALL_FUNCTION", "LocalProxy(p)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.currentframe" ], [ "CALL_METHOD", "inspect.currentframe()" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_GLOBAL", "ThreadingMixIn" ], [ "LOAD_ATTR", "ThreadingMixIn.process_request_thread" ], [ "LOAD_ATTR", "ThreadingMixIn.process_request_thread.__code__" ], [ "COMPARE_OP", "frame.f_code == ThreadingMixIn.process_request_thread.__code__" ], [ "LOAD_GLOBAL", "fake_stream" ], [ "CALL_FUNCTION", "fake_stream()" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_GLOBAL", "thread_proxies" ], [ "LOOKUP_METHOD", "thread_proxies.get" ], [ "LOAD_GLOBAL", "currentThread" ], [ "CALL_FUNCTION", "currentThread()" ], [ "LOAD_ATTR", "currentThread().ident" ], [ "LOAD_DEREF", "original" ], [ "CALL_METHOD", "thread_proxies.get(currentThread().ident,\n original)" ], [ "LOAD_FAST", "show_server_output" ], [ "LOAD_GLOBAL", "fake_stream" ], [ "CALL_FUNCTION", "fake_stream()" ], [ "LOAD_GLOBAL", "thread_proxies" ], [ "LOAD_GLOBAL", "currentThread" ], [ "CALL_FUNCTION", "currentThread()" ], [ "LOAD_ATTR", "currentThread().ident" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_ATTR", "server.app" ], [ "LOOKUP_METHOD", "server.app.run" ], [ "LOAD_FAST", "port" ], [ "LOAD_FAST", "bind_host" ], [ "CALL_METHOD", "server.app.run(\n debug=True,\n port=port,\n host=bind_host,\n use_reloader=False,\n )" ], [ "LOAD_GLOBAL", "socket" ], [ "LOAD_ATTR", "socket.error" ], [ "LOAD_NAME", "Unicode" ], [ "CALL_FUNCTION", "Unicode(\n u'', config=True,\n help='If set, a server will not be automatically started by %%eye. '\n 'The iframe containing birdseye output will use this value as the base '\n 'of its URL.'\n )" ], [ "LOAD_NAME", "Int" ], [ "CALL_FUNCTION", "Int(\n 7777, config=True,\n help='Port number for the server started by %%eye.'\n )" ], [ "LOAD_NAME", "Unicode" ], [ "CALL_FUNCTION", "Unicode(\n '127.0.0.1', config=True,\n help='Host that the server started by %%eye listens on. '\n 'Set to 0.0.0.0 to make it accessible anywhere.'\n )" ], [ "LOAD_NAME", "Bool" ], [ "CALL_FUNCTION", "Bool(\n False, config=True,\n help='Set to True to show stdout and stderr from the server started by %%eye.'\n )" ], [ "LOAD_NAME", "Unicode" ], [ "CALL_FUNCTION", "Unicode(\n u'', config=True,\n help='The database URL that the server started by %%eye reads from. '\n 'Equivalent to the environment variable BIRDSEYE_DB.'\n )" ], [ "LOAD_NAME", "cell_magic" ], [ "CALL_FUNCTION", "cell_magic" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.server_url" ], [ "LOAD_GLOBAL", "Database" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.db_url" ], [ "CALL_FUNCTION", "Database(self.db_url)" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_ATTR", "server.db" ], [ "LOAD_ATTR", "server.db.Function" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_ATTR", "server.db" ], [ "LOAD_ATTR", "server.db.Call" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_ATTR", "server.db" ], [ "LOAD_ATTR", "server.db.Session" ], [ "LOAD_GLOBAL", "server" ], [ "LOAD_GLOBAL", "Thread" ], [ "LOAD_GLOBAL", "run_server" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.port" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.bind_host" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.show_server_output" ], [ "CALL_FUNCTION", "Thread(\n target=run_server,\n args=(\n self.port,\n self.bind_host,\n self.show_server_output,\n ),\n )" ], [ "LOOKUP_METHOD", "Thread(\n target=run_server,\n args=(\n self.port,\n self.bind_host,\n self.show_server_output,\n ),\n ).start" ], [ "CALL_METHOD", "Thread(\n target=run_server,\n args=(\n self.port,\n self.bind_host,\n self.show_server_output,\n ),\n ).start()" ], [ "LOAD_GLOBAL", "Database" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.db_url" ], [ "CALL_FUNCTION", "Database(self.db_url)" ], [ "LOAD_GLOBAL", "eye" ], [ "LOAD_GLOBAL", "eye" ], [ "LOOKUP_METHOD", "eye.exec_ipython_cell" ], [ "LOAD_FAST", "cell" ], [ "LOAD_FAST", "callback" ], [ "CALL_METHOD", "eye.exec_ipython_cell(cell, callback)" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "call_id" ], [ "COMPARE_OP", "call_id is None" ], [ "LOAD_GLOBAL", "HTML" ], [ "LOAD_GLOBAL", "templates_env" ], [ "LOOKUP_METHOD", "templates_env.get_template" ], [ "CALL_METHOD", "templates_env.get_template('ipython_iframe.html')" ], [ "LOOKUP_METHOD", "templates_env.get_template('ipython_iframe.html').render" ], [ "LOAD_FAST", "call_id" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.server_url" ], [ "LOOKUP_METHOD", "self.server_url.rstrip" ], [ "CALL_METHOD", "self.server_url.rstrip('/')" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.port" ], [ "LOAD_GLOBAL", "uuid4" ], [ "CALL_FUNCTION", "uuid4()" ], [ "LOAD_ATTR", "uuid4().hex" ], [ "CALL_METHOD", "templates_env.get_template('ipython_iframe.html').render(\n call_id=call_id,\n url=self.server_url.rstrip('/'),\n port=self.port,\n container_id=uuid4().hex,\n )" ], [ "CALL_FUNCTION", "HTML(templates_env.get_template('ipython_iframe.html').render(\n call_id=call_id,\n url=self.server_url.rstrip('/'),\n port=self.port,\n container_id=uuid4().hex,\n ))" ], [ "LOAD_GLOBAL", "display" ], [ "LOAD_FAST", "html" ], [ "CALL_FUNCTION", "display(html)" ] ], "server.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOOKUP_METHOD", "standard_library.install_aliases" ], [ "CALL_METHOD", "standard_library.install_aliases()" ], [ "LOAD_NAME", "Flask" ], [ "CALL_FUNCTION", "Flask('birdseye')" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.jinja_env" ], [ "LOAD_NAME", "Humanize" ], [ "LOAD_NAME", "app" ], [ "CALL_FUNCTION", "Humanize(app)" ], [ "LOAD_NAME", "PathConverter" ], [ "LOAD_NAME", "FileConverter" ], [ "LOAD_NAME", "app" ], [ "LOAD_ATTR", "app.url_map" ], [ "LOAD_ATTR", "app.url_map.converters" ], [ "LOAD_NAME", "Database" ], [ "CALL_FUNCTION", "Database()" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.Session" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.Function" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.Call" ], [ "LOAD_NAME", "app" ], [ "LOOKUP_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/')" ], [ "LOAD_NAME", "app" ], [ "LOOKUP_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/file/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/file/')" ], [ "LOAD_NAME", "app" ], [ "LOOKUP_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/file//__function__/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/file//__function__/')" ], [ "LOAD_NAME", "app" ], [ "LOOKUP_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/api/file//__function__//latest_call/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/api/file//__function__//latest_call/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "LOAD_NAME", "app" ], [ "LOOKUP_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/call/')" ], [ "CALL_FUNCTION", "app.route('/call/')" ], [ "LOAD_NAME", "app" ], [ "LOOKUP_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/ipython_call/')" ], [ "CALL_FUNCTION", "app.route('/ipython_call/')" ], [ "LOAD_NAME", "app" ], [ "LOOKUP_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/ipython_iframe/')" ], [ "CALL_FUNCTION", "app.route('/ipython_iframe/')" ], [ "LOAD_NAME", "app" ], [ "LOOKUP_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/kill', methods=['POST'])" ], [ "CALL_FUNCTION", "app.route('/kill', methods=['POST'])" ], [ "LOAD_NAME", "app" ], [ "LOOKUP_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/api/call/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/api/call/')" ], [ "LOAD_NAME", "app" ], [ "LOOKUP_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/api/calls_by_body_hash/')" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/api/calls_by_body_hash/')" ], [ "LOAD_NAME", "app" ], [ "LOOKUP_METHOD", "app.route" ], [ "CALL_METHOD", "app.route('/api/body_hashes_present/', methods=['POST'])" ], [ "LOAD_NAME", "db" ], [ "LOAD_ATTR", "db.provide_session" ], [ "CALL_FUNCTION", "db.provide_session" ], [ "CALL_FUNCTION", "app.route('/api/body_hashes_present/', methods=['POST'])" ], [ "LOAD_NAME", "sys" ], [ "LOAD_ATTR", "sys.argv" ], [ "BINARY_SUBSCR", "sys.argv[1:]" ], [ "LOAD_NAME", "__name__" ], [ "COMPARE_OP", "__name__ == '__main__'" ], [ "LOAD_NAME", "main" ], [ "CALL_FUNCTION", "main()" ], [ "LOAD_GLOBAL", "db" ], [ "LOOKUP_METHOD", "db.all_file_paths" ], [ "CALL_METHOD", "db.all_file_paths()" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_columns" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.basic_columns" ], [ "BINARY_ADD", "Call.basic_columns + Function.basic_columns" ], [ "CALL_FUNCTION_VAR", "session.query(*(Call.basic_columns + Function.basic_columns))" ], [ "LOOKUP_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)" ], [ "LOOKUP_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .order_by" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.start_time" ], [ "LOOKUP_METHOD", "Call.start_time.desc" ], [ "CALL_METHOD", "Call.start_time.desc()" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .order_by(Call.start_time.desc())" ], [ "BINARY_SUBSCR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .order_by(Call.start_time.desc())[:100]" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "CALL_FUNCTION", "OrderedDict()" ], [ "LOAD_FAST", "recent_calls" ], [ "LOAD_GLOBAL", "is_ipython_cell" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.file" ], [ "CALL_FUNCTION", "is_ipython_cell(row.file)" ], [ "LOAD_FAST", "files" ], [ "LOOKUP_METHOD", "files.setdefault" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.file" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "CALL_FUNCTION", "OrderedDict()" ], [ "CALL_METHOD", "files.setdefault(\n row.file, OrderedDict()\n )" ], [ "LOOKUP_METHOD", "files.setdefault(\n row.file, OrderedDict()\n ).setdefault" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.name" ], [ "LOAD_FAST", "row" ], [ "CALL_METHOD", "files.setdefault(\n row.file, OrderedDict()\n ).setdefault(\n row.name, row\n )" ], [ "LOAD_FAST", "all_paths" ], [ "LOAD_FAST", "files" ], [ "LOOKUP_METHOD", "files.setdefault" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "CALL_FUNCTION", "OrderedDict()" ], [ "CALL_METHOD", "files.setdefault(\n path, OrderedDict()\n )" ], [ "LOAD_GLOBAL", "partial" ], [ "LOAD_GLOBAL", "short_path" ], [ "LOAD_FAST", "all_paths" ], [ "CALL_FUNCTION", "partial(short_path, all_paths=all_paths)" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "short" ], [ "LOAD_FAST", "files" ], [ "CALL_FUNCTION", "render_template('index.html',\n short=short,\n files=files)" ], [ "LOAD_GLOBAL", "fix_abs_path" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "fix_abs_path(path)" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_columns" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.basic_columns" ], [ "BINARY_ADD", "Call.basic_columns + Function.basic_columns" ], [ "CALL_FUNCTION_VAR", "session.query(*(Call.basic_columns + Function.basic_columns))" ], [ "LOOKUP_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)" ], [ "LOOKUP_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by" ], [ "LOAD_FAST", "path" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path)" ], [ "LOOKUP_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path)\n .subquery" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path)\n .subquery('filtered_calls')" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.query" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.name" ], [ "LOAD_GLOBAL", "sqlalchemy" ], [ "LOAD_ATTR", "sqlalchemy.func" ], [ "LOOKUP_METHOD", "sqlalchemy.func.max" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.start_time" ], [ "CALL_METHOD", "sqlalchemy.func.max(filtered_calls.c.start_time)" ], [ "LOOKUP_METHOD", "sqlalchemy.func.max(filtered_calls.c.start_time).label" ], [ "CALL_METHOD", "sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')" ], [ "CALL_METHOD", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n )" ], [ "LOOKUP_METHOD", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n ).group_by" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.name" ], [ "CALL_METHOD", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n ).group_by(\n filtered_calls.c.name,\n )" ], [ "LOOKUP_METHOD", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n ).group_by(\n filtered_calls.c.name,\n ).subquery" ], [ "CALL_METHOD", "session.query(\n filtered_calls.c.name,\n sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime')\n ).group_by(\n filtered_calls.c.name,\n ).subquery('latest_calls')" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.query" ], [ "LOAD_FAST", "filtered_calls" ], [ "CALL_METHOD", "session.query(filtered_calls)" ], [ "LOOKUP_METHOD", "session.query(filtered_calls).join" ], [ "LOAD_FAST", "latest_calls" ], [ "LOAD_GLOBAL", "sqlalchemy" ], [ "LOOKUP_METHOD", "sqlalchemy.and_" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.name" ], [ "LOAD_FAST", "latest_calls" ], [ "LOAD_ATTR", "latest_calls.c" ], [ "LOAD_ATTR", "latest_calls.c.name" ], [ "COMPARE_OP", "filtered_calls.c.name == latest_calls.c.name" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.start_time" ], [ "LOAD_FAST", "latest_calls" ], [ "LOAD_ATTR", "latest_calls.c" ], [ "LOAD_ATTR", "latest_calls.c.maxtime" ], [ "COMPARE_OP", "filtered_calls.c.start_time == latest_calls.c.maxtime" ], [ "CALL_METHOD", "sqlalchemy.and_(\n filtered_calls.c.name == latest_calls.c.name,\n filtered_calls.c.start_time == latest_calls.c.maxtime,\n )" ], [ "CALL_METHOD", "session.query(filtered_calls).join(\n latest_calls,\n sqlalchemy.and_(\n filtered_calls.c.name == latest_calls.c.name,\n filtered_calls.c.start_time == latest_calls.c.maxtime,\n )\n )" ], [ "LOOKUP_METHOD", "session.query(filtered_calls).join(\n latest_calls,\n sqlalchemy.and_(\n filtered_calls.c.name == latest_calls.c.name,\n filtered_calls.c.start_time == latest_calls.c.maxtime,\n )\n ).order_by" ], [ "LOAD_FAST", "filtered_calls" ], [ "LOAD_ATTR", "filtered_calls.c" ], [ "LOAD_ATTR", "filtered_calls.c.start_time" ], [ "LOOKUP_METHOD", "filtered_calls.c.start_time.desc" ], [ "CALL_METHOD", "filtered_calls.c.start_time.desc()" ], [ "CALL_METHOD", "session.query(filtered_calls).join(\n latest_calls,\n sqlalchemy.and_(\n filtered_calls.c.name == latest_calls.c.name,\n filtered_calls.c.start_time == latest_calls.c.maxtime,\n )\n ).order_by(filtered_calls.c.start_time.desc())" ], [ "LOAD_GLOBAL", "group_by_attr" ], [ "LOAD_FAST", "query" ], [ "CALL_FUNCTION", "group_by_attr(query, 'type')" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.query" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.name" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.type" ], [ "CALL_METHOD", "session.query(Function.name, Function.type)" ], [ "LOOKUP_METHOD", "session.query(Function.name, Function.type)\n .filter_by" ], [ "LOAD_FAST", "path" ], [ "CALL_METHOD", "session.query(Function.name, Function.type)\n .filter_by(file=path)" ], [ "LOOKUP_METHOD", "session.query(Function.name, Function.type)\n .filter_by(file=path)\n .distinct" ], [ "CALL_METHOD", "session.query(Function.name, Function.type)\n .filter_by(file=path)\n .distinct()" ], [ "CALL_FUNCTION", "sorted(session.query(Function.name, Function.type)\n .filter_by(file=path)\n .distinct())" ], [ "LOAD_FAST", "query" ], [ "LOAD_FAST", "all_funcs" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.name" ], [ "LOAD_FAST", "func_names" ], [ "COMPARE_OP", "func.name not in func_names" ], [ "LOAD_FAST", "funcs" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.type" ], [ "BINARY_SUBSCR", "funcs[func.type]" ], [ "LOOKUP_METHOD", "funcs[func.type].append" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "funcs[func.type].append(func)" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "funcs" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "COMPARE_OP", "path == IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "basename" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "basename(path)" ], [ "CALL_FUNCTION", "render_template('file.html',\n funcs=funcs,\n is_ipython=path == IPYTHON_FILE_PATH,\n full_path=path,\n short_path=basename(path))" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.name" ], [ "LOAD_GLOBAL", "fix_abs_path" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "fix_abs_path(path)" ], [ "LOAD_GLOBAL", "get_calls" ], [ "LOAD_FAST", "session" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "func_name" ], [ "CALL_FUNCTION", "get_calls(session, path, func_name, 200)" ], [ "LOAD_FAST", "query" ], [ "LOAD_FAST", "query" ], [ "BINARY_SUBSCR", "query[0]" ], [ "LOAD_FAST", "query" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.query" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_METHOD", "session.query(Function)" ], [ "LOOKUP_METHOD", "session.query(Function).filter_by" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "func_name" ], [ "CALL_METHOD", "session.query(Function).filter_by(file=path, name=func_name)" ], [ "BINARY_SUBSCR", "session.query(Function).filter_by(file=path, name=func_name)[0]" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "func" ], [ "LOAD_GLOBAL", "basename" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "basename(path)" ], [ "LOAD_FAST", "calls" ], [ "CALL_FUNCTION", "render_template('function.html',\n func=func,\n short_path=basename(path),\n calls=calls)" ], [ "LOAD_GLOBAL", "withattrs" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_FUNCTION", "Call()" ], [ "LOAD_FAST", "row" ], [ "LOOKUP_METHOD", "row._asdict" ], [ "CALL_METHOD", "row._asdict()" ], [ "CALL_FUNCTION_KW", "withattrs(Call(), **row._asdict())" ], [ "LOAD_GLOBAL", "fix_abs_path" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "fix_abs_path(path)" ], [ "LOAD_GLOBAL", "get_calls" ], [ "LOAD_FAST", "session" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "func_name" ], [ "CALL_FUNCTION", "get_calls(session, path, func_name, 1)" ], [ "BINARY_SUBSCR", "get_calls(session, path, func_name, 1)[0]" ], [ "LOAD_GLOBAL", "jsonify" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.id" ], [ "LOAD_GLOBAL", "url_for" ], [ "LOAD_GLOBAL", "call_view" ], [ "LOAD_ATTR", "call_view.__name__" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.id" ], [ "CALL_FUNCTION", "url_for(call_view.__name__,\n call_id=call.id)" ], [ "CALL_FUNCTION", "dict(\n id=call.id,\n url=url_for(call_view.__name__,\n call_id=call.id),\n )" ], [ "CALL_FUNCTION", "jsonify(dict(\n id=call.id,\n url=url_for(call_view.__name__,\n call_id=call.id),\n ))" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_columns" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.basic_columns" ], [ "BINARY_ADD", "Call.basic_columns + Function.basic_columns" ], [ "CALL_FUNCTION_VAR", "session.query(*(Call.basic_columns + Function.basic_columns))" ], [ "LOOKUP_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)" ], [ "LOOKUP_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "func_name" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path, name=func_name)" ], [ "LOOKUP_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path, name=func_name)\n .order_by" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.start_time" ], [ "LOOKUP_METHOD", "Call.start_time.desc" ], [ "CALL_METHOD", "Call.start_time.desc()" ], [ "CALL_METHOD", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path, name=func_name)\n .order_by(Call.start_time.desc())" ], [ "LOAD_FAST", "limit" ], [ "BINARY_SUBSCR", "session.query(*(Call.basic_columns + Function.basic_columns))\n .join(Function)\n .filter_by(file=path, name=func_name)\n .order_by(Call.start_time.desc())[:limit]" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_METHOD", "session.query(Call)" ], [ "LOOKUP_METHOD", "session.query(Call).filter_by" ], [ "LOAD_FAST", "call_id" ], [ "CALL_METHOD", "session.query(Call).filter_by(id=call_id)" ], [ "LOOKUP_METHOD", "session.query(Call).filter_by(id=call_id).one" ], [ "CALL_METHOD", "session.query(Call).filter_by(id=call_id).one()" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.function" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "template" ], [ "LOAD_GLOBAL", "basename" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.file" ], [ "CALL_FUNCTION", "basename(func.file)" ], [ "LOAD_FAST", "call" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "render_template(template,\n short_path=basename(func.file),\n call=call,\n func=func)" ], [ "LOAD_GLOBAL", "base_call_view" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION", "base_call_view(call_id, 'call.html')" ], [ "LOAD_GLOBAL", "base_call_view" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION", "base_call_view(call_id, 'ipython_call.html')" ], [ "LOAD_GLOBAL", "render_template" ], [ "LOAD_FAST", "call_id" ], [ "CALL_FUNCTION", "render_template('ipython_iframe.html',\n container_id='1234',\n port=7777,\n call_id=call_id)" ], [ "LOAD_GLOBAL", "request" ], [ "LOAD_ATTR", "request.environ" ], [ "LOOKUP_METHOD", "request.environ.get" ], [ "CALL_METHOD", "request.environ.get('werkzeug.server.shutdown')" ], [ "LOAD_FAST", "func" ], [ "COMPARE_OP", "func is None" ], [ "LOAD_GLOBAL", "RuntimeError" ], [ "CALL_FUNCTION", "RuntimeError('Not running with the Werkzeug Server')" ], [ "LOAD_FAST", "func" ], [ "CALL_FUNCTION", "func()" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_METHOD", "session.query(Call)" ], [ "LOOKUP_METHOD", "session.query(Call).filter_by" ], [ "LOAD_FAST", "call_id" ], [ "CALL_METHOD", "session.query(Call).filter_by(id=call_id)" ], [ "LOOKUP_METHOD", "session.query(Call).filter_by(id=call_id).one" ], [ "CALL_METHOD", "session.query(Call).filter_by(id=call_id).one()" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.function" ], [ "LOAD_GLOBAL", "DecentJSONEncoder" ], [ "CALL_FUNCTION", "DecentJSONEncoder()" ], [ "LOOKUP_METHOD", "DecentJSONEncoder().encode" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.parsed_data" ], [ "LOAD_GLOBAL", "Call" ], [ "LOOKUP_METHOD", "Call.basic_dict" ], [ "LOAD_FAST", "call" ], [ "CALL_METHOD", "Call.basic_dict(call)" ], [ "CALL_FUNCTION_KW", "dict(data=call.parsed_data, **Call.basic_dict(call))" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.parsed_data" ], [ "LOAD_GLOBAL", "Function" ], [ "LOOKUP_METHOD", "Function.basic_dict" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "Function.basic_dict(func)" ], [ "CALL_FUNCTION_KW", "dict(data=func.parsed_data, **Function.basic_dict(func))" ], [ "CALL_FUNCTION", "dict(\n call=dict(data=call.parsed_data, **Call.basic_dict(call)),\n function=dict(data=func.parsed_data, **Function.basic_dict(func)))" ], [ "CALL_METHOD", "DecentJSONEncoder().encode(dict(\n call=dict(data=call.parsed_data, **Call.basic_dict(call)),\n function=dict(data=func.parsed_data, **Function.basic_dict(func))))" ], [ "LOAD_FAST", "session" ], [ "LOAD_ATTR", "session.query" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.basic_columns" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.data" ], [ "BINARY_ADD", "Call.basic_columns + (Function.data,)" ], [ "CALL_FUNCTION_VAR", "session.query(*Call.basic_columns + (Function.data,))" ], [ "LOOKUP_METHOD", "session.query(*Call.basic_columns + (Function.data,))\n .join" ], [ "LOAD_GLOBAL", "Function" ], [ "CALL_METHOD", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)" ], [ "LOOKUP_METHOD", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by" ], [ "LOAD_FAST", "body_hash" ], [ "CALL_METHOD", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by(body_hash=body_hash)" ], [ "LOOKUP_METHOD", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by(body_hash=body_hash)\n .order_by" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.start_time" ], [ "LOOKUP_METHOD", "Call.start_time.desc" ], [ "CALL_METHOD", "Call.start_time.desc()" ], [ "CALL_METHOD", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by(body_hash=body_hash)\n .order_by(Call.start_time.desc())" ], [ "BINARY_SUBSCR", "session.query(*Call.basic_columns + (Function.data,))\n .join(Function)\n .filter_by(body_hash=body_hash)\n .order_by(Call.start_time.desc())[:200]" ], [ "LOAD_FAST", "query" ], [ "LOAD_FAST", "query" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "function_data_set" ], [ "LOAD_GLOBAL", "json" ], [ "LOOKUP_METHOD", "json.loads" ], [ "LOAD_DEREF", "function_data" ], [ "CALL_METHOD", "json.loads(function_data)" ], [ "LOAD_FAST", "add" ], [ "LOAD_FAST", "ranges" ], [ "CALL_FUNCTION", "add('node_ranges', ranges)" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "add" ], [ "LOAD_FAST", "current_loop_ranges" ], [ "CALL_FUNCTION", "add('loop_ranges', current_loop_ranges)" ], [ "LOAD_FAST", "loop_ranges" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "current_loop_ranges" ], [ "COMPARE_OP", "loop_ranges in (set(), current_loop_ranges)" ], [ "LOAD_FAST", "current_loop_ranges" ], [ "LOAD_FAST", "ranges" ], [ "LOAD_FAST", "loop_ranges" ], [ "LOAD_GLOBAL", "DecentJSONEncoder" ], [ "CALL_FUNCTION", "DecentJSONEncoder()" ], [ "LOOKUP_METHOD", "DecentJSONEncoder().encode" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "calls" ], [ "LOAD_FAST", "ranges" ], [ "LOAD_FAST", "loop_ranges" ], [ "CALL_FUNCTION", "dict(\n calls=calls, ranges=ranges, loop_ranges=loop_ranges)" ], [ "CALL_METHOD", "DecentJSONEncoder().encode(dict(\n calls=calls, ranges=ranges, loop_ranges=loop_ranges))" ], [ "LOAD_GLOBAL", "Call" ], [ "LOOKUP_METHOD", "Call.basic_dict" ], [ "LOAD_GLOBAL", "withattrs" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_FUNCTION", "Call()" ], [ "LOAD_FAST", "row" ], [ "LOOKUP_METHOD", "row._asdict" ], [ "CALL_METHOD", "row._asdict()" ], [ "CALL_FUNCTION_KW", "withattrs(Call(), **row._asdict())" ], [ "CALL_METHOD", "Call.basic_dict(withattrs(Call(), **row._asdict()))" ], [ "LOAD_FAST", "row" ], [ "LOAD_ATTR", "row.data" ], [ "LOAD_DEREF", "function_data" ], [ "LOAD_FAST", "key" ], [ "BINARY_SUBSCR", "function_data[key]" ], [ "LOAD_FAST", "ranges_set" ], [ "LOOKUP_METHOD", "ranges_set.add" ], [ "LOAD_FAST", "node" ], [ "BINARY_SUBSCR", "node['start']" ], [ "LOAD_FAST", "node" ], [ "BINARY_SUBSCR", "node['end']" ], [ "CALL_METHOD", "ranges_set.add((node['start'], node['end']))" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "CALL_FUNCTION", "dict(start=start, end=end)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "CALL_FUNCTION", "dict(start=start, end=end)" ], [ "LOAD_GLOBAL", "request" ], [ "LOOKUP_METHOD", "request.get_json" ], [ "CALL_METHOD", "request.get_json()" ], [ "LOAD_FAST", "session" ], [ "LOOKUP_METHOD", "session.query" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.body_hash" ], [ "LOAD_GLOBAL", "sqlalchemy" ], [ "LOAD_ATTR", "sqlalchemy.func" ], [ "LOOKUP_METHOD", "sqlalchemy.func.count" ], [ "LOAD_GLOBAL", "Call" ], [ "LOAD_ATTR", "Call.id" ], [ "CALL_METHOD", "sqlalchemy.func.count(Call.id)" ], [ "CALL_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))" ], [ "LOOKUP_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin" ], [ "LOAD_GLOBAL", "Call" ], [ "CALL_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)" ], [ "LOOKUP_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)\n .filter" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.body_hash" ], [ "LOOKUP_METHOD", "Function.body_hash.in_" ], [ "LOAD_FAST", "hashes" ], [ "CALL_METHOD", "Function.body_hash.in_(hashes)" ], [ "CALL_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)\n .filter(Function.body_hash.in_(hashes))" ], [ "LOOKUP_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)\n .filter(Function.body_hash.in_(hashes))\n .group_by" ], [ "LOAD_GLOBAL", "Function" ], [ "LOAD_ATTR", "Function.body_hash" ], [ "CALL_METHOD", "session.query(Function.body_hash, sqlalchemy.func.count(Call.id))\n .outerjoin(Call)\n .filter(Function.body_hash.in_(hashes))\n .group_by(Function.body_hash)" ], [ "LOAD_GLOBAL", "DecentJSONEncoder" ], [ "CALL_FUNCTION", "DecentJSONEncoder()" ], [ "LOOKUP_METHOD", "DecentJSONEncoder().encode" ], [ "LOAD_FAST", "query" ], [ "CALL_METHOD", "DecentJSONEncoder().encode([\n dict(hash=h, count=count)\n for h, count in query\n ])" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_FAST", "h" ], [ "LOAD_FAST", "count" ], [ "CALL_FUNCTION", "dict(hash=h, count=count)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "argv" ], [ "CALL_FUNCTION", "len(argv)" ], [ "COMPARE_OP", "len(argv) == 1" ], [ "LOAD_FAST", "argv" ], [ "BINARY_SUBSCR", "argv[0]" ], [ "LOOKUP_METHOD", "argv[0].isdigit" ], [ "CALL_METHOD", "argv[0].isdigit()" ], [ "LOAD_FAST", "argv" ], [ "LOOKUP_METHOD", "argv.insert" ], [ "CALL_METHOD", "argv.insert(0, '--port')" ], [ "LOAD_GLOBAL", "argparse" ], [ "LOOKUP_METHOD", "argparse.ArgumentParser" ], [ "CALL_METHOD", "argparse.ArgumentParser(description=\"Bird's Eye: A graphical Python debugger\")" ], [ "LOAD_FAST", "parser" ], [ "LOOKUP_METHOD", "parser.add_argument" ], [ "LOAD_GLOBAL", "int" ], [ "CALL_METHOD", "parser.add_argument('-p', '--port', help='HTTP port, default is 7777', default=7777, type=int)" ], [ "LOAD_FAST", "parser" ], [ "LOOKUP_METHOD", "parser.add_argument" ], [ "CALL_METHOD", "parser.add_argument('--host', help=\"HTTP host, default is 'localhost'\", default='localhost')" ], [ "LOAD_FAST", "parser" ], [ "LOOKUP_METHOD", "parser.parse_args" ], [ "LOAD_FAST", "argv" ], [ "CALL_METHOD", "parser.parse_args(argv)" ], [ "LOAD_GLOBAL", "app" ], [ "LOOKUP_METHOD", "app.run" ], [ "LOAD_FAST", "args" ], [ "LOAD_ATTR", "args.port" ], [ "LOAD_FAST", "args" ], [ "LOAD_ATTR", "args.host" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.environ" ], [ "LOOKUP_METHOD", "os.environ.get" ], [ "CALL_METHOD", "os.environ.get('BIRDSEYE_RELOADER')" ], [ "COMPARE_OP", "os.environ.get('BIRDSEYE_RELOADER') == '1'" ], [ "CALL_METHOD", "app.run(\n port=args.port,\n host=args.host,\n use_reloader=os.environ.get('BIRDSEYE_RELOADER') == '1',\n )" ] ], "tests.py": [ [ "LOAD_NAME", "unittest" ], [ "LOAD_ATTR", "unittest.TestCase" ], [ "LOAD_NAME", "unittest" ], [ "LOAD_ATTR", "unittest.TestCase" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "TestFile" ], [ "CALL_FUNCTION", "TestFile()" ], [ "LOOKUP_METHOD", "TestFile().test_file" ], [ "CALL_METHOD", "TestFile().test_file()" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "Tester" ], [ "CALL_FUNCTION", "Tester()" ], [ "LOAD_NAME", "tester" ], [ "CALL_FUNCTION", "tester([1, 2, 3])" ], [ "COMPARE_OP", "tester([1, 2, 3]) == [1, 2, 3]" ], [ "LOAD_NAME", "tester" ], [ "LOAD_ATTR", "tester.asd" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester.asd is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_SUBSCR", "tester[19]" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester[19] is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_POWER", "tester ** 4" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester ** 4 is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_MULTIPLY", "tester * 3" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester * 3 is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_SUBTRACT", "tester - 2" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester - 2 is tester" ], [ "LOAD_NAME", "tester" ], [ "BINARY_ADD", "tester + 1" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester + 1 is tester" ], [ "LOAD_NAME", "tester" ], [ "UNARY_NEGATIVE", "-tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "-tester is tester" ], [ "LOAD_NAME", "tester" ], [ "UNARY_POSITIVE", "+tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "+tester is tester" ], [ "LOAD_NAME", "tester" ], [ "UNARY_INVERT", "~tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "~tester is tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester < 7" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "(tester < 7) is tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester >= 78" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "(tester >= 78) is tester" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "tester != 79" ], [ "LOAD_NAME", "tester" ], [ "COMPARE_OP", "(tester != 79) is tester" ], [ "LOAD_NAME", "tester" ], [ "LOOKUP_METHOD", "tester.foo" ], [ "CALL_METHOD", "tester.foo(45, False)" ], [ "COMPARE_OP", "tester.foo(45, False) == 45" ], [ "LOAD_NAME", "__name__" ], [ "COMPARE_OP", "__name__ == '__main__'" ], [ "LOAD_NAME", "unittest" ], [ "LOOKUP_METHOD", "unittest.main" ], [ "CALL_METHOD", "unittest.main()" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(1)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(2)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(3)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(9\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n 8)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n 99\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(33)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([4,\n 5, 6, [\n 7]])" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "LOAD_GLOBAL", "decorator_with_args" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('123')" ], [ "LOAD_GLOBAL", "int" ], [ "CALL_FUNCTION", "int()" ], [ "CALL_FUNCTION", "decorator_with_args(tester('123'), x=int())" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "tuple([1, 2])" ], [ "CALL_FUNCTION", "list(tuple([1, 2]))" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "CALL_FUNCTION", "tester(list(tuple([1, 2])), returns=empty_decorator)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "tuple(\n [3, 4])" ], [ "CALL_FUNCTION", "list(\n tuple(\n [3, 4]))" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "CALL_FUNCTION", "tester(\n list(\n tuple(\n [3, 4])),\n returns=empty_decorator)" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "LOAD_GLOBAL", "decorator_with_args" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "str()" ], [ "LOAD_GLOBAL", "int" ], [ "CALL_FUNCTION", "int()" ], [ "CALL_FUNCTION", "decorator_with_args(\n str(),\n x=int())" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "tuple([5, 6])" ], [ "CALL_FUNCTION", "list(tuple([5, 6]))" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "CALL_FUNCTION", "tester(list(tuple([5, 6])), returns=empty_decorator)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "tuple([7, 8])" ], [ "CALL_FUNCTION", "list(tuple([7, 8]))" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "CALL_FUNCTION", "tester(list(tuple([7, 8])), returns=empty_decorator)" ], [ "LOAD_GLOBAL", "empty_decorator" ], [ "LOAD_GLOBAL", "decorator_with_args" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('sdf')" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('123234')" ], [ "CALL_FUNCTION", "decorator_with_args(tester('sdf'), x=tester('123234'))" ], [ "CALL_FUNCTION", "decorator_with_args(tester('sdf'), x=tester('123234'))" ], [ "CALL_FUNCTION", "empty_decorator" ], [ "CALL_FUNCTION", "tester(list(tuple([7, 8])), returns=empty_decorator)" ], [ "CALL_FUNCTION", "tester(list(tuple([5, 6])), returns=empty_decorator)" ], [ "CALL_FUNCTION", "decorator_with_args(\n str(),\n x=int())" ], [ "CALL_FUNCTION", "empty_decorator" ], [ "CALL_FUNCTION", "tester(\n list(\n tuple(\n [3, 4])),\n returns=empty_decorator)" ], [ "CALL_FUNCTION", "tester(list(tuple([1, 2])), returns=empty_decorator)" ], [ "CALL_FUNCTION", "decorator_with_args(tester('123'), x=int())" ], [ "CALL_FUNCTION", "empty_decorator" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "str([{tester(x) for x in [1]}, {tester(y) for y in [1]}])" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "str([{tester(x) for x in [1]},\n {tester(x) for x in [1]}])" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "list(tester(x) for x in [1])" ], [ "CALL_FUNCTION", "str([{tester(x) for x in [1]}, list(tester(x) for x in [1])])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "y" ], [ "CALL_FUNCTION", "tester(y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertEqual" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(3)" ], [ "CALL_FUNCTION", "(lambda x: (tester(x), tester(x)))(tester(3))" ], [ "CALL_METHOD", "self.assertEqual(\n (lambda x: (tester(x), tester(x)))(tester(3)),\n (3, 3),\n )" ], [ "CALL_FUNCTION", "(lambda: (lambda: tester(1))())()" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertEqual" ], [ "CALL_FUNCTION", "(lambda: [tester(x) for x in tester([1, 2])])()" ], [ "CALL_METHOD", "self.assertEqual(\n (lambda: [tester(x) for x in tester([1, 2])])(),\n [1, 2],\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "CALL_FUNCTION", "(lambda: tester(1))()" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(1)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x): {tester(b+x): {tester(c+x) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_FAST", "foo" ], [ "CALL_FUNCTION", "foo()" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "CALL_FUNCTION", "tester(a+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "CALL_FUNCTION", "tester(b+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "CALL_FUNCTION", "tester(c+x)" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x): {tester(b+x): {tester(c+x) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+y): {tester(b+y): {tester(c+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x+y): {tester(b+x+y): {tester(c+x+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_FAST", "bar" ], [ "CALL_FUNCTION", "bar()" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "CALL_FUNCTION", "tester(a+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "CALL_FUNCTION", "tester(b+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "CALL_FUNCTION", "tester(c+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+y" ], [ "CALL_FUNCTION", "tester(a+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+y" ], [ "CALL_FUNCTION", "tester(b+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+y" ], [ "CALL_FUNCTION", "tester(c+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+x+y" ], [ "CALL_FUNCTION", "tester(a+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+x+y" ], [ "CALL_FUNCTION", "tester(b+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+x+y" ], [ "CALL_FUNCTION", "tester(c+x+y)" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x): {tester(b+x): {tester(c+x) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+y): {tester(b+y): {tester(c+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x+y): {tester(b+x+y): {tester(c+x+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([5, 6])" ], [ "CALL_FUNCTION", "str({tester(a+x+y+z): {tester(b+x+y+z): {tester(c+x+y+z) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])})" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "CALL_FUNCTION", "tester(a+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "CALL_FUNCTION", "tester(b+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "CALL_FUNCTION", "tester(c+x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+y" ], [ "CALL_FUNCTION", "tester(a+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+y" ], [ "CALL_FUNCTION", "tester(b+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+y" ], [ "CALL_FUNCTION", "tester(c+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+x+y" ], [ "CALL_FUNCTION", "tester(a+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+x+y" ], [ "CALL_FUNCTION", "tester(b+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+x+y" ], [ "CALL_FUNCTION", "tester(c+x+y)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([3, 4])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "a" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "a+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "a+x+y" ], [ "LOAD_DEREF", "z" ], [ "BINARY_ADD", "a+x+y+z" ], [ "CALL_FUNCTION", "tester(a+x+y+z)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "b" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "b+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "b+x+y" ], [ "LOAD_DEREF", "z" ], [ "BINARY_ADD", "b+x+y+z" ], [ "CALL_FUNCTION", "tester(b+x+y+z)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_DEREF", "x" ], [ "BINARY_ADD", "c+x" ], [ "LOAD_DEREF", "y" ], [ "BINARY_ADD", "c+x+y" ], [ "LOAD_DEREF", "z" ], [ "BINARY_ADD", "c+x+y+z" ], [ "CALL_FUNCTION", "tester(c+x+y+z)" ], [ "LOAD_GLOBAL", "dict" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "dict(x=tester)" ], [ "BINARY_SUBSCR", "dict(x=tester)['x']" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "dict(x=tester)['x'](tester)" ], [ "CALL_FUNCTION", "dict(x=tester)['x'](tester)(3, check_func=False)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertRaises" ], [ "LOAD_GLOBAL", "TypeError" ], [ "CALL_METHOD", "self.assertRaises(TypeError)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2, 3])" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(0)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(4)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(5)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "tester(ValueError)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(9)" ], [ "LOAD_GLOBAL", "TypeError" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(10)" ], [ "LOAD_GLOBAL", "str" ], [ "CALL_FUNCTION", "str()" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertRaises" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_GLOBAL", "Exception" ], [ "CALL_FUNCTION", "tester(Exception)" ], [ "CALL_METHOD", "self.assertRaises(tester(Exception))" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(0)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(0)" ], [ "LOAD_GLOBAL", "tester" ], [ "BINARY_TRUE_DIVIDE", "1 / 0" ], [ "CALL_FUNCTION", "tester(1 / 0)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "gen" ], [ "CALL_FUNCTION", "gen()" ], [ "CALL_FUNCTION", "list(gen())" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_FAST", "gen2" ], [ "CALL_FUNCTION", "list(gen2)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tester(x)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(4)" ], [ "LOAD_GLOBAL", "time" ], [ "LOOKUP_METHOD", "time.time" ], [ "CALL_METHOD", "time.time()" ], [ "LOAD_GLOBAL", "range" ], [ "CALL_FUNCTION", "range(10000)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOOKUP_METHOD", "Source.executing" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.currentframe" ], [ "CALL_METHOD", "inspect.currentframe()" ], [ "CALL_METHOD", "Source.executing(inspect.currentframe())" ], [ "LOAD_ATTR", "Source.executing(inspect.currentframe()).node" ], [ "LOAD_FAST", "node" ], [ "COMPARE_OP", "node is None" ], [ "LOAD_FAST", "new_node" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertIs" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "new_node" ], [ "CALL_METHOD", "self.assertIs(node, new_node)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertLess" ], [ "LOAD_GLOBAL", "time" ], [ "LOOKUP_METHOD", "time.time" ], [ "CALL_METHOD", "time.time()" ], [ "LOAD_FAST", "start" ], [ "BINARY_SUBTRACT", "time.time() - start" ], [ "CALL_METHOD", "self.assertLess(time.time() - start, 1)" ], [ "LOAD_FAST", "check" ], [ "CALL_FUNCTION", "check(u'# coding=utf8\\n\u00e9', 'utf8')" ], [ "LOAD_FAST", "check" ], [ "CALL_FUNCTION", "check(u'# coding=gbk\\n\u00e9', 'gbk')" ], [ "LOAD_FAST", "check" ], [ "LOAD_GLOBAL", "UnicodeDecodeError" ], [ "CALL_FUNCTION", "check(u'# coding=utf8\\n\u00e9', 'gbk', exception=UnicodeDecodeError)" ], [ "LOAD_FAST", "check" ], [ "CALL_FUNCTION", "check(u'# coding=gbk\\n\u00e9', 'utf8', matches=False)" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_FAST", "check" ], [ "CALL_FUNCTION", "check(u'\u00e9', 'utf8')" ], [ "LOAD_FAST", "check" ], [ "LOAD_GLOBAL", "SyntaxError" ], [ "CALL_FUNCTION", "check(u'\u00e9', 'gbk', exception=SyntaxError)" ], [ "LOAD_FAST", "source" ], [ "LOOKUP_METHOD", "source.encode" ], [ "LOAD_FAST", "encoding" ], [ "CALL_METHOD", "source.encode(encoding)" ], [ "LOAD_FAST", "exception" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self.assertRaises" ], [ "LOAD_FAST", "exception" ], [ "CALL_METHOD", "self.assertRaises(exception)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOOKUP_METHOD", "Source.decode_source" ], [ "LOAD_FAST", "encoded" ], [ "CALL_METHOD", "Source.decode_source(encoded)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOOKUP_METHOD", "Source.decode_source" ], [ "LOAD_FAST", "encoded" ], [ "CALL_METHOD", "Source.decode_source(encoded)" ], [ "LOAD_FAST", "matches" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self.assertEqual" ], [ "LOAD_FAST", "decoded" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "self.assertEqual(decoded, source)" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self.assertNotEqual" ], [ "LOAD_FAST", "decoded" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "self.assertNotEqual(decoded, source)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('a')" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('''\n ab''')" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester('''\n abc\n def\n '''\n )" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n '''\n 123\n 456\n '''\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n '''\n 345\n 456786\n '''\n )" ], [ "CALL_FUNCTION", "str([\n tester(\n '''\n 123\n 456\n '''\n ),\n tester(\n '''\n 345\n 456786\n '''\n ),\n ])" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(\n [\n '''\n 123\n 456\n '''\n '''\n 345\n 456786\n '''\n ,\n '''\n 123\n 456\n ''',\n '''\n 345\n 456786\n '''\n ]\n )" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(1)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(2)" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester([1, 2])" ], [ "LOAD_GLOBAL", "tester" ], [ "CALL_FUNCTION", "tester(3)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOOKUP_METHOD", "Source.for_filename" ], [ "LOAD_GLOBAL", "__file__" ], [ "CALL_METHOD", "Source.for_filename(__file__)" ], [ "LOOKUP_METHOD", "Source.for_filename(__file__).code_qualname" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.__code__" ], [ "CALL_METHOD", "Source.for_filename(__file__).code_qualname(func.__code__)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertEqual" ], [ "LOAD_FAST", "qn" ], [ "LOAD_FAST", "qualname" ], [ "CALL_METHOD", "self.assertEqual(qn, qualname)" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_FAST", "check_actual_qualname" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertEqual" ], [ "LOAD_FAST", "qn" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.__qualname__" ], [ "CALL_METHOD", "self.assertEqual(qn, func.__qualname__)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertTrue" ], [ "LOAD_FAST", "qn" ], [ "LOOKUP_METHOD", "qn.endswith" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.__name__" ], [ "CALL_METHOD", "qn.endswith(func.__name__)" ], [ "CALL_METHOD", "self.assertTrue(qn.endswith(func.__name__))" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assert_qualname" ], [ "LOAD_GLOBAL", "C" ], [ "LOAD_ATTR", "C.f" ], [ "CALL_METHOD", "self.assert_qualname(C.f, 'C.f')" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assert_qualname" ], [ "LOAD_GLOBAL", "C" ], [ "LOAD_ATTR", "C.D" ], [ "LOAD_ATTR", "C.D.g" ], [ "CALL_METHOD", "self.assert_qualname(C.D.g, 'C.D.g')" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assert_qualname" ], [ "LOAD_GLOBAL", "f" ], [ "CALL_METHOD", "self.assert_qualname(f, 'f')" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assert_qualname" ], [ "LOAD_GLOBAL", "f" ], [ "CALL_FUNCTION", "f()" ], [ "CALL_METHOD", "self.assert_qualname(f(), 'f..g')" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assert_qualname" ], [ "LOAD_GLOBAL", "C" ], [ "LOAD_ATTR", "C.D" ], [ "LOOKUP_METHOD", "C.D.h" ], [ "CALL_METHOD", "C.D.h()" ], [ "CALL_METHOD", "self.assert_qualname(C.D.h(), 'C.D.h..i..j')" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assert_qualname" ], [ "LOAD_GLOBAL", "lamb" ], [ "CALL_METHOD", "self.assert_qualname(lamb, '')" ], [ "LOAD_GLOBAL", "lambda_maker" ], [ "CALL_FUNCTION", "lambda_maker()" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assert_qualname" ], [ "LOAD_FAST", "foo" ], [ "CALL_METHOD", "self.assert_qualname(foo, 'lambda_maker..foo')" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assert_qualname" ], [ "LOAD_FAST", "foo" ], [ "LOAD_ATTR", "foo.x" ], [ "CALL_METHOD", "self.assert_qualname(foo.x, 'lambda_maker..')" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assert_qualname" ], [ "LOAD_FAST", "foo" ], [ "CALL_FUNCTION", "foo()" ], [ "CALL_METHOD", "self.assert_qualname(foo(), 'lambda_maker..foo..')" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assert_qualname" ], [ "LOAD_FAST", "foo" ], [ "CALL_FUNCTION", "foo()" ], [ "CALL_FUNCTION", "foo()()" ], [ "CALL_METHOD", "self.assert_qualname(foo()(), 'lambda_maker..foo..', check_actual_qualname=False)" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "range" ], [ "CALL_FUNCTION", "range(66000)" ], [ "CALL_FUNCTION", "list(range(66000))" ], [ "BINARY_MODULO", "'tester(6)\\n%s\\ntester(9)' % list(range(66000))" ], [ "LOAD_GLOBAL", "tempfile" ], [ "LOOKUP_METHOD", "tempfile.mkstemp" ], [ "CALL_METHOD", "tempfile.mkstemp()" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "compile(source, filename, 'exec')" ], [ "LOAD_GLOBAL", "open" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "open(filename, 'w')" ], [ "LOAD_FAST", "outfile" ], [ "LOOKUP_METHOD", "outfile.write" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "outfile.write(source)" ], [ "LOAD_GLOBAL", "exec" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "exec(code)" ], [ "LOAD_GLOBAL", "range" ], [ "CALL_FUNCTION", "range(5)" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "n" ], [ "CALL_FUNCTION", "range(n)" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "n == 1" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertEqual" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_FAST", "gen" ], [ "CALL_FUNCTION", "only(gen)" ], [ "CALL_METHOD", "self.assertEqual(only(gen), 0)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertRaises" ], [ "LOAD_GLOBAL", "NotOneValueFound" ], [ "CALL_METHOD", "self.assertRaises(NotOneValueFound)" ], [ "LOAD_GLOBAL", "only" ], [ "LOAD_FAST", "gen" ], [ "CALL_FUNCTION", "only(gen)" ], [ "LOAD_FAST", "i" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOOKUP_METHOD", "os.path.join" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOOKUP_METHOD", "os.path.dirname" ], [ "LOAD_GLOBAL", "__file__" ], [ "CALL_METHOD", "os.path.dirname(__file__)" ], [ "CALL_METHOD", "os.path.join(os.path.dirname(__file__), 'not_code.txt', )" ], [ "LOAD_GLOBAL", "Source" ], [ "LOOKUP_METHOD", "Source.for_filename" ], [ "LOAD_FAST", "path" ], [ "CALL_METHOD", "Source.for_filename(path)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertIsNone" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.tree" ], [ "CALL_METHOD", "self.assertIsNone(source.tree)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.currentframe" ], [ "CALL_METHOD", "inspect.currentframe()" ], [ "LOAD_GLOBAL", "Source" ], [ "LOOKUP_METHOD", "Source.executing" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "Source.executing(frame)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertEqual" ], [ "LOAD_FAST", "executing" ], [ "LOOKUP_METHOD", "executing.code_qualname" ], [ "CALL_METHOD", "executing.code_qualname()" ], [ "CALL_METHOD", "self.assertEqual(executing.code_qualname(), 'TestStuff.test_executing_methods')" ], [ "LOAD_GLOBAL", "sys" ], [ "LOAD_ATTR", "sys.version" ], [ "LOOKUP_METHOD", "sys.version.lower" ], [ "CALL_METHOD", "sys.version.lower()" ], [ "COMPARE_OP", "'pypy' not in sys.version.lower()" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertEqual" ], [ "LOAD_FAST", "executing" ], [ "LOOKUP_METHOD", "executing.text" ], [ "CALL_METHOD", "executing.text()" ], [ "LOAD_FAST", "text" ], [ "CALL_METHOD", "self.assertEqual(executing.text(), text)" ], [ "LOAD_FAST", "executing" ], [ "LOOKUP_METHOD", "executing.text_range" ], [ "CALL_METHOD", "executing.text_range()" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.assertEqual" ], [ "LOAD_FAST", "executing" ], [ "LOAD_ATTR", "executing.source" ], [ "LOAD_ATTR", "executing.source.text" ], [ "LOAD_FAST", "start" ], [ "LOAD_FAST", "end" ], [ "BINARY_SUBSCR", "executing.source.text[start:end]" ], [ "LOAD_FAST", "text" ], [ "CALL_METHOD", "self.assertEqual(executing.source.text[start:end], text)" ], [ "LOAD_GLOBAL", "C" ], [ "CALL_FUNCTION", "C()" ], [ "LOAD_GLOBAL", "tester" ], [ "LOAD_FAST", "c" ], [ "LOAD_FAST", "c" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.x" ], [ "LOAD_ATTR", "c.x.x" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.x" ], [ "LOAD_ATTR", "c.x.y" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.y" ], [ "LOAD_ATTR", "c.y.x" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.y" ], [ "LOAD_ATTR", "c.y.y" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.x" ], [ "LOAD_ATTR", "c.x.asd" ], [ "LOAD_FAST", "c" ], [ "LOAD_ATTR", "c.y" ], [ "LOAD_ATTR", "c.y.qwe" ], [ "CALL_FUNCTION", "str((c.x.x, c.x.y, c.y.x, c.y.y, c.x.asd, c.y.qwe))" ], [ "LOAD_GLOBAL", "Source" ], [ "LOOKUP_METHOD", "Source.for_frame" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.currentframe" ], [ "CALL_METHOD", "inspect.currentframe()" ], [ "CALL_METHOD", "Source.for_frame(inspect.currentframe())" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.text" ], [ "LOAD_FAST", "source" ], [ "LOAD_ATTR", "source.filename" ], [ "CALL_FUNCTION", "compile(source.text, source.filename, 'exec')" ], [ "LOAD_GLOBAL", "get_instructions" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "get_instructions(code)" ], [ "LOAD_FAST", "instructions" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.starts_line" ], [ "COMPARE_OP", "inst.starts_line is not None" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.starts_line" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.opname" ], [ "LOOKUP_METHOD", "inst.opname.startswith" ], [ "CALL_METHOD", "inst.opname.startswith(\n ('BINARY_', 'UNARY_', 'LOAD_ATTR', 'LOAD_METHOD', 'LOOKUP_METHOD', 'COMPARE_OP'))" ], [ "LOAD_GLOBAL", "C" ], [ "CALL_FUNCTION", "C()" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.offset" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "code" ], [ "LOAD_FAST", "frame" ], [ "LOAD_GLOBAL", "globals" ], [ "CALL_FUNCTION", "globals()" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "lineno" ], [ "LOAD_FAST", "frame" ], [ "LOAD_GLOBAL", "print" ], [ "LOAD_FAST", "inst" ], [ "LOAD_ATTR", "inst.opname" ], [ "CALL_FUNCTION", "print(inst.opname)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOOKUP_METHOD", "Source.executing" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "Source.executing(frame)" ], [ "LOAD_ATTR", "Source.executing(frame).node" ], [ "COMPARE_OP", "Source.executing(frame).node is not None" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_FAST", "i" ], [ "CALL_FUNCTION", "i()" ], [ "LOAD_FAST", "j" ], [ "LOAD_FAST", "g" ], [ "LOAD_FAST", "assign" ], [ "CALL_FUNCTION", "assign(lambda: 1)" ], [ "CALL_FUNCTION", "assign(lambda: 1)" ], [ "LOAD_FAST", "foo" ], [ "LOAD_FAST", "decorator" ], [ "LOAD_DEREF", "x" ], [ "LOAD_FAST", "func" ], [ "LOAD_FAST", "func" ], [ "LOAD_NAME", "__add__" ], [ "LOAD_NAME", "__invert__" ], [ "LOAD_NAME", "__lt__" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.currentframe" ], [ "CALL_METHOD", "inspect.currentframe()" ], [ "LOAD_ATTR", "inspect.currentframe().f_back" ], [ "LOAD_ATTR", "inspect.currentframe().f_back.f_back" ], [ "LOAD_GLOBAL", "Source" ], [ "LOOKUP_METHOD", "Source.lazycache" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "Source.lazycache(frame)" ], [ "LOAD_GLOBAL", "Source" ], [ "LOOKUP_METHOD", "Source.executing" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "Source.executing(frame)" ], [ "LOAD_ATTR", "Source.executing(frame).node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "typ" ], [ "CALL_FUNCTION", "isinstance(node, typ)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "typ" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.currentframe" ], [ "CALL_METHOD", "inspect.currentframe()" ], [ "LOAD_ATTR", "inspect.currentframe().f_back" ], [ "LOAD_ATTR", "inspect.currentframe().f_back.f_back" ], [ "LOAD_GLOBAL", "eval" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.Expression" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.Expression(node)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_filename" ], [ "CALL_FUNCTION", "compile(ast.Expression(node), frame.f_code.co_filename, 'eval')" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_globals" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "CALL_FUNCTION", "eval(\n compile(ast.Expression(node), frame.f_code.co_filename, 'eval'),\n frame.f_globals,\n frame.f_locals,\n )" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "value" ], [ "COMPARE_OP", "result == value" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Call" ], [ "CALL_METHOD", "self.get_node(ast.Call)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.check" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.args" ], [ "BINARY_SUBSCR", "call.args[0]" ], [ "LOAD_FAST", "arg" ], [ "CALL_METHOD", "self.check(call.args[0], arg)" ], [ "LOAD_FAST", "check_func" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.check" ], [ "LOAD_FAST", "call" ], [ "LOAD_ATTR", "call.func" ], [ "LOAD_FAST", "self" ], [ "CALL_METHOD", "self.check(call.func, self)" ], [ "LOAD_FAST", "returns" ], [ "COMPARE_OP", "returns is None" ], [ "LOAD_FAST", "arg" ], [ "LOAD_FAST", "returns" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Attribute" ], [ "CALL_METHOD", "self.get_node(ast.Attribute)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.value" ], [ "LOAD_FAST", "self" ], [ "CALL_METHOD", "self.check(node.value, self)" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.attr" ], [ "LOAD_FAST", "item" ], [ "COMPARE_OP", "node.attr == item" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Subscript" ], [ "CALL_METHOD", "self.get_node(ast.Subscript)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.value" ], [ "LOAD_FAST", "self" ], [ "CALL_METHOD", "self.check(node.value, self)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.slice" ], [ "LOAD_ATTR", "node.slice.value" ], [ "LOAD_FAST", "item" ], [ "CALL_METHOD", "self.check(node.slice.value, item)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.BinOp" ], [ "CALL_METHOD", "self.get_node(ast.BinOp)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.left" ], [ "LOAD_FAST", "self" ], [ "CALL_METHOD", "self.check(node.left, self)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.right" ], [ "LOAD_FAST", "other" ], [ "CALL_METHOD", "self.check(node.right, other)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.UnaryOp" ], [ "CALL_METHOD", "self.get_node(ast.UnaryOp)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.operand" ], [ "LOAD_FAST", "self" ], [ "CALL_METHOD", "self.check(node.operand, self)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.get_node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Compare" ], [ "CALL_METHOD", "self.get_node(ast.Compare)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.left" ], [ "LOAD_FAST", "self" ], [ "CALL_METHOD", "self.check(node.left, self)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.check" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.comparators" ], [ "BINARY_SUBSCR", "node.comparators[0]" ], [ "LOAD_FAST", "other" ], [ "CALL_METHOD", "self.check(node.comparators[0], other)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "func" ], [ "LOAD_GLOBAL", "empty_decorator" ] ], "tracer.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOOKUP_METHOD", "standard_library.install_aliases" ], [ "CALL_METHOD", "standard_library.install_aliases()" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "NamedTuple" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "Union" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "BINARY_SUBSCR", "Union[ast.expr, ast.stmt]" ], [ "BINARY_SUBSCR", "Optional[Union[ast.expr, ast.stmt]]" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.AST" ], [ "LOAD_NAME", "FrameType" ], [ "LOAD_NAME", "FrameType" ], [ "CALL_FUNCTION", "NamedTuple('EnterCallInfo', [\n\n # Node from where the call was made\n ('call_node', Optional[Union[ast.expr, ast.stmt]]),\n\n # Node where the call begins\n ('enter_node', ast.AST),\n\n # Frame from which the call was made\n ('caller_frame', FrameType),\n\n # Frame of the call\n ('current_frame', FrameType)])" ], [ "LOAD_NAME", "NamedTuple" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "Union" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "BINARY_SUBSCR", "Union[ast.expr, ast.stmt]" ], [ "BINARY_SUBSCR", "Optional[Union[ast.expr, ast.stmt]]" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.Return" ], [ "BINARY_SUBSCR", "Optional[ast.Return]" ], [ "LOAD_NAME", "FrameType" ], [ "LOAD_NAME", "FrameType" ], [ "LOAD_NAME", "Any" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "Exception" ], [ "BINARY_SUBSCR", "Optional[Exception]" ], [ "LOAD_NAME", "Optional" ], [ "LOAD_NAME", "TracebackType" ], [ "BINARY_SUBSCR", "Optional[TracebackType]" ], [ "CALL_FUNCTION", "NamedTuple('ExitCallInfo', [\n\n # Node from where the call was made\n ('call_node', Optional[Union[ast.expr, ast.stmt]]),\n\n # Node where the call explicitly returned\n ('return_node', Optional[ast.Return]),\n\n # Frame from which the call was made\n ('caller_frame', FrameType),\n\n # Frame of the call\n ('current_frame', FrameType),\n\n # Node where the call explicitly returned\n ('return_value', Any),\n\n # Exception raised in the call causing it to end,\n # will propagate to the caller\n ('exc_value', Optional[Exception]),\n\n # Traceback corresponding to exc_value\n ('exc_tb', Optional[TracebackType])])" ], [ "LOAD_NAME", "namedtuple" ], [ "CALL_FUNCTION", "namedtuple('ChangeValue', 'value')" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.NodeTransformer" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "Union" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "LOAD_NAME", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "BINARY_SUBSCR", "Union[ast.For, ast.While, ast.comprehension]" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.PyCF_ONLY_AST" ], [ "LOAD_FAST", "flags" ], [ "BINARY_OR", "ast.PyCF_ONLY_AST | flags" ], [ "CALL_FUNCTION", "compile(source, filename, 'exec', ast.PyCF_ONLY_AST | flags, dont_inherit=True)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.set_basic_node_attributes" ], [ "CALL_METHOD", "self.set_basic_node_attributes()" ], [ "LOAD_FAST", "tracer" ], [ "LOOKUP_METHOD", "tracer.parse_extra" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "CALL_METHOD", "tracer.parse_extra(self.root, source, filename)" ], [ "LOAD_FAST", "new_root" ], [ "COMPARE_OP", "new_root is not None" ], [ "LOAD_FAST", "new_root" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.set_basic_node_attributes" ], [ "CALL_METHOD", "self.set_basic_node_attributes()" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.set_enter_call_nodes" ], [ "CALL_METHOD", "self.set_enter_call_nodes()" ], [ "LOAD_GLOBAL", "deepcopy" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "CALL_FUNCTION", "deepcopy(self.root)" ], [ "LOAD_GLOBAL", "_NodeVisitor" ], [ "CALL_FUNCTION", "_NodeVisitor()" ], [ "LOOKUP_METHOD", "_NodeVisitor().visit" ], [ "LOAD_FAST", "new_root" ], [ "CALL_METHOD", "_NodeVisitor().visit(new_root)" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "new_root" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "flags" ], [ "CALL_FUNCTION", "compile(new_root, filename, \"exec\", dont_inherit=True, flags=flags)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.walk" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "CALL_METHOD", "ast.walk(self.root)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.iter_child_nodes" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.iter_child_nodes(node)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "child" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.nodes" ], [ "CALL_FUNCTION", "len(self.nodes)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.nodes" ], [ "LOOKUP_METHOD", "self.nodes.append" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self.nodes.append(node)" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "LOAD_ATTR", "self.root.body" ], [ "CALL_FUNCTION", "enumerate(self.root.body)" ], [ "LOAD_GLOBAL", "is_future_import" ], [ "LOAD_FAST", "stmt" ], [ "CALL_FUNCTION", "is_future_import(stmt)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.root" ], [ "LOAD_ATTR", "self.root.body" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "self.root.body[:i + 1]" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.walk" ], [ "LOAD_FAST", "s" ], [ "CALL_METHOD", "ast.walk(s)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.nodes" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Module" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(node, (ast.Module, ast.FunctionDef))" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.body" ], [ "LOAD_GLOBAL", "is_future_import" ], [ "LOAD_FAST", "stmt" ], [ "CALL_FUNCTION", "is_future_import(stmt)" ], [ "LOAD_FAST", "stmt" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_NAME", "lru_cache" ], [ "CALL_FUNCTION", "lru_cache()" ], [ "CALL_FUNCTION", "lru_cache()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "defaultdict" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "defaultdict(list)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "TracedFile" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "flags" ], [ "CALL_FUNCTION", "TracedFile(self, source, filename, flags)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._treetrace_hidden_with_stmt" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._treetrace_hidden_before_expr" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self._treetrace_hidden_after_expr" ], [ "LOAD_GLOBAL", "partial" ], [ "LOAD_FAST", "f" ], [ "LOAD_DEREF", "traced_file" ], [ "CALL_FUNCTION", "partial(f, traced_file)" ], [ "LOAD_FAST", "f" ], [ "LOAD_ATTR", "f.__name__" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_DEREF", "func" ], [ "LOAD_GLOBAL", "FunctionType" ], [ "CALL_FUNCTION", "isinstance(func, FunctionType)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError('You can only trace user-defined functions. '\n 'The birdseye decorator must be applied first, '\n 'at the bottom of the list.')" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.iscoroutinefunction" ], [ "LOAD_DEREF", "func" ], [ "CALL_METHOD", "inspect.iscoroutinefunction(func)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.isasyncgenfunction" ], [ "LOAD_DEREF", "func" ], [ "CALL_METHOD", "inspect.isasyncgenfunction(func)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError('You cannot trace async functions')" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_GLOBAL", "is_lambda" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "is_lambda(func)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError('You cannot trace lambdas')" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.getsourcefile" ], [ "LOAD_DEREF", "func" ], [ "CALL_METHOD", "inspect.getsourcefile(func)" ], [ "LOAD_GLOBAL", "is_ipython_cell" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "is_ipython_cell(filename)" ], [ "LOAD_FAST", "get_ipython" ], [ "CALL_FUNCTION", "get_ipython()" ], [ "LOAD_ATTR", "get_ipython().compile" ], [ "LOAD_ATTR", "get_ipython().compile.flags" ], [ "LOOKUP_METHOD", "''.join" ], [ "LOAD_FAST", "linecache" ], [ "LOAD_ATTR", "linecache.cache" ], [ "LOAD_FAST", "filename" ], [ "BINARY_SUBSCR", "linecache.cache[filename]" ], [ "BINARY_SUBSCR", "linecache.cache[filename][2]" ], [ "CALL_METHOD", "''.join(linecache.cache[filename][2])" ], [ "LOAD_GLOBAL", "read_source_file" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "read_source_file(filename)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.compile" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "filename" ], [ "LOAD_FAST", "flags" ], [ "CALL_METHOD", "self.compile(source, filename, flags)" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__dict__" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError('The birdseye decorator must be applied first, '\n 'at the bottom of the list.')" ], [ "LOAD_DEREF", "find_code" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.code" ], [ "CALL_FUNCTION", "find_code(traced_file.code)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_DEREF", "code_options" ], [ "CALL_FUNCTION", "len(code_options)" ], [ "COMPARE_OP", "len(code_options) > 1" ], [ "LOAD_GLOBAL", "is_lambda" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "is_lambda(func)" ], [ "LOAD_GLOBAL", "ValueError" ], [ "CALL_FUNCTION", "ValueError(\"Failed to trace lambda. Convert the function to a def.\")" ], [ "LOAD_DEREF", "code_options" ], [ "BINARY_SUBSCR", "code_options[0]" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__globals__" ], [ "LOOKUP_METHOD", "func.__globals__.update" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._trace_methods_dict" ], [ "LOAD_FAST", "traced_file" ], [ "CALL_METHOD", "self._trace_methods_dict(traced_file)" ], [ "CALL_METHOD", "func.__globals__.update(self._trace_methods_dict(traced_file))" ], [ "LOAD_GLOBAL", "FunctionType" ], [ "LOAD_FAST", "new_func_code" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__globals__" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__name__" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__defaults__" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__closure__" ], [ "CALL_FUNCTION", "FunctionType(new_func_code, func.__globals__, func.__name__, func.__defaults__, func.__closure__)" ], [ "LOAD_GLOBAL", "update_wrapper" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "update_wrapper(new_func, func)" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "getattr(func, '__kwdefaults__', None)" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_FAST", "new_func" ], [ "LOAD_FAST", "root_code" ], [ "LOAD_ATTR", "root_code.co_consts" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.iscode" ], [ "LOAD_FAST", "const" ], [ "CALL_METHOD", "inspect.iscode(const)" ], [ "LOAD_FAST", "const" ], [ "LOAD_ATTR", "const.co_firstlineno" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__code__" ], [ "LOAD_ATTR", "func.__code__.co_firstlineno" ], [ "COMPARE_OP", "const.co_firstlineno == func.__code__.co_firstlineno" ], [ "LOAD_FAST", "const" ], [ "LOAD_ATTR", "const.co_name" ], [ "LOAD_DEREF", "func" ], [ "LOAD_ATTR", "func.__code__" ], [ "LOAD_ATTR", "func.__code__.co_name" ], [ "COMPARE_OP", "const.co_name == func.__code__.co_name" ], [ "LOAD_FAST", "matches" ], [ "LOAD_DEREF", "code_options" ], [ "LOOKUP_METHOD", "code_options.append" ], [ "LOAD_FAST", "const" ], [ "CALL_METHOD", "code_options.append(const)" ], [ "LOAD_DEREF", "find_code" ], [ "LOAD_FAST", "const" ], [ "CALL_FUNCTION", "find_code(const)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.isclass" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "inspect.isclass(func)" ], [ "LOAD_GLOBAL", "TypeError" ], [ "CALL_FUNCTION", "TypeError('Decorating classes is no longer supported')" ], [ "LOAD_FAST", "func" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self.trace_function" ], [ "LOAD_FAST", "func" ], [ "CALL_METHOD", "self.trace_function(func)" ], [ "LOAD_FAST", "optional" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.trace_function" ], [ "LOAD_FAST", "decorator" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self.trace_function" ], [ "LOAD_DEREF", "actual_func" ], [ "CALL_METHOD", "self.trace_function(actual_func)" ], [ "LOAD_GLOBAL", "wraps" ], [ "LOAD_DEREF", "actual_func" ], [ "CALL_FUNCTION", "wraps(actual_func)" ], [ "CALL_FUNCTION", "wraps(actual_func)" ], [ "LOAD_FAST", "wrapper" ], [ "LOAD_FAST", "kwargs" ], [ "LOOKUP_METHOD", "kwargs.pop" ], [ "CALL_METHOD", "kwargs.pop('trace_call', False)" ], [ "LOAD_FAST", "trace_call" ], [ "LOAD_DEREF", "traced" ], [ "LOAD_DEREF", "actual_func" ], [ "LOAD_FAST", "f" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "f(*args, **kwargs)" ], [ "LOAD_GLOBAL", "sys" ], [ "LOOKUP_METHOD", "sys._getframe" ], [ "CALL_METHOD", "sys._getframe(2)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.secondary_to_main_frames" ], [ "LOOKUP_METHOD", "self.secondary_to_main_frames.get" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self.secondary_to_main_frames.get(frame)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "COMPARE_OP", "frame.f_code.co_name in ('', '', '')" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_GLOBAL", "ancestors" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "ancestors(node)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Lambda" ], [ "CALL_FUNCTION", "isinstance(node, (ast.FunctionDef, ast.Lambda))" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.ClassDef" ], [ "CALL_FUNCTION", "isinstance(node, ast.ClassDef)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "COMPARE_OP", "frame.f_code.co_name in ('', '')" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.secondary_to_main_frames" ], [ "LOAD_FAST", "original_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.main_to_secondary_frames" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.main_to_secondary_frames[frame]" ], [ "LOOKUP_METHOD", "self.main_to_secondary_frames[frame].append" ], [ "LOAD_FAST", "original_frame" ], [ "CALL_METHOD", "self.main_to_secondary_frames[frame].append(original_frame)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.nodes" ], [ "LOAD_FAST", "_tree_index" ], [ "BINARY_SUBSCR", "traced_file.nodes[_tree_index]" ], [ "LOAD_GLOBAL", "cast" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "cast(ast.stmt, node)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._main_frame" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self._main_frame(node)" ], [ "LOAD_GLOBAL", "_StmtContext" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "_StmtContext(self, node, frame)" ], [ "LOAD_FAST", "traced_file" ], [ "LOAD_ATTR", "traced_file.nodes" ], [ "LOAD_FAST", "_tree_index" ], [ "BINARY_SUBSCR", "traced_file.nodes[_tree_index]" ], [ "LOAD_GLOBAL", "cast" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "cast(ast.expr, node)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._main_frame" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self._main_frame(node)" ], [ "LOAD_FAST", "frame" ], [ "COMPARE_OP", "frame is None" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_stack" ], [ "LOOKUP_METHOD", "frame_info.expression_stack.append" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "frame_info.expression_stack.append(node)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.before_expr" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self.before_expr(node, frame)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._main_frame" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self._main_frame(node)" ], [ "LOAD_FAST", "frame" ], [ "COMPARE_OP", "frame is None" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._after_expr" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "value" ], [ "CALL_METHOD", "self._after_expr(node, frame, value, None, None)" ], [ "LOAD_FAST", "result" ], [ "COMPARE_OP", "result is not None" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "ChangeValue" ], [ "CALL_FUNCTION", "isinstance(result, ChangeValue)" ], [ "LOAD_FAST", "result" ], [ "LOAD_ATTR", "result.value" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.stack[frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_stack" ], [ "LOOKUP_METHOD", "frame_info.expression_stack.pop" ], [ "CALL_METHOD", "frame_info.expression_stack.pop()" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_values" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.after_expr" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "exc_value" ], [ "LOAD_FAST", "exc_tb" ], [ "CALL_METHOD", "self.after_expr(node, frame, value, exc_value, exc_tb)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._get_caller_stuff" ], [ "LOAD_FAST", "current_frame" ], [ "CALL_METHOD", "self._get_caller_stuff(current_frame)" ], [ "LOAD_GLOBAL", "FrameInfo" ], [ "CALL_FUNCTION", "FrameInfo()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "current_frame" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.enter_call" ], [ "LOAD_GLOBAL", "EnterCallInfo" ], [ "LOAD_FAST", "call_node" ], [ "LOAD_FAST", "enter_node" ], [ "LOAD_FAST", "caller_frame" ], [ "LOAD_FAST", "current_frame" ], [ "CALL_FUNCTION", "EnterCallInfo(call_node, enter_node, caller_frame, current_frame)" ], [ "CALL_METHOD", "self.enter_call(EnterCallInfo(call_node, enter_node, caller_frame, current_frame))" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_back" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.secondary_to_main_frames" ], [ "LOOKUP_METHOD", "self.secondary_to_main_frames.get" ], [ "LOAD_FAST", "caller_frame" ], [ "CALL_METHOD", "self.secondary_to_main_frames.get(caller_frame)" ], [ "LOAD_FAST", "main_frame" ], [ "LOAD_FAST", "main_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.stack" ], [ "LOAD_FAST", "caller_frame" ], [ "BINARY_SUBSCR", "self.stack[caller_frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_stack" ], [ "LOAD_FAST", "expression_stack" ], [ "LOAD_FAST", "expression_stack" ], [ "BINARY_SUBSCR", "expression_stack[-1]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.statement_stack" ], [ "BINARY_SUBSCR", "frame_info.statement_stack[-1]" ], [ "LOAD_FAST", "caller_frame" ], [ "LOAD_FAST", "call_node" ], [ "LOAD_NAME", "staticmethod" ], [ "CALL_FUNCTION", "staticmethod" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "getattr(node, '_visit_ignore', False)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.expr" ], [ "CALL_FUNCTION", "isinstance(node, ast.expr)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "hasattr(node, \"ctx\")" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.ctx" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Load" ], [ "CALL_FUNCTION", "isinstance(node.ctx, ast.Load)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_GLOBAL", "ast" ], [ "CALL_FUNCTION", "getattr(ast, 'Starred', ())" ], [ "CALL_FUNCTION", "isinstance(node, getattr(ast, 'Starred', ()))" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.visit_expr" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self.visit_expr(node)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.stmt" ], [ "CALL_FUNCTION", "isinstance(node, ast.stmt)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.visit_stmt" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "self.visit_stmt(node)" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "_NodeVisitor" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self)" ], [ "LOOKUP_METHOD", "super(_NodeVisitor, self).generic_visit" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "super(_NodeVisitor, self).generic_visit(node)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._create_simple_marker_call" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "TreeTracerBase" ], [ "LOAD_ATTR", "TreeTracerBase._treetrace_hidden_before_expr" ], [ "CALL_METHOD", "self._create_simple_marker_call(node, TreeTracerBase._treetrace_hidden_before_expr)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.copy_location" ], [ "LOAD_FAST", "before_marker" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.copy_location(before_marker, node)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.Call" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.Name" ], [ "LOAD_GLOBAL", "TreeTracerBase" ], [ "LOAD_ATTR", "TreeTracerBase._treetrace_hidden_after_expr" ], [ "LOAD_ATTR", "TreeTracerBase._treetrace_hidden_after_expr.__name__" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.Load" ], [ "CALL_METHOD", "ast.Load()" ], [ "CALL_METHOD", "ast.Name(id=TreeTracerBase._treetrace_hidden_after_expr.__name__,\n ctx=ast.Load())" ], [ "LOAD_FAST", "before_marker" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "_NodeVisitor" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self)" ], [ "LOOKUP_METHOD", "super(_NodeVisitor, self).generic_visit" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "super(_NodeVisitor, self).generic_visit(node)" ], [ "CALL_METHOD", "ast.Call(\n func=ast.Name(id=TreeTracerBase._treetrace_hidden_after_expr.__name__,\n ctx=ast.Load()),\n args=[\n before_marker,\n super(_NodeVisitor, self).generic_visit(node),\n ],\n keywords=[],\n )" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.copy_location" ], [ "LOAD_FAST", "after_marker" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.copy_location(after_marker, node)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.fix_missing_locations" ], [ "LOAD_FAST", "after_marker" ], [ "CALL_METHOD", "ast.fix_missing_locations(after_marker)" ], [ "LOAD_FAST", "after_marker" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._create_simple_marker_call" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "_NodeVisitor" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(_NodeVisitor, self)" ], [ "LOOKUP_METHOD", "super(_NodeVisitor, self).generic_visit" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "super(_NodeVisitor, self).generic_visit(node)" ], [ "LOAD_GLOBAL", "TreeTracerBase" ], [ "LOAD_ATTR", "TreeTracerBase._treetrace_hidden_with_stmt" ], [ "CALL_METHOD", "self._create_simple_marker_call(\n super(_NodeVisitor, self).generic_visit(node),\n TreeTracerBase._treetrace_hidden_with_stmt)" ], [ "LOAD_GLOBAL", "PY3" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.With" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.withitem" ], [ "LOAD_FAST", "context_expr" ], [ "CALL_METHOD", "ast.withitem(context_expr=context_expr)" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.With(\n items=[ast.withitem(context_expr=context_expr)],\n body=[node],\n )" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.With" ], [ "LOAD_FAST", "context_expr" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.With(\n context_expr=context_expr,\n body=[node],\n )" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.copy_location" ], [ "LOAD_FAST", "wrapped" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "ast.copy_location(wrapped, node)" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.fix_missing_locations" ], [ "LOAD_FAST", "wrapped" ], [ "CALL_METHOD", "ast.fix_missing_locations(wrapped)" ], [ "LOAD_FAST", "wrapped" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.Call" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.Name" ], [ "LOAD_FAST", "func" ], [ "LOAD_ATTR", "func.__name__" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.Load" ], [ "CALL_METHOD", "ast.Load()" ], [ "CALL_METHOD", "ast.Name(id=func.__name__,\n ctx=ast.Load())" ], [ "LOAD_GLOBAL", "ast" ], [ "LOOKUP_METHOD", "ast.Num" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node._tree_index" ], [ "CALL_METHOD", "ast.Num(node._tree_index)" ], [ "CALL_METHOD", "ast.Call(\n func=ast.Name(id=func.__name__,\n ctx=ast.Load()),\n args=[ast.Num(node._tree_index)],\n keywords=[],\n )" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tracer" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_GLOBAL", "getattr" ], [ "LOAD_FAST", "node" ], [ "CALL_FUNCTION", "getattr(node, '_enter_call_node', False)" ], [ "LOAD_FAST", "tracer" ], [ "LOOKUP_METHOD", "tracer._enter_call" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "tracer._enter_call(node, frame)" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "tracer.stack[frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.statement_stack" ], [ "LOOKUP_METHOD", "frame_info.statement_stack.append" ], [ "LOAD_FAST", "node" ], [ "CALL_METHOD", "frame_info.statement_stack.append(node)" ], [ "LOAD_FAST", "tracer" ], [ "LOOKUP_METHOD", "tracer.before_stmt" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "tracer.before_stmt(node, frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.node" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tracer" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.stack" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "tracer.stack[frame]" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.statement_stack" ], [ "LOOKUP_METHOD", "frame_info.statement_stack.pop" ], [ "CALL_METHOD", "frame_info.statement_stack.pop()" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.exc_value" ], [ "COMPARE_OP", "exc_val is not frame_info.exc_value" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_stack" ], [ "LOAD_FAST", "expression_stack" ], [ "LOAD_FAST", "expression_stack" ], [ "BINARY_SUBSCR", "expression_stack[-1]" ], [ "LOAD_FAST", "tracer" ], [ "LOOKUP_METHOD", "tracer._after_expr" ], [ "LOAD_FAST", "exc_node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "exc_tb" ], [ "CALL_METHOD", "tracer._after_expr(exc_node, frame, None, exc_val, exc_tb)" ], [ "LOAD_FAST", "tracer" ], [ "LOOKUP_METHOD", "tracer.after_stmt" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "exc_tb" ], [ "LOAD_FAST", "exc_node" ], [ "CALL_METHOD", "tracer.after_stmt(node, frame, exc_val, exc_tb, exc_node)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "node" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Return" ], [ "CALL_FUNCTION", "isinstance(node, ast.Return)" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.return_node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.Module" ], [ "CALL_FUNCTION", "isinstance(parent, (ast.FunctionDef, ast.Module))" ], [ "LOAD_FAST", "node" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.body" ], [ "BINARY_SUBSCR", "parent.body[-1]" ], [ "COMPARE_OP", "node is parent.body[-1]" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_FAST", "exiting" ], [ "LOAD_FAST", "tracer" ], [ "LOOKUP_METHOD", "tracer._get_caller_stuff" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "tracer._get_caller_stuff(frame)" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_ATTR", "return_node.value" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.expression_values" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_ATTR", "return_node.value" ], [ "BINARY_SUBSCR", "frame_info.expression_values[return_node.value]" ], [ "LOAD_FAST", "tracer" ], [ "LOOKUP_METHOD", "tracer.exit_call" ], [ "LOAD_GLOBAL", "ExitCallInfo" ], [ "LOAD_FAST", "call_node" ], [ "LOAD_FAST", "return_node" ], [ "LOAD_FAST", "caller_frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "return_value" ], [ "LOAD_FAST", "exc_val" ], [ "LOAD_FAST", "exc_tb" ], [ "CALL_FUNCTION", "ExitCallInfo(call_node,\n return_node,\n caller_frame,\n frame,\n return_value,\n exc_val,\n exc_tb\n )" ], [ "CALL_METHOD", "tracer.exit_call(ExitCallInfo(call_node,\n return_node,\n caller_frame,\n frame,\n return_value,\n exc_val,\n exc_tb\n ))" ], [ "LOAD_FAST", "tracer" ], [ "LOAD_ATTR", "tracer.stack" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tracer" ], [ "LOAD_ATTR", "self.tracer.main_to_secondary_frames" ], [ "LOOKUP_METHOD", "self.tracer.main_to_secondary_frames.pop" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self.tracer.main_to_secondary_frames.pop(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.tracer" ], [ "LOAD_ATTR", "self.tracer.secondary_to_main_frames" ], [ "LOAD_FAST", "secondary_frame" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "node" ], [ "LOAD_DEREF", "node" ], [ "LOAD_ATTR", "node.parent" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.FunctionDef" ], [ "CALL_FUNCTION", "isinstance(parent, ast.FunctionDef)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.For" ], [ "CALL_FUNCTION", "isinstance(parent, ast.For)" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.iter" ], [ "LOAD_DEREF", "node" ], [ "COMPARE_OP", "parent.iter is not node" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.While" ], [ "CALL_FUNCTION", "isinstance(parent, ast.While)" ], [ "LOAD_DEREF", "node" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.orelse" ], [ "COMPARE_OP", "node not in parent.orelse" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.comprehension" ], [ "CALL_FUNCTION", "isinstance(parent, ast.comprehension)" ], [ "LOAD_DEREF", "node" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.ifs" ], [ "COMPARE_OP", "node in parent.ifs" ], [ "LOAD_FAST", "is_containing_loop" ], [ "LOAD_FAST", "result" ], [ "LOOKUP_METHOD", "result.append" ], [ "LOAD_FAST", "parent" ], [ "CALL_METHOD", "result.append(parent)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "parent" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.ListComp" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.GeneratorExp" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.DictComp" ], [ "LOAD_GLOBAL", "ast" ], [ "LOAD_ATTR", "ast.SetComp" ], [ "CALL_FUNCTION", "isinstance(parent, (ast.ListComp,\n ast.GeneratorExp,\n ast.DictComp,\n ast.SetComp))" ], [ "LOAD_FAST", "parent" ], [ "LOAD_ATTR", "parent.generators" ], [ "LOAD_DEREF", "node" ], [ "LOAD_FAST", "generators" ], [ "COMPARE_OP", "node in generators" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "takewhile" ], [ "LOAD_FAST", "generators" ], [ "CALL_FUNCTION", "takewhile(lambda n: n != node, generators)" ], [ "CALL_FUNCTION", "list(takewhile(lambda n: n != node, generators))" ], [ "LOAD_FAST", "result" ], [ "LOOKUP_METHOD", "result.extend" ], [ "LOAD_GLOBAL", "reversed" ], [ "LOAD_FAST", "generators" ], [ "CALL_FUNCTION", "reversed(generators)" ], [ "CALL_METHOD", "result.extend(reversed(generators))" ], [ "LOAD_FAST", "parent" ], [ "LOAD_FAST", "result" ], [ "LOOKUP_METHOD", "result.reverse" ], [ "CALL_METHOD", "result.reverse()" ], [ "LOAD_GLOBAL", "tuple" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "tuple(result)" ], [ "LOAD_FAST", "n" ], [ "LOAD_DEREF", "node" ], [ "COMPARE_OP", "n != node" ] ], "tracer2.py": [ [ "LOAD_NAME", "find_repr_function" ], [ "LOAD_NAME", "six" ], [ "LOAD_ATTR", "six.text_type" ], [ "CALL_FUNCTION", "find_repr_function(six.text_type)" ], [ "LOAD_NAME", "find_repr_function" ], [ "LOAD_NAME", "six" ], [ "LOAD_ATTR", "six.binary_type" ], [ "CALL_FUNCTION", "find_repr_function(six.binary_type)" ], [ "LOAD_NAME", "find_repr_function" ], [ "LOAD_NAME", "object" ], [ "CALL_FUNCTION", "find_repr_function(object)" ], [ "LOAD_NAME", "find_repr_function" ], [ "LOAD_NAME", "int" ], [ "CALL_FUNCTION", "find_repr_function(int)" ], [ "LOAD_NAME", "cheap_repr" ], [ "LOAD_NAME", "object" ], [ "LOAD_NAME", "threading" ], [ "LOOKUP_METHOD", "threading.local" ], [ "CALL_METHOD", "threading.local()" ], [ "LOAD_NAME", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOOKUP_METHOD", "os.path.dirname" ], [ "LOAD_ATTR", "(lambda: 0).__code__" ], [ "LOAD_ATTR", "(lambda: 0).__code__.co_filename" ], [ "CALL_METHOD", "os.path.dirname((lambda: 0).__code__.co_filename)" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOOKUP_METHOD", "os.path.dirname" ], [ "LOAD_NAME", "birdseye" ], [ "LOAD_ATTR", "birdseye.__file__" ], [ "CALL_METHOD", "os.path.dirname(birdseye.__file__)" ], [ "LOAD_NAME", "type" ], [ "LOAD_NAME", "six" ], [ "LOOKUP_METHOD", "six.add_metaclass" ], [ "LOAD_NAME", "TracerMeta" ], [ "CALL_METHOD", "six.add_metaclass(TracerMeta)" ], [ "LOAD_NAME", "object" ], [ "CALL_FUNCTION", "six.add_metaclass(TracerMeta)" ], [ "LOAD_NAME", "object" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_lineno" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "CALL_FUNCTION", "OrderedDict()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "Source" ], [ "LOOKUP_METHOD", "Source.for_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "Source.for_frame(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_flags" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOAD_ATTR", "inspect.CO_GENERATOR" ], [ "BINARY_AND", "frame.f_code.co_flags & inspect.CO_GENERATOR" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "is_comprehension_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "is_comprehension_frame(frame)" ], [ "LOAD_GLOBAL", "re" ], [ "LOOKUP_METHOD", "re.match" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "CALL_METHOD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name)" ], [ "LOOKUP_METHOD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group" ], [ "CALL_METHOD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group(1)" ], [ "LOOKUP_METHOD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group(1).title" ], [ "CALL_METHOD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group(1).title()" ], [ "BINARY_ADD", "re.match(r'<(\\w+)comp>', frame.f_code.co_name).group(1).title()\n + u' comprehension'" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_ATTR", "self.frame.f_lineno" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.local_reprs" ], [ "LOAD_GLOBAL", "OrderedDict" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.get_local_reprs" ], [ "LOAD_FAST", "watch" ], [ "LOAD_FAST", "watch_extras" ], [ "CALL_METHOD", "self.get_local_reprs(watch, watch_extras)" ], [ "CALL_FUNCTION", "OrderedDict(\n (source, my_cheap_repr(value))\n for source, value in\n self.get_local_reprs(watch, watch_extras)\n )" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.comprehension_type" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.local_reprs" ], [ "LOOKUP_METHOD", "self.local_reprs.items" ], [ "CALL_METHOD", "self.local_reprs.items()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.comprehension_variables" ], [ "LOOKUP_METHOD", "self.comprehension_variables.setdefault" ], [ "LOAD_FAST", "name" ], [ "CALL_METHOD", "self.comprehension_variables.setdefault(name, [])" ], [ "LOAD_FAST", "values" ], [ "LOAD_FAST", "values" ], [ "BINARY_SUBSCR", "values[-1]" ], [ "LOAD_FAST", "value_repr" ], [ "COMPARE_OP", "values[-1] != value_repr" ], [ "LOAD_FAST", "values" ], [ "LOOKUP_METHOD", "values.append" ], [ "LOAD_FAST", "value_repr" ], [ "CALL_METHOD", "values.append(value_repr)" ], [ "LOAD_GLOBAL", "truncate_list" ], [ "LOAD_FAST", "values" ], [ "CALL_FUNCTION", "truncate_list(values, 11)" ], [ "LOAD_FAST", "values" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event in ('return', 'exception')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.comprehension_variables" ], [ "LOOKUP_METHOD", "self.comprehension_variables.items" ], [ "CALL_METHOD", "self.comprehension_variables.items()" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.local_reprs" ], [ "LOOKUP_METHOD", "self.local_reprs.items" ], [ "CALL_METHOD", "self.local_reprs.items()" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "old_local_reprs" ], [ "COMPARE_OP", "name not in old_local_reprs" ], [ "LOAD_FAST", "old_local_reprs" ], [ "LOAD_FAST", "name" ], [ "BINARY_SUBSCR", "old_local_reprs[name]" ], [ "LOAD_FAST", "value_repr" ], [ "COMPARE_OP", "old_local_reprs[name] != value_repr" ], [ "LOAD_FAST", "variables" ], [ "LOOKUP_METHOD", "variables.append" ], [ "LOAD_FAST", "name" ], [ "LOAD_FAST", "value_repr" ], [ "CALL_METHOD", "variables.append((name, value_repr))" ], [ "LOAD_FAST", "variables" ], [ "LOAD_FAST", "source" ], [ "LOAD_GLOBAL", "my_cheap_repr" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "my_cheap_repr(value)" ], [ "LOAD_FAST", "name" ], [ "LOOKUP_METHOD", "', '.join" ], [ "LOAD_FAST", "values" ], [ "CALL_METHOD", "', '.join(values)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_varnames" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_cellvars" ], [ "BINARY_ADD", "code.co_varnames + code.co_cellvars" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_freevars" ], [ "BINARY_ADD", "code.co_varnames + code.co_cellvars + code.co_freevars" ], [ "LOAD_GLOBAL", "tuple" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "LOOKUP_METHOD", "frame.f_locals.keys" ], [ "CALL_METHOD", "frame.f_locals.keys()" ], [ "CALL_FUNCTION", "tuple(frame.f_locals.keys())" ], [ "BINARY_ADD", "code.co_varnames + code.co_cellvars + code.co_freevars + tuple(frame.f_locals.keys())" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_locals" ], [ "LOOKUP_METHOD", "frame.f_locals.items" ], [ "CALL_METHOD", "frame.f_locals.items()" ], [ "CALL_FUNCTION", "sorted(\n frame.f_locals.items(),\n key=lambda key_value: vars_order.index(key_value[0])\n )" ], [ "LOAD_FAST", "watch" ], [ "LOAD_GLOBAL", "sorted" ], [ "LOAD_FAST", "variable" ], [ "LOOKUP_METHOD", "variable.items" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "variable.items(frame)" ], [ "CALL_FUNCTION", "sorted(variable.items(frame))" ], [ "LOAD_FAST", "result_items" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "value" ], [ "LOAD_FAST", "watch_extras" ], [ "LOAD_FAST", "extra" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "value" ], [ "CALL_FUNCTION", "extra(source, value)" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_FAST", "pair" ], [ "COMPARE_OP", "pair is not None" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "pair" ], [ "CALL_FUNCTION", "len(pair)" ], [ "COMPARE_OP", "len(pair) == 2" ], [ "LOAD_FAST", "pair" ], [ "LOAD_DEREF", "vars_order" ], [ "LOOKUP_METHOD", "vars_order.index" ], [ "LOAD_FAST", "key_value" ], [ "BINARY_SUBSCR", "key_value[0]" ], [ "CALL_METHOD", "vars_order.index(key_value[0])" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "TracerMeta" ], [ "LOAD_FAST", "mcs" ], [ "CALL_FUNCTION", "super(TracerMeta, mcs)" ], [ "LOAD_ATTR", "super(TracerMeta, mcs).__new__" ], [ "LOAD_FAST", "mcs" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "super(TracerMeta, mcs).__new__(mcs, *args, **kwargs)" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "result()" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "no_args_decorator" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION", "no_args_decorator(args, kwargs)" ], [ "LOAD_FAST", "cls" ], [ "LOOKUP_METHOD", "cls.default" ], [ "LOAD_FAST", "args" ], [ "BINARY_SUBSCR", "args[0]" ], [ "CALL_METHOD", "cls.default(args[0])" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "TracerMeta" ], [ "LOAD_FAST", "cls" ], [ "CALL_FUNCTION", "super(TracerMeta, cls)" ], [ "LOAD_ATTR", "super(TracerMeta, cls).__call__" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "super(TracerMeta, cls).__call__(*args, **kwargs)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.default" ], [ "LOOKUP_METHOD", "self.default.__enter__" ], [ "CALL_METHOD", "self.default.__enter__(context=1)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.default" ], [ "LOAD_ATTR", "self.default.__exit__" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION_VAR", "self.default.__exit__(*args, context=1)" ], [ "LOAD_GLOBAL", "ensure_tuple" ], [ "LOAD_FAST", "watch" ], [ "CALL_FUNCTION", "ensure_tuple(watch)" ], [ "LOAD_GLOBAL", "ensure_tuple" ], [ "LOAD_FAST", "watch_explode" ], [ "CALL_FUNCTION", "ensure_tuple(watch_explode)" ], [ "BINARY_ADD", "[\n v if isinstance(v, BaseVariable) else CommonVariable(v)\n for v in ensure_tuple(watch)\n ] + [\n v if isinstance(v, BaseVariable) else Exploding(v)\n for v in ensure_tuple(watch_explode)\n ]" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "ArgDefaultDict" ], [ "LOAD_GLOBAL", "FrameInfo" ], [ "CALL_FUNCTION", "ArgDefaultDict(FrameInfo)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "depth" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.depth" ], [ "COMPARE_OP", "self.depth >= 1" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "set" ], [ "CALL_FUNCTION", "set()" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "BaseVariable" ], [ "CALL_FUNCTION", "isinstance(v, BaseVariable)" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "CommonVariable" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "CommonVariable(v)" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "BaseVariable" ], [ "CALL_FUNCTION", "isinstance(v, BaseVariable)" ], [ "LOAD_FAST", "v" ], [ "LOAD_GLOBAL", "Exploding" ], [ "LOAD_FAST", "v" ], [ "CALL_FUNCTION", "Exploding(v)" ], [ "LOAD_GLOBAL", "iscoroutinefunction" ], [ "LOAD_DEREF", "function" ], [ "CALL_FUNCTION", "iscoroutinefunction(function)" ], [ "LOAD_GLOBAL", "NotImplementedError" ], [ "CALL_FUNCTION", "NotImplementedError(\"coroutines are not supported, sorry!\")" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.target_codes" ], [ "LOOKUP_METHOD", "self.target_codes.add" ], [ "LOAD_DEREF", "function" ], [ "LOAD_ATTR", "function.__code__" ], [ "CALL_METHOD", "self.target_codes.add(function.__code__)" ], [ "LOAD_GLOBAL", "functools" ], [ "LOOKUP_METHOD", "functools.wraps" ], [ "LOAD_DEREF", "function" ], [ "CALL_METHOD", "functools.wraps(function)" ], [ "CALL_FUNCTION", "functools.wraps(function)" ], [ "LOAD_GLOBAL", "functools" ], [ "LOOKUP_METHOD", "functools.wraps" ], [ "LOAD_DEREF", "function" ], [ "CALL_METHOD", "functools.wraps(function)" ], [ "CALL_FUNCTION", "functools.wraps(function)" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.isgeneratorfunction" ], [ "LOAD_DEREF", "function" ], [ "CALL_METHOD", "inspect.isgeneratorfunction(function)" ], [ "LOAD_FAST", "generator_wrapper" ], [ "LOAD_FAST", "simple_wrapper" ], [ "LOAD_DEREF", "self" ], [ "LOAD_DEREF", "function" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "function(*args, **kwargs)" ], [ "LOAD_DEREF", "function" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "function(*args, **kwargs)" ], [ "LOAD_FAST", "gen" ], [ "LOAD_ATTR", "gen.send" ], [ "LOAD_DEREF", "self" ], [ "LOAD_FAST", "method" ], [ "LOAD_FAST", "incoming" ], [ "CALL_FUNCTION", "method(incoming)" ], [ "LOAD_GLOBAL", "StopIteration" ], [ "LOAD_FAST", "gen" ], [ "LOAD_ATTR", "gen.send" ], [ "LOAD_FAST", "outgoing" ], [ "LOAD_GLOBAL", "Exception" ], [ "LOAD_FAST", "gen" ], [ "LOAD_ATTR", "gen.throw" ], [ "LOAD_FAST", "e" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.enabled" ], [ "LOAD_GLOBAL", "sys" ], [ "LOOKUP_METHOD", "sys._getframe" ], [ "LOAD_FAST", "context" ], [ "BINARY_ADD", "context + 1" ], [ "CALL_METHOD", "sys._getframe(context + 1)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._is_internal_frame" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_METHOD", "self._is_internal_frame(calling_frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.trace" ], [ "LOAD_FAST", "calling_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.target_frames" ], [ "LOOKUP_METHOD", "self.target_frames.add" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_METHOD", "self.target_frames.add(calling_frame)" ], [ "LOAD_FAST", "calling_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.trace" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_METHOD", "self.trace(calling_frame, 'enter', None)" ], [ "LOAD_GLOBAL", "thread_global" ], [ "LOAD_ATTR", "thread_global.__dict__" ], [ "LOOKUP_METHOD", "thread_global.__dict__.setdefault" ], [ "CALL_METHOD", "thread_global.__dict__.setdefault('original_trace_functions', [])" ], [ "LOAD_FAST", "stack" ], [ "LOOKUP_METHOD", "stack.append" ], [ "LOAD_GLOBAL", "sys" ], [ "LOOKUP_METHOD", "sys.gettrace" ], [ "CALL_METHOD", "sys.gettrace()" ], [ "CALL_METHOD", "stack.append(sys.gettrace())" ], [ "LOAD_GLOBAL", "sys" ], [ "LOOKUP_METHOD", "sys.settrace" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.trace" ], [ "CALL_METHOD", "sys.settrace(self.trace)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.enabled" ], [ "LOAD_GLOBAL", "thread_global" ], [ "LOAD_ATTR", "thread_global.original_trace_functions" ], [ "LOAD_GLOBAL", "sys" ], [ "LOOKUP_METHOD", "sys.settrace" ], [ "LOAD_FAST", "stack" ], [ "LOOKUP_METHOD", "stack.pop" ], [ "CALL_METHOD", "stack.pop()" ], [ "CALL_METHOD", "sys.settrace(stack.pop())" ], [ "LOAD_GLOBAL", "sys" ], [ "LOOKUP_METHOD", "sys._getframe" ], [ "LOAD_FAST", "context" ], [ "BINARY_ADD", "context + 1" ], [ "CALL_METHOD", "sys._getframe(context + 1)" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.trace" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_METHOD", "self.trace(calling_frame, 'exit', None)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.target_frames" ], [ "LOOKUP_METHOD", "self.target_frames.discard" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_METHOD", "self.target_frames.discard(calling_frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame_infos" ], [ "LOOKUP_METHOD", "self.frame_infos.pop" ], [ "LOAD_FAST", "calling_frame" ], [ "CALL_METHOD", "self.frame_infos.pop(calling_frame, None)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_filename" ], [ "LOOKUP_METHOD", "frame.f_code.co_filename.startswith" ], [ "LOAD_GLOBAL", "internal_directories" ], [ "CALL_METHOD", "frame.f_code.co_filename.startswith(internal_directories)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.target_codes" ], [ "COMPARE_OP", "frame.f_code in self.target_codes" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.target_frames" ], [ "COMPARE_OP", "frame in self.target_frames" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._is_traced_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self._is_traced_frame(frame)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.depth" ], [ "COMPARE_OP", "self.depth == 1" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._is_internal_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_METHOD", "self._is_internal_frame(frame)" ], [ "LOAD_GLOBAL", "is_comprehension_frame" ], [ "LOAD_FAST", "frame" ], [ "CALL_FUNCTION", "is_comprehension_frame(frame)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_GLOBAL", "is_comprehension_frame" ], [ "LOAD_FAST", "candidate" ], [ "CALL_FUNCTION", "is_comprehension_frame(candidate)" ], [ "LOAD_FAST", "candidate" ], [ "LOAD_ATTR", "candidate.f_back" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._is_traced_frame" ], [ "LOAD_FAST", "candidate" ], [ "CALL_METHOD", "self._is_traced_frame(candidate)" ], [ "LOAD_FAST", "candidate" ], [ "LOAD_ATTR", "candidate.f_back" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.depth" ], [ "COMPARE_OP", "i >= self.depth" ], [ "LOAD_FAST", "candidate" ], [ "COMPARE_OP", "candidate is None" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self._is_internal_frame" ], [ "LOAD_FAST", "candidate" ], [ "CALL_METHOD", "self._is_internal_frame(candidate)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.thread_local" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_ATTR", "thread_local.__dict__" ], [ "LOOKUP_METHOD", "thread_local.__dict__.setdefault" ], [ "CALL_METHOD", "thread_local.__dict__.setdefault('depth', -1)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame_infos" ], [ "LOAD_FAST", "frame" ], [ "BINARY_SUBSCR", "self.frame_infos[frame]" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event in ('call', 'enter')" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.last_frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.last_frame" ], [ "LOAD_FAST", "frame" ], [ "COMPARE_OP", "self.config.last_frame is not frame" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_ATTR", "frame_info.last_line_no" ], [ "LOAD_GLOBAL", "Event" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "event" ], [ "LOAD_FAST", "arg" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_ATTR", "thread_local.depth" ], [ "LOAD_FAST", "line_no" ], [ "CALL_FUNCTION", "Event(frame_info, event, arg, thread_local.depth, line_no=line_no)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.formatter" ], [ "LOOKUP_METHOD", "self.config.formatter.format_line_only" ], [ "LOAD_FAST", "trace_event" ], [ "CALL_METHOD", "self.config.formatter.format_line_only(trace_event)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOOKUP_METHOD", "self.config.write" ], [ "LOAD_FAST", "line" ], [ "CALL_METHOD", "self.config.write(line)" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event == 'exception'" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_GLOBAL", "Event" ], [ "LOAD_FAST", "frame_info" ], [ "LOAD_FAST", "event" ], [ "LOAD_FAST", "arg" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_ATTR", "thread_local.depth" ], [ "CALL_FUNCTION", "Event(frame_info, event, arg, thread_local.depth)" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "COMPARE_OP", "frame.f_code.co_name == ''" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event not in ('return', 'exception')" ], [ "LOAD_FAST", "frame_info" ], [ "LOOKUP_METHOD", "frame_info.update_variables" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.watch" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.watch_extras" ], [ "LOAD_FAST", "event" ], [ "CALL_METHOD", "frame_info.update_variables(\n self.watch,\n self.config.watch_extras,\n event,\n )" ], [ "LOAD_FAST", "trace_event" ], [ "LOAD_FAST", "event" ], [ "COMPARE_OP", "event in ('return', 'exit')" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.frame_infos" ], [ "LOAD_FAST", "frame" ], [ "LOAD_FAST", "thread_local" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.formatter" ], [ "LOOKUP_METHOD", "self.config.formatter.format" ], [ "LOAD_FAST", "trace_event" ], [ "CALL_METHOD", "self.config.formatter.format(trace_event)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOOKUP_METHOD", "self.config.write" ], [ "LOAD_FAST", "formatted" ], [ "CALL_METHOD", "self.config.write(formatted)" ], [ "LOAD_FAST", "self" ], [ "LOAD_ATTR", "self.trace" ], [ "LOAD_FAST", "config" ], [ "LOAD_FAST", "self" ], [ "LOAD_GLOBAL", "NO_ASTTOKENS" ], [ "LOAD_GLOBAL", "Exception" ], [ "CALL_FUNCTION", "Exception(\"birdseye doesn't support this version of Python\")" ], [ "LOAD_GLOBAL", "ImportError" ], [ "LOAD_GLOBAL", "Exception" ], [ "CALL_FUNCTION", "Exception(\"You must install birdseye separately to use spy: pip install birdseye\")" ], [ "LOAD_GLOBAL", "no_args_decorator" ], [ "LOAD_DEREF", "args" ], [ "LOAD_DEREF", "kwargs" ], [ "CALL_FUNCTION", "no_args_decorator(args, kwargs)" ], [ "LOAD_DEREF", "self" ], [ "LOOKUP_METHOD", "self._trace" ], [ "LOAD_DEREF", "args" ], [ "BINARY_SUBSCR", "args[0]" ], [ "CALL_METHOD", "self._trace(args[0])" ], [ "LOAD_FAST", "decorator" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self._trace" ], [ "LOAD_FAST", "func" ], [ "LOAD_DEREF", "args" ], [ "LOAD_DEREF", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "self._trace(func, *args, **kwargs)" ], [ "LOAD_FAST", "eye" ], [ "LOAD_DEREF", "func" ], [ "CALL_FUNCTION", "eye(func)" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.snoop" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "kwargs" ], [ "CALL_FUNCTION_VAR_KW", "self.config.snoop(*args, **kwargs)" ], [ "LOAD_DEREF", "traced" ], [ "CALL_FUNCTION", "self.config.snoop(*args, **kwargs)(traced)" ], [ "LOAD_GLOBAL", "functools" ], [ "LOOKUP_METHOD", "functools.wraps" ], [ "LOAD_DEREF", "func" ], [ "CALL_METHOD", "functools.wraps(func)" ], [ "CALL_FUNCTION", "functools.wraps(func)" ], [ "LOAD_FAST", "wrapper" ], [ "LOAD_DEREF", "self" ], [ "LOAD_ATTR", "self.config" ], [ "LOAD_ATTR", "self.config.enabled" ], [ "LOAD_DEREF", "traced" ], [ "LOAD_DEREF", "func" ], [ "LOAD_FAST", "final_func" ], [ "LOAD_FAST", "func_args" ], [ "LOAD_FAST", "func_kwargs" ], [ "CALL_FUNCTION_VAR_KW", "final_func(*func_args, **func_kwargs)" ] ], "utils.py": [ [ "LOAD_NAME", "standard_library" ], [ "LOOKUP_METHOD", "standard_library.install_aliases" ], [ "CALL_METHOD", "standard_library.install_aliases()" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "type" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_NAME", "version_info" ], [ "LOAD_ATTR", "version_info.major" ], [ "COMPARE_OP", "version_info.major == 2" ], [ "LOAD_NAME", "PY2" ], [ "UNARY_NOT", "not PY2" ], [ "LOAD_NAME", "TypeVar" ], [ "CALL_FUNCTION", "TypeVar('T')" ], [ "LOAD_NAME", "TypeVar" ], [ "CALL_FUNCTION", "TypeVar('RT')" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "unicode" ], [ "LOAD_NAME", "str" ], [ "LOAD_NAME", "PY2" ], [ "LOAD_NAME", "type" ], [ "LOAD_NAME", "json" ], [ "LOAD_ATTR", "json.JSONEncoder" ], [ "LOAD_NAME", "ImportError" ], [ "LOAD_GLOBAL", "ntpath" ], [ "LOOKUP_METHOD", "ntpath.split" ], [ "LOAD_FAST", "path" ], [ "CALL_METHOD", "ntpath.split(path)" ], [ "LOAD_FAST", "tail" ], [ "LOAD_GLOBAL", "ntpath" ], [ "LOOKUP_METHOD", "ntpath.basename" ], [ "LOAD_FAST", "head" ], [ "CALL_METHOD", "ntpath.basename(head)" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOOKUP_METHOD", "os.path.commonprefix" ], [ "LOAD_FAST", "paths" ], [ "CALL_METHOD", "os.path.commonprefix(paths)" ], [ "LOAD_GLOBAL", "ntpath" ], [ "LOOKUP_METHOD", "ntpath.split" ], [ "LOAD_FAST", "prefix" ], [ "CALL_METHOD", "ntpath.split(prefix)" ], [ "BINARY_SUBSCR", "ntpath.split(prefix)[0]" ], [ "LOAD_FAST", "paths" ], [ "BINARY_SUBSCR", "paths[0]" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "prefix" ], [ "CALL_FUNCTION", "len(prefix)" ], [ "BINARY_SUBSCR", "paths[0][len(prefix)]" ], [ "LOAD_FAST", "first_char_after" ], [ "COMPARE_OP", "first_char_after in r'\\/'" ], [ "LOAD_FAST", "first_char_after" ], [ "LOAD_FAST", "prefix" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "COMPARE_OP", "path == IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "all_paths" ], [ "LOAD_GLOBAL", "common_ancestor" ], [ "LOAD_FAST", "all_paths" ], [ "CALL_FUNCTION", "common_ancestor(all_paths)" ], [ "LOAD_FAST", "prefix" ], [ "COMPARE_OP", "prefix in r'\\/'" ], [ "LOAD_GLOBAL", "strip_required_prefix" ], [ "LOAD_FAST", "path" ], [ "LOAD_FAST", "prefix" ], [ "CALL_FUNCTION", "strip_required_prefix(path, prefix)" ], [ "LOAD_GLOBAL", "path_leaf" ], [ "LOAD_FAST", "path" ], [ "CALL_FUNCTION", "path_leaf(path)" ], [ "LOAD_FAST", "f" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "COMPARE_OP", "f != IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "f" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "IPYTHON_FILE_PATH" ], [ "COMPARE_OP", "path == IPYTHON_FILE_PATH" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOAD_ATTR", "os.path.sep" ], [ "COMPARE_OP", "os.path.sep == '/'" ], [ "LOAD_FAST", "path" ], [ "LOOKUP_METHOD", "path.startswith" ], [ "CALL_METHOD", "path.startswith('/')" ], [ "LOAD_FAST", "path" ], [ "BINARY_ADD", "'/' + path" ], [ "LOAD_FAST", "path" ], [ "LOAD_GLOBAL", "type" ], [ "LOAD_FAST", "obj" ], [ "CALL_FUNCTION", "type(obj)" ], [ "LOAD_FAST", "t" ], [ "LOAD_GLOBAL", "types" ], [ "LOAD_ATTR", "types.InstanceType" ], [ "COMPARE_OP", "t is types.InstanceType" ], [ "LOAD_FAST", "obj" ], [ "LOAD_ATTR", "obj.__class__" ], [ "LOAD_FAST", "t" ], [ "LOAD_FAST", "iterable" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_DEREF", "type_or_tuple" ], [ "CALL_FUNCTION", "isinstance(x, type_or_tuple)" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "next" ], [ "LOAD_FAST", "it" ], [ "CALL_FUNCTION", "next(it)" ], [ "LOAD_GLOBAL", "StopIteration" ], [ "LOAD_GLOBAL", "raise_from" ], [ "LOAD_GLOBAL", "RuntimeError" ], [ "LOAD_FAST", "e" ], [ "CALL_FUNCTION", "raise_from(RuntimeError, e)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "expression" ], [ "CALL_FUNCTION", "hasattr(expression, 'one_or_none')" ], [ "LOAD_FAST", "expression" ], [ "LOOKUP_METHOD", "expression.one_or_none" ], [ "CALL_METHOD", "expression.one_or_none()" ], [ "LOAD_FAST", "expression" ], [ "LOOKUP_METHOD", "expression.all" ], [ "CALL_METHOD", "expression.all()" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "len(result)" ], [ "COMPARE_OP", "len(result) == 0" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "result" ], [ "CALL_FUNCTION", "len(result)" ], [ "COMPARE_OP", "len(result) == 1" ], [ "LOAD_FAST", "result" ], [ "BINARY_SUBSCR", "result[0]" ], [ "LOAD_GLOBAL", "Exception" ], [ "CALL_FUNCTION", "Exception(\"There is more than one item returned for the supplied filter\")" ], [ "LOAD_FAST", "lst" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "list" ], [ "CALL_FUNCTION", "isinstance(x, list)" ], [ "LOAD_FAST", "result" ], [ "LOOKUP_METHOD", "result.extend" ], [ "LOAD_GLOBAL", "flatten_list" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "flatten_list(x)" ], [ "CALL_METHOD", "result.extend(flatten_list(x))" ], [ "LOAD_FAST", "result" ], [ "LOOKUP_METHOD", "result.append" ], [ "LOAD_FAST", "x" ], [ "CALL_METHOD", "result.append(x)" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "f" ], [ "LOAD_ATTR", "f.__code__" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_name" ], [ "LOAD_ATTR", "(lambda: 0).__code__" ], [ "LOAD_ATTR", "(lambda: 0).__code__.co_name" ], [ "COMPARE_OP", "code.co_name == (lambda: 0).__code__.co_name" ], [ "LOAD_FAST", "o" ], [ "LOAD_ATTR", "o.as_json" ], [ "LOAD_GLOBAL", "AttributeError" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "ProtocolEncoder" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(ProtocolEncoder, self)" ], [ "LOOKUP_METHOD", "super(ProtocolEncoder, self).default" ], [ "LOAD_FAST", "o" ], [ "CALL_METHOD", "super(ProtocolEncoder, self).default(o)" ], [ "LOAD_FAST", "method" ], [ "CALL_FUNCTION", "method()" ], [ "LOAD_GLOBAL", "io" ], [ "LOOKUP_METHOD", "io.open" ], [ "LOAD_FAST", "filename" ], [ "CALL_METHOD", "io.open(filename, 'rb')" ], [ "LOAD_GLOBAL", "detect_encoding" ], [ "LOAD_FAST", "fp" ], [ "LOAD_ATTR", "fp.readline" ], [ "CALL_FUNCTION", "detect_encoding(fp.readline)" ], [ "LOAD_FAST", "fp" ], [ "LOOKUP_METHOD", "fp.seek" ], [ "CALL_METHOD", "fp.seek(0)" ], [ "LOAD_GLOBAL", "io" ], [ "LOOKUP_METHOD", "io.TextIOWrapper" ], [ "LOAD_FAST", "fp" ], [ "LOAD_FAST", "encoding" ], [ "CALL_METHOD", "io.TextIOWrapper(fp, encoding, line_buffering=True)" ], [ "LOAD_FAST", "text" ], [ "LOAD_FAST", "text" ], [ "LOAD_FAST", "fp" ], [ "LOOKUP_METHOD", "fp.close" ], [ "CALL_METHOD", "fp.close()" ], [ "LOAD_FAST", "filename" ], [ "LOOKUP_METHOD", "filename.endswith" ], [ "CALL_METHOD", "filename.endswith('.pyc')" ], [ "LOAD_FAST", "filename" ], [ "BINARY_SUBSCR", "filename[:-1]" ], [ "LOAD_GLOBAL", "open_with_encoding_check" ], [ "LOAD_FAST", "filename" ], [ "CALL_FUNCTION", "open_with_encoding_check(filename)" ], [ "LOOKUP_METHOD", "''.join" ], [ "LOAD_GLOBAL", "enumerate" ], [ "LOAD_FAST", "f" ], [ "CALL_FUNCTION", "enumerate(f)" ], [ "CALL_METHOD", "''.join([\n '\\n' if i < 2 and cookie_re.match(line)\n else line\n for i, line in enumerate(f)\n ])" ], [ "LOAD_FAST", "i" ], [ "COMPARE_OP", "i < 2" ], [ "LOAD_DEREF", "cookie_re" ], [ "LOOKUP_METHOD", "cookie_re.match" ], [ "LOAD_FAST", "line" ], [ "CALL_METHOD", "cookie_re.match(line)" ], [ "LOAD_FAST", "line" ], [ "LOAD_GLOBAL", "safe_next" ], [ "LOAD_FAST", "tokens" ], [ "LOOKUP_METHOD", "tokens.get_tokens" ], [ "LOAD_FAST", "function_node" ], [ "CALL_METHOD", "tokens.get_tokens(function_node)" ], [ "CALL_FUNCTION", "safe_next(t for t in tokens.get_tokens(function_node)\n if t.string == 'def' and t.type == token.NAME)" ], [ "LOAD_FAST", "def_token" ], [ "LOAD_ATTR", "def_token.startpos" ], [ "LOAD_FAST", "tokens" ], [ "LOAD_ATTR", "tokens.text" ], [ "LOAD_FAST", "startpos" ], [ "LOAD_FAST", "function_node" ], [ "LOAD_ATTR", "function_node.last_token" ], [ "LOAD_ATTR", "function_node.last_token.endpos" ], [ "BINARY_SUBSCR", "tokens.text[startpos:function_node.last_token.endpos]" ], [ "LOOKUP_METHOD", "tokens.text[startpos:function_node.last_token.endpos].rstrip" ], [ "CALL_METHOD", "tokens.text[startpos:function_node.last_token.endpos].rstrip()" ], [ "LOAD_FAST", "source" ], [ "LOOKUP_METHOD", "source.startswith" ], [ "CALL_METHOD", "source.startswith('def')" ], [ "LOAD_FAST", "startpos" ], [ "LOAD_FAST", "source" ], [ "LOAD_FAST", "t" ], [ "LOAD_ATTR", "t.string" ], [ "COMPARE_OP", "t.string == 'def'" ], [ "LOAD_FAST", "t" ], [ "LOAD_ATTR", "t.type" ], [ "LOAD_GLOBAL", "token" ], [ "LOAD_ATTR", "token.NAME" ], [ "COMPARE_OP", "t.type == token.NAME" ], [ "LOAD_FAST", "t" ], [ "LOAD_FAST", "args" ], [ "LOAD_GLOBAL", "print" ], [ "LOAD_FAST", "arg" ], [ "CALL_FUNCTION", "print(arg)" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION", "len(args)" ], [ "COMPARE_OP", "len(args) == 1" ], [ "LOAD_FAST", "args" ], [ "BINARY_SUBSCR", "args[0]" ], [ "LOAD_FAST", "args" ], [ "LOAD_FAST", "filename" ], [ "LOOKUP_METHOD", "filename.startswith" ], [ "CALL_METHOD", "filename.startswith(' max_length" ], [ "LOAD_FAST", "max_length" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "middle" ], [ "CALL_FUNCTION", "len(middle)" ], [ "BINARY_SUBTRACT", "max_length - len(middle)" ], [ "BINARY_FLOOR_DIVIDE", "(max_length - len(middle)) // 2" ], [ "LOAD_FAST", "max_length" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "middle" ], [ "CALL_FUNCTION", "len(middle)" ], [ "BINARY_SUBTRACT", "max_length - len(middle)" ], [ "LOAD_FAST", "left" ], [ "BINARY_SUBTRACT", "max_length - len(middle) - left" ], [ "LOAD_FAST", "seq" ], [ "LOAD_FAST", "left" ], [ "BINARY_SUBSCR", "seq[:left]" ], [ "LOAD_FAST", "middle" ], [ "BINARY_ADD", "seq[:left] + middle" ], [ "LOAD_FAST", "seq" ], [ "LOAD_FAST", "right" ], [ "UNARY_NEGATIVE", "-right" ], [ "BINARY_SUBSCR", "seq[-right:]" ], [ "BINARY_ADD", "seq[:left] + middle + seq[-right:]" ], [ "LOAD_FAST", "seq" ], [ "LOAD_GLOBAL", "truncate" ], [ "LOAD_FAST", "string" ], [ "LOAD_FAST", "max_length" ], [ "CALL_FUNCTION", "truncate(string, max_length, '...')" ], [ "LOAD_GLOBAL", "truncate" ], [ "LOAD_FAST", "lst" ], [ "LOAD_FAST", "max_length" ], [ "CALL_FUNCTION", "truncate(lst, max_length, ['...'])" ], [ "LOAD_FAST", "split" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "six" ], [ "LOAD_ATTR", "six.string_types" ], [ "CALL_FUNCTION", "isinstance(x, six.string_types)" ], [ "LOAD_FAST", "x" ], [ "LOOKUP_METHOD", "x.replace" ], [ "CALL_METHOD", "x.replace(',', ' ')" ], [ "LOOKUP_METHOD", "x.replace(',', ' ').split" ], [ "CALL_METHOD", "x.replace(',', ' ').split()" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "list" ], [ "LOAD_GLOBAL", "set" ], [ "LOAD_GLOBAL", "tuple" ], [ "CALL_FUNCTION", "isinstance(x, (list, set, tuple))" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "tuple" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "tuple(x)" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.path" ], [ "LOOKUP_METHOD", "os.path.basename" ], [ "LOAD_FAST", "code" ], [ "LOAD_ATTR", "code.co_filename" ], [ "CALL_METHOD", "os.path.basename(code.co_filename)" ], [ "LOAD_FAST", "result" ], [ "LOOKUP_METHOD", "result.endswith" ], [ "CALL_METHOD", "result.endswith('.pyc')" ], [ "LOAD_FAST", "result" ], [ "BINARY_SUBSCR", "result[:-1]" ], [ "LOAD_FAST", "result" ], [ "LOAD_FAST", "frame" ], [ "LOAD_ATTR", "frame.f_code" ], [ "LOAD_ATTR", "frame.f_code.co_name" ], [ "COMPARE_OP", "frame.f_code.co_name in ('', '', '')" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "code('{}.x')" ], [ "LOAD_GLOBAL", "SyntaxError" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "code('({})')" ], [ "LOAD_FAST", "without_parens" ], [ "LOAD_FAST", "code" ], [ "CALL_FUNCTION", "code('({}).x')" ], [ "COMPARE_OP", "without_parens != code('({}).x')" ], [ "LOAD_GLOBAL", "compile" ], [ "LOAD_FAST", "s" ], [ "LOOKUP_METHOD", "s.format" ], [ "LOAD_DEREF", "source" ], [ "CALL_METHOD", "s.format(source)" ], [ "CALL_FUNCTION", "compile(s.format(source), '', 'eval')" ], [ "LOAD_ATTR", "compile(s.format(source), '', 'eval').co_code" ], [ "LOAD_GLOBAL", "needs_parentheses" ], [ "LOAD_FAST", "source" ], [ "CALL_FUNCTION", "needs_parentheses(source)" ], [ "LOOKUP_METHOD", "'({})'.format" ], [ "LOAD_FAST", "source" ], [ "CALL_METHOD", "'({})'.format(source)" ], [ "LOAD_FAST", "source" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "REPR_TARGET_LENGTH" ], [ "CALL_FUNCTION", "cheap_repr(x, target_length=REPR_TARGET_LENGTH)" ], [ "LOAD_GLOBAL", "super" ], [ "LOAD_GLOBAL", "ArgDefaultDict" ], [ "LOAD_FAST", "self" ], [ "CALL_FUNCTION", "super(ArgDefaultDict, self)" ], [ "LOOKUP_METHOD", "super(ArgDefaultDict, self).__init__" ], [ "CALL_METHOD", "super(ArgDefaultDict, self).__init__()" ], [ "LOAD_FAST", "factory" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "self" ], [ "LOOKUP_METHOD", "self.factory" ], [ "LOAD_FAST", "key" ], [ "CALL_METHOD", "self.factory(key)" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "key" ], [ "LOAD_FAST", "result" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "lst" ], [ "CALL_FUNCTION", "len(lst)" ], [ "COMPARE_OP", "len(lst) == 1" ], [ "LOAD_GLOBAL", "str" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "CALL_FUNCTION", "str(i + 1)" ], [ "BINARY_ADD", "' ' + str(i + 1)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_GLOBAL", "os" ], [ "CALL_FUNCTION", "hasattr(os, 'PathLike')" ], [ "LOAD_GLOBAL", "isinstance" ], [ "LOAD_FAST", "x" ], [ "LOAD_GLOBAL", "os" ], [ "LOAD_ATTR", "os.PathLike" ], [ "CALL_FUNCTION", "isinstance(x, os.PathLike)" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "hasattr(x, '__fspath__')" ], [ "LOAD_GLOBAL", "hasattr" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "hasattr(x, 'open')" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.__class__" ], [ "LOAD_ATTR", "x.__class__.__name__" ], [ "LOOKUP_METHOD", "x.__class__.__name__.lower" ], [ "CALL_METHOD", "x.__class__.__name__.lower()" ], [ "COMPARE_OP", "'path' in x.__class__.__name__.lower()" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "args" ], [ "CALL_FUNCTION", "len(args)" ], [ "COMPARE_OP", "len(args) == 1" ], [ "LOAD_GLOBAL", "inspect" ], [ "LOOKUP_METHOD", "inspect.isfunction" ], [ "LOAD_FAST", "args" ], [ "BINARY_SUBSCR", "args[0]" ], [ "CALL_METHOD", "inspect.isfunction(args[0])" ], [ "LOAD_FAST", "kwargs" ], [ "UNARY_NOT", "not kwargs" ], [ "LOAD_FAST", "self" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_ADD", "max_length + 2" ], [ "COMPARE_OP", "length <= max_length + 2" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "range(length)" ], [ "LOAD_GLOBAL", "chain" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_FLOOR_DIVIDE", "max_length // 2" ], [ "CALL_FUNCTION", "range(max_length // 2)" ], [ "LOAD_GLOBAL", "range" ], [ "LOAD_FAST", "length" ], [ "LOAD_FAST", "max_length" ], [ "BINARY_FLOOR_DIVIDE", "max_length // 2" ], [ "BINARY_SUBTRACT", "length - max_length // 2" ], [ "LOAD_FAST", "length" ], [ "CALL_FUNCTION", "range(length - max_length // 2,\n length)" ], [ "CALL_FUNCTION", "chain(range(max_length // 2),\n range(length - max_length // 2,\n length))" ], [ "LOAD_GLOBAL", "len" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "len(x)" ], [ "LOAD_FAST", "n" ], [ "COMPARE_OP", "n == 0" ], [ "LOAD_GLOBAL", "repr" ], [ "LOAD_FAST", "x" ], [ "CALL_FUNCTION", "repr(x)" ], [ "LOAD_FAST", "helper" ], [ "LOAD_ATTR", "helper.level" ], [ "BINARY_SUBTRACT", "helper.level - 1" ], [ "LOAD_GLOBAL", "_repr_series_one_line" ], [ "LOAD_ATTR", "_repr_series_one_line.maxparts" ], [ "LOAD_GLOBAL", "_sample_indices" ], [ "LOAD_FAST", "n" ], [ "LOAD_FAST", "maxparts" ], [ "CALL_FUNCTION", "_sample_indices(n, maxparts)" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.index" ], [ "LOAD_FAST", "i" ], [ "LOAD_FAST", "i" ], [ "BINARY_ADD", "i + 1" ], [ "BINARY_SUBSCR", "x.index[i:i + 1]" ], [ "LOOKUP_METHOD", "x.index[i:i + 1].format" ], [ "CALL_METHOD", "x.index[i:i + 1].format(sparsify=False)" ], [ "BINARY_SUBSCR", "x.index[i:i + 1].format(sparsify=False)[0]" ], [ "LOAD_FAST", "x" ], [ "LOAD_ATTR", "x.iloc" ], [ "LOAD_FAST", "i" ], [ "BINARY_SUBSCR", "x.iloc[i]" ], [ "LOAD_FAST", "pieces" ], [ "LOOKUP_METHOD", "pieces.append" ], [ "LOAD_FAST", "k" ], [ "LOAD_GLOBAL", "cheap_repr" ], [ "LOAD_FAST", "v" ], [ "LOAD_FAST", "newlevel" ], [ "CALL_FUNCTION", "cheap_repr(v, newlevel)" ], [ "BINARY_MODULO", "'%s = %s' % (k, cheap_repr(v, newlevel))" ], [ "CALL_METHOD", "pieces.append('%s = %s' % (k, cheap_repr(v, newlevel)))" ], [ "LOAD_FAST", "n" ], [ "LOAD_FAST", "maxparts" ], [ "BINARY_ADD", "maxparts + 2" ], [ "COMPARE_OP", "n > maxparts + 2" ], [ "LOAD_FAST", "pieces" ], [ "LOOKUP_METHOD", "pieces.insert" ], [ "LOAD_FAST", "maxparts" ], [ "BINARY_FLOOR_DIVIDE", "maxparts // 2" ], [ "CALL_METHOD", "pieces.insert(maxparts // 2, '...')" ], [ "LOOKUP_METHOD", "'; '.join" ], [ "LOAD_FAST", "pieces" ], [ "CALL_METHOD", "'; '.join(pieces)" ] ] }executing-0.8.0/tests/samples/000077500000000000000000000000001410133640400163145ustar00rootroot00000000000000executing-0.8.0/tests/samples/bird.py000066400000000000000000001211141410133640400176060ustar00rootroot00000000000000from __future__ import absolute_import, division, print_function from future import standard_library standard_library.install_aliases() from future.utils import iteritems from typing import List, Dict, Any, Optional, NamedTuple, Tuple, Iterator, Iterable, Union, cast from types import FrameType, TracebackType, CodeType, FunctionType, ModuleType import typing import ast # noinspection PyCompatibility import html import inspect import json import os import traceback from collections import defaultdict, Sequence, Set, Mapping, deque, namedtuple, Counter from functools import partial from itertools import chain, islice from threading import Lock from uuid import uuid4 import hashlib import sys from asttokens import ASTTokens from littleutils import group_by_key_func, only from outdated import warn_if_outdated from cached_property import cached_property from cheap_repr import cheap_repr, try_register_repr from cheap_repr.utils import safe_qualname, exception_string from birdseye.db import Database, retry_db from birdseye.tracer import TreeTracerBase, TracedFile, EnterCallInfo, ExitCallInfo, FrameInfo, ChangeValue, Loop from birdseye import tracer from birdseye.utils import correct_type, PY3, PY2, one_or_none, \ of_type, Deque, Text, flatten_list, lru_cache, ProtocolEncoder, IPYTHON_FILE_PATH, source_without_decorators, \ is_future_import, get_unfrozen_datetime, FILE_SENTINEL_NAME, read_source_file from birdseye import __version__ try: from numpy import ndarray except ImportError: class ndarray(object): pass try: from pandas import DataFrame, Series except ImportError: class DataFrame(object): pass class Series(object): pass try: from django.db.models import QuerySet except ImportError: class QuerySet(object): pass warn_if_outdated('birdseye', __version__) CodeInfo = namedtuple('CodeInfo', 'db_func traced_file arg_names') class BirdsEye(TreeTracerBase): """ Decorate functions with an instance of this class to debug them, or just use the existing instance `eye`. """ def __init__(self, db_uri=None, num_samples=None): """ Set db_uri to specify where the database lives, as an alternative to the environment variable BIRDSEYE_DB. """ super(BirdsEye, self).__init__() self._db_uri = db_uri self._code_infos = {} # type: Dict[CodeType, CodeInfo] self._last_call_id = None self._ipython_cell_value = None self.num_samples = num_samples or dict( big=dict( attributes=50, dict=50, list=30, set=30, pandas_rows=20, pandas_cols=100, ), small=dict( attributes=50, dict=10, list=6, set=6, pandas_rows=6, pandas_cols=10, ), ) @cached_property def db(self): return Database(self._db_uri) def parse_extra(self, root, source, filename): # type: (ast.Module, str, str) -> None for node in ast.walk(root): # type: ast.AST node._loops = tracer.loops(node) if isinstance(node, ast.expr): node._is_interesting_expression = is_interesting_expression(node) @lru_cache() def compile(self, source, filename, flags=0): traced_file = super(BirdsEye, self).compile(source, filename, flags) traced_file.tokens = ASTTokens(source, tree=traced_file.root) return traced_file def before_stmt(self, node, frame): # type: (ast.stmt, FrameType) -> None if frame.f_code not in self._code_infos: return if isinstance(node.parent, ast.For) and node is node.parent.body[0]: self._add_iteration(node._loops, frame) def before_expr(self, node, frame): if isinstance(node.parent, ast.While) and node is node.parent.test: self._add_iteration(node._loops, frame) def _add_iteration(self, loops, frame): # type: (typing.Sequence[Loop], FrameType) -> None """ Given one or more nested loops, add an iteration for the innermost loop (the last in the sequence). """ iteration = self.stack[frame].iteration # type: Iteration for i, loop_node in enumerate(loops): loop = iteration.loops[loop_node._tree_index] if i == len(loops) - 1: loop.append(Iteration()) else: iteration = loop.last() def after_expr(self, node, frame, value, exc_value, exc_tb): # type: (ast.expr, FrameType, Any, Optional[BaseException], Optional[TracebackType]) -> Optional[ChangeValue] if _tracing_recursively(frame): return None if frame.f_code not in self._code_infos: return None if node._is_interesting_expression: # If this is an expression statement and the last statement # in the body, the value is returned from the cell magic # to be displayed as usual if (self._code_infos[frame.f_code].traced_file.is_ipython_cell and isinstance(node.parent, ast.Expr) and node.parent is node.parent.parent.body[-1]): self._ipython_cell_value = value if is_obvious_builtin(node, self.stack[frame].expression_values[node]): return None frame_info = self.stack[frame] if exc_value: node_value = self._exception_value(node, frame, exc_value) else: node_value = NodeValue.expression( self.num_samples, value, level=max(1, 3 - len(node._loops) * (not self._is_first_loop_iteration(node, frame))), ) self._set_node_value(node, frame, node_value) self._check_inner_call(frame_info, node, node_value) # i.e. is `node` the `y` in `[f(x) for x in y]`, making `node.parent` the `for x in y` is_special_comprehension_iter = ( isinstance(node.parent, ast.comprehension) and node is node.parent.iter and # Generators execute in their own time and aren't directly attached to the parent frame not isinstance(node.parent.parent, ast.GeneratorExp)) if not is_special_comprehension_iter: return None # Mark `for x in y` as a bit that executed, so it doesn't show as grey self._set_node_value(node.parent, frame, NodeValue.covered()) if exc_value: return None # Track each iteration over `y` so that the 'loop' can be stepped through loops = node._loops + (node.parent,) # type: Tuple[Loop, ...] def comprehension_iter_proxy(): for item in value: self._add_iteration(loops, frame) yield item # This effectively changes to code to `for x in comprehension_iter_proxy()` return ChangeValue(comprehension_iter_proxy()) def _check_inner_call(self, frame_info, node, node_value): # type: (FrameInfo, Union[ast.stmt, ast.expr], NodeValue) -> None inner_calls = frame_info.inner_calls.pop(node, None) if inner_calls: node_value.set_meta('inner_calls', inner_calls) def _is_first_loop_iteration(self, node, frame): # type: (ast.AST, FrameType) -> bool iteration = self.stack[frame].iteration # type: Iteration for loop_node in node._loops: # type: ast.AST loop = iteration.loops[loop_node._tree_index] iteration = loop.last() if iteration.index > 0: return False return True def _set_node_value(self, node, frame, value): # type: (ast.AST, FrameType, NodeValue) -> None iteration = self.stack[frame].iteration # type: Iteration for loop_node in node._loops: # type: ast.AST loop = iteration.loops[loop_node._tree_index] loop.recorded_node(node) iteration = loop.last() iteration.vals[node._tree_index] = value def _exception_value(self, node, frame, exc_value): # type: (Union[ast.expr, ast.stmt], FrameType, BaseException) -> NodeValue value = NodeValue.exception(exc_value) self._set_node_value(node, frame, value) return value def after_stmt(self, node, frame, exc_value, exc_traceback, exc_node): # type: (ast.stmt, FrameType, Optional[BaseException], Optional[TracebackType], Optional[ast.AST]) -> Optional[bool] if frame.f_code not in self._code_infos or _tracing_recursively(frame): return None if exc_value and node is exc_node: value = self._exception_value(node, frame, exc_value) else: value = NodeValue.covered() self._set_node_value(node, frame, value) self._check_inner_call(self.stack[frame], node, value) return None def enter_call(self, enter_info): # type: (EnterCallInfo) -> None frame = enter_info.current_frame # type: FrameType if frame.f_code not in self._code_infos or _tracing_recursively(frame): return frame_info = self.stack[frame] frame_info.start_time = get_unfrozen_datetime() frame_info.iteration = Iteration() code_info = self._code_infos[frame.f_code] if isinstance(enter_info.enter_node.parent, ast.Module): arguments = [] else: f_locals = frame.f_locals.copy() # type: Dict[str, Any] arguments = [(name, f_locals.pop(name)) for name in code_info.arg_names if name] + [ # Local variables other than actual arguments. These are variables from # the enclosing scope. It's handy to treat them like arguments in the UI it for it in f_locals.items() if it[0][0] != '.' # Appears when using nested tuple arguments ] frame_info.arguments = json.dumps([[k, cheap_repr(v)] for k, v in arguments]) frame_info.call_id = self._call_id() frame_info.inner_calls = defaultdict(list) prev = self.stack.get(enter_info.caller_frame) if prev: inner_calls = getattr(prev, 'inner_calls', None) if inner_calls is not None: inner_calls[enter_info.call_node].append(frame_info.call_id) def _call_id(self): # type: () -> Text return uuid4().hex def exit_call(self, exit_info): # type: (ExitCallInfo) -> None """ This is where all the data collected during the call is gathered up and sent to the database. """ frame = exit_info.current_frame # type: FrameType if frame.f_code not in self._code_infos or _tracing_recursively(frame): return frame_info = self.stack[frame] top_iteration = frame_info.iteration # type: Iteration node_values = _deep_dict() self._extract_node_values(top_iteration, (), node_values) db_func = self._code_infos[frame.f_code].db_func exc = exit_info.exc_value # type: Optional[Exception] if exc: traceback_str = ''.join(traceback.format_exception(type(exc), exc, exit_info.exc_tb)) exception = exception_string(exc) else: traceback_str = exception = None @retry_db def add_call(): Call = self.db.Call call = Call(id=frame_info.call_id, function_id=db_func, arguments=frame_info.arguments, return_value=cheap_repr(exit_info.return_value), exception=exception, traceback=traceback_str, data=json.dumps( dict( node_values=node_values, loop_iterations=top_iteration.extract_iterations()['loops'], type_names=type_registry.names(), num_special_types=type_registry.num_special_types, ), cls=ProtocolEncoder, separators=(',', ':') ), start_time=frame_info.start_time) with self.db.session_scope() as session: session.add(call) add_call() self._last_call_id = frame_info.call_id def _extract_node_values(self, iteration, path, node_values): # type: (Iteration, Tuple[int, ...], dict) -> None """ Populates node_values with values inside iteration. """ # Each element of `path` is an index of a loop iteration # e.g. given the nested loops: # # for i in [0, 1, 2]: # for j in [0, 1, 2, 3]: # # path may be (i, j) for each of the iterations for tree_index, node_value in iteration.vals.items(): # So this `full_path` is a tuple of ints, but the first # int has a different meaning from the others full_path = (tree_index,) + path # Given a path (a, b, c) we're making node_values 'contain' # this structure: # {a: {b: {c: node_value}}} d = node_values for path_k in full_path[:-1]: d = d[path_k] d[full_path[-1]] = node_value for loop in iteration.loops.values(): for i, iteration in enumerate(loop): self._extract_node_values(iteration, path + (i,), node_values) def trace_function(self, func): # type: (FunctionType) -> FunctionType new_func = super(BirdsEye, self).trace_function(func) code_info = self._code_infos.get(new_func.__code__) if code_info: return new_func lines, start_lineno = inspect.getsourcelines(func) # type: List[Text], int end_lineno = start_lineno + len(lines) name = safe_qualname(func) source_file = inspect.getsourcefile(func) if source_file.startswith('= 0: frame = frame.f_back filename = inspect.getsourcefile(frame) if filename is not None: context -= 1 filename = os.path.abspath(filename) if frame.f_globals.get('__name__') != '__main__': if PY3 and self._treetrace_hidden_with_stmt.__name__ not in frame.f_globals: raise RuntimeError( 'To trace an imported module, you must import birdseye before ' 'importing that module.') return lines = read_source_file(filename).splitlines() lines[:frame.f_lineno] = [''] * frame.f_lineno source = '\n'.join(lines) self.exec_string(source, filename, frame.f_globals, frame.f_locals, deep) sys.exit(0) def exec_string(self, source, filename, globs=None, locs=None, deep=False): globs = globs or {} locs = locs or {} traced_file = self.compile(source, filename) globs.update(self._trace_methods_dict(traced_file)) self._trace(FILE_SENTINEL_NAME, filename, traced_file, traced_file.code, 'module', source) if deep: nodes_by_lineno = { node.lineno: node for node in traced_file.nodes if isinstance(node, ast.FunctionDef) } def find_code(root_code): # type: (CodeType) -> None for code in root_code.co_consts: # type: CodeType if not inspect.iscode(code) or code.co_name.startswith('<'): continue find_code(code) lineno = code.co_firstlineno node = nodes_by_lineno.get(lineno) if not node: continue self._trace( code.co_name, filename, traced_file, code, typ='function', source=source, start_lineno=lineno, end_lineno=node.last_token.end[0] + 1, ) find_code(traced_file.code) exec(traced_file.code, globs, locs) def _trace( self, name, filename, traced_file, code, typ, source='', start_lineno=1, end_lineno=None, arg_names=(), ): if not end_lineno: end_lineno = start_lineno + len(source.splitlines()) nodes = list(self._nodes_of_interest(traced_file, start_lineno, end_lineno)) html_body = self._nodes_html(nodes, start_lineno, end_lineno, traced_file) data_dict = dict( # This maps each node to the loops enclosing that node node_loops={ node._tree_index: [n._tree_index for n in node._loops] for node, _ in nodes if node._loops }, ) if typ == 'function': tokens = traced_file.tokens func_node = only(node for node, _ in nodes if isinstance(node, ast.FunctionDef) and node.first_token.start[0] == start_lineno) func_startpos, source = source_without_decorators(tokens, func_node) # These are for the PyCharm plugin data_dict.update( node_ranges=list(self._node_ranges(nodes, tokens, func_startpos)), loop_ranges=list(self._loop_ranges(nodes, tokens, func_startpos)), ) data = json.dumps(data_dict, sort_keys=True) db_func = self._db_func(data, filename, html_body, name, start_lineno, source, typ) self._code_infos[code] = CodeInfo(db_func, traced_file, arg_names) def _loop_ranges(self, nodes, tokens, func_start): # For a for loop, e.g. # # for x in y: # # this yields the range of the target 'x'. # # For a while loop, e.g. # # while x < 10: # # this yields the range of the condition 'x < 10'. for node, (classes, _, __) in nodes: if 'loop' not in classes: continue try: target = node.target # for loop except AttributeError: target = node.test # while loop start, end = tokens.get_text_range(target) start -= func_start end -= func_start yield dict( tree_index=node._tree_index, start=start, end=end ) def _node_ranges(self, nodes, tokens, func_start): for node, (classes, _, __) in nodes: start, end = tokens.get_text_range(node) start -= func_start end -= func_start if start < 0: assert (end < 0 # nodes before the def, i.e. decorators or isinstance(node, ast.FunctionDef)) continue yield dict( tree_index=node._tree_index, start=start, end=end, depth=node._depth, classes=classes, ) @retry_db def _db_func(self, data, filename, html_body, name, start_lineno, source, typ): """ Retrieve the Function object from the database if one exists, or create one. """ def h(s): return hashlib.sha256(s.encode('utf8')).hexdigest() function_hash = h(filename + name + html_body + data + str(start_lineno)) Function = self.db.Function with self.db.session_scope() as session: db_func = one_or_none(session.query(Function).filter_by(hash=function_hash)) # type: Optional[Function] if not db_func: db_func = Function(file=filename, name=name, type=typ, html_body=html_body, lineno=start_lineno, data=data, body_hash=h(source), hash=function_hash) session.add(db_func) session.commit() # ensure .id exists assert isinstance(db_func.id, int) return db_func.id def _nodes_of_interest(self, traced_file, start_lineno, end_lineno): # type: (TracedFile, int, int) -> Iterator[Tuple[ast.AST, Tuple]] """ Nodes that may have a value, show up as a box in the UI, and lie within the given line range. """ for node in traced_file.nodes: classes = [] if (isinstance(node, (ast.While, ast.For, ast.comprehension)) and not isinstance(node.parent, ast.GeneratorExp)): classes.append('loop') if isinstance(node, ast.stmt): classes.append('stmt') if isinstance(node, ast.expr): if not node._is_interesting_expression: continue elif not classes: continue assert isinstance(node, ast.AST) # In particular FormattedValue is missing this if not hasattr(node, 'first_token'): continue if not start_lineno <= node.first_token.start[0] <= end_lineno: continue start, end = traced_file.tokens.get_text_range(node) # type: int, int if start == end == 0: continue yield node, (classes, start, end) def _nodes_html(self, nodes, start_lineno, end_lineno, traced_file): # type: (list, int, int, TracedFile) -> str """ The algorithm for generating the HTML works as follows. We generate a list of HTMLPositions, which are essentially places to insert HTML into the source plus some metadata. The order of the fields of HTMLPosition ensure that when the list is sorted, the resulting HTML is valid and correct. Specifically, the fields are: 1. index: the index in the source string where the HTML would be inserted 2. is_start: Indicates if this piece of HTML is the start of a tag, rather than the end. Ends should appear first, so that the resulting HTML looks like: ... ... rather than: ... ... (I think this might actually be unnecessary, since I can't think of any cases of two expressions right next to each other with nothing in between) 3. depth: the depth of the corresponding node in the AST. We want the start of a tag from a node to appear before the start of a tag nested within, e.g. `foo()` should become: foo() rather than: foo() 4. html: the actual HTML to insert. Not important for ordering. Mostly the list contains pairs of HTMLPositions corresponding to AST nodes, one for the start and one for the end. After the list is sorted, the HTML generated is essentially: source[0:positions[0].index] + positions[0].html + source[positions[0].index:positions[1].index] + positions[1].html + ... """ traced_file.root._depth = 0 for node in ast.walk(traced_file.root): # type: ast.AST for child in ast.iter_child_nodes(node): child._depth = node._depth + 1 positions = [] # type: List[HTMLPosition] for node, (classes, start, end) in nodes: # noinspection PyArgumentList positions.extend(map( HTMLPosition, [start, end], [True, False], # is_start [node._depth, node._depth], ['' % (node._tree_index, ' '.join(classes)), ''])) end_lineno = self._separate_comprehensions( [n[0] for n in nodes], end_lineno, positions, traced_file) # This just makes the loop below simpler positions.append(HTMLPosition(len(traced_file.source), False, 0, '')) positions.sort() html_parts = [] start = 0 for position in positions: html_parts.append(html.escape(traced_file.source[start:position.index])) html_parts.append(position.html) start = position.index html_body = ''.join(html_parts) html_body = '\n'.join(html_body.split('\n')[start_lineno - 1:end_lineno - 1]) return html_body.strip('\n') def _separate_comprehensions(self, nodes, end_lineno, positions, traced_file): # type: (list, int, List[HTMLPosition], TracedFile) -> int """ Comprehensions (e.g. list comprehensions) are troublesome because they can be navigated like loops, and the buttons for these need to be on separate lines. This function inserts newlines to turn: [x + y for x in range(3) for y in range(5)] and [[x + y for x in range(3)] for y in range(5)] into [x + y for x in range(3) for y in range(5)] and [[x + y for x in range(3)] for y in range(5)] """ comprehensions = group_by_key_func(of_type((ast.comprehension, ast.While, ast.For), nodes), lambda c: c.first_token.start[0] ) # type: Dict[Any, Iterable[ast.comprehension]] def get_start(n): # type: (ast.AST) -> int return traced_file.tokens.get_text_range(n)[0] for comp_list in comprehensions.values(): prev_start = None # type: Optional[int] for comp in sorted(comp_list, key=lambda c: c.first_token.startpos): if isinstance(comp, ast.comprehension) and comp is comp.parent.generators[0]: start = get_start(comp.parent) if prev_start is not None and start < prev_start: start = get_start(comp) else: start = get_start(comp) if prev_start is not None: positions.append(HTMLPosition(start, True, 0, '\n ')) end_lineno += 1 prev_start = start return end_lineno eye = BirdsEye() HTMLPosition = NamedTuple('HTMLPosition', [ ('index', int), ('is_start', bool), ('depth', int), ('html', str), ]) def _deep_dict(): return defaultdict(_deep_dict) _bad_codes = (eye.enter_call.__code__, eye.exit_call.__code__, eye.after_expr.__code__, eye.after_stmt.__code__) def _tracing_recursively(frame): while frame: if frame.f_code in _bad_codes: return True frame = frame.f_back class Iteration(object): """ Corresponds to an iteration of a loop during a call, OR the call itself (FrameInfo.iteration). """ def __init__(self): # Mapping of nodes (via node._tree_index) to the value of that # node in this iteration. Only contains nodes within the corresponding # loop or at the top of the function, but not in loops further within # (those will be somewhere within self.loops) # Therefore those nodes have at most one value. self.vals = {} # type: Dict[int, NodeValue] # Mapping of loop nodes (via node._tree_index) to IterationLists # for loops that happened during this iteration self.loops = defaultdict(IterationList) # type: Dict[int, IterationList] # 0-based index of this iteration self.index = None # type: int self.keep = False def extract_iterations(self): # type: () -> Dict[str, Union[int, Dict]] return { 'index': self.index, 'loops': { tree_index: [iteration.extract_iterations() for iteration in iteration_list] for tree_index, iteration_list in self.loops.items() } } class IterationList(Iterable[Iteration]): """ A list of Iterations, corresponding to a run of a loop. If the loop has many iterations, only contains the first and last few and any in the middle where unique nodes had values, so that any node which appeared during this loop exists in at least some iterations. """ side_len = 3 def __init__(self): # Contains the first few iterations # and any after that have unique nodes in them self.start = [] # type: List[Iteration] # Contains the last few iterations self.end = deque(maxlen=self.side_len) # type: Deque[Iteration] # Total number of iterations in the loop, not all of which # are kept self.length = 0 # type: int # Number of times each node has been recorded in this loop self.recorded = Counter() def append(self, iteration): # type: (Iteration) -> None if self.length < self.side_len: self.start.append(iteration) else: # If self.end is too long, the first element self.end[0] # is about to be dropped by the deque. If that iteration # should be kept because of some node that was recorded, # add it to self.start if len(self.end) >= self.side_len and self.end[0].keep: self.start.append(self.end[0]) self.end.append(iteration) iteration.index = self.length self.length += 1 def __iter__(self): # type: () -> Iterator[Iteration] return chain(self.start, self.end) def last(self): # type: () -> Iteration if self.end: return self.end[-1] else: return self.start[-1] def recorded_node(self, node): # type: (ast.AST) -> None if self.recorded[node] >= 2: # We've already seen this node enough return # This node is new(ish), make sure we keep this iteration self.last().keep = True self.recorded[node] += 1 class TypeRegistry(object): basic_types = (type(None), bool, int, float, complex) if PY2: basic_types += (long,) special_types = basic_types + (list, dict, tuple, set, frozenset, str) if PY2: special_types += (unicode if PY2 else bytes,) num_special_types = len(special_types) def __init__(self): self.lock = Lock() self.data = defaultdict(lambda: len(self.data)) # type: Dict[type, int] for t in self.special_types: _ = self.data[t] def __getitem__(self, item): t = correct_type(item) with self.lock: return self.data[t] def names(self): # type: () -> List[str] rev = dict((v, k) for k, v in self.data.items()) return [safe_qualname(rev[i]) for i in range(len(rev))] type_registry = TypeRegistry() class NodeValue(object): """ The 'value' of a node during a particular iteration. This can mean different things, see the classmethods. Can also contain some metadata, including links to other calls. """ __slots__ = ('val_repr', 'type_index', 'meta', 'children') def __init__(self, val_repr, type_index): self.val_repr = val_repr # type: str self.type_index = type_index # type: int self.meta = None # type: Optional[Dict[str, Any]] self.children = None # type: Optional[List[Tuple[str, NodeValue]]] def set_meta(self, key, value): # type: (str, Any) -> None self.meta = self.meta or {} self.meta[key] = value def add_child(self, samples, level, key, value): # type: (dict, int, str, Any) -> None self.children = self.children or [] self.children.append((key, NodeValue.expression(samples, value, level))) def as_json(self): result = [self.val_repr, self.type_index, self.meta or {}] # type: list if self.children: result.extend(self.children) return result @classmethod def covered(cls): """ Represents a bit of code, usually a statement, that executed successfully but doesn't have an actual value. """ return cls('', -2) @classmethod def exception(cls, exc_value): """ Means that exc_value was raised by a node when executing, and not any inner node. """ return cls(exception_string(exc_value), -1) @classmethod def expression(cls, samples, val, level): # type: (dict, Any, int) -> NodeValue """ The value of an expression or one of its children, with attributes, dictionary items, etc as children. Has a max depth of `level` levels. """ result = cls(cheap_repr(val), type_registry[val]) if isinstance(val, (TypeRegistry.basic_types, BirdsEye)): return result length = None if not isinstance(val, QuerySet): # len triggers a database query try: length = len(val) except: pass else: result.set_meta('len', length) if isinstance(val, ModuleType): level = min(level, 2) add_child = partial(result.add_child, samples, level - 1) if isinstance(val, (Series, ndarray)): attrs = ['dtype'] if isinstance(val, ndarray): attrs.append('shape') for name in attrs: try: attr = getattr(val, name) except AttributeError: pass else: add_child(name, attr) if level >= 3 or level >= 2 and isinstance(val, Series): sample_type = 'big' else: sample_type = 'small' samples = samples[sample_type] # Always expand DataFrames and Series regardless of level to # make the table view of DataFrames work if isinstance(val, DataFrame): meta = {} result.set_meta('dataframe', meta) max_rows = samples['pandas_rows'] max_cols = samples['pandas_cols'] if length > max_rows + 2: meta['row_break'] = max_rows // 2 columns = val.columns num_cols = len(columns) if num_cols > max_cols + 2: meta['col_break'] = max_cols // 2 indices = set(_sample_indices(num_cols, max_cols)) for i, (formatted_name, label) in enumerate(zip(val.columns.format(sparsify=False), val.columns)): if i in indices: add_child(formatted_name, val[label]) return result if isinstance(val, Series): for i in _sample_indices(length, samples['pandas_rows']): try: k = val.index[i:i + 1].format(sparsify=False)[0] v = val.iloc[i] except: pass else: add_child(k, v) return result if (level <= 0 or isinstance(val, (str, bytes, range) if PY3 else (str, unicode, xrange))): return result if isinstance(val, (Sequence, ndarray)) and length is not None: for i in _sample_indices(length, samples['list']): try: v = val[i] except: pass else: add_child(str(i), v) if isinstance(val, Mapping): for k, v in islice(_safe_iter(val, iteritems), samples['dict']): add_child(cheap_repr(k), v) if isinstance(val, Set): vals = _safe_iter(val) num_items = samples['set'] if length is None or length > num_items + 2: vals = islice(vals, num_items) for i, v in enumerate(vals): add_child('<%s>' % i, v) d = getattr(val, '__dict__', None) if d: for k in sorted(islice(_safe_iter(d), samples['attributes']), key=str): v = d[k] if isinstance(v, TracedFile): continue add_child(str(k), v) else: for s in sorted(getattr(type(val), '__slots__', None) or ()): try: attr = getattr(val, s) except AttributeError: pass else: add_child(str(s), attr) return result def _safe_iter(val, f=lambda x: x): try: for x in f(val): yield x except: pass def _sample_indices(length, max_length): if length <= max_length + 2: return range(length) else: return chain(range(max_length // 2), range(length - max_length // 2, length)) @try_register_repr('pandas', 'Series') def _repr_series_one_line(x, helper): n = len(x) if n == 0: return repr(x) newlevel = helper.level - 1 pieces = [] maxparts = _repr_series_one_line.maxparts for i in _sample_indices(n, maxparts): k = x.index[i:i + 1].format(sparsify=False)[0] v = x.iloc[i] pieces.append('%s = %s' % (k, cheap_repr(v, newlevel))) if n > maxparts + 2: pieces.insert(maxparts // 2, '...') return '; '.join(pieces) def is_interesting_expression(node): # type: (ast.AST) -> bool """ If this expression has a value that may not be exactly what it looks like, return True. Put differently, return False if this is just a literal. """ return (isinstance(node, ast.expr) and not (isinstance(node, (ast.Num, ast.Str, getattr(ast, 'NameConstant', ()))) or isinstance(getattr(node, 'ctx', None), (ast.Store, ast.Del)) or (isinstance(node, ast.UnaryOp) and isinstance(node.op, (ast.UAdd, ast.USub)) and isinstance(node.operand, ast.Num)) or (isinstance(node, (ast.List, ast.Tuple, ast.Dict)) and not any(is_interesting_expression(n) for n in ast.iter_child_nodes(node))))) def is_obvious_builtin(node, value): # type: (ast.expr, Any) -> bool """ Return True if this node looks like a builtin and it really is (i.e. hasn't been shadowed). """ # noinspection PyUnresolvedReferences builtins = cast(dict, __builtins__) return ((isinstance(node, ast.Name) and node.id in builtins and builtins[node.id] is value) or isinstance(node, getattr(ast, 'NameConstant', ()))) executing-0.8.0/tests/samples/configuration.py000066400000000000000000000170201410133640400215350ustar00rootroot00000000000000import inspect import os import sys import threading from collections import Set, Mapping, Sequence from io import open import six import snoop as package from snoop.formatting import DefaultFormatter from snoop.pp_module import PP from snoop.tracer import Spy, Tracer from snoop.utils import builtins as builtins_module, is_pathlike, shitcode, ensure_tuple, QuerySet try: # Enable ANSI escape codes in Windows 10 import ctypes kernel32 = ctypes.windll.kernel32 kernel32.SetConsoleMode(kernel32.GetStdHandle(-11), 7) can_color = True except Exception: can_color = os.name != 'nt' def install( builtins=True, snoop="snoop", pp="pp", spy="spy", out=None, prefix='', columns='time', overwrite=False, color=None, enabled=True, watch_extras=(), replace_watch_extras=None, formatter_class=DefaultFormatter, ): """ Configure output, enable or disable, and add names to builtins. Parameters: - builtins: set to False to not add any names to builtins, so importing will still be required. - snoop, pp, and spy: set to other strings to choose the names of these functions in builtins - `out`: determines the output destination. By default this is stderr. You can also pass: - A string or a `Path` object to write to a file at that location. By default this always will append to the file. Pass `overwrite=True` to clear the file initially. - Anything with a `write` method, e.g. `sys.stdout` or a file object. - Any callable with a single string argument, e.g. `logger.info`. - `color`: determines whether the output includes escape characters to display colored text in the console. If you see weird characters in your output, your console doesn't support colors, so pass `color=False`. - Code is syntax highlighted using [Pygments](http://pygments.org/), and this argument is passed as the style. You can choose a different color scheme by passing a string naming a style (see [this gallery](https://help.farbox.com/pygments.html)) or a style class. The default style is monokai. - By default this parameter is set to `out.isatty()`, which is usually true for stdout and stderr but will be false if they are redirected or piped. Pass `True` or a style if you want to force coloring. - To see colors in the PyCharm Run window, edit the Run Configuration and tick "Emulate terminal in output console". - `prefix`: Pass a string to start all snoop lines with that string so you can grep for them easily. - `columns`: This specifies the columns at the start of each output line. You can pass a string with the names of built in columns separated by spaces or commas. These are the available columns: - `time`: The current time. This is the only column by default. - `thread`: The name of the current thread. - `thread_ident`: The [identifier](https://docs.python.org/3/library/threading.html#threading.Thread.ident) of the current thread, in case thread names are not unique. - `file`: The filename (not the full path) of the current function. - `full_file`: The full path to the file (also shown anyway when the function is called). - `function`: The name of the current function. - `function_qualname`: The qualified name of the current function. If you want a custom column, please open an issue to tell me what you're interested in! In the meantime, you can pass a list, where the elements are either strings or callables. The callables should take one argument, which will be an `Event` object. It has attributes `frame`, `event`, and `arg`, as specified in [`sys.settrace()`](https://docs.python.org/3/library/sys.html#sys.settrace), and other attributes which may change. """ if builtins: setattr(builtins_module, snoop, package.snoop) setattr(builtins_module, pp, package.pp) setattr(builtins_module, spy, package.spy) config = Config( out=out, prefix=prefix, columns=columns, overwrite=overwrite, color=color, enabled=enabled, watch_extras=watch_extras, replace_watch_extras=replace_watch_extras, formatter_class=formatter_class, ) package.snoop.config = config package.pp.config = config package.spy.config = config class Config(object): """" If you need more control than the global `install` function, e.g. if you want to write to several different files in one process, you can create a `Config` object, e.g: `config = snoop.Config(out=filename)`. Then `config.snoop`, `config.pp` and `config.spy` will use that configuration rather than the global one. The arguments are the same as the arguments of `install()` relating to output configuration and `enabled`. """ def __init__( self, out=None, prefix='', columns='time', overwrite=False, color=None, enabled=True, watch_extras=(), replace_watch_extras=None, formatter_class=DefaultFormatter, ): if can_color: if color is None: isatty = getattr(out or sys.stderr, 'isatty', lambda: False) color = bool(isatty()) else: color = False self.write = get_write_function(out, overwrite) self.formatter = formatter_class(prefix, columns, color) self.enabled = enabled self.pp = PP(self) class ConfiguredTracer(Tracer): config = self self.snoop = ConfiguredTracer self.spy = Spy(self) self.last_frame = None self.thread_local = threading.local() if replace_watch_extras is not None: self.watch_extras = ensure_tuple(replace_watch_extras) else: self.watch_extras = (len_shape_watch, dtype_watch) + ensure_tuple(watch_extras) def len_shape_watch(source, value): try: shape = value.shape except Exception: pass else: if not inspect.ismethod(shape): return '{}.shape'.format(source), shape if isinstance(value, QuerySet): # Getting the length of a Django queryset evaluates it return None length = len(value) if ( (isinstance(value, six.string_types) and length < 50) or (isinstance(value, (Mapping, Set, Sequence)) and length == 0) ): return None return 'len({})'.format(source), length def dtype_watch(source, value): dtype = value.dtype if not inspect.ismethod(dtype): return '{}.dtype'.format(source), dtype def get_write_function(output, overwrite): is_path = ( isinstance(output, six.string_types) or is_pathlike(output) ) if is_path: return FileWriter(output, overwrite).write elif callable(output): write = output else: def write(s): stream = output if stream is None: stream = sys.stderr try: stream.write(s) except UnicodeEncodeError: # God damn Python 2 stream.write(shitcode(s)) return write class FileWriter(object): def __init__(self, path, overwrite): self.path = six.text_type(path) self.overwrite = overwrite def write(self, s): with open(self.path, 'w' if self.overwrite else 'a', encoding='utf-8') as f: f.write(s) self.overwrite = False executing-0.8.0/tests/samples/db.py000066400000000000000000000176261410133640400172670ustar00rootroot00000000000000from __future__ import print_function, division, absolute_import import functools import sys from future import standard_library from sqlalchemy.exc import OperationalError, InterfaceError, InternalError, ProgrammingError, ArgumentError standard_library.install_aliases() import json import os from typing import List from contextlib import contextmanager from humanize import naturaltime from markupsafe import Markup from sqlalchemy import Sequence, UniqueConstraint, create_engine, Column, Integer, Text, ForeignKey, DateTime, String, \ Index from sqlalchemy.ext.declarative import declarative_base, declared_attr from sqlalchemy.orm import backref, relationship, sessionmaker from sqlalchemy.dialects.mysql import LONGTEXT from littleutils import select_attrs, retry from birdseye.utils import IPYTHON_FILE_PATH, is_ipython_cell from sqlalchemy.dialects.mysql.base import RESERVED_WORDS RESERVED_WORDS.add('function') DB_VERSION = 1 class Database(object): def __init__(self, db_uri=None, _skip_version_check=False): self.db_uri = db_uri = ( db_uri or os.environ.get('BIRDSEYE_DB') or os.path.join(os.path.expanduser('~'), '.birdseye.db')) kwargs = dict( pool_recycle=280, echo=False, # for convenience when debugging ) try: engine = create_engine(db_uri, **kwargs) except ArgumentError: db_uri = 'sqlite:///' + db_uri engine = create_engine(db_uri, **kwargs) self.engine = engine self.Session = sessionmaker(bind=engine) class Base(object): @declared_attr def __tablename__(cls): return cls.__name__.lower() Base = declarative_base(cls=Base) # type: ignore class KeyValue(Base): key = Column(String(50), primary_key=True) value = Column(Text) db_self = self class KeyValueStore(object): def __getitem__(self, item): with db_self.session_scope() as session: return (session .query(KeyValue.value) .filter_by(key=item) .scalar()) def __setitem__(self, key, value): with db_self.session_scope() as session: session.query(KeyValue).filter_by(key=key).delete() session.add(KeyValue(key=key, value=str(value))) __getattr__ = __getitem__ __setattr__ = __setitem__ LongText = LONGTEXT if engine.name == 'mysql' else Text class Call(Base): id = Column(String(length=32), primary_key=True) function_id = Column(Integer, ForeignKey('function.id'), index=True) function = relationship('Function', backref=backref('calls', lazy='dynamic')) arguments = Column(Text) return_value = Column(Text) exception = Column(Text) traceback = Column(Text) data = Column(LongText) start_time = Column(DateTime, index=True) @property def pretty_start_time(self): return self._pretty_time(self.start_time) @staticmethod def _pretty_time(dt): if not dt: return '' return Markup('%s (%s)' % ( dt.strftime('%Y-%m-%d %H:%M:%S'), naturaltime(dt))) @property def state_icon(self): return Markup('' % ( ('ok', 'green') if self.success else ('remove', 'red'))) @property def success(self): if self.exception: assert self.traceback assert self.return_value == 'None' return False else: assert not self.traceback return True @property def result(self): if self.success: return str(self.return_value) else: return str(self.exception) @property def arguments_list(self): return json.loads(self.arguments) @property def parsed_data(self): return json.loads(self.data) @staticmethod def basic_dict(call): return dict(arguments=call.arguments_list, **select_attrs(call, 'id function_id return_value traceback ' 'exception start_time')) basic_columns = (id, function_id, return_value, traceback, exception, start_time, arguments) class Function(Base): id = Column(Integer, Sequence('function_id_seq'), primary_key=True) file = Column(Text) name = Column(Text) type = Column(Text) # function or module html_body = Column(LongText) lineno = Column(Integer) data = Column(LongText) hash = Column(String(length=64), index=True) body_hash = Column(String(length=64), index=True) __table_args__ = ( UniqueConstraint('hash', name='everything_unique'), Index('idx_file', 'file', mysql_length=256), Index('idx_name', 'name', mysql_length=32), ) @property def parsed_data(self): return json.loads(self.data) @staticmethod def basic_dict(func): return select_attrs(func, 'file name lineno hash body_hash type') basic_columns = (file, name, lineno, hash, body_hash, type) self.Call = Call self.Function = Function self._KeyValue = KeyValue self.key_value_store = kv = KeyValueStore() if _skip_version_check: return if not self.table_exists(Function): Base.metadata.create_all(engine) kv.version = DB_VERSION elif not self.table_exists(KeyValue) or int(kv.version) < DB_VERSION: sys.exit('The birdseye database schema is out of date. ' 'Run "python -m birdseye.clear_db" to delete the existing tables.') def table_exists(self, table): return self.engine.dialect.has_table(self.engine, table.__name__) def all_file_paths(self): # type: () -> List[str] with self.session_scope() as session: paths = [f[0] for f in session.query(self.Function.file).distinct() if not is_ipython_cell(f[0])] paths.sort() if IPYTHON_FILE_PATH in paths: paths.remove(IPYTHON_FILE_PATH) paths.insert(0, IPYTHON_FILE_PATH) return paths def clear(self): for model in [self.Call, self.Function, self._KeyValue]: if self.table_exists(model): model.__table__.drop(self.engine) @contextmanager def session_scope(self): """Provide a transactional scope around a series of operations.""" session = self.Session() try: yield session session.commit() except: session.rollback() raise finally: session.close() def provide_session(self, func): @functools.wraps(func) def wrapper(*args, **kwargs): with self.session_scope() as session: return func(session, *args, **kwargs) return retry_db(wrapper) # Based on https://docs.sqlalchemy.org/en/latest/errors.html#error-dbapi retry_db = retry(3, (InterfaceError, OperationalError, InternalError, ProgrammingError)) executing-0.8.0/tests/samples/executing.py000066400000000000000000000357741410133640400207010ustar00rootroot00000000000000""" Get information about what a frame is currently doing. Typical usage: import executing node = executing.Source.executing(frame).node # node will be an AST node or None """ import __future__ import ast import dis import functools import inspect import io import linecache import sys from collections import defaultdict, namedtuple, Sized from itertools import islice from lib2to3.pgen2.tokenize import cookie_re as encoding_pattern from operator import attrgetter from threading import RLock __all__ = ["Source"] PY3 = sys.version_info[0] == 3 if PY3: # noinspection PyUnresolvedReferences from functools import lru_cache # noinspection PyUnresolvedReferences from tokenize import detect_encoding cache = lru_cache(maxsize=None) text_type = str else: from lib2to3.pgen2.tokenize import detect_encoding def cache(func): d = {} @functools.wraps(func) def wrapper(*args): if args in d: return d[args] result = d[args] = func(*args) return result return wrapper # noinspection PyUnresolvedReferences text_type = unicode try: # noinspection PyUnresolvedReferences get_instructions = dis.get_instructions except AttributeError: Instruction = namedtuple('Instruction', 'offset argval opname') from dis import HAVE_ARGUMENT, EXTENDED_ARG, hasconst, opname # Based on dis.disassemble from 2.7 # Left as similar as possible for easy diff def get_instructions(co): code = co.co_code n = len(code) i = 0 extended_arg = 0 while i < n: offset = i c = code[i] op = ord(c) argval = None i = i + 1 if op >= HAVE_ARGUMENT: oparg = ord(code[i]) + ord(code[i + 1]) * 256 + extended_arg extended_arg = 0 i = i + 2 if op == EXTENDED_ARG: extended_arg = oparg * 65536 if op in hasconst: argval = co.co_consts[oparg] yield Instruction(offset, argval, opname[op]) class NotOneValueFound(Exception): pass def only(it): if isinstance(it, Sized): if len(it) != 1: raise NotOneValueFound('Expected one value, found %s' % len(it)) # noinspection PyTypeChecker return list(it)[0] lst = tuple(islice(it, 2)) if len(lst) == 0: raise NotOneValueFound('Expected one value, found 0') if len(lst) > 1: raise NotOneValueFound('Expected one value, found several') return lst[0] class Source(object): """ The source code of a single file and associated metadata. The main method of interest is the classmethod `executing(frame)`. If you want an instance of this class, don't construct it. Ideally use the classmethod `for_frame(frame)`. If you don't have a frame, use `for_filename(filename [, module_globals])`. These methods cache instances by filename, so at most one instance exists per filename. Attributes: - filename - text - tree: AST parsed from text, or None if text is not valid Python All nodes in the tree have an extra `parent` attribute Other methods of interest: - statements_at_line - asttokens - code_qualname """ def __init__(self, filename, text): """ Don't call this constructor, see the class docstring. """ self.filename = filename if not isinstance(text, text_type): text = self.decode_source(text) self.text = text if PY3: ast_text = text else: # In python 2 it's a syntax error to parse unicode # with an encoding declaration, so we remove it but # leave empty lines in its place to keep line numbers the same ast_text = ''.join([ '\n' if i < 2 and encoding_pattern.match(line) else line for i, line in enumerate(text.splitlines(True)) ]) self._nodes_by_line = defaultdict(list) self.tree = None self._qualnames = {} if text: try: self.tree = ast.parse(ast_text, filename=filename) except SyntaxError: pass else: for node in ast.walk(self.tree): for child in ast.iter_child_nodes(node): child.parent = node if hasattr(node, 'lineno'): self._nodes_by_line[node.lineno].append(node) visitor = QualnameVisitor() visitor.visit(self.tree) self._qualnames = visitor.qualnames @classmethod def for_frame(cls, frame): """ Returns the `Source` object corresponding to the file the frame is executing in. """ return cls.for_filename(frame.f_code.co_filename, frame.f_globals or {}) @classmethod def for_filename(cls, filename, module_globals=None): source_cache = cls._class_local('__source_cache', {}) try: return source_cache[filename] except KeyError: pass lines = linecache.getlines(filename, module_globals) result = source_cache[filename] = cls(filename, ''.join(lines)) return result @classmethod def lazycache(cls, frame): if hasattr(linecache, 'lazycache'): linecache.lazycache(frame.f_code.co_filename, frame.f_globals) @classmethod def executing(cls, frame): """ Returns an `Executing` object representing the operation currently executing in the given frame. """ key = (frame.f_code, frame.f_lasti) executing_cache = cls._class_local('__executing_cache', {}) try: args = executing_cache[key] except KeyError: source = cls.for_frame(frame) node = stmts = None if source.tree: stmts = source.statements_at_line(frame.f_lineno) try: node = NodeFinder(frame, stmts, source.tree).result except Exception: raise else: new_stmts = {statement_containing_node(node)} assert new_stmts <= stmts stmts = new_stmts args = source, node, stmts executing_cache[key] = args return Executing(frame, *args) @classmethod def _class_local(cls, name, default): """ Returns an attribute directly associated with this class (as opposed to subclasses), setting default if necessary """ # classes have a mappingproxy preventing us from using setdefault result = cls.__dict__.get(name, default) setattr(cls, name, result) return result @cache def statements_at_line(self, lineno): """ Returns the statement nodes overlapping the given line. Returns at most one statement unless semicolons are present. If the `text` attribute is not valid python, meaning `tree` is None, returns an empty set. Otherwise, `Source.for_frame(frame).statements_at_line(frame.f_lineno)` should return at least one statement. """ return { statement_containing_node(node) for node in self._nodes_by_line[lineno] } @cache def asttokens(self): """ Returns an ASTTokens object for getting the source of specific AST nodes. See http://asttokens.readthedocs.io/en/latest/api-index.html """ from asttokens import ASTTokens # must be installed separately return ASTTokens( self.text, tree=self.tree, filename=self.filename, ) @staticmethod def decode_source(source): if isinstance(source, bytes): encoding, _ = detect_encoding(io.BytesIO(source).readline) source = source.decode(encoding) return source def code_qualname(self, code): """ Imitates the __qualname__ attribute of functions for code objects. Given: - A function `func` - A frame `frame` for an execution of `func`, meaning: `frame.f_code is func.__code__` `Source.for_frame(frame).code_qualname(frame.f_code)` will be equal to `func.__qualname__`*. Works for Python 2 as well, where of course no `__qualname__` attribute exists. Falls back to `code.co_name` if there is no appropriate qualname. Based on https://github.com/wbolster/qualname (* unless `func` is a lambda nested inside another lambda on the same line, in which case the outer lambda's qualname will be returned for the codes of both lambdas) """ assert code.co_filename == self.filename return self._qualnames.get((code.co_name, code.co_firstlineno), code.co_name) class Executing(object): """ Information about the operation a frame is currently executing. Generally you will just want `node`, which is the AST node being executed, or None if it's unknown. Currently `node` can only be an `ast.Call` object, other operations will be supported in future. """ def __init__(self, frame, source, node, stmts): self.frame = frame self.source = source self.node = node self.statements = stmts def code_qualname(self): return self.source.code_qualname(self.frame.f_code) def text(self): return self.source.asttokens().get_text(self.node) def text_range(self): return self.source.asttokens().get_text_range(self.node) class QualnameVisitor(ast.NodeVisitor): def __init__(self): super(QualnameVisitor, self).__init__() self.stack = [] self.qualnames = {} def visit_FunctionDef(self, node, name=None): name = name or node.name self.stack.append(name) self.qualnames.setdefault((name, node.lineno), ".".join(self.stack)) self.stack.append('') if isinstance(node, ast.Lambda): children = [node.body] else: children = node.body for child in children: self.visit(child) self.stack.pop() self.stack.pop() # Find lambdas in the function definition outside the body, # e.g. decorators or default arguments # Based on iter_child_nodes for field, child in ast.iter_fields(node): if field == 'body': continue if isinstance(child, ast.AST): self.visit(child) elif isinstance(child, list): for grandchild in child: if isinstance(grandchild, ast.AST): self.visit(grandchild) def visit_Lambda(self, node): self.visit_FunctionDef(node, '') def visit_ClassDef(self, node): self.stack.append(node.name) self.generic_visit(node) self.stack.pop() future_flags = sum( getattr(__future__, fname).compiler_flag for fname in __future__.all_feature_names ) def compile_similar_to(source, matching_code): return compile( source, matching_code.co_filename, 'exec', flags=future_flags & matching_code.co_flags, dont_inherit=True, ) sentinel = '' class NodeFinder(object): def __init__(self, frame, stmts, tree): self.frame = frame self.tree = tree b = frame.f_code.co_code[frame.f_lasti] if not PY3: b = ord(b) op_name = dis.opname[b] if op_name.startswith('CALL_'): typ = ast.Call elif op_name == 'BINARY_SUBSCR': typ = ast.Subscript elif op_name.startswith('BINARY_'): typ = ast.BinOp elif op_name.startswith('UNARY_'): typ = ast.UnaryOp elif op_name in ('LOAD_ATTR', 'LOAD_METHOD', 'LOOKUP_METHOD'): typ = ast.Attribute elif op_name == 'COMPARE_OP': typ = ast.Compare else: raise RuntimeError(op_name) with lock: exprs = { node for stmt in stmts for node in ast.walk(stmt) if isinstance(node, typ) if not (hasattr(node, "ctx") and not isinstance(node.ctx, ast.Load)) } self.result = only(list(self.matching_nodes(exprs))) def matching_nodes(self, exprs): for i, expr in enumerate(exprs): setter = get_setter(expr) replacement = ast.BinOp( left=expr, op=ast.Pow(), right=ast.Str(s=sentinel), ) ast.fix_missing_locations(replacement) setter(replacement) try: instructions = self.compile_instructions() except SyntaxError: continue finally: setter(expr) indices = [ i for i, instruction in enumerate(instructions) if instruction.argval == sentinel ] if not indices: continue arg_index = only(indices) - 1 while instructions[arg_index].opname == 'EXTENDED_ARG': arg_index -= 1 if instructions[arg_index].offset == self.frame.f_lasti: yield expr def compile_instructions(self): module_code = compile_similar_to(self.tree, self.frame.f_code) code = only(find_codes(module_code, self.frame.f_code)) return list(get_instructions(code)) def get_setter(node): parent = node.parent for name, field in ast.iter_fields(parent): if field is node: return lambda new_node: setattr(parent, name, new_node) elif isinstance(field, list): for i, item in enumerate(field): if item is node: def setter(new_node): field[i] = new_node return setter lock = RLock() def find_codes(root_code, matching): def matches(c): return all( f(c) == f(matching) for f in [ attrgetter('co_firstlineno'), attrgetter('co_name'), code_names, ] ) code_options = [] if matches(root_code): code_options.append(root_code) def finder(code): for const in code.co_consts: if not inspect.iscode(const): continue if matches(const): code_options.append(const) finder(const) finder(root_code) return code_options def code_names(code): return frozenset().union( code.co_names, code.co_varnames, code.co_freevars, code.co_cellvars, ) @cache def statement_containing_node(node): while not isinstance(node, ast.stmt): node = node.parent return node executing-0.8.0/tests/samples/import_hook.py000066400000000000000000000072331410133640400212250ustar00rootroot00000000000000import logging import sys from importlib.util import spec_from_loader import ast # This is based on the MacroPy import hook # https://github.com/lihaoyi/macropy/blob/46ee500b877d5a32b17391bb8122c09b15a1826a/macropy/core/import_hooks.py class BirdsEyeLoader: def __init__(self, spec, source, deep): self._spec = spec self.source = source self.deep = deep def create_module(self, spec): pass def exec_module(self, module): from birdseye.bird import eye eye.exec_string( source=self.source, filename=self._spec.origin, globs=module.__dict__, locs=module.__dict__, deep=self.deep, ) def get_filename(self, fullname): return self._spec.loader.get_filename(fullname) def is_package(self, fullname): return self._spec.loader.is_package(fullname) class BirdsEyeFinder(object): """Loads a module and looks for tracing inside, only providing a loader if it finds some. """ def _find_plain_spec(self, fullname, path, target): """Try to find the original module using all the remaining meta_path finders.""" spec = None for finder in sys.meta_path: # when testing with pytest, it installs a finder that for # some yet unknown reasons makes birdseye # fail. For now it will just avoid using it and pass to # the next one if finder is self or 'pytest' in finder.__module__: continue if hasattr(finder, 'find_spec'): spec = finder.find_spec(fullname, path, target=target) elif hasattr(finder, 'load_module'): spec = spec_from_loader(fullname, finder) if spec is not None and spec.origin != 'builtin': return spec def find_spec(self, fullname, path, target=None): spec = self._find_plain_spec(fullname, path, target) if spec is None or not (hasattr(spec.loader, 'get_source') and callable(spec.loader.get_source)): # noqa: E128 if fullname != 'org': # stdlib pickle.py at line 94 contains a ``from # org.python.core for Jython which is always failing, # of course logging.debug('Failed finding spec for %s', fullname) return try: source = spec.loader.get_source(fullname) except ImportError: logging.debug('Loader for %s was unable to find the sources', fullname) return except Exception: logging.exception('Loader for %s raised an error', fullname) return if not source or 'birdseye' not in source: return deep, trace_stmt = should_trace(source) if not trace_stmt: return loader = BirdsEyeLoader(spec, source, deep) return spec_from_loader(fullname, loader) def should_trace(source): trace_stmt = None deep = False for stmt in ast.parse(source).body: if isinstance(stmt, ast.Import): for alias in stmt.names: if alias.name.startswith('birdseye.trace_module'): trace_stmt = stmt if alias.name.endswith('deep'): deep = True if isinstance(stmt, ast.ImportFrom) and stmt.module == 'birdseye': for alias in stmt.names: if alias.name.startswith('trace_module'): trace_stmt = stmt if alias.name.endswith('deep'): deep = True return deep, trace_stmt executing-0.8.0/tests/samples/ipython.py000066400000000000000000000072101410133640400203600ustar00rootroot00000000000000import inspect import socket import sys from io import BytesIO, StringIO from threading import currentThread, Thread from uuid import uuid4 from IPython.core.display import HTML, display from IPython.core.magic import Magics, cell_magic, magics_class from jinja2 import Environment, PackageLoader, select_autoescape from traitlets import Unicode, Int, Bool from werkzeug.local import LocalProxy from werkzeug.serving import ThreadingMixIn from birdseye.bird import PY2, Database from birdseye import server, eye fake_stream = BytesIO if PY2 else StringIO thread_proxies = {} def stream_proxy(original): def p(): frame = inspect.currentframe() while frame: if frame.f_code == ThreadingMixIn.process_request_thread.__code__: return fake_stream() frame = frame.f_back return thread_proxies.get(currentThread().ident, original) return LocalProxy(p) sys.stderr = stream_proxy(sys.stderr) sys.stdout = stream_proxy(sys.stdout) def run_server(port, bind_host, show_server_output): if not show_server_output: thread_proxies[currentThread().ident] = fake_stream() try: server.app.run( debug=True, port=port, host=bind_host, use_reloader=False, ) except socket.error: pass templates_env = Environment( loader=PackageLoader('birdseye', 'templates'), autoescape=select_autoescape(['html', 'xml']) ) @magics_class class BirdsEyeMagics(Magics): server_url = Unicode( u'', config=True, help='If set, a server will not be automatically started by %%eye. ' 'The iframe containing birdseye output will use this value as the base ' 'of its URL.' ) port = Int( 7777, config=True, help='Port number for the server started by %%eye.' ) bind_host = Unicode( '127.0.0.1', config=True, help='Host that the server started by %%eye listens on. ' 'Set to 0.0.0.0 to make it accessible anywhere.' ) show_server_output = Bool( False, config=True, help='Set to True to show stdout and stderr from the server started by %%eye.' ) db_url = Unicode( u'', config=True, help='The database URL that the server started by %%eye reads from. ' 'Equivalent to the environment variable BIRDSEYE_DB.' ) @cell_magic def eye(self, _line, cell): if not self.server_url: server.db = Database(self.db_url) server.Function = server.db.Function server.Call = server.db.Call server.Session = server.db.Session Thread( target=run_server, args=( self.port, self.bind_host, self.show_server_output, ), ).start() eye.db = Database(self.db_url) def callback(call_id): """ Always executes after the cell, whether or not an exception is raised in the user code. """ if call_id is None: # probably means a bug return html = HTML(templates_env.get_template('ipython_iframe.html').render( call_id=call_id, url=self.server_url.rstrip('/'), port=self.port, container_id=uuid4().hex, )) # noinspection PyTypeChecker display(html) value = eye.exec_ipython_cell(cell, callback) # Display the value as would happen if the %eye magic wasn't there return value executing-0.8.0/tests/samples/server.py000066400000000000000000000205561410133640400202040ustar00rootroot00000000000000from __future__ import print_function, division, absolute_import import json from collections import OrderedDict from functools import partial from os.path import basename from future import standard_library from littleutils import DecentJSONEncoder, withattrs, group_by_attr standard_library.install_aliases() import argparse import os import sys from flask import Flask, request, jsonify, url_for from flask.templating import render_template from flask_humanize import Humanize from werkzeug.routing import PathConverter import sqlalchemy from birdseye.db import Database from birdseye.utils import short_path, IPYTHON_FILE_PATH, fix_abs_path, is_ipython_cell app = Flask('birdseye') app.jinja_env.auto_reload = True Humanize(app) class FileConverter(PathConverter): regex = '.*?' app.url_map.converters['file'] = FileConverter db = Database() Session = db.Session Function = db.Function Call = db.Call @app.route('/') @db.provide_session def index(session): all_paths = db.all_file_paths() recent_calls = (session.query(*(Call.basic_columns + Function.basic_columns)) .join(Function) .order_by(Call.start_time.desc())[:100]) files = OrderedDict() for row in recent_calls: if is_ipython_cell(row.file): continue files.setdefault( row.file, OrderedDict() ).setdefault( row.name, row ) for path in all_paths: files.setdefault( path, OrderedDict() ) short = partial(short_path, all_paths=all_paths) return render_template('index.html', short=short, files=files) @app.route('/file/') @db.provide_session def file_view(session, path): path = fix_abs_path(path) # Get all calls and functions in this file filtered_calls = (session.query(*(Call.basic_columns + Function.basic_columns)) .join(Function) .filter_by(file=path) .subquery('filtered_calls')) # Get the latest call *time* for each function in the file latest_calls = session.query( filtered_calls.c.name, sqlalchemy.func.max(filtered_calls.c.start_time).label('maxtime') ).group_by( filtered_calls.c.name, ).subquery('latest_calls') # Get the latest call for each function query = session.query(filtered_calls).join( latest_calls, sqlalchemy.and_( filtered_calls.c.name == latest_calls.c.name, filtered_calls.c.start_time == latest_calls.c.maxtime, ) ).order_by(filtered_calls.c.start_time.desc()) funcs = group_by_attr(query, 'type') # Add any functions which were never called all_funcs = sorted(session.query(Function.name, Function.type) .filter_by(file=path) .distinct()) func_names = {row.name for row in query} for func in all_funcs: if func.name not in func_names: funcs[func.type].append(func) return render_template('file.html', funcs=funcs, is_ipython=path == IPYTHON_FILE_PATH, full_path=path, short_path=basename(path)) @app.route('/file//__function__/') @db.provide_session def func_view(session, path, func_name): path = fix_abs_path(path) query = get_calls(session, path, func_name, 200) if query: func = query[0] calls = [withattrs(Call(), **row._asdict()) for row in query] else: func = session.query(Function).filter_by(file=path, name=func_name)[0] calls = None return render_template('function.html', func=func, short_path=basename(path), calls=calls) @app.route('/api/file//__function__//latest_call/') @db.provide_session def latest_call(session, path, func_name): path = fix_abs_path(path) call = get_calls(session, path, func_name, 1)[0] return jsonify(dict( id=call.id, url=url_for(call_view.__name__, call_id=call.id), )) def get_calls(session, path, func_name, limit): return (session.query(*(Call.basic_columns + Function.basic_columns)) .join(Function) .filter_by(file=path, name=func_name) .order_by(Call.start_time.desc())[:limit]) @db.provide_session def base_call_view(session, call_id, template): call = session.query(Call).filter_by(id=call_id).one() func = call.function return render_template(template, short_path=basename(func.file), call=call, func=func) @app.route('/call/') def call_view(call_id): return base_call_view(call_id, 'call.html') @app.route('/ipython_call/') def ipython_call_view(call_id): return base_call_view(call_id, 'ipython_call.html') @app.route('/ipython_iframe/') def ipython_iframe_view(call_id): """ This view isn't generally used, it's just an easy way to play with the template without a notebook. """ return render_template('ipython_iframe.html', container_id='1234', port=7777, call_id=call_id) @app.route('/kill', methods=['POST']) def kill(): func = request.environ.get('werkzeug.server.shutdown') if func is None: raise RuntimeError('Not running with the Werkzeug Server') func() return 'Server shutting down...' @app.route('/api/call/') @db.provide_session def api_call_view(session, call_id): call = session.query(Call).filter_by(id=call_id).one() func = call.function return DecentJSONEncoder().encode(dict( call=dict(data=call.parsed_data, **Call.basic_dict(call)), function=dict(data=func.parsed_data, **Function.basic_dict(func)))) @app.route('/api/calls_by_body_hash/') @db.provide_session def calls_by_body_hash(session, body_hash): query = (session.query(*Call.basic_columns + (Function.data,)) .join(Function) .filter_by(body_hash=body_hash) .order_by(Call.start_time.desc())[:200]) calls = [Call.basic_dict(withattrs(Call(), **row._asdict())) for row in query] function_data_set = {row.data for row in query} ranges = set() loop_ranges = set() for function_data in function_data_set: function_data = json.loads(function_data) def add(key, ranges_set): for node in function_data[key]: ranges_set.add((node['start'], node['end'])) add('node_ranges', ranges) # All functions are expected to have the same set # of loop nodes current_loop_ranges = set() add('loop_ranges', current_loop_ranges) assert loop_ranges in (set(), current_loop_ranges) loop_ranges = current_loop_ranges ranges = [dict(start=start, end=end) for start, end in ranges] loop_ranges = [dict(start=start, end=end) for start, end in loop_ranges] return DecentJSONEncoder().encode(dict( calls=calls, ranges=ranges, loop_ranges=loop_ranges)) @app.route('/api/body_hashes_present/', methods=['POST']) @db.provide_session def body_hashes_present(session): hashes = request.get_json() query = (session.query(Function.body_hash, sqlalchemy.func.count(Call.id)) .outerjoin(Call) .filter(Function.body_hash.in_(hashes)) .group_by(Function.body_hash)) return DecentJSONEncoder().encode([ dict(hash=h, count=count) for h, count in query ]) def main(argv=sys.argv[1:]): # Support legacy CLI where there was just one positional argument: the port if len(argv) == 1 and argv[0].isdigit(): argv.insert(0, '--port') parser = argparse.ArgumentParser(description="Bird's Eye: A graphical Python debugger") parser.add_argument('-p', '--port', help='HTTP port, default is 7777', default=7777, type=int) parser.add_argument('--host', help="HTTP host, default is 'localhost'", default='localhost') args = parser.parse_args(argv) app.run( port=args.port, host=args.host, use_reloader=os.environ.get('BIRDSEYE_RELOADER') == '1', ) if __name__ == '__main__': main() executing-0.8.0/tests/samples/tests.py000066400000000000000000000314641410133640400200400ustar00rootroot00000000000000# -*- coding: utf-8 -*- from __future__ import print_function, division import ast import inspect import os import sys import tempfile import time import unittest from executing import Source, only, PY3, NotOneValueFound, get_instructions class TestStuff(unittest.TestCase): # noinspection PyTrailingSemicolon def test_semicolons(self): # @formatter:off tester(1); tester(2); tester(3) tester(9 ); tester( 8); tester( 99 ); tester(33); tester([4, 5, 6, [ 7]]) # @formatter:on def test_decorator(self): @empty_decorator @decorator_with_args(tester('123'), x=int()) @tester(list(tuple([1, 2])), returns=empty_decorator) @tester( list( tuple( [3, 4])), returns=empty_decorator) @empty_decorator @decorator_with_args( str(), x=int()) @tester(list(tuple([5, 6])), returns=empty_decorator) @tester(list(tuple([7, 8])), returns=empty_decorator) @empty_decorator @decorator_with_args(tester('sdf'), x=tester('123234')) def foo(): pass def test_comprehensions(self): # Comprehensions can be separated if they contain different names str([{tester(x) for x in [1]}, {tester(y) for y in [1]}]) # or are on different lines str([{tester(x) for x in [1]}, {tester(x) for x in [1]}]) # or are of different types str([{tester(x) for x in [1]}, list(tester(x) for x in [1])]) # but not if everything is the same # noinspection PyTypeChecker # with self.assertRaises((AttributeError, NotOneValueFound)): # str([{tester(x) for x in [1]}, {tester(x) for x in [2]}]) def test_lambda(self): self.assertEqual( (lambda x: (tester(x), tester(x)))(tester(3)), (3, 3), ) (lambda: (lambda: tester(1))())() self.assertEqual( (lambda: [tester(x) for x in tester([1, 2])])(), [1, 2], ) def test_closures_and_nested_comprehensions(self): x = 1 # @formatter:off str({tester(a+x): {tester(b+x): {tester(c+x) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])}) def foo(): y = 2 str({tester(a+x): {tester(b+x): {tester(c+x) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])}) str({tester(a+y): {tester(b+y): {tester(c+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])}) str({tester(a+x+y): {tester(b+x+y): {tester(c+x+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])}) def bar(): z = 3 str({tester(a+x): {tester(b+x): {tester(c+x) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])}) str({tester(a+y): {tester(b+y): {tester(c+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])}) str({tester(a+x+y): {tester(b+x+y): {tester(c+x+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])}) str({tester(a+x+y+z): {tester(b+x+y+z): {tester(c+x+y+z) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])}) bar() foo() # @formatter:on def test_indirect_call(self): dict(x=tester)['x'](tester)(3, check_func=False) def test_compound_statements(self): with self.assertRaises(TypeError): try: for _ in tester([1, 2, 3]): while tester(0): pass else: tester(4) else: tester(5) raise ValueError except tester(ValueError): tester(9) raise TypeError finally: tester(10) # PyCharm getting confused somehow? # noinspection PyUnreachableCode str() with self.assertRaises(tester(Exception)): if tester(0): pass elif tester(0): pass elif tester(1 / 0): pass def test_generator(self): def gen(): for x in [1, 2]: yield tester(x) gen2 = (tester(x) for x in tester([1, 2])) assert list(gen()) == list(gen2) == [1, 2] def test_future_import(self): tester(4) def test_many_calls(self): node = None start = time.time() for i in range(10000): new_node = Source.executing(inspect.currentframe()).node if node is None: node = new_node else: self.assertIs(node, new_node) self.assertLess(time.time() - start, 1) def test_decode_source(self): def check(source, encoding, exception=None, matches=True): encoded = source.encode(encoding) if exception: with self.assertRaises(exception): Source.decode_source(encoded) else: decoded = Source.decode_source(encoded) if matches: self.assertEqual(decoded, source) else: self.assertNotEqual(decoded, source) check(u'# coding=utf8\né', 'utf8') check(u'# coding=gbk\né', 'gbk') check(u'# coding=utf8\né', 'gbk', exception=UnicodeDecodeError) check(u'# coding=gbk\né', 'utf8', matches=False) # In Python 3 the default encoding is assumed to be UTF8 if PY3: check(u'é', 'utf8') check(u'é', 'gbk', exception=SyntaxError) def test_multiline_strings(self): tester('a') tester(''' ab''') tester(''' abc def ''' ) str([ tester( ''' 123 456 ''' ), tester( ''' 345 456786 ''' ), ]) tester( [ ''' 123 456 ''' ''' 345 456786 ''' , ''' 123 456 ''', ''' 345 456786 ''' ] ) def test_multiple_statements_on_one_line(self): if tester(1): tester(2) for _ in tester([1, 2]): tester(3) def assert_qualname(self, func, qn, check_actual_qualname=True): qualname = Source.for_filename(__file__).code_qualname(func.__code__) self.assertEqual(qn, qualname) if PY3 and check_actual_qualname: self.assertEqual(qn, func.__qualname__) self.assertTrue(qn.endswith(func.__name__)) def test_qualname(self): self.assert_qualname(C.f, 'C.f') self.assert_qualname(C.D.g, 'C.D.g') self.assert_qualname(f, 'f') self.assert_qualname(f(), 'f..g') self.assert_qualname(C.D.h(), 'C.D.h..i..j') self.assert_qualname(lamb, '') foo = lambda_maker() self.assert_qualname(foo, 'lambda_maker..foo') self.assert_qualname(foo.x, 'lambda_maker..') self.assert_qualname(foo(), 'lambda_maker..foo..') self.assert_qualname(foo()(), 'lambda_maker..foo..', check_actual_qualname=False) def test_extended_arg(self): source = 'tester(6)\n%s\ntester(9)' % list(range(66000)) _, filename = tempfile.mkstemp() code = compile(source, filename, 'exec') with open(filename, 'w') as outfile: outfile.write(source) exec(code) def test_only(self): for n in range(5): gen = (i for i in range(n)) if n == 1: self.assertEqual(only(gen), 0) else: with self.assertRaises(NotOneValueFound): only(gen) def test_invalid_python(self): path = os.path.join(os.path.dirname(__file__), 'not_code.txt', ) source = Source.for_filename(path) self.assertIsNone(source.tree) def test_executing_methods(self): frame = inspect.currentframe() executing = Source.executing(frame) self.assertEqual(executing.code_qualname(), 'TestStuff.test_executing_methods') if 'pypy' not in sys.version.lower(): text = 'Source.executing(frame)' self.assertEqual(executing.text(), text) start, end = executing.text_range() self.assertEqual(executing.source.text[start:end], text) def test_attr(self): c = C() c.x = c.y = tester str((c.x.x, c.x.y, c.y.x, c.y.y, c.x.asd, c.y.qwe)) class TestFile(unittest.TestCase): def test_file(self): source = Source.for_frame(inspect.currentframe()) code = compile(source.text, source.filename, 'exec') instructions = get_instructions(code) lineno = None for inst in instructions: if inst.starts_line is not None: lineno = inst.starts_line if not inst.opname.startswith( ('BINARY_', 'UNARY_', 'LOAD_ATTR', 'LOAD_METHOD', 'LOOKUP_METHOD', 'COMPARE_OP')): continue frame = C() frame.f_lasti = inst.offset frame.f_code = code frame.f_globals = globals() frame.f_lineno = lineno print(inst.opname) assert Source.executing(frame).node is not None class C(object): @staticmethod def f(): pass class D(object): @staticmethod def g(): pass @staticmethod def h(): def i(): def j(): pass return j return i() TestFile().test_file() def f(): def g(): pass return g def lambda_maker(): def assign(x): def decorator(func): func.x = x return func return decorator @assign(lambda: 1) def foo(): return lambda: lambda: 3 return foo lamb = lambda: 0 class Tester(object): def get_node(self, typ): frame = inspect.currentframe().f_back.f_back Source.lazycache(frame) node = Source.executing(frame).node assert isinstance(node, typ), (node, typ) return node def check(self, node, value): frame = inspect.currentframe().f_back.f_back result = eval( compile(ast.Expression(node), frame.f_code.co_filename, 'eval'), frame.f_globals, frame.f_locals, ) assert result == value, (result, value) def __call__(self, arg, check_func=True, returns=None): call = self.get_node(ast.Call) self.check(call.args[0], arg) if check_func: self.check(call.func, self) if returns is None: return arg return returns def __getattr__(self, item): node = self.get_node(ast.Attribute) self.check(node.value, self) assert node.attr == item return self def __getitem__(self, item): node = self.get_node(ast.Subscript) self.check(node.value, self) self.check(node.slice.value, item) return self def __add__(self, other): node = self.get_node(ast.BinOp) self.check(node.left, self) self.check(node.right, other) return self __pow__ = __mul__ = __sub__ = __add__ def __invert__(self): node = self.get_node(ast.UnaryOp) self.check(node.operand, self) return self __neg__ = __pos__ = __invert__ def __lt__(self, other): node = self.get_node(ast.Compare) self.check(node.left, self) self.check(node.comparators[0], other) return self __ne__ = __ge__ = __lt__ tester = Tester() assert tester([1, 2, 3]) == [1, 2, 3] assert tester.asd is tester assert tester[19] is tester assert tester ** 4 is tester assert tester * 3 is tester assert tester - 2 is tester assert tester + 1 is tester assert -tester is tester assert +tester is tester assert ~tester is tester assert (tester < 7) is tester assert (tester >= 78) is tester assert (tester != 79) is tester # assert (5 != tester != 6) is tester assert tester.foo(45, False) == 45 def empty_decorator(func): return func def decorator_with_args(*_, **__): return empty_decorator if __name__ == '__main__': unittest.main() executing-0.8.0/tests/samples/tracer.py000066400000000000000000000626311410133640400201560ustar00rootroot00000000000000""" This module provides the generic functionality of tracing code by modifying its AST. Eventually this will become a separate package. This is similar to the standard library module bdb, while birdseye itself would correspond to pdb. Most of the work is in TreeTracerBase. """ from __future__ import print_function, division, absolute_import from future import standard_library standard_library.install_aliases() import ast import inspect import sys from collections import namedtuple, defaultdict from copy import deepcopy from functools import partial, update_wrapper, wraps from itertools import takewhile from typing import List, Dict, Any, Optional, NamedTuple, Tuple, Iterator, Callable, cast, Union from types import FrameType, TracebackType, CodeType, FunctionType from birdseye.utils import PY3, Type, is_lambda, lru_cache, read_source_file, is_ipython_cell, \ is_future_import class TracedFile(object): """ An instance of this class corresponds to a single .py file. It contains some useful data in the following attributes: - filename: name of the source file - source: textual contents of the file - root: root of the original Abstract Syntax Tree (AST) of the source, where the nodes of this tree have an additional handy attribute: - parent: parent of the node, so this node is a child node of its parent - tracer: instance of TreeTracerBase - code: executable code object compiled from the modified AST """ is_ipython_cell = False def __init__(self, tracer, source, filename, flags): # type: (TreeTracerBase, str, str, int) -> None # Here the source code is parsed, modified, and compiled self.root = compile(source, filename, 'exec', ast.PyCF_ONLY_AST | flags, dont_inherit=True) # type: ast.Module self.nodes = [] # type: List[ast.AST] self.set_basic_node_attributes() new_root = tracer.parse_extra(self.root, source, filename) if new_root is not None: self.root = new_root self.set_basic_node_attributes() self.set_enter_call_nodes() new_root = deepcopy(self.root) new_root = _NodeVisitor().visit(new_root) self.code = compile(new_root, filename, "exec", dont_inherit=True, flags=flags) # type: CodeType self.tracer = tracer self.source = source self.filename = filename def set_basic_node_attributes(self): self.nodes = [] # type: List[ast.AST] for node in ast.walk(self.root): # type: ast.AST for child in ast.iter_child_nodes(node): child.parent = node node._tree_index = len(self.nodes) self.nodes.append(node) # Mark __future__ imports and anything before (i.e. module docstrings) # to be ignored by the AST transformer for i, stmt in enumerate(self.root.body): if is_future_import(stmt): for s in self.root.body[:i + 1]: for node in ast.walk(s): node._visit_ignore = True def set_enter_call_nodes(self): for node in self.nodes: if isinstance(node, (ast.Module, ast.FunctionDef)): for stmt in node.body: if not is_future_import(stmt): stmt._enter_call_node = True break class FrameInfo(object): """ Contains extra data about an execution frame. Can be obtained from the stack attribute of a TreeTracerBase instance """ def __init__(self): # Stack of statements currently being executed self.statement_stack = [] # type: List[ast.stmt] # Stack of expression nodes within the above statement that # the interpreter is planning on evaluating, or has just evaluated # in the case of the last element of the list. For example, given # the expression f(g(x)), the stack would be [f, g, x] before and just # after evaluating x, since function arguments are evaluated before the # actual function call. self.expression_stack = [] # type: List[ast.expr] # Mapping from the expression node to its most recent value # in the corresponding frame self.expression_values = {} # type: Dict[ast.expr, Any] # Node where the frame has explicitly returned # There may be parent nodes such as enclosing loops that still need to finish executing self.return_node = None # type: Optional[ast.Return] # Most recent exception raised in the frame self.exc_value = None # type: Optional[BaseException] # Some of the attributes of the classes below are unused for now and are # intended for future use, possibly by other debuggers # Argument of TreeTracerBase.enter_call EnterCallInfo = NamedTuple('EnterCallInfo', [ # Node from where the call was made ('call_node', Optional[Union[ast.expr, ast.stmt]]), # Node where the call begins ('enter_node', ast.AST), # Frame from which the call was made ('caller_frame', FrameType), # Frame of the call ('current_frame', FrameType)]) # Argument of TreeTracerBase.exit_call ExitCallInfo = NamedTuple('ExitCallInfo', [ # Node from where the call was made ('call_node', Optional[Union[ast.expr, ast.stmt]]), # Node where the call explicitly returned ('return_node', Optional[ast.Return]), # Frame from which the call was made ('caller_frame', FrameType), # Frame of the call ('current_frame', FrameType), # Node where the call explicitly returned ('return_value', Any), # Exception raised in the call causing it to end, # will propagate to the caller ('exc_value', Optional[Exception]), # Traceback corresponding to exc_value ('exc_tb', Optional[TracebackType])]) # see TreeTracerBase.after_expr ChangeValue = namedtuple('ChangeValue', 'value') class TreeTracerBase(object): """ Create a subclass of this class with one or more of the 'hooks' (methods which are empty in this class) overridden to take a custom action in the given situation. Then decorate functions with an instance of this class to trace them. """ def __init__(self): # Mapping from frames of execution being traced to FrameInfo objects # for extra metadata. self.stack = {} # type: Dict[FrameType, FrameInfo] self.main_to_secondary_frames = defaultdict(list) self.secondary_to_main_frames = {} @lru_cache() def compile(self, source, filename, flags=0): # type: (str, str, int) -> TracedFile return TracedFile(self, source, filename, flags) def _trace_methods_dict(self, traced_file): # type: (TracedFile) -> Dict[str, Callable] return {f.__name__: partial(f, traced_file) for f in [ self._treetrace_hidden_with_stmt, self._treetrace_hidden_before_expr, self._treetrace_hidden_after_expr, ]} def trace_function(self, func): # type: (FunctionType) -> FunctionType """ Returns a version of the passed function with the AST modified to trigger the tracing hooks. """ if not isinstance(func, FunctionType): raise ValueError('You can only trace user-defined functions. ' 'The birdseye decorator must be applied first, ' 'at the bottom of the list.') try: if inspect.iscoroutinefunction(func) or inspect.isasyncgenfunction(func): raise ValueError('You cannot trace async functions') except AttributeError: pass if is_lambda(func): raise ValueError('You cannot trace lambdas') filename = inspect.getsourcefile(func) # type: str if is_ipython_cell(filename): # noinspection PyPackageRequirements from IPython import get_ipython import linecache flags = get_ipython().compile.flags source = ''.join(linecache.cache[filename][2]) else: source = read_source_file(filename) flags = 0 # We compile the entire file instead of just the function source # because it can contain context which affects the function code, # e.g. enclosing functions and classes or __future__ imports traced_file = self.compile(source, filename, flags) if func.__dict__: raise ValueError('The birdseye decorator must be applied first, ' 'at the bottom of the list.') # Then we have to recursively search through the newly compiled # code to find the code we actually want corresponding to this function code_options = [] # type: List[CodeType] def find_code(root_code): # type: (CodeType) -> None for const in root_code.co_consts: # type: CodeType if not inspect.iscode(const): continue matches = (const.co_firstlineno == func.__code__.co_firstlineno and const.co_name == func.__code__.co_name) if matches: code_options.append(const) find_code(const) find_code(traced_file.code) if len(code_options) > 1: # Currently lambdas aren't allowed anyway, but should be in the future assert is_lambda(func) raise ValueError("Failed to trace lambda. Convert the function to a def.") new_func_code = code_options[0] # type: CodeType # Give the new function access to the hooks # We have to use the original __globals__ and not a copy # because it's the actual module namespace that may get updated by other code func.__globals__.update(self._trace_methods_dict(traced_file)) # http://stackoverflow.com/a/13503277/2482744 # noinspection PyArgumentList new_func = FunctionType(new_func_code, func.__globals__, func.__name__, func.__defaults__, func.__closure__) update_wrapper(new_func, func) # type: FunctionType if PY3: new_func.__kwdefaults__ = getattr(func, '__kwdefaults__', None) new_func.traced_file = traced_file return new_func def __call__(self, func=None, optional=False): # type: (FunctionType, bool) -> Callable """ Decorator which returns a (possibly optionally) traced function. This decorator can be called with or without arguments. Typically it is called without arguments, in which case it returns a traced function. If optional=True, it returns a function similar to the original but with an additional optional parameter trace_call, default False. If trace_call is false, the underlying untraced function is used. If true, the traced version is used. """ if inspect.isclass(func): raise TypeError('Decorating classes is no longer supported') if func: # The decorator has been called without arguments/parentheses, # e.g. # @eye # def ... return self.trace_function(func) # The decorator has been called with arguments/parentheses, # e.g. # @eye(...) # def ... # We must return a decorator if not optional: return self.trace_function def decorator(actual_func): traced = self.trace_function(actual_func) @wraps(actual_func) def wrapper(*args, **kwargs): trace_call = kwargs.pop('trace_call', False) if trace_call: f = traced else: f = actual_func return f(*args, **kwargs) return wrapper return decorator def _main_frame(self, node): # type: (ast.AST) -> Optional[FrameType] frame = sys._getframe(2) result = self.secondary_to_main_frames.get(frame) if result: return result original_frame = frame while frame.f_code.co_name in ('', '', ''): frame = frame.f_back for node in ancestors(node): if isinstance(node, (ast.FunctionDef, ast.Lambda)): break if isinstance(node, ast.ClassDef): frame = frame.f_back if frame.f_code.co_name in ('', ''): return None self.secondary_to_main_frames[original_frame] = frame self.main_to_secondary_frames[frame].append(original_frame) return frame def _treetrace_hidden_with_stmt(self, traced_file, _tree_index): # type: (TracedFile, int) -> _StmtContext """ Called directly from the modified code. Every statement in the original code becomes: with _treetrace_hidden_with_stmt(...): """ node = traced_file.nodes[_tree_index] node = cast(ast.stmt, node) frame = self._main_frame(node) return _StmtContext(self, node, frame) def _treetrace_hidden_before_expr(self, traced_file, _tree_index): # type: (TracedFile, int) -> ast.expr """ Called directly from the modified code before an expression is evaluated. """ node = traced_file.nodes[_tree_index] node = cast(ast.expr, node) frame = self._main_frame(node) if frame is None: return node frame_info = self.stack[frame] frame_info.expression_stack.append(node) self.before_expr(node, frame) return node def _treetrace_hidden_after_expr(self, _, node, value): # type: (TracedFile, ast.expr, Any) -> Any """ Called directly from the modified code after an expression is evaluated. """ frame = self._main_frame(node) if frame is None: return value result = self._after_expr(node, frame, value, None, None) if result is not None: assert isinstance(result, ChangeValue), "after_expr must return None or an instance of ChangeValue" value = result.value return value def _after_expr(self, node, frame, value, exc_value, exc_tb): frame_info = self.stack[frame] frame_info.expression_stack.pop() frame_info.expression_values[node] = value return self.after_expr(node, frame, value, exc_value, exc_tb) def _enter_call(self, enter_node, current_frame): # type: (ast.AST, FrameType) -> None caller_frame, call_node = self._get_caller_stuff(current_frame) self.stack[current_frame] = FrameInfo() self.enter_call(EnterCallInfo(call_node, enter_node, caller_frame, current_frame)) def _get_caller_stuff(self, frame): # type: (FrameType) -> Tuple[FrameType, Optional[Union[ast.expr, ast.stmt]]] caller_frame = frame.f_back call_node = None main_frame = self.secondary_to_main_frames.get(caller_frame) if main_frame: caller_frame = main_frame frame_info = self.stack[caller_frame] expression_stack = frame_info.expression_stack if expression_stack: call_node = expression_stack[-1] else: call_node = frame_info.statement_stack[-1] # type: ignore return caller_frame, call_node # The methods below are hooks meant to be overridden in subclasses to take custom actions def before_expr(self, node, frame): # type: (ast.expr, FrameType) -> None """ Called right before the expression corresponding to `node` is evaluated within `frame`. """ def after_expr(self, node, frame, value, exc_value, exc_tb): # type: (ast.expr, FrameType, Any, Optional[BaseException], Optional[TracebackType]) -> Optional[ChangeValue] """ Called right after the expression corresponding to `node` is evaluated within `frame`. `value` is the value of the expression, if it succeeded. If the evaluation raised an exception, exc_value will be the exception object and exc_tb the traceback. Return `ChangeValue(x)` to change the value of the expression as seen by the rest of the program from `value` to `x`. """ def before_stmt(self, node, frame): # type: (ast.stmt, FrameType) -> None """ Called right before the statement corresponding to `node` is executed within `frame`. """ def after_stmt(self, node, frame, exc_value, exc_traceback, exc_node): # type: (ast.stmt, FrameType, Optional[BaseException], Optional[TracebackType], Optional[ast.AST]) -> Optional[bool] """ Called right after the statement corresponding to `node` is executed within `frame`. If the statement raised an exception, exc_value will be the exception object, exc_tb the traceback, and exc_node the node where the exception was raised (either this statement or an expression within). Returning True will suppress any exception raised (as with __exit__ in general). """ def enter_call(self, enter_info): # type: (EnterCallInfo) -> None """ Called before a function call begins executing. For typical `def` functions, this is called before the `before_stmt` for to the first statement in the function. """ def exit_call(self, exit_info): # type: (ExitCallInfo) -> None """ Called after a function call finishes executing. For typical `def` functions, this is called after the `after_stmt` for to the last statement to execute. """ def parse_extra(self, root, source, filename): # type: (ast.Module, str, str) -> Optional[ast.Module] """ Called before the AST (root) is modified to let subclasses make additional changes first. """ class _NodeVisitor(ast.NodeTransformer): """ This does the AST modifications that call the hooks. """ def generic_visit(self, node): # type: (ast.AST) -> ast.AST if not getattr(node, '_visit_ignore', False): if (isinstance(node, ast.expr) and not (hasattr(node, "ctx") and not isinstance(node.ctx, ast.Load)) and not isinstance(node, getattr(ast, 'Starred', ()))): return self.visit_expr(node) if isinstance(node, ast.stmt): return self.visit_stmt(node) return super(_NodeVisitor, self).generic_visit(node) def visit_expr(self, node): # type: (ast.expr) -> ast.Call """ each expression e gets wrapped like this: _treetrace_hidden_after_expr(_treetrace_hidden_before_expr(_tree_index), e) where the _treetrace_* functions are the corresponding methods with the TreeTracerBase and traced_file arguments already filled in (see _trace_methods_dict) """ before_marker = self._create_simple_marker_call(node, TreeTracerBase._treetrace_hidden_before_expr) ast.copy_location(before_marker, node) after_marker = ast.Call( func=ast.Name(id=TreeTracerBase._treetrace_hidden_after_expr.__name__, ctx=ast.Load()), args=[ before_marker, super(_NodeVisitor, self).generic_visit(node), ], keywords=[], ) ast.copy_location(after_marker, node) ast.fix_missing_locations(after_marker) return after_marker def visit_stmt(self, node): # type: (ast.stmt) -> ast.With """ Every statement in the original code becomes: with _treetrace_hidden_with_stmt(_tree_index): where the _treetrace_hidden_with_stmt function is the the corresponding method with the TreeTracerBase and traced_file arguments already filled in (see _trace_methods_dict) """ context_expr = self._create_simple_marker_call( super(_NodeVisitor, self).generic_visit(node), TreeTracerBase._treetrace_hidden_with_stmt) if PY3: wrapped = ast.With( items=[ast.withitem(context_expr=context_expr)], body=[node], ) else: wrapped = ast.With( context_expr=context_expr, body=[node], ) ast.copy_location(wrapped, node) ast.fix_missing_locations(wrapped) return wrapped @staticmethod def _create_simple_marker_call(node, func): # type: (ast.AST, Callable) -> ast.Call """ Returns a Call node representing `func(node._tree_index)` where node._tree_index is a numerical literal which allows the node object to be retrieved later through the nodes attribute of a TracedFile. """ return ast.Call( func=ast.Name(id=func.__name__, ctx=ast.Load()), args=[ast.Num(node._tree_index)], keywords=[], ) class _StmtContext(object): __slots__ = ('tracer', 'node', 'frame') def __init__(self, tracer, node, frame): # type: (TreeTracerBase, ast.stmt, FrameType) -> None self.tracer = tracer self.node = node self.frame = frame def __enter__(self): tracer = self.tracer node = self.node frame = self.frame if getattr(node, '_enter_call_node', False): tracer._enter_call(node, frame) frame_info = tracer.stack[frame] frame_info.expression_stack = [] frame_info.statement_stack.append(node) tracer.before_stmt(node, frame) def __exit__(self, exc_type, exc_val, exc_tb): # type: (Type[Exception], Exception, TracebackType) -> bool node = self.node tracer = self.tracer frame = self.frame frame_info = tracer.stack[frame] frame_info.statement_stack.pop() exc_node = None # type: Optional[Union[ast.expr, ast.stmt]] if exc_val and exc_val is not frame_info.exc_value: exc_node = node frame_info.exc_value = exc_val # Call the after_expr hook if the exception was raised by an expression expression_stack = frame_info.expression_stack if expression_stack: exc_node = expression_stack[-1] tracer._after_expr(exc_node, frame, None, exc_val, exc_tb) result = tracer.after_stmt(node, frame, exc_val, exc_tb, exc_node) if isinstance(node, ast.Return): frame_info.return_node = node parent = node.parent # type: ast.AST return_node = frame_info.return_node exiting = (isinstance(parent, (ast.FunctionDef, ast.Module)) and (node is parent.body[-1] or exc_val or return_node)) if exiting: caller_frame, call_node = tracer._get_caller_stuff(frame) return_value = None if return_node and return_node.value and not exc_val: return_value = frame_info.expression_values[return_node.value] tracer.exit_call(ExitCallInfo(call_node, return_node, caller_frame, frame, return_value, exc_val, exc_tb )) del tracer.stack[frame] for secondary_frame in self.tracer.main_to_secondary_frames.pop(frame): del self.tracer.secondary_to_main_frames[secondary_frame] return result def ancestors(node): # type: (ast.AST) -> Iterator[ast.AST] while True: try: node = node.parent except AttributeError: break yield node Loop = Union[ast.For, ast.While, ast.comprehension] def loops(node): # type: (ast.AST) -> Tuple[Loop, ...] """ Return all the 'enclosing loops' of a node, up to the innermost class or function definition. This also includes the 'for in' clauses in list/dict/set/generator comprehensions. So for example, in this code: for x in ...: def foo(): while True: print([z for y in ...]) The loops enclosing the node 'z' are 'while True' and 'for y in ...', in that order. """ result = [] while True: try: parent = node.parent except AttributeError: break if isinstance(parent, ast.FunctionDef): break is_containing_loop = (((isinstance(parent, ast.For) and parent.iter is not node or isinstance(parent, ast.While)) and node not in parent.orelse) or (isinstance(parent, ast.comprehension) and node in parent.ifs)) if is_containing_loop: result.append(parent) elif isinstance(parent, (ast.ListComp, ast.GeneratorExp, ast.DictComp, ast.SetComp)): generators = parent.generators if node in generators: generators = list(takewhile(lambda n: n != node, generators)) result.extend(reversed(generators)) node = parent result.reverse() return tuple(result) executing-0.8.0/tests/samples/tracer2.py000066400000000000000000000242071410133640400202350ustar00rootroot00000000000000import functools import inspect import os import re import sys import threading from collections import OrderedDict import six # noinspection PyUnresolvedReferences from cheap_repr import cheap_repr, find_repr_function from snoop.utils import my_cheap_repr, NO_ASTTOKENS, ArgDefaultDict, iscoroutinefunction, \ truncate_list, ensure_tuple, is_comprehension_frame, no_args_decorator from .formatting import Event, Source from .variables import CommonVariable, Exploding, BaseVariable find_repr_function(six.text_type).maxparts = 100 find_repr_function(six.binary_type).maxparts = 100 find_repr_function(object).maxparts = 100 find_repr_function(int).maxparts = 999999 cheap_repr.suppression_threshold = 999999 class FrameInfo(object): def __init__(self, frame): self.frame = frame self.local_reprs = {} self.last_line_no = frame.f_lineno self.comprehension_variables = OrderedDict() self.source = Source.for_frame(frame) self.is_generator = frame.f_code.co_flags & inspect.CO_GENERATOR self.had_exception = False if is_comprehension_frame(frame): self.comprehension_type = ( re.match(r'<(\w+)comp>', frame.f_code.co_name).group(1).title() + u' comprehension' ) else: self.comprehension_type = '' def update_variables(self, watch, watch_extras, event): self.last_line_no = self.frame.f_lineno old_local_reprs = self.local_reprs self.local_reprs = OrderedDict( (source, my_cheap_repr(value)) for source, value in self.get_local_reprs(watch, watch_extras) ) if self.comprehension_type: for name, value_repr in self.local_reprs.items(): values = self.comprehension_variables.setdefault(name, []) if not values or values[-1] != value_repr: values.append(value_repr) values[:] = truncate_list(values, 11) if event in ('return', 'exception'): return [ (name, ', '.join(values)) for name, values in self.comprehension_variables.items() ] else: return [] variables = [] for name, value_repr in self.local_reprs.items(): if name not in old_local_reprs or old_local_reprs[name] != value_repr: variables.append((name, value_repr)) return variables def get_local_reprs(self, watch, watch_extras): frame = self.frame code = frame.f_code vars_order = code.co_varnames + code.co_cellvars + code.co_freevars + tuple(frame.f_locals.keys()) result_items = sorted( frame.f_locals.items(), key=lambda key_value: vars_order.index(key_value[0]) ) for variable in watch: result_items += sorted(variable.items(frame)) for source, value in result_items: yield source, value for extra in watch_extras: try: pair = extra(source, value) except Exception: pass else: if pair is not None: assert len(pair) == 2, "Watch extra must return pair or None" yield pair thread_global = threading.local() internal_directories = (os.path.dirname((lambda: 0).__code__.co_filename),) try: # noinspection PyUnresolvedReferences import birdseye except ImportError: pass else: internal_directories += (os.path.dirname(birdseye.__file__),) class TracerMeta(type): def __new__(mcs, *args, **kwargs): result = super(TracerMeta, mcs).__new__(mcs, *args, **kwargs) result.default = result() return result def __call__(cls, *args, **kwargs): if no_args_decorator(args, kwargs): return cls.default(args[0]) else: return super(TracerMeta, cls).__call__(*args, **kwargs) def __enter__(self): return self.default.__enter__(context=1) def __exit__(self, *args): return self.default.__exit__(*args, context=1) @six.add_metaclass(TracerMeta) class Tracer(object): def __init__( self, watch=(), watch_explode=(), depth=1, ): self.watch = [ v if isinstance(v, BaseVariable) else CommonVariable(v) for v in ensure_tuple(watch) ] + [ v if isinstance(v, BaseVariable) else Exploding(v) for v in ensure_tuple(watch_explode) ] self.frame_infos = ArgDefaultDict(FrameInfo) self.depth = depth assert self.depth >= 1 self.target_codes = set() self.target_frames = set() def __call__(self, function): if iscoroutinefunction(function): raise NotImplementedError("coroutines are not supported, sorry!") self.target_codes.add(function.__code__) @functools.wraps(function) def simple_wrapper(*args, **kwargs): with self: return function(*args, **kwargs) @functools.wraps(function) def generator_wrapper(*args, **kwargs): gen = function(*args, **kwargs) method, incoming = gen.send, None while True: with self: try: outgoing = method(incoming) except StopIteration: return try: method, incoming = gen.send, (yield outgoing) except Exception as e: method, incoming = gen.throw, e if inspect.isgeneratorfunction(function): return generator_wrapper else: return simple_wrapper def __enter__(self, context=0): if not self.config.enabled: return calling_frame = sys._getframe(context + 1) if not self._is_internal_frame(calling_frame): calling_frame.f_trace = self.trace self.target_frames.add(calling_frame) self.config.last_frame = calling_frame self.trace(calling_frame, 'enter', None) stack = thread_global.__dict__.setdefault('original_trace_functions', []) stack.append(sys.gettrace()) sys.settrace(self.trace) def __exit__(self, exc_type, exc_value, exc_traceback, context=0): if not self.config.enabled: return stack = thread_global.original_trace_functions sys.settrace(stack.pop()) calling_frame = sys._getframe(context + 1) self.trace(calling_frame, 'exit', None) self.target_frames.discard(calling_frame) self.frame_infos.pop(calling_frame, None) def _is_internal_frame(self, frame): return frame.f_code.co_filename.startswith(internal_directories) def _is_traced_frame(self, frame): return frame.f_code in self.target_codes or frame in self.target_frames def trace(self, frame, event, arg): if not self._is_traced_frame(frame): if ( self.depth == 1 or self._is_internal_frame(frame) ) and not is_comprehension_frame(frame): return None else: candidate = frame i = 0 while True: if is_comprehension_frame(candidate): candidate = candidate.f_back continue i += 1 if self._is_traced_frame(candidate): break candidate = candidate.f_back if i >= self.depth or candidate is None or self._is_internal_frame(candidate): return None thread_local = self.config.thread_local thread_local.__dict__.setdefault('depth', -1) frame_info = self.frame_infos[frame] if event in ('call', 'enter'): thread_local.depth += 1 elif self.config.last_frame and self.config.last_frame is not frame: line_no = frame_info.last_line_no trace_event = Event(frame_info, event, arg, thread_local.depth, line_no=line_no) line = self.config.formatter.format_line_only(trace_event) self.config.write(line) if event == 'exception': frame_info.had_exception = True self.config.last_frame = frame trace_event = Event(frame_info, event, arg, thread_local.depth) if not (frame.f_code.co_name == '' and event not in ('return', 'exception')): trace_event.variables = frame_info.update_variables( self.watch, self.config.watch_extras, event, ) if event in ('return', 'exit'): del self.frame_infos[frame] thread_local.depth -= 1 formatted = self.config.formatter.format(trace_event) self.config.write(formatted) return self.trace class Spy(object): def __init__(self, config): self.config = config def __call__(self, *args, **kwargs): if NO_ASTTOKENS: raise Exception("birdseye doesn't support this version of Python") try: import birdseye except ImportError: raise Exception("You must install birdseye separately to use spy: pip install birdseye") # Decorator without parentheses if no_args_decorator(args, kwargs): return self._trace(args[0]) # Decorator with parentheses and perhaps arguments def decorator(func): return self._trace(func, *args, **kwargs) return decorator def _trace(self, func, *args, **kwargs): # noinspection PyUnresolvedReferences from birdseye import eye traced = eye(func) traced = self.config.snoop(*args, **kwargs)(traced) @functools.wraps(func) def wrapper(*func_args, **func_kwargs): if self.config.enabled: final_func = traced else: final_func = func return final_func(*func_args, **func_kwargs) return wrapper executing-0.8.0/tests/samples/utils.py000066400000000000000000000145241410133640400200340ustar00rootroot00000000000000from __future__ import print_function, division, absolute_import import ast import json from future import standard_library standard_library.install_aliases() import token from future.utils import raise_from import ntpath import os import types from sys import version_info from typing import TypeVar, Union, List, Any, Iterator, Tuple, Iterable try: from typing import Type except ImportError: Type = type try: from typing import Deque except ImportError: from collections import deque as Deque try: from functools import lru_cache except ImportError: from backports.functools_lru_cache import lru_cache from littleutils import strip_required_prefix PY2 = version_info.major == 2 PY3 = not PY2 T = TypeVar('T') RT = TypeVar('RT') IPYTHON_FILE_PATH = 'IPython notebook or shell' FILE_SENTINEL_NAME = '$$__FILE__$$' if PY2: Text = unicode else: Text = str def path_leaf(path): # type: (str) -> str # http://stackoverflow.com/a/8384788/2482744 head, tail = ntpath.split(path) return tail or ntpath.basename(head) def common_ancestor(paths): # type: (List[str]) -> str """ Returns a path to a directory that contains all the given absolute paths """ prefix = os.path.commonprefix(paths) # Ensure that the prefix doesn't end in part of the name of a file/directory prefix = ntpath.split(prefix)[0] # Ensure that it ends with a slash first_char_after = paths[0][len(prefix)] if first_char_after in r'\/': prefix += first_char_after return prefix def short_path(path, all_paths): # type: (str, List[str]) -> str if path == IPYTHON_FILE_PATH: return path all_paths = [f for f in all_paths if f != IPYTHON_FILE_PATH] prefix = common_ancestor(all_paths) if prefix in r'\/': prefix = '' return strip_required_prefix(path, prefix) or path_leaf(path) def fix_abs_path(path): if path == IPYTHON_FILE_PATH: return path if os.path.sep == '/' and not path.startswith('/'): path = '/' + path return path if PY2: def correct_type(obj): """ Returns the correct type of obj, regardless of __class__ assignment or old-style classes: >>> class A: ... pass ... ... ... class B(object): ... pass ... ... ... class C(object): ... __class__ = A ... >>> correct_type(A()) is A True >>> correct_type(B()) is B True >>> correct_type(C()) is C True """ t = type(obj) # noinspection PyUnresolvedReferences if t is types.InstanceType: return obj.__class__ return t else: correct_type = type def of_type(type_or_tuple, iterable): # type: (Union[type, Tuple[Union[type, tuple], ...]], Iterable[Any]) -> Iterator[Any] return (x for x in iterable if isinstance(x, type_or_tuple)) def safe_next(it): # type: (Iterator[T]) -> T """ next() can raise a StopIteration which can cause strange bugs inside generators. """ try: return next(it) except StopIteration as e: raise_from(RuntimeError, e) raise # isn't reached def one_or_none(expression): """Performs a one_or_none on a sqlalchemy expression.""" if hasattr(expression, 'one_or_none'): return expression.one_or_none() result = expression.all() if len(result) == 0: return None elif len(result) == 1: return result[0] else: raise Exception("There is more than one item returned for the supplied filter") def flatten_list(lst): result = [] for x in lst: if isinstance(x, list): result.extend(flatten_list(x)) else: result.append(x) return result def is_lambda(f): try: code = f.__code__ except AttributeError: return False return code.co_name == (lambda: 0).__code__.co_name class ProtocolEncoder(json.JSONEncoder): def default(self, o): try: method = o.as_json except AttributeError: return super(ProtocolEncoder, self).default(o) else: return method() try: # Python 3 from tokenize import open as open_with_encoding_check except ImportError: # Python 2 from lib2to3.pgen2.tokenize import detect_encoding import io def open_with_encoding_check(filename): # type: ignore """Open a file in read only mode using the encoding detected by detect_encoding(). """ fp = io.open(filename, 'rb') try: encoding, lines = detect_encoding(fp.readline) fp.seek(0) text = io.TextIOWrapper(fp, encoding, line_buffering=True) text.mode = 'r' return text except: fp.close() raise def read_source_file(filename): from lib2to3.pgen2.tokenize import cookie_re if filename.endswith('.pyc'): filename = filename[:-1] with open_with_encoding_check(filename) as f: return ''.join([ '\n' if i < 2 and cookie_re.match(line) else line for i, line in enumerate(f) ]) def source_without_decorators(tokens, function_node): def_token = safe_next(t for t in tokens.get_tokens(function_node) if t.string == 'def' and t.type == token.NAME) startpos = def_token.startpos source = tokens.text[startpos:function_node.last_token.endpos].rstrip() assert source.startswith('def') return startpos, source def prn(*args): for arg in args: print(arg) if len(args) == 1: return args[0] return args def is_ipython_cell(filename): return filename.startswith(' max_length: left = (max_length - len(middle)) // 2 right = max_length - len(middle) - left seq = seq[:left] + middle + seq[-right:] return seq def truncate_string(string, max_length): return truncate(string, max_length, '...') def truncate_list(lst, max_length): return truncate(lst, max_length, ['...']) def ensure_tuple(x, split=False): if split and isinstance(x, six.string_types): x = x.replace(',', ' ').split() if not isinstance(x, (list, set, tuple)): x = (x,) return tuple(x) def short_filename(code): result = os.path.basename(code.co_filename) if result.endswith('.pyc'): result = result[:-1] return result def is_comprehension_frame(frame): return frame.f_code.co_name in ('', '', '') def needs_parentheses(source): def code(s): return compile(s.format(source), '', 'eval').co_code try: without_parens = code('{}.x') except SyntaxError: # Likely a multiline expression that needs parentheses to be valid code('({})') return True else: return without_parens != code('({}).x') def with_needed_parentheses(source): if needs_parentheses(source): return '({})'.format(source) else: return source REPR_TARGET_LENGTH = 100 def my_cheap_repr(x): return cheap_repr(x, target_length=REPR_TARGET_LENGTH) class ArgDefaultDict(dict): def __init__(self, factory): super(ArgDefaultDict, self).__init__() self.factory = factory def __missing__(self, key): result = self[key] = self.factory(key) return result def optional_numeric_label(i, lst): if len(lst) == 1: return '' else: return ' ' + str(i + 1) def is_pathlike(x): if hasattr(os, 'PathLike'): return isinstance(x, os.PathLike) return ( hasattr(x, '__fspath__') or # Make a concession for older `pathlib` versions: (hasattr(x, 'open') and 'path' in x.__class__.__name__.lower()) ) try: iscoroutinefunction = inspect.iscoroutinefunction except AttributeError: def iscoroutinefunction(_): return False try: try_statement = ast.Try except AttributeError: try_statement = ast.TryExcept try: builtins = __import__("__builtin__") except ImportError: builtins = __import__("builtins") try: FormattedValue = ast.FormattedValue except: class FormattedValue(object): pass def no_args_decorator(args, kwargs): return len(args) == 1 and inspect.isfunction(args[0]) and not kwargs try: from functools import lru_cache except ImportError: from backports.functools_lru_cache import lru_cache class DirectRepr(str): def __repr__(self): return self try: from django.db.models import QuerySet except ImportError: class QuerySet(object): pass def _sample_indices(length, max_length): if length <= max_length + 2: return range(length) else: return chain(range(max_length // 2), range(length - max_length // 2, length)) @try_register_repr('pandas', 'Series') def _repr_series_one_line(x, helper): n = len(x) if n == 0: return repr(x) newlevel = helper.level - 1 pieces = [] maxparts = _repr_series_one_line.maxparts for i in _sample_indices(n, maxparts): k = x.index[i:i + 1].format(sparsify=False)[0] v = x.iloc[i] pieces.append('%s = %s' % (k, cheap_repr(v, newlevel))) if n > maxparts + 2: pieces.insert(maxparts // 2, '...') return '; '.join(pieces) executing-0.8.0/tests/test_main.py000066400000000000000000000541151410133640400172130ustar00rootroot00000000000000# -*- coding: utf-8 -*- from __future__ import print_function, division import ast import contextlib import dis import inspect import json import os import re import sys import tempfile import time import unittest from collections import defaultdict from random import shuffle sys.path.append(os.path.dirname(os.path.dirname(__file__))) from tests.utils import tester, subscript_item, in_finally PYPY = 'pypy' in sys.version.lower() from executing import Source, only, NotOneValueFound from executing.executing import PY3, get_instructions, function_node_types if eval("0"): global_never_defined = 1 class TestStuff(unittest.TestCase): # noinspection PyTrailingSemicolon def test_semicolons(self): # @formatter:off tester(1); tester(2); tester(3) tester(9 ); tester( 8); tester( 99 ); tester(33); tester([4, 5, 6, [ 7]]) # @formatter:on def test_decorator(self): @empty_decorator # 0 @decorator_with_args(tester('123'), x=int()) # 1 @tester(list(tuple([1, 2]))) # 2! @tester( # 3! list( tuple( [3, 4])), ) @empty_decorator # 4 @decorator_with_args( # 5 str(), x=int()) @tester(list(tuple([5, 6]))) # 6! @tester(list(tuple([7, 8]))) # 7! @empty_decorator @decorator_with_args(tester('sdf'), x=tester('123234')) def foo(): pass tester.check_decorators([7, 6, 3, 2]) empty_decorator.tester = tester @empty_decorator @tester @empty_decorator @tester.qwe @empty_decorator @tester("1") @empty_decorator.tester("2") @empty_decorator def foo2(_=tester("3"), __=tester("4")): pass tester.check_decorators([6, 5, 3, 1]) @tester @empty_decorator @tester.qwe @empty_decorator @tester("11") @empty_decorator.tester("22") @empty_decorator class foo3(tester("5") and list): pass tester.check_decorators([5, 4, 2, 0]) class Foo(object): @tester @tester @empty_decorator @tester.qwe @empty_decorator def foo(self): super(Foo, self) class Bar: @tester @empty_decorator @tester.qwe @empty_decorator def bar(self): pass Foo().foo() tester.check_decorators([3, 1, 0, 2, 0]) def test_comprehensions(self): # Comprehensions can be separated if they contain different names str([{tester(x) for x in [1]}, {tester(y) for y in [1]}]) # or are on different lines str([{tester(x) for x in [1]}, {tester(x) for x in [1]}]) # or are of different types str([{tester(x) for x in [1]}, list(tester(x) for x in [1])]) # but not if everything is the same # noinspection PyTypeChecker with self.assertRaises(NotOneValueFound): str([{tester(x) for x in [1]}, {tester(x) for x in [2]}]) def test_lambda(self): self.assertEqual( (lambda x: (tester(x), tester(x)))(tester(3)), (3, 3), ) (lambda: (lambda: tester(1))())() self.assertEqual( (lambda: [tester(x) for x in tester([1, 2])])(), [1, 2], ) def test_closures_and_nested_comprehensions(self): x = 1 # @formatter:off str({tester(a+x): {tester(b+x): {tester(c+x) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])}) def foo(): y = 2 str({tester(a+x): {tester(b+x): {tester(c+x) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])}) str({tester(a+y): {tester(b+y): {tester(c+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])}) str({tester(a+x+y): {tester(b+x+y): {tester(c+x+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])}) def bar(): z = 3 str({tester(a+x): {tester(b+x): {tester(c+x) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])}) str({tester(a+y): {tester(b+y): {tester(c+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])}) str({tester(a+x+y): {tester(b+x+y): {tester(c+x+y) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])}) str({tester(a+x+y+z): {tester(b+x+y+z): {tester(c+x+y+z) for c in tester([1, 2])} for b in tester([3, 4])} for a in tester([5, 6])}) bar() foo() # @formatter:on def test_indirect_call(self): dict(x=tester)['x'](tester)(3, check_func=False) def test_compound_statements(self): with self.assertRaises(TypeError): try: for _ in tester([1, 2, 3]): while tester(0): pass else: tester(4) else: tester(5) raise ValueError except tester(ValueError): tester(9) raise TypeError finally: tester(10) # PyCharm getting confused somehow? # noinspection PyUnreachableCode str() with self.assertRaises(tester(Exception)): if tester(0): pass elif tester(0): pass elif tester(1 / 0): pass def test_generator(self): def gen(): for x in [1, 2]: yield tester(x) gen2 = (tester(x) for x in tester([1, 2])) assert list(gen()) == list(gen2) == [1, 2] def test_future_import(self): print(1 / 2) tester(4) def test_many_calls(self): node = None start = time.time() for i in range(10000): new_node = Source.executing(inspect.currentframe()).node if node is None: node = new_node else: self.assertIs(node, new_node) self.assertLess(time.time() - start, 1) def test_decode_source(self): def check(source, encoding, exception=None, matches=True): encoded = source.encode(encoding) if exception: with self.assertRaises(exception): Source.decode_source(encoded) else: decoded = Source.decode_source(encoded) if matches: self.assertEqual(decoded, source) else: self.assertNotEqual(decoded, source) check(u'# coding=utf8\né', 'utf8') check(u'# coding=gbk\né', 'gbk') check(u'# coding=utf8\né', 'gbk', exception=UnicodeDecodeError) check(u'# coding=gbk\né', 'utf8', matches=False) # In Python 3 the default encoding is assumed to be UTF8 if PY3: check(u'é', 'utf8') check(u'é', 'gbk', exception=SyntaxError) def test_multiline_strings(self): tester('a') tester(''' ab''') tester(''' abc def ''' ) str([ tester( ''' 123 456 ''' ), tester( ''' 345 456786 ''' ), ]) tester( [ ''' 123 456 ''' ''' 345 456786 ''' , ''' 123 456 ''', ''' 345 456786 ''' ] ) def test_multiple_statements_on_one_line(self): if tester(1): tester(2) for _ in tester([1, 2]): tester(3) def assert_qualname(self, func, qn, check_actual_qualname=True): qualname = Source.for_filename(__file__).code_qualname(func.__code__) self.assertEqual(qn, qualname) if PY3 and check_actual_qualname: self.assertEqual(qn, func.__qualname__) self.assertTrue(qn.endswith(func.__name__)) def test_qualname(self): self.assert_qualname(C.f, 'C.f') self.assert_qualname(C.D.g, 'C.D.g') self.assert_qualname(f, 'f') self.assert_qualname(f(), 'f..g') self.assert_qualname(C.D.h(), 'C.D.h..i..j') self.assert_qualname(lamb, '') foo = lambda_maker() self.assert_qualname(foo, 'lambda_maker..foo') self.assert_qualname(foo.x, 'lambda_maker..') self.assert_qualname(foo(), 'lambda_maker..foo..') self.assert_qualname(foo()(), 'lambda_maker..foo..', check_actual_qualname=False) def test_extended_arg(self): source = 'tester(6)\n%s\ntester(9)' % list(range(66000)) _, filename = tempfile.mkstemp() code = compile(source, filename, 'exec') with open(filename, 'w') as outfile: outfile.write(source) exec(code) def test_only(self): for n in range(5): gen = (i for i in range(n)) if n == 1: self.assertEqual(only(gen), 0) else: with self.assertRaises(NotOneValueFound): only(gen) def test_invalid_python(self): path = os.path.join(os.path.dirname(__file__), 'not_code.txt', ) source = Source.for_filename(path) self.assertIsNone(source.tree) def test_executing_methods(self): frame = inspect.currentframe() executing = Source.executing(frame) self.assertEqual(executing.code_qualname(), 'TestStuff.test_executing_methods') text = 'Source.executing(frame)' self.assertEqual(executing.text(), text) start, end = executing.text_range() self.assertEqual(executing.source.text[start:end], text) def test_attr(self): c = C() c.x = c.y = tester str((c.x.x, c.x.y, c.y.x, c.y.y, c.x.asd, c.y.qwe)) def test_traceback(self): try: 134895 / 0 except: tb = sys.exc_info()[2] ex = Source.executing(tb) self.assertTrue(isinstance(ex.node, ast.BinOp)) self.assertEqual(ex.text(), "134895 / 0") def test_retry_cache(self): _, filename = tempfile.mkstemp() def check(x): source = 'tester(6)\n%s\ntester(9)' % list(range(x)) code = compile(source, filename, 'exec') with open(filename, 'w') as outfile: outfile.write(source) exec(code, globals(), locals()) check(3) check(5) @contextlib.contextmanager def assert_name_error(self): try: yield except NameError as e: tb = sys.exc_info()[2] ex = Source.executing(tb.tb_next) self.assertEqual(type(ex.node), ast.Name) self.assertIn(ex.node.id, str(e)) self.assertEqual(ex.text(), ex.node.id) else: self.fail("NameError not raised") def test_names(self): with self.assert_name_error(): self, completely_nonexistent # noqa with self.assert_name_error(): self, global_never_defined # noqa with self.assert_name_error(): self, local_not_defined_yet # noqa local_not_defined_yet = 1 # noqa def foo(): with self.assert_name_error(): self, closure_not_defined_yet # noqa foo() closure_not_defined_yet = 1 # noqa def is_unary_not(node): return isinstance(node, ast.UnaryOp) and isinstance(node.op, ast.Not) class TimeOut(Exception): pass @unittest.skipUnless( os.getenv('EXECUTING_SLOW_TESTS'), 'These tests are very slow, enable them explicitly', ) class TestFiles(unittest.TestCase): maxDiff = None def test_files(self): self.start_time = time.time() root_dir = os.path.dirname(__file__) samples_dir = os.path.join(root_dir, 'samples') result_filename = PYPY * 'pypy' + '.'.join(map(str, sys.version_info[:2])) + '.json' result_filename = os.path.join(root_dir, 'sample_results', result_filename) result = {} for filename in os.listdir(samples_dir): full_filename = os.path.join(samples_dir, filename) result[filename] = self.check_filename(full_filename, check_names=True) if os.getenv('FIX_EXECUTING_TESTS'): with open(result_filename, 'w') as outfile: json.dump(result, outfile, indent=4, sort_keys=True) return else: with open(result_filename, 'r') as infile: self.assertEqual(result, json.load(infile)) modules = list(sys.modules.values()) shuffle(modules) for module in modules: try: filename = inspect.getsourcefile(module) except TypeError: continue if not filename: continue filename = os.path.abspath(filename) if ( # The sentinel actually appearing in code messes things up 'executing' in filename # A file that's particularly slow or 'errorcodes.py' in filename # Contains unreachable code which pypy removes or PYPY and ('sysconfig.py' in filename or 'pyparsing.py' in filename) ): continue try: self.check_filename(filename, check_names=False) except TimeOut: print("Time's up") def check_filename(self, filename, check_names): print(filename) source = Source.for_filename(filename) if PY3: code = compile(source.text, filename, "exec", dont_inherit=True) for subcode, qualname in find_qualnames(code): if not qualname.endswith(">"): code_qualname = source.code_qualname(subcode) self.assertEqual(code_qualname, qualname) nodes = defaultdict(list) decorators = defaultdict(list) expected_decorators = {} for node in ast.walk(source.tree): if isinstance(node, ( (ast.Name,) * check_names, ast.UnaryOp, ast.BinOp, ast.Subscript, ast.Call, ast.Compare, ast.Attribute )): nodes[node] = [] elif isinstance(node, (ast.ClassDef, function_node_types)): expected_decorators[(node.lineno, node.name)] = node.decorator_list[::-1] decorators[(node.lineno, node.name)] = [] code = compile(source.tree, source.filename, 'exec') result = list(self.check_code(code, nodes, decorators, check_names=check_names)) if not re.search(r'^\s*if 0(:| and )', source.text, re.MULTILINE): for node, values in nodes.items(): if is_unary_not(node): continue if isinstance(getattr(node, 'ctx', None), (ast.Store, ast.Del, getattr(ast, 'Param', ()))): assert not values continue if isinstance(node, ast.Compare): if sys.version_info >= (3, 10): continue if len(node.ops) > 1: assert not values continue if is_unary_not(node.parent) and isinstance(node.ops[0], (ast.In, ast.Is)): continue if is_literal(node): continue if sys.version_info >= (3, 10): correct = len(values) >= 1 elif sys.version_info >= (3, 9) and in_finally(node): correct = len(values) > 1 else: correct = len(values) == 1 if not correct: print(source.text, '---', node_string(source, node), node.lineno, len(values), correct, values, file=sys.stderr, sep='\n') self.fail() return result def check_code(self, code, nodes, decorators, check_names): linestarts = dict(dis.findlinestarts(code)) instructions = get_instructions(code) lineno = None for inst in instructions: if time.time() - self.start_time > 45 * 60: # Avoid travis time limit of 50 minutes raise TimeOut lineno = linestarts.get(inst.offset, lineno) if not inst.opname.startswith( ( 'BINARY_', 'UNARY_', 'LOAD_ATTR', 'LOAD_METHOD', 'LOOKUP_METHOD', 'SLICE+', 'COMPARE_OP', 'CALL_', 'IS_OP', 'CONTAINS_OP', ) + ('LOAD_NAME', 'LOAD_GLOBAL', 'LOAD_FAST', 'LOAD_DEREF', 'LOAD_CLASSDEREF') * check_names ): continue frame = C() frame.f_lasti = inst.offset frame.f_code = code frame.f_globals = globals() frame.f_lineno = lineno source = Source.for_frame(frame) node = None try: try: ex = Source.executing(frame) node = ex.node except Exception: if inst.opname.startswith(('COMPARE_OP', 'IS_OP', 'CALL_', 'LOAD_NAME')): continue if inst.opname == 'LOAD_FAST' and inst.argval == '.0': continue if inst.argval == 'AssertionError': continue if any( isinstance(stmt, (ast.AugAssign, ast.Import)) for stmt in source.statements_at_line(lineno) ): continue raise # argval isn't set for all relevant instructions in python 2 if isinstance(node, ast.Name) and (PY3 or inst.argval): self.assertEqual(inst.argval, node.id) except Exception: print(source.text, lineno, inst, node and ast.dump(node), code, file=sys.stderr, sep='\n') raise if ex.decorator: decorators[(node.lineno, node.name)].append(ex.decorator) else: nodes[node].append((inst, frame.__dict__)) yield [inst.opname, node_string(source, ex.decorator or node)] for const in code.co_consts: if isinstance(const, type(code)): for x in self.check_code(const, nodes, decorators, check_names=check_names): yield x def node_string(source, node): return source.asttokens().get_text(node) def is_literal(node): if isinstance(node, ast.UnaryOp): return is_literal(node.operand) if isinstance(node, ast.BinOp): return is_literal(node.left) and is_literal(node.right) if isinstance(node, ast.Compare): return all(map(is_literal, [node.left] + node.comparators)) if isinstance(node, ast.Subscript) and is_literal(node.value): if isinstance(node.slice, ast.Slice): return all( x is None or is_literal(x) for x in [ node.slice.lower, node.slice.upper, node.slice.step, ] ) else: return is_literal(subscript_item(node)) try: ast.literal_eval(node) return True except ValueError: return False class C(object): @staticmethod def f(): pass class D(object): @staticmethod def g(): pass @staticmethod def h(): def i(): def j(): pass return j return i() def f(): def g(): pass return g # TestFiles().test_files() def lambda_maker(): def assign(x): def decorator(func): func.x = x return func return decorator @assign(lambda: 1) def foo(): return lambda: lambda: 3 return foo lamb = lambda: 0 assert tester([1, 2, 3]) == [1, 2, 3] assert tester.asd is tester assert tester[1 + 2] is tester assert tester ** 4 is tester assert tester * 3 is tester assert tester - 2 is tester assert tester + 1 is tester assert -tester is +tester is ~tester is tester assert (tester < 7) is tester assert (tester >= 78) is tester assert (tester != 79) is tester # assert (5 != tester != 6) is tester assert tester.foo(45, False) == 45 assert (tester or 234) == 234 assert (tester and 1123) is tester def empty_decorator(func): return func def decorator_with_args(*_, **__): return empty_decorator def find_qualnames(code, prefix=""): for subcode in code.co_consts: if type(subcode) != type(code): continue qualname = prefix + subcode.co_name instructions = list(get_instructions(subcode))[:4] opnames = [inst.opname for inst in instructions] arg_reprs = [inst.argrepr for inst in instructions] is_class = ( opnames == "LOAD_NAME STORE_NAME LOAD_CONST STORE_NAME".split() and arg_reprs == ["__name__", "__module__", repr(qualname), "__qualname__"] ) yield subcode, qualname for x in find_qualnames( subcode, qualname + ("." if is_class else "..") ): yield x if __name__ == '__main__': unittest.main() executing-0.8.0/tests/test_pytest.py000066400000000000000000000005351410133640400176140ustar00rootroot00000000000000import os import sys sys.path.append(os.path.dirname(os.path.dirname(__file__))) def test_pytest(): from tests.utils import tester lst = [1, 2, 3] lst2 = tester(lst) assert lst == lst2 lst3 = tester(lst + [4]) assert ( [1, 2, 3, 4] == lst3 ), 'message' x = tester.x assert x is tester executing-0.8.0/tests/utils.py000066400000000000000000000060031410133640400163610ustar00rootroot00000000000000import sys import ast import inspect import executing.executing executing.executing.TESTING = 1 from executing import Source class Tester(object): def __init__(self): self.decorators = [] self.__name__ = "" # weird pypy3.6 thing def check_decorators(self, expected): assert self.decorators == expected, (self.decorators, expected) self.decorators = [] def get_node(self, typ): ex = self.get_executing(inspect.currentframe().f_back.f_back) node = ex.node assert isinstance(node, typ), (node, typ) return node def get_executing(self, frame): Source.lazycache(frame) return Source.executing(frame) def check(self, node, value): frame = inspect.currentframe().f_back.f_back result = eval( compile(ast.Expression(node), frame.f_code.co_filename, 'eval'), frame.f_globals, frame.f_locals, ) assert result == value, (result, value) def __call__(self, arg, check_func=True): ex = self.get_executing(inspect.currentframe().f_back) if ex.decorator: assert {ex.node} == ex.statements self.decorators.append(ex.node.decorator_list.index(ex.decorator)) else: call = ex.node self.check(call.args[0], arg) if check_func: self.check(call.func, self) if ( isinstance(call.parent, (ast.ClassDef, ast.FunctionDef)) and call in call.parent.decorator_list ): return self return arg def __getattr__(self, item): node = self.get_node(ast.Attribute) self.check(node.value, self) assert node.attr == item return self def __getitem__(self, item): node = self.get_node(ast.Subscript) self.check(node.value, self) self.check(subscript_item(node), item) return self def __add__(self, other): node = self.get_node(ast.BinOp) self.check(node.left, self) self.check(node.right, other) return self __pow__ = __mul__ = __sub__ = __add__ def __invert__(self): node = self.get_node(ast.UnaryOp) self.check(node.operand, self) return self __neg__ = __pos__ = __invert__ def __lt__(self, other): node = self.get_node(ast.Compare) self.check(node.left, self) self.check(node.comparators[0], other) return self __ne__ = __ge__ = __lt__ def __bool__(self): try: self.get_node(None) except RuntimeError: return False assert 0 __nonzero__ = __bool__ tester = Tester() def subscript_item(node): if sys.version_info < (3, 9): return node.slice.value else: return node.slice def in_finally(node): while hasattr(node, 'parent'): if isinstance(node.parent, ast.Try) and node in node.parent.finalbody: return True node = node.parent return False executing-0.8.0/tox.ini000066400000000000000000000003751410133640400150260ustar00rootroot00000000000000[tox] envlist = py27,py34,py35,py36,py37,py38,py39,py310,pypy2,pypy35,pypy36 [testenv] commands = python tests/test_main.py pytest tests/test_pytest.py deps = asttokens pytest passenv = FIX_EXECUTING_TESTS EXECUTING_SLOW_TESTS