SYMBOL INDEX (524 symbols across 32 files)

FILE: codetransformer/__init__.py
  function load_ipython_extension (line 23) | def load_ipython_extension(ipython):  # pragma: no cover

FILE: codetransformer/_version.py
  function get_keywords (line 18) | def get_keywords():
  class VersioneerConfig (line 29) | class VersioneerConfig:
  function get_config (line 33) | def get_config():
  class NotThisMethod (line 46) | class NotThisMethod(Exception):
  function register_vcs_handler (line 54) | def register_vcs_handler(vcs, method):  # decorator
  function run_command (line 63) | def run_command(commands, args, cwd=None, verbose=False, hide_stderr=Fal...
  function versions_from_parentdir (line 96) | def versions_from_parentdir(parentdir_prefix, root, verbose):
  function git_get_keywords (line 111) | def git_get_keywords(versionfile_abs):
  function git_versions_from_keywords (line 135) | def git_versions_from_keywords(keywords, tag_prefix, verbose):
  function git_pieces_from_vcs (line 180) | def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_comma...
  function plus_or_dot (line 261) | def plus_or_dot(pieces):
  function render_pep440 (line 267) | def render_pep440(pieces):
  function render_pep440_pre (line 291) | def render_pep440_pre(pieces):
  function render_pep440_post (line 307) | def render_pep440_post(pieces):
  function render_pep440_old (line 333) | def render_pep440_old(pieces):
  function render_git_describe (line 353) | def render_git_describe(pieces):
  function render_git_describe_long (line 372) | def render_git_describe_long(pieces):
  function render (line 390) | def render(pieces, style):
  function get_versions (line 419) | def get_versions():

FILE: codetransformer/code.py
  function _sparse_args (line 27) | def _sparse_args(instrs):
  function _sparse_args (line 36) | def _sparse_args(instrs):
  class Flag (line 65) | class Flag(IntEnum):
    class max (line 100) | class max:
      method __get__ (line 103) | def __get__(self, instance, owner):
      method __set__ (line 106) | def __set__(self, instance, value):
    method pack (line 110) | def pack(cls,
    method unpack (line 167) | def unpack(cls, mask):
  function _freevar_argname (line 193) | def _freevar_argname(arg, cellvars, freevars):
  function pycode (line 220) | def pycode(argcount,
  class Code (line 260) | class Code:
    method __init__ (line 321) | def __init__(self,
    method from_pyfunc (line 413) | def from_pyfunc(cls, f):
    method from_pycode (line 429) | def from_pycode(cls, co):
    method to_pycode (line 512) | def to_pycode(self):
    method instrs (line 603) | def instrs(self):
    method sparse_instrs (line 609) | def sparse_instrs(self):
    method argcount (line 618) | def argcount(self):
    method kwonlyargcount (line 626) | def kwonlyargcount(self):
    method consts (line 634) | def consts(self):
    method names (line 647) | def names(self):
    method argnames (line 660) | def argnames(self):
    method varnames (line 669) | def varnames(self):
    method cellvars (line 681) | def cellvars(self):
    method freevars (line 687) | def freevars(self):
    method flags (line 693) | def flags(self):
    method py_flags (line 705) | def py_flags(self):
    method is_nested (line 711) | def is_nested(self):
    method is_generator (line 717) | def is_generator(self):
    method is_coroutine (line 723) | def is_coroutine(self):
    method is_iterable_coroutine (line 731) | def is_iterable_coroutine(self):
    method constructs_new_locals (line 739) | def constructs_new_locals(self):
    method filename (line 749) | def filename(self):
    method name (line 755) | def name(self):
    method firstlineno (line 761) | def firstlineno(self):
    method lnotab (line 768) | def lnotab(self):
    method lno_of_instr (line 774) | def lno_of_instr(self):
    method py_lnotab (line 783) | def py_lnotab(self):
    method stacksize (line 814) | def stacksize(self):
    method index (line 823) | def index(self, instr):
    method bytecode_offset (line 838) | def bytecode_offset(self, instr):
    method __getitem__ (line 853) | def __getitem__(self, key):
    method __iter__ (line 856) | def __iter__(self):
    method __len__ (line 859) | def __len__(self):
    method __contains__ (line 862) | def __contains__(self, instr):
    method dis (line 865) | def dis(self, file=None):

FILE: codetransformer/core.py
  function _a_if_not_none (line 28) | def _a_if_not_none(a, b):
  function _new_lnotab (line 32) | def _new_lnotab(instrs, lnotab):
  class NoContext (line 53) | class NoContext(Exception):
    method __init__ (line 57) | def __init__(self):
  class Context (line 61) | class Context:
    method __init__ (line 64) | def __init__(self, code):
    method __repr__ (line 68) | def __repr__(self):  # pragma: no cover
  class CodeTransformerMeta (line 72) | class CodeTransformerMeta(type):
    method __new__ (line 79) | def __new__(mcls, name, bases, dict_):
    method __prepare__ (line 90) | def __prepare__(self, bases):
  class CodeTransformer (line 94) | class CodeTransformer(metaclass=CodeTransformerMeta):
    method transform_consts (line 104) | def transform_consts(self, consts):
    method _id (line 126) | def _id(self, obj):
    method transform (line 150) | def transform(self, code, *, name=None, filename=None):
    method __call__ (line 206) | def __call__(self, f, *,
    class _context_stack (line 223) | class _context_stack(threading.local):
      method __get__ (line 237) | def __get__(self, instance, owner):
    method _new_context (line 251) | def _new_context(self, code):
    method context (line 259) | def context(self):
    method code (line 273) | def code(self):
    method startcode (line 279) | def startcode(self):
    method begin (line 284) | def begin(self, startcode):

FILE: codetransformer/decompiler/_343.py
  class DecompilationError (line 26) | class DecompilationError(Exception):
  class DecompilationContext (line 30) | class DecompilationContext(immutable,
  class MakeFunctionContext (line 48) | class MakeFunctionContext(immutable):
  function decompile (line 52) | def decompile(f):
  function pycode_to_body (line 100) | def pycode_to_body(co, context):
  function instrs_to_body (line 124) | def instrs_to_body(instrs, context):
  function process_instrs (line 139) | def process_instrs(queue, stack, body, context):
  function _process_instr (line 151) | def _process_instr(instr, queue, stack, body, context):
  function _instr (line 158) | def _instr(instr, queue, stack, body, context):
  function _process_jump (line 166) | def _process_jump(instr, queue, stack, body, context):
  function make_if_statement (line 182) | def make_if_statement(instr, queue, stack, context):
  function _process_instr_extended_arg (line 215) | def _process_instr_extended_arg(instr, queue, stack, body, context):
  function _process_instr_unpack_sequence (line 221) | def _process_instr_unpack_sequence(instr, queue, stack, body, context):
  function _process_instr_import_name (line 226) | def _process_instr_import_name(instr, queue, stack, body, context):
  function _pop_import_LOAD_ATTRs (line 286) | def _pop_import_LOAD_ATTRs(module_name, queue):
  function make_importfrom_alias (line 316) | def make_importfrom_alias(queue, body, context, name):
  function _push (line 375) | def _push(instr, queue, stack, body, context):
  function _make_function (line 385) | def _make_function(instr, queue, stack, body, context):
  function _store (line 409) | def _store(instr, queue, stack, body, context):
  function _dup_top (line 425) | def _dup_top(instr, queue, stack, body, context):
  function make_assignment (line 429) | def make_assignment(instr, queue, stack):
  function make_assign_target (line 451) | def make_assign_target(instr, queue, stack):
  function make_assign_target_store (line 462) | def make_assign_target_store(instr, queue, stack):
  function make_assign_target_setattr (line 467) | def make_assign_target_setattr(instr, queue, stack):
  function make_assign_target_setitem (line 476) | def make_assign_target_setitem(instr, queue, stack):
  function make_assign_target_unpack (line 487) | def make_assign_target_unpack(instr, queue, stack):
  function make_assign_target_load_name (line 500) | def make_assign_target_load_name(instr, queue, stack):
  function _store_subscr (line 510) | def _store_subscr(instr, queue, stack, body, context):
  function _pop (line 517) | def _pop(instr, queue, stack, body, context):
  function _return (line 522) | def _return(instr, queue, stack, body, context):
  function _jump_break_loop (line 539) | def _jump_break_loop(instr, queue, stack, body, context):
  function _jump_absolute (line 546) | def _jump_absolute(instr, queue, stack, body, context):
  function _process_instr_setup_with (line 554) | def _process_instr_setup_with(instr, queue, stack, body, context):
  function pop_with_body_instrs (line 574) | def pop_with_body_instrs(setup_with_instr, queue):
  function make_withitem (line 602) | def make_withitem(queue, stack):
  function _loop (line 627) | def _loop(instr, queue, stack, body, context):
  function make_for_loop (line 636) | def make_for_loop(loop_body_instrs, else_body_instrs, context):
  function make_loop_body_and_orelse (line 672) | def make_loop_body_and_orelse(top_of_loop, body_instrs, else_instrs, con...
  function make_while_loop (line 713) | def make_while_loop(test_and_body_instrs, else_body_instrs, context):
  function make_while_loop_test_expr (line 739) | def make_while_loop_test_expr(loop_body_instrs):
  function pop_loop_instrs (line 784) | def pop_loop_instrs(setup_loop_instr, queue):
  function make_expr (line 842) | def make_expr(stack_builders):
  function _make_expr (line 856) | def _make_expr(toplevel, stack_builders):
  function make_boolop (line 884) | def make_boolop(exprs, op_types):
  function normalize_boolop (line 901) | def normalize_boolop(expr):
  function _make_expr_internal (line 920) | def _make_expr_internal(toplevel, stack_builders):
  function _make_lambda (line 928) | def _make_lambda(toplevel, stack_builders):
  function _make_expr_unary_not (line 977) | def _make_expr_unary_not(toplevel, stack_builders):
  function _make_expr_call_function (line 985) | def _make_expr_call_function(toplevel, stack_builders):
  function _make_expr_call_function_var (line 998) | def _make_expr_call_function_var(toplevel, stack_builders):
  function _make_expr_call_function_kw (line 1012) | def _make_expr_call_function_kw(toplevel, stack_builders):
  function _make_expr_call_function_var_kw (line 1026) | def _make_expr_call_function_var_kw(toplevel, stack_builders):
  function make_call_keywords (line 1040) | def make_call_keywords(stack_builders, count):
  function make_call_positionals (line 1061) | def make_call_positionals(stack_builders, count):
  function _make_expr_tuple (line 1071) | def _make_expr_tuple(toplevel, stack_builders):
  function _make_expr_set (line 1079) | def _make_expr_set(toplevel, stack_builders):
  function _make_expr_list (line 1087) | def _make_expr_list(toplevel, stack_builders):
  function make_exprs (line 1094) | def make_exprs(stack_builders, count):
  function _make_expr_empty_dict (line 1106) | def _make_expr_empty_dict(toplevel, stack_builders):
  function _make_expr_dict (line 1124) | def _make_expr_dict(toplevel, stack_builders):
  function find_build_map (line 1143) | def find_build_map(stack_builders):
  function _make_dict_elems (line 1165) | def _make_dict_elems(build_instr, builders):
  function _make_expr_name (line 1194) | def _make_expr_name(toplevel, stack_builders):
  function _make_expr_attr (line 1199) | def _make_expr_attr(toplevel, stack_builders):
  function _make_expr_getitem (line 1208) | def _make_expr_getitem(toplevel, stack_builders):
  function make_slice (line 1214) | def make_slice(stack_builders):
  function _make_slice (line 1225) | def _make_slice(toplevel, stack_builders):
  function make_slice_build_slice (line 1230) | def make_slice_build_slice(toplevel, stack_builders):
  function make_slice_tuple (line 1235) | def make_slice_tuple(toplevel, stack_builders):
  function normalize_tuple_slice (line 1244) | def normalize_tuple_slice(node):
  function _make_expr_build_slice (line 1265) | def _make_expr_build_slice(toplevel, stack_builders):
  function _make_expr_const (line 1290) | def _make_expr_const(toplevel, stack_builders):
  function _make_const (line 1295) | def _make_const(const):
  function _make_const_number (line 1304) | def _make_const_number(const):
  function _make_const_str (line 1309) | def _make_const_str(const):
  function _make_const_bytes (line 1314) | def _make_const_bytes(const):
  function _make_const_tuple (line 1319) | def _make_const_tuple(const):
  function _make_const_none (line 1324) | def _make_const_none(none):
  function _binop_handler (line 1344) | def _binop_handler(nodetype):
  function make_function (line 1360) | def make_function(function_builders, *, closure):
  function make_function_arguments (line 1433) | def make_function_arguments(args,
  function make_closure_cells (line 1459) | def make_closure_cells(stack_builders):
  function make_global_and_nonlocal_decls (line 1469) | def make_global_and_nonlocal_decls(code_instrs):
  function make_defaults_and_annotations (line 1490) | def make_defaults_and_annotations(make_function_instr, builders):
  function unpack_make_function_arg (line 1530) | def unpack_make_function_arg(arg):
  function _check_make_function_instrs (line 1550) | def _check_make_function_instrs(load_code_instr,
  function pop_arguments (line 1604) | def pop_arguments(instr, stack):
  function _check_stack_for_module_return (line 1630) | def _check_stack_for_module_return(stack):
  function expect (line 1648) | def expect(instr, expected, context):
  function is_lambda_name (line 1661) | def is_lambda_name(name):
  function popwhile (line 1668) | def popwhile(cond, queue, *, side):
  function _current_test (line 1716) | def _current_test():

FILE: codetransformer/decompiler/__init__.py
  function paramnames (line 6) | def paramnames(co):

FILE: codetransformer/instructions.py
  function _notimplemented (line 47) | def _notimplemented(name):
  function _vartype (line 56) | def _vartype(self):
  class InstructionMeta (line 66) | class InstructionMeta(ABCMeta, matchable):
    method __init__ (line 70) | def __init__(self, *args, opcode=None):
    method __new__ (line 73) | def __new__(mcls, name, bases, dict_, *, opcode=None):
    method mcompile (line 118) | def mcompile(self):
    method __repr__ (line 121) | def __repr__(self):
  class Instruction (line 126) | class Instruction(InstructionMeta._marker, metaclass=InstructionMeta):
    method __init__ (line 141) | def __init__(self, arg=_no_arg):
    method __repr__ (line 150) | def __repr__(self):
    method _normalize_arg (line 158) | def _normalize_arg(arg):
    method steal (line 161) | def steal(self, instr):
    method from_opcode (line 189) | def from_opcode(cls, opcode, arg=_no_arg):
    method stack_effect (line 208) | def stack_effect(self):
    method equiv (line 238) | def equiv(self, instr):
  class _RawArg (line 262) | class _RawArg(int):
  function _mk_call_init (line 270) | def _mk_call_init(class_):
  function _call_repr (line 296) | def _call_repr(self):
  function _check_jmp_arg (line 304) | def _check_jmp_arg(self, arg):
  class CompareOpMeta (line 316) | class CompareOpMeta(InstructionMeta):
    class comparator (line 332) | class comparator(IntEnum):
      method __repr__ (line 345) | def __repr__(self):
    class ComparatorDescr (line 350) | class ComparatorDescr:
      method __init__ (line 361) | def __init__(self, op):
      method __get__ (line 364) | def __get__(self, instance, owner):

FILE: codetransformer/patterns.py
  function _prepr (line 14) | def _prepr(m):
  function coerce_ellipsis (line 21) | def coerce_ellipsis(p):
  class matchable (line 30) | class matchable:
    method __or__ (line 33) | def __or__(self, other):
    method __ror__ (line 53) | def __ror__(self, other):
    method __invert__ (line 60) | def __invert__(self):
    method __getitem__ (line 63) | def __getitem__(self, key):
  class postfix_modifier (line 80) | class postfix_modifier(immutable, matchable):
    method mcompile (line 85) | def mcompile(self):
    method __repr__ (line 88) | def __repr__(self):
  class meta (line 93) | class meta(matchable):
    method mcompile (line 96) | def mcompile(self):
    method __repr__ (line 99) | def __repr__(self):
  class modifier (line 104) | class modifier(meta):
  class var (line 111) | class var(modifier):
  class plus (line 118) | class plus(modifier):
  class option (line 125) | class option(modifier):
  class matchrange (line 131) | class matchrange(immutable, meta, defaults={'m': None}):
    method mcompile (line 134) | def mcompile(self):
    method __repr__ (line 144) | def __repr__(self):
  class matchany (line 152) | class matchany(meta):
    method __repr__ (line 157) | def __repr__(self):
  class seq (line 161) | class seq(immutable, matchable):
    method __new__ (line 171) | def __new__(cls, *matchables):
    method __init__ (line 179) | def __init__(self, *matchables):
    method mcompile (line 182) | def mcompile(self):
    method __repr__ (line 185) | def __repr__(self):
  class or_ (line 192) | class or_(immutable, matchable):
    method mcompile (line 202) | def mcompile(self):
    method __repr__ (line 205) | def __repr__(self):
  class not_ (line 209) | class not_(immutable, matchable):
    method mcompile (line 214) | def mcompile(self):
    method __repr__ (line 221) | def __repr__(self):
  class pattern (line 225) | class pattern(immutable):
    method __init__ (line 261) | def __init__(self, *matchables, startcodes=(DEFAULT_STARTCODE,)):
    method __call__ (line 268) | def __call__(self, f):
    method __repr__ (line 271) | def __repr__(self):
  class boundpattern (line 279) | class boundpattern(immutable):
    method __get__ (line 284) | def __get__(self, instance, owner):
    method __call__ (line 294) | def __call__(self, compiled_instrs, instrs, startcode):
  class NoMatch (line 306) | class NoMatch(Exception):
  class patterndispatcher (line 312) | class patterndispatcher(immutable):
    method __get__ (line 317) | def __get__(self, instance, owner):
  class boundpatterndispatcher (line 330) | class boundpatterndispatcher(immutable):
    method _dispatch (line 335) | def _dispatch(self, compiled_instrs, instrs, startcode):
    method __call__ (line 344) | def __call__(self, instrs):

FILE: codetransformer/tests/test_code.py
  function sample_flags (line 14) | def sample_flags(request):
  function test_lnotab_roundtrip (line 26) | def test_lnotab_roundtrip():
  function test_lnotab_really_dumb_whitespace (line 53) | def test_lnotab_really_dumb_whitespace():
  function test_flag_packing (line 68) | def test_flag_packing(sample_flags):
  function test_flag_unpack_too_big (line 73) | def test_flag_unpack_too_big():
  function test_flag_max (line 79) | def test_flag_max():
  function test_flag_max_immutable (line 100) | def test_flag_max_immutable():
  function test_code_multiple_varargs (line 105) | def test_code_multiple_varargs():
  function test_code_multiple_kwargs (line 117) | def test_code_multiple_kwargs():
  function test_dangling_var (line 130) | def test_dangling_var(cls):
  function test_code_flags (line 141) | def test_code_flags(sample_flags):
  function abc_code (line 177) | def abc_code():
  function test_instr_index (line 186) | def test_instr_index(abc_code):
  function test_code_contains (line 196) | def test_code_contains(abc_code):
  function test_code_dis (line 204) | def test_code_dis(capsys):

FILE: codetransformer/tests/test_core.py
  function test_inherit_patterns (line 11) | def test_inherit_patterns():
  function test_override_patterns (line 33) | def test_override_patterns():
  function test_updates_lnotab (line 61) | def test_updates_lnotab():
  function test_context (line 106) | def test_context():
  function test_no_context (line 122) | def test_no_context():

FILE: codetransformer/tests/test_decompiler.py
  function make_indented_body (line 31) | def make_indented_body(body_str):
  function compare (line 43) | def compare(computed, expected):
  function check (line 64) | def check(text, ast_text=None):
  function check_formatted (line 87) | def check_formatted(text, ast_text=None, **fmt_kwargs):
  function test_decompile (line 129) | def test_decompile():
  function test_trivial_expr (line 146) | def test_trivial_expr():
  function test_assign (line 153) | def test_assign(lhs, rhs):
  function test_unpack_to_attribute (line 157) | def test_unpack_to_attribute():
  function test_chained_assign (line 163) | def test_chained_assign():
  function test_unary_not (line 169) | def test_unary_not():
  function test_binary_ops (line 191) | def test_binary_ops(op):
  function test_string_literal (line 198) | def test_string_literal():
  function test_bytes_literal (line 209) | def test_bytes_literal():
  function test_int_literal (line 215) | def test_int_literal():
  function test_float_literal (line 222) | def test_float_literal():
  function test_complex_literal (line 229) | def test_complex_literal():
  function test_tuple_literals (line 236) | def test_tuple_literals():
  function test_set_literals (line 246) | def test_set_literals():
  function test_list_literals (line 252) | def test_list_literals():
  function test_dict_literals (line 259) | def test_dict_literals():
  function test_function_call (line 273) | def test_function_call():
  function test_paramnames (line 290) | def test_paramnames():
  function test_lambda (line 358) | def test_lambda(signature, expr):
  function test_simple_function (line 373) | def test_simple_function():
  function test_annotations (line 384) | def test_annotations():
  function test_function_signatures (line 457) | def test_function_signatures(signature, body):
  function test_decorators (line 468) | def test_decorators():
  function test_store_twice_to_global (line 486) | def test_store_twice_to_global():
  function test_store_twice_to_nonlocal (line 501) | def test_store_twice_to_nonlocal():
  function test_getattr (line 518) | def test_getattr():
  function test_setattr (line 531) | def test_setattr():
  function test_getitem (line 538) | def test_getitem():
  function test_setitem (line 553) | def test_setitem():
  function test_for (line 580) | def test_for(loop, body, else_body):
  function test_while (line 614) | def test_while(condition, body, else_body):
  function test_while_False (line 633) | def test_while_False():
  function test_import (line 647) | def test_import():
  function test_import_from (line 673) | def test_import_from():
  function test_import_star (line 679) | def test_import_star():
  function test_import_attribute_aliasing_module (line 684) | def test_import_attribute_aliasing_module():
  function test_import_in_function (line 688) | def test_import_in_function():
  function test_with_block (line 727) | def test_with_block():
  function test_nested_with (line 786) | def test_nested_with():
  function test_simple_if (line 815) | def test_simple_if():
  function test_if_return (line 827) | def test_if_return():
  function test_if_else (line 840) | def test_if_else():
  function test_if_elif (line 861) | def test_if_elif(last_statement, prefix):
  function test_boolops (line 903) | def test_boolops(op):
  function test_normalize_nested_boolops (line 919) | def test_normalize_nested_boolops(op):
  function test_mixed_boolops (line 934) | def test_mixed_boolops():

FILE: codetransformer/tests/test_instructions.py
  function test_repr_types (line 4) | def test_repr_types():

FILE: codetransformer/transformers/add2mul.py
  class add2mul (line 14) | class add2mul(CodeTransformer):
    method _add2mul (line 16) | def _add2mul(self, add_instr):

FILE: codetransformer/transformers/constants.py
  function _assign_or_del (line 22) | def _assign_or_del(type_):
  class asconstants (line 48) | class asconstants(CodeTransformer):
    method __init__ (line 98) | def __init__(self, *builtin_names, **kwargs):
    method transform (line 112) | def transform(self, code, **kwargs):
    method _load_name (line 121) | def _load_name(self, instr):

FILE: codetransformer/transformers/interpolated_strings.py
  class interpolated_strings (line 18) | class interpolated_strings(CodeTransformer):
    method __init__ (line 43) | def __init__(self, *, transform_bytes=True, transform_str=False):
    method __init__ (line 49) | def __init__(self, *, transform_bytes=True, transform_str=False):
    method types (line 55) | def types(self):
    method _load_const (line 67) | def _load_const(self, instr):
    method _transform_constant_sequence (line 81) | def _transform_constant_sequence(self, seq):
    method transform_stringlike (line 109) | def transform_stringlike(self, const):
    method bytes_instrs (line 120) | def bytes_instrs(self):
    method str_instrs (line 130) | def str_instrs(self):

FILE: codetransformer/transformers/literals.py
  class overloaded_dicts (line 16) | class overloaded_dicts(CodeTransformer):
    method __init__ (line 51) | def __init__(self, astype):
    method _start_comprehension (line 56) | def _start_comprehension(self, instr, *instrs):
    method _return_value (line 84) | def _return_value(self, instr):
    method _build_map (line 94) | def _build_map(self, instr):
    method _store_map (line 107) | def _store_map(self, instr):
    method _construct_map (line 137) | def _construct_map(self, key_value_pairs):
    method _build_map (line 144) | def _build_map(self, instr):
    method _construct_const_map (line 166) | def _construct_const_map(self, values, keys):
    method _build_const_map (line 173) | def _build_const_map(self, keys, instr):
  function _format_constant_docstring (line 197) | def _format_constant_docstring(type_):
  class _ConstantTransformerBase (line 215) | class _ConstantTransformerBase(CodeTransformer):
    method __init__ (line 217) | def __init__(self, xform):
    method transform_consts (line 221) | def transform_consts(self, consts):
  function overloaded_constants (line 237) | def overloaded_constants(type_, __doc__=None):
  function _start_comprehension (line 311) | def _start_comprehension(self, *instrs):
  function _return_value (line 316) | def _return_value(self, instr):
  function _build (line 334) | def _build(self, instr):
  function overloaded_build (line 350) | def overloaded_build(type_, add_name=None):
  function transform_consts (line 420) | def transform_consts(self, consts):
  function transform_consts (line 438) | def transform_consts(self, consts):
  class islice_literals (line 451) | class islice_literals(CodeTransformer):
    method _binary_subscr (line 467) | def _binary_subscr(self, instr):
    method _islicer (line 482) | def _islicer(m, k):

FILE: codetransformer/transformers/pattern_matched_exceptions.py
  function match (line 15) | def match(match_expr, exc_type, exc_value, exc_traceback):
  class pattern_matched_exceptions (line 34) | class pattern_matched_exceptions(CodeTransformer):
    method __init__ (line 69) | def __init__(self, matcher=match):
    method _match (line 76) | def _match(self,
    method _match (line 94) | def _match(self,
    method _compare_op (line 112) | def _compare_op(self, instr):

FILE: codetransformer/transformers/precomputed_slices.py
  class precomputed_slices (line 6) | class precomputed_slices(CodeTransformer):
    method make_constant_slice (line 30) | def make_constant_slice(self, *instrs):

FILE: codetransformer/transformers/tests/test_add2mul.py
  function test_add2mul (line 4) | def test_add2mul():

FILE: codetransformer/transformers/tests/test_constants.py
  function test_global (line 14) | def test_global():
  function test_name (line 23) | def test_name():
  function test_closure (line 39) | def test_closure():
  function test_store (line 52) | def test_store():
  function test_delete (line 65) | def test_delete():
  function test_argname_overlap (line 78) | def test_argname_overlap():

FILE: codetransformer/transformers/tests/test_exc_patterns.py
  function test_patterns (line 5) | def test_patterns():
  function test_patterns_bind_name (line 23) | def test_patterns_bind_name():
  function test_patterns_reraise (line 39) | def test_patterns_reraise():
  function test_normal_exc_match (line 55) | def test_normal_exc_match():
  function test_exc_match_custom_func (line 69) | def test_exc_match_custom_func():

FILE: codetransformer/transformers/tests/test_interpolated_strings.py
  function test_interpolated_bytes (line 14) | def test_interpolated_bytes():
  function test_interpolated_str (line 35) | def test_interpolated_str():
  function test_no_cross_pollination (line 56) | def test_no_cross_pollination():
  function test_string_in_nested_const (line 75) | def test_string_in_nested_const():

FILE: codetransformer/transformers/tests/test_literals.py
  function test_overload_thing_with_thing_is_noop (line 21) | def test_overload_thing_with_thing_is_noop():
  function test_overloaded_dicts (line 30) | def test_overloaded_dicts():
  function test_overloaded_bytes (line 45) | def test_overloaded_bytes():
  function test_overloaded_floats (line 73) | def test_overloaded_floats():
  function test_overloaded_lists (line 98) | def test_overloaded_lists():
  function test_overloaded_strs (line 126) | def test_overloaded_strs():
  function test_overloaded_sets (line 141) | def test_overloaded_sets():
  function test_overloaded_tuples (line 168) | def test_overloaded_tuples():
  function test_overloaded_slices (line 186) | def test_overloaded_slices():
  function test_islice_literals (line 208) | def test_islice_literals():

FILE: codetransformer/transformers/tests/test_precomputed_slices.py
  function test_precomputed_slices (line 7) | def test_precomputed_slices():
  function test_precomputed_slices_non_const (line 22) | def test_precomputed_slices_non_const():

FILE: codetransformer/utils/functional.py
  function is_a (line 11) | def is_a(type_):
  function not_a (line 16) | def not_a(type_):
  function scanl (line 21) | def scanl(f, n, ns):
  function reverse_dict (line 52) | def reverse_dict(d):
  function ffill (line 75) | def ffill(iterable):
  function flatten (line 99) | def flatten(seq, *, recurse_types=(tuple, list, set, frozenset)):

FILE: codetransformer/utils/immutable.py
  class immutableattr (line 15) | class immutableattr:
    method __init__ (line 23) | def __init__(self, attr):
    method __get__ (line 26) | def __get__(self, instance, owner):
  class lazyval (line 30) | class lazyval:
    method __init__ (line 38) | def __init__(self, func):
    method __get__ (line 42) | def __get__(self, instance, owner):
  function _no_arg_init (line 54) | def _no_arg_init(self):
  function initialize_slot (line 61) | def initialize_slot(obj, name, value):
  function _create_init (line 79) | def _create_init(name, slots, defaults):
  function _wrapinit (line 177) | def _wrapinit(init):
  function _check_missing_slots (line 264) | def _check_missing_slots(ob):
  function __setattr__ (line 290) | def __setattr__(self, name, value):
  function __repr__ (line 299) | def __repr__(self):
  class ImmutableMeta (line 309) | class ImmutableMeta(type):
    method __new__ (line 312) | def __new__(mcls, name, bases, dict_, *, defaults=None):
    method __init__ (line 337) | def __init__(self, *args, defaults=None):
  class immutable (line 342) | class immutable(metaclass=ImmutableMeta):
    method to_dict (line 347) | def to_dict(self):
    method update (line 350) | def update(self, **updates):

FILE: codetransformer/utils/instance.py
  function instance (line 1) | def instance(cls):

FILE: codetransformer/utils/no_default.py
  class no_default (line 2) | class no_default:
    method __new__ (line 3) | def __new__(cls):
    method __repr__ (line 6) | def __repr__(self):
    method __reduce__ (line 10) | def __reduce__(self):
    method __deepcopy__ (line 13) | def __deepcopy__(self):

FILE: codetransformer/utils/pretty.py
  function pformat_ast (line 31) | def pformat_ast(node,
  function _extend_name (line 111) | def _extend_name(prev, parent_co):
  function pprint_ast (line 117) | def pprint_ast(node,
  function walk_code (line 149) | def walk_code(co, _prefix=''):
  function iter_attributes (line 164) | def iter_attributes(node):
  function a (line 172) | def a(text, mode='exec', indent='  ', file=None):
  function d (line 193) | def d(obj, mode='exec', file=None):
  function extract_code (line 225) | def extract_code(obj, compile_mode):
  function _ (line 245) | def _(obj, compile_mode):
  function _ (line 250) | def _(obj, compile_mode):
  function display (line 275) | def display(text, mode='exec', file=None):

FILE: codetransformer/utils/tests/test_immutable.py
  class a (line 8) | class a(immutable):
    method spec (line 11) | def spec(__self, a):
  class b (line 15) | class b(immutable):
    method spec (line 18) | def spec(__self, a, b):
  class c (line 22) | class c(immutable):
    method spec (line 25) | def spec(__self, a, b, *c):
  class d (line 29) | class d(immutable):
    method spec (line 32) | def spec(__self, a, b, **c):
  class e (line 36) | class e(immutable):
    method spec (line 39) | def spec(__self, a, b, *, c):
  class f (line 43) | class f(immutable):
    method spec (line 46) | def spec(__self, a, b, *c, d):
  class g (line 50) | class g(immutable, defaults={'a': 1}):
    method spec (line 53) | def spec(__self, a=1):
  class h (line 57) | class h(immutable, defaults={'b': 2}):
    method spec (line 60) | def spec(__self, a, b=2):
  class i (line 64) | class i(immutable, defaults={'a': 1, 'b': 2}):
    method spec (line 67) | def spec(__self, a=1, b=2):
  class j (line 71) | class j(immutable, defaults={'c': 3}):
    method spec (line 74) | def spec(__self, a, b, *, c=3):
  function test_created_signature_single (line 79) | def test_created_signature_single(cls):
  class k (line 83) | class k(immutable):
    method __init__ (line 86) | def __init__(self, a):
  class l (line 90) | class l(immutable):
    method __init__ (line 93) | def __init__(self, *a):
  class m (line 97) | class m(immutable):
    method __init__ (line 100) | def __init__(self, **a):
  class n (line 104) | class n(immutable):
    method __init__ (line 107) | def __init__(self, *, a):
  class o (line 111) | class o(immutable):
    method __init__ (line 114) | def __init__(self, a, b=2):
  class p (line 118) | class p(immutable):
    method __init__ (line 121) | def __init__(self, a=1, b=2):
  class q (line 125) | class q(immutable):
    method __init__ (line 128) | def __init__(self, a, *b):
  class r (line 132) | class r(immutable):
    method __init__ (line 135) | def __init__(self, a=1, *b):
  class s (line 139) | class s(immutable):
    method __init__ (line 142) | def __init__(self, a=1, *b, c):
  class t (line 146) | class t(immutable):
    method __init__ (line 149) | def __init__(self, a, *b, c=3):
  class u (line 153) | class u(immutable):
    method __init__ (line 156) | def __init__(self, a=1, *b, c=3):
  class v (line 160) | class v(immutable):
    method __init__ (line 163) | def __init__(self, a, **b):
  class w (line 167) | class w(immutable):
    method __init__ (line 170) | def __init__(self, a, b, **c):
  class x (line 174) | class x(immutable):
    method __init__ (line 177) | def __init__(self, a, *b, **c):
  class y (line 181) | class y(immutable):
    method __init__ (line 184) | def __init__(self, a, *b, c, **d):
  class z (line 188) | class z(immutable):
    method __init__ (line 191) | def __init__(self, a, *b, c=1, **d):
  function test_preserve_custom_init_signature (line 198) | def test_preserve_custom_init_signature(cls):

FILE: codetransformer/utils/tests/test_pretty.py
  function test_a (line 8) | def test_a(capsys):
  function test_walk_code (line 71) | def test_walk_code():

FILE: versioneer.py
  class VersioneerConfig (line 355) | class VersioneerConfig:
  function get_root (line 359) | def get_root():
  function get_config_from_root (line 393) | def get_config_from_root(root):
  class NotThisMethod (line 419) | class NotThisMethod(Exception):
  function register_vcs_handler (line 427) | def register_vcs_handler(vcs, method):  # decorator
  function run_command (line 436) | def run_command(commands, args, cwd=None, verbose=False, hide_stderr=Fal...
  function git_get_keywords (line 931) | def git_get_keywords(versionfile_abs):
  function git_versions_from_keywords (line 955) | def git_versions_from_keywords(keywords, tag_prefix, verbose):
  function git_pieces_from_vcs (line 1000) | def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_comma...
  function do_vcs_install (line 1081) | def do_vcs_install(manifest_in, versionfile_source, ipy):
  function versions_from_parentdir (line 1114) | def versions_from_parentdir(parentdir_prefix, root, verbose):
  function versions_from_file (line 1146) | def versions_from_file(filename):
  function write_to_version_file (line 1159) | def write_to_version_file(filename, versions):
  function plus_or_dot (line 1169) | def plus_or_dot(pieces):
  function render_pep440 (line 1175) | def render_pep440(pieces):
  function render_pep440_pre (line 1199) | def render_pep440_pre(pieces):
  function render_pep440_post (line 1215) | def render_pep440_post(pieces):
  function render_pep440_old (line 1241) | def render_pep440_old(pieces):
  function render_git_describe (line 1261) | def render_git_describe(pieces):
  function render_git_describe_long (line 1280) | def render_git_describe_long(pieces):
  function render (line 1298) | def render(pieces, style):
  class VersioneerBadRootError (line 1327) | class VersioneerBadRootError(Exception):
  function get_versions (line 1331) | def get_versions(verbose=False):
  function get_version (line 1404) | def get_version():
  function get_cmdclass (line 1408) | def get_cmdclass():
  function do_setup (line 1577) | def do_setup():
  function scan_setup_py (line 1658) | def scan_setup_py():