SYMBOL INDEX (6017 symbols across 241 files)

FILE: benchmarks/bm_call_method.py
  class Foo (line 13) | class Foo(object):
    method foo (line 15) | def foo(self, a, b, c, d):
    method bar (line 38) | def bar(self, a, b, c):
    method baz (line 61) | def baz(self, a, b):
    method quux (line 84) | def quux(self, a):
    method qux (line 107) | def qux(self):
  function BenchmarkCallMethod (line 111) | def BenchmarkCallMethod(b):

FILE: benchmarks/bm_call_simple.py
  function foo (line 13) | def foo(a, b, c, d):
  function bar (line 37) | def bar(a, b, c):
  function baz (line 61) | def baz(a, b):
  function quux (line 85) | def quux(a):
  function qux (line 109) | def qux():
  function BenchmarkCallSimple (line 113) | def BenchmarkCallSimple(b):

FILE: benchmarks/call.py
  function BenchmarkCallNoArgs (line 22) | def BenchmarkCallNoArgs(b):
  function BenchmarkCallPositionalArgs (line 29) | def BenchmarkCallPositionalArgs(b):
  function BenchmarkCallKeywords (line 36) | def BenchmarkCallKeywords(b):
  function BenchmarkCallDefaults (line 43) | def BenchmarkCallDefaults(b):
  function BenchmarkCallVarArgs (line 50) | def BenchmarkCallVarArgs(b):
  function BenchmarkCallKwargs (line 57) | def BenchmarkCallKwargs(b):

FILE: benchmarks/comprehension.py
  function BenchmarkGeneratorExpCreate (line 22) | def BenchmarkGeneratorExpCreate(b):
  function BenchmarkGeneratorExpIterate (line 28) | def BenchmarkGeneratorExpIterate(b):
  function BenchmarkListCompCreate (line 33) | def BenchmarkListCompCreate(b):
  function BenchmarkDictCompCreate (line 38) | def BenchmarkDictCompCreate(b):

FILE: benchmarks/concurrent.py
  function Arithmetic (line 22) | def Arithmetic(n):
  function Fib (line 26) | def Fib(n):
  function _MakeParallelBenchmark (line 38) | def _MakeParallelBenchmark(p, work_func, *args):
  function _RegisterBenchmarks (line 58) | def _RegisterBenchmarks():

FILE: benchmarks/dict.py
  function BenchmarkDictCreate (line 22) | def BenchmarkDictCreate(b):
  function BenchmarkDictCreateFunc (line 27) | def BenchmarkDictCreateFunc(b):
  function BenchmarkDictGetItem (line 32) | def BenchmarkDictGetItem(b):
  function BenchmarkDictStringOnlyGetItem (line 38) | def BenchmarkDictStringOnlyGetItem(b):
  function BenchmarkDictSetItem (line 44) | def BenchmarkDictSetItem(b):
  function BenchmarkDictStringOnlySetItem (line 50) | def BenchmarkDictStringOnlySetItem(b):
  function BenchmarkHashStrCached (line 56) | def BenchmarkHashStrCached(b):

FILE: benchmarks/generator.py
  function BenchmarkGeneratorIterate (line 20) | def BenchmarkGeneratorIterate(b):
  function BenchmarkGeneratorCreate (line 28) | def BenchmarkGeneratorCreate(b):

FILE: benchmarks/list.py
  function BenchmarkListGetItem (line 22) | def BenchmarkListGetItem(b):
  function BenchmarkListContains3 (line 28) | def BenchmarkListContains3(b):
  function BenchmarkListContains10 (line 34) | def BenchmarkListContains10(b):

FILE: benchmarks/loop.py
  function BenchmarkForXRange (line 20) | def BenchmarkForXRange(b):
  function BenchmarkWhileCounter (line 25) | def BenchmarkWhileCounter(b):
  function BenchmarkWhileXRange (line 31) | def BenchmarkWhileXRange(b):

FILE: benchmarks/tuple.py
  function BenchmarkTupleGetItem (line 22) | def BenchmarkTupleGetItem(b):
  function BenchmarkTupleContains3 (line 28) | def BenchmarkTupleContains3(b):
  function BenchmarkTupleContains10 (line 34) | def BenchmarkTupleContains10(b):

FILE: compiler/block.py
  class Package (line 35) | class Package(object):
    method __init__ (line 38) | def __init__(self, name, alias=None):
  class Loop (line 45) | class Loop(object):
    method __init__ (line 48) | def __init__(self, breakvar):
  class Block (line 52) | class Block(object):
    method __init__ (line 57) | def __init__(self, parent, name):
    method bind_var (line 70) | def bind_var(self, writer, name, value):
    method del_var (line 85) | def del_var(self, writer, name):
    method resolve_name (line 89) | def resolve_name(self, writer, name):
    method genlabel (line 102) | def genlabel(self, is_checkpoint=False):
    method alloc_temp (line 108) | def alloc_temp(self, type_='*πg.Object'):
    method free_temp (line 121) | def free_temp(self, v):
    method push_loop (line 126) | def push_loop(self, breakvar):
    method pop_loop (line 131) | def pop_loop(self):
    method top_loop (line 134) | def top_loop(self):
    method _resolve_global (line 137) | def _resolve_global(self, writer, name):
  class ModuleBlock (line 144) | class ModuleBlock(Block):
    method __init__ (line 147) | def __init__(self, importer, full_package_name,
    method bind_var (line 157) | def bind_var(self, writer, name, value):
    method del_var (line 162) | def del_var(self, writer, name):
    method resolve_name (line 166) | def resolve_name(self, writer, name):
    method intern (line 169) | def intern(self, s):
  class ClassBlock (line 176) | class ClassBlock(Block):
    method __init__ (line 179) | def __init__(self, parent, name, global_vars):
    method bind_var (line 183) | def bind_var(self, writer, name, value):
    method del_var (line 189) | def del_var(self, writer, name):
    method resolve_name (line 195) | def resolve_name(self, writer, name):
  class FunctionBlock (line 217) | class FunctionBlock(Block):
    method __init__ (line 220) | def __init__(self, parent, name, block_vars, is_generator):
    method bind_var (line 226) | def bind_var(self, writer, name, value):
    method del_var (line 231) | def del_var(self, writer, name):
    method resolve_name (line 244) | def resolve_name(self, writer, name):
  class Var (line 260) | class Var(object):
    method __init__ (line 267) | def __init__(self, name, var_type, arg_index=None):
  class BlockVisitor (line 281) | class BlockVisitor(algorithm.Visitor):
    method __init__ (line 286) | def __init__(self):
    method visit_Assign (line 289) | def visit_Assign(self, node):
    method visit_AugAssign (line 294) | def visit_AugAssign(self, node):
    method visit_ClassDef (line 298) | def visit_ClassDef(self, node):
    method visit_ExceptHandler (line 301) | def visit_ExceptHandler(self, node):
    method visit_For (line 306) | def visit_For(self, node):
    method visit_FunctionDef (line 310) | def visit_FunctionDef(self, node):
    method visit_Global (line 316) | def visit_Global(self, node):
    method visit_Import (line 320) | def visit_Import(self, node):
    method visit_ImportFrom (line 324) | def visit_ImportFrom(self, node):
    method visit_With (line 328) | def visit_With(self, node):
    method _assign_target (line 334) | def _assign_target(self, target):
    method _register_global (line 341) | def _register_global(self, node, name):
    method _register_local (line 353) | def _register_local(self, name):
  class FunctionBlockVisitor (line 358) | class FunctionBlockVisitor(BlockVisitor):
    method __init__ (line 363) | def __init__(self, node):
    method visit_Yield (line 378) | def visit_Yield(self, unused_node): # pylint: disable=unused-argument

FILE: compiler/block_test.py
  class PackageTest (line 29) | class PackageTest(unittest.TestCase):
    method testCreate (line 31) | def testCreate(self):
    method testCreateGrump (line 36) | def testCreateGrump(self):
  class BlockTest (line 42) | class BlockTest(unittest.TestCase):
    method testLoop (line 44) | def testLoop(self):
    method testResolveName (line 53) | def testResolveName(self):
    method _ResolveName (line 89) | def _ResolveName(self, b, name):
  class BlockVisitorTest (line 95) | class BlockVisitorTest(unittest.TestCase):
    method testAssignSingle (line 97) | def testAssignSingle(self):
    method testAssignMultiple (line 103) | def testAssignMultiple(self):
    method testAssignTuple (line 110) | def testAssignTuple(self):
    method testAssignNested (line 117) | def testAssignNested(self):
    method testAugAssignSingle (line 125) | def testAugAssignSingle(self):
    method testVisitClassDef (line 131) | def testVisitClassDef(self):
    method testExceptHandler (line 137) | def testExceptHandler(self):
    method testFor (line 150) | def testFor(self):
    method testFunctionDef (line 156) | def testFunctionDef(self):
    method testImport (line 162) | def testImport(self):
    method testImportFrom (line 169) | def testImportFrom(self):
    method testGlobal (line 176) | def testGlobal(self):
    method testGlobalIsParam (line 183) | def testGlobalIsParam(self):
    method testGlobalUsedPriorToDeclaration (line 189) | def testGlobalUsedPriorToDeclaration(self):
  class FunctionBlockVisitorTest (line 196) | class FunctionBlockVisitorTest(unittest.TestCase):
    method testArgs (line 198) | def testArgs(self):
    method testArgsDuplicate (line 210) | def testArgsDuplicate(self):
    method testYield (line 215) | def testYield(self):
    method testYieldExpr (line 220) | def testYieldExpr(self):
  function _MakeModuleBlock (line 228) | def _MakeModuleBlock():
  function _ParseStmt (line 234) | def _ParseStmt(stmt_str):

FILE: compiler/expr.py
  class GeneratedExpr (line 26) | class GeneratedExpr(object):
    method __enter__ (line 31) | def __enter__(self):
    method __exit__ (line 34) | def __exit__(self, unused_type, unused_value, unused_traceback):
    method expr (line 38) | def expr(self):
    method free (line 41) | def free(self):
  class GeneratedTempVar (line 45) | class GeneratedTempVar(GeneratedExpr):
    method __init__ (line 48) | def __init__(self, block_, name, type_):
    method expr (line 54) | def expr(self):
    method free (line 57) | def free(self):
  class GeneratedLocalVar (line 61) | class GeneratedLocalVar(GeneratedExpr):
    method __init__ (line 64) | def __init__(self, name):
    method expr (line 68) | def expr(self):
  class GeneratedLiteral (line 72) | class GeneratedLiteral(GeneratedExpr):
    method __init__ (line 75) | def __init__(self, expr):
    method expr (line 79) | def expr(self):
  class BlankVar (line 86) | class BlankVar(GeneratedExpr):
    method __init__ (line 87) | def __init__(self):
    method expr (line 91) | def expr(self):

FILE: compiler/expr_visitor.py
  class ExprVisitor (line 30) | class ExprVisitor(algorithm.Visitor):
    method __init__ (line 35) | def __init__(self, stmt_visitor):
    method generic_visit (line 40) | def generic_visit(self, node):
    method visit_Attribute (line 44) | def visit_Attribute(self, node):
    method visit_BinOp (line 52) | def visit_BinOp(self, node):
    method visit_BoolOp (line 65) | def visit_BoolOp(self, node):
    method visit_Call (line 87) | def visit_Call(self, node):
    method visit_Compare (line 131) | def visit_Compare(self, node):
    method visit_Dict (line 174) | def visit_Dict(self, node):
    method visit_Set (line 185) | def visit_Set(self, node):
    method visit_DictComp (line 196) | def visit_DictComp(self, node):
    method visit_ExtSlice (line 206) | def visit_ExtSlice(self, node):
    method visit_GeneratorExp (line 223) | def visit_GeneratorExp(self, node):
    method visit_IfExp (line 239) | def visit_IfExp(self, node):
    method visit_Index (line 258) | def visit_Index(self, node):
    method visit_Lambda (line 264) | def visit_Lambda(self, node):
    method visit_List (line 270) | def visit_List(self, node):
    method visit_ListComp (line 277) | def visit_ListComp(self, node):
    method visit_Name (line 286) | def visit_Name(self, node):
    method visit_Num (line 289) | def visit_Num(self, node):
    method visit_Slice (line 310) | def visit_Slice(self, node):
    method visit_Subscript (line 325) | def visit_Subscript(self, node):
    method visit_Str (line 333) | def visit_Str(self, node):
    method visit_Tuple (line 341) | def visit_Tuple(self, node):
    method visit_UnaryOp (line 353) | def visit_UnaryOp(self, node):
    method visit_Yield (line 372) | def visit_Yield(self, node):
    method _visit_seq_elts (line 416) | def _visit_seq_elts(self, elts):
    method _node_not_implemented (line 425) | def _node_not_implemented(self, node):

FILE: compiler/expr_visitor_test.py
  function _MakeExprTest (line 32) | def _MakeExprTest(expr):
  function _MakeLiteralTest (line 39) | def _MakeLiteralTest(lit, expected=None):
  function _MakeSliceTest (line 49) | def _MakeSliceTest(subscript, want):
  class ExprVisitorTest (line 63) | class ExprVisitorTest(unittest.TestCase):
    method testAttribute (line 67) | def testAttribute(self):
    method testCall (line 93) | def testCall(self):
    method testCallKeywords (line 100) | def testCallKeywords(self):
    method testCallVarArgs (line 107) | def testCallVarArgs(self):
    method testCallKwargs (line 114) | def testCallKwargs(self):
    method testNameGlobal (line 171) | def testNameGlobal(self):
    method testNameLocal (line 177) | def testNameLocal(self):
  function _MakeModuleBlock (line 224) | def _MakeModuleBlock():
  function _ParseExpr (line 229) | def _ParseExpr(expr):
  function _ParseAndVisitExpr (line 233) | def _ParseAndVisitExpr(expr):
  function _GrumpRun (line 239) | def _GrumpRun(cmd):

FILE: compiler/imputil.py
  class Import (line 36) | class Import(object):
    method __init__ (line 49) | def __init__(self, name, script=None, is_native=False):
    method add_binding (line 55) | def add_binding(self, bind_type, alias, value):
  class Importer (line 59) | class Importer(algorithm.Visitor):
    method __init__ (line 64) | def __init__(self, gopath, modname, script, absolute_import):
    method generic_visit (line 82) | def generic_visit(self, node):
    method visit_Import (line 85) | def visit_Import(self, node):
    method visit_ImportFrom (line 103) | def visit_ImportFrom(self, node):
    method _resolve_import (line 149) | def _resolve_import(self, node, modname):
    method _resolve_relative_import (line 160) | def _resolve_relative_import(self, level, node, modname):
  class _ImportCollector (line 176) | class _ImportCollector(algorithm.Visitor):
    method __init__ (line 180) | def __init__(self, importer, future_node):
    method visit_Import (line 185) | def visit_Import(self, node):
    method visit_ImportFrom (line 188) | def visit_ImportFrom(self, node):
  function collect_imports (line 196) | def collect_imports(modname, script, gopath):
  function calculate_transitive_deps (line 207) | def calculate_transitive_deps(modname, script, gopath):
  function find_script (line 236) | def find_script(dirname, name):
  class FutureFeatures (line 265) | class FutureFeatures(object):
    method __init__ (line 268) | def __init__(self, absolute_import=False, division=False,
  function _make_future_features (line 276) | def _make_future_features(node):
  function parse_future_features (line 296) | def parse_future_features(mod):

FILE: compiler/imputil_test.py
  class ImportVisitorTest (line 33) | class ImportVisitorTest(unittest.TestCase):
    method setUp (line 50) | def setUp(self):
    method tearDown (line 81) | def tearDown(self):
    method testImportEmptyPath (line 84) | def testImportEmptyPath(self):
    method testImportTopLevelModule (line 89) | def testImportTopLevelModule(self):
    method testImportTopLevelPackage (line 94) | def testImportTopLevelPackage(self):
    method testImportPackageModuleAbsolute (line 99) | def testImportPackageModuleAbsolute(self):
    method testImportFromSubModule (line 104) | def testImportFromSubModule(self):
    method testImportPackageModuleRelative (line 109) | def testImportPackageModuleRelative(self):
    method testImportPackageModuleRelativeFromSubModule (line 115) | def testImportPackageModuleRelativeFromSubModule(self):
    method testImportPackageModuleAbsoluteImport (line 123) | def testImportPackageModuleAbsoluteImport(self):
    method testImportMultiple (line 131) | def testImportMultiple(self):
    method testImportAs (line 138) | def testImportAs(self):
    method testImportFrom (line 143) | def testImportFrom(self):
    method testImportFromMember (line 148) | def testImportFromMember(self):
    method testImportFromMultiple (line 153) | def testImportFromMultiple(self):
    method testImportFromMixedMembers (line 160) | def testImportFromMixedMembers(self):
    method testImportFromAs (line 167) | def testImportFromAs(self):
    method testImportFromAsMembers (line 172) | def testImportFromAsMembers(self):
    method testImportFromWildcardRaises (line 177) | def testImportFromWildcardRaises(self):
    method testImportFromFuture (line 181) | def testImportFromFuture(self):
    method testImportFromNative (line 184) | def testImportFromNative(self):
    method testImportFromNativeMultiple (line 189) | def testImportFromNativeMultiple(self):
    method testImportFromNativeAs (line 195) | def testImportFromNativeAs(self):
    method testRelativeImportNonPackage (line 200) | def testRelativeImportNonPackage(self):
    method testRelativeImportBeyondTopLevel (line 204) | def testRelativeImportBeyondTopLevel(self):
    method testRelativeModuleNoExist (line 208) | def testRelativeModuleNoExist(self):
    method testRelativeModule (line 212) | def testRelativeModule(self):
    method testRelativeModuleFromSubModule (line 218) | def testRelativeModuleFromSubModule(self):
    method testRelativeModuleMember (line 226) | def testRelativeModuleMember(self):
    method testRelativeModuleMemberMixed (line 232) | def testRelativeModuleMemberMixed(self):
    method testRelativeUpLevel (line 240) | def testRelativeUpLevel(self):
    method testRelativeUpLevelMember (line 246) | def testRelativeUpLevelMember(self):
    method _check_imports (line 252) | def _check_imports(self, stmt, want):
    method _assert_imports_equal (line 256) | def _assert_imports_equal(self, want, got):
    method _materialize_tree (line 260) | def _materialize_tree(self, dirname, spec):
  class MakeFutureFeaturesTest (line 271) | class MakeFutureFeaturesTest(unittest.TestCase):
    method testImportFromFuture (line 273) | def testImportFromFuture(self):
    method testImportFromFutureParseError (line 289) | def testImportFromFutureParseError(self):
  class ParseFutureFeaturesTest (line 308) | class ParseFutureFeaturesTest(unittest.TestCase):
    method testFutureFeatures (line 310) | def testFutureFeatures(self):
    method testUnimplementedFutureRaises (line 341) | def testUnimplementedFutureRaises(self):
    method testUndefinedFutureRaises (line 347) | def testUndefinedFutureRaises(self):

FILE: compiler/shard_test.py
  class _ShardAction (line 26) | class _ShardAction(argparse.Action):
    method __call__ (line 28) | def __call__(self, parser, args, values, option_string=None):
  class _ShardTestLoader (line 39) | class _ShardTestLoader(unittest.TestLoader):
    method __init__ (line 41) | def __init__(self, shard, count):
    method getTestCaseNames (line 46) | def getTestCaseNames(self, test_case_cls):
  class _ShardTestRunner (line 57) | class _ShardTestRunner(object):
    method run (line 59) | def run(self, test):
  function main (line 69) | def main():

FILE: compiler/stmt.py
  class StatementVisitor (line 46) | class StatementVisitor(algorithm.Visitor):
    method __init__ (line 51) | def __init__(self, block_, future_node=None):
    method generic_visit (line 57) | def generic_visit(self, node):
    method visit_expr (line 61) | def visit_expr(self, node):
    method visit_Assert (line 64) | def visit_Assert(self, node):
    method visit_AugAssign (line 72) | def visit_AugAssign(self, node):
    method visit_Assign (line 86) | def visit_Assign(self, node):
    method visit_Break (line 92) | def visit_Break(self, node):
    method visit_ClassDef (line 100) | def visit_ClassDef(self, node):
    method visit_Continue (line 167) | def visit_Continue(self, node):
    method visit_Delete (line 173) | def visit_Delete(self, node):
    method visit_Expr (line 192) | def visit_Expr(self, node):
    method visit_For (line 196) | def visit_For(self, node):
    method visit_FunctionDef (line 219) | def visit_FunctionDef(self, node):
    method visit_Global (line 231) | def visit_Global(self, node):
    method visit_If (line 234) | def visit_If(self, node):
    method visit_Import (line 275) | def visit_Import(self, node):
    method visit_ImportFrom (line 280) | def visit_ImportFrom(self, node):
    method visit_Module (line 289) | def visit_Module(self, node):
    method visit_Pass (line 292) | def visit_Pass(self, node):
    method visit_Print (line 295) | def visit_Print(self, node):
    method visit_Raise (line 308) | def visit_Raise(self, node):
    method visit_Return (line 321) | def visit_Return(self, node):
    method visit_Try (line 333) | def visit_Try(self, node):
    method visit_While (line 412) | def visit_While(self, node):
    method visit_With (line 420) | def visit_With(self, node):
    method visit_function_inline (line 496) | def visit_function_inline(self, node):
    method _assign_target (line 583) | def _assign_target(self, target, value):
    method _build_assign_target (line 600) | def _build_assign_target(self, target, assigns):
    method _import_and_bind (line 612) | def _import_and_bind(self, imp):
    method _tie_target (line 642) | def _tie_target(self, target, value):
    method _visit_each (line 655) | def _visit_each(self, nodes):
    method _visit_loop (line 659) | def _visit_loop(self, testfunc, node):
    method _write_except_block (line 697) | def _write_except_block(self, label, exc, except_node):
    method _write_except_dispatcher (line 706) | def _write_except_dispatcher(self, exc, tb, handlers):
    method _write_py_context (line 745) | def _write_py_context(self, lineno):

FILE: compiler/stmt_test.py
  class StatementVisitorTest (line 35) | class StatementVisitorTest(unittest.TestCase):
    method testAssertNoMsg (line 37) | def testAssertNoMsg(self):
    method testAssertMsg (line 44) | def testAssertMsg(self):
    method testBareAssert (line 52) | def testBareAssert(self):
    method testAssignAttribute (line 66) | def testAssignAttribute(self):
    method testAssignName (line 72) | def testAssignName(self):
    method testAssignMultiple (line 77) | def testAssignMultiple(self):
    method testAssignSubscript (line 82) | def testAssignSubscript(self):
    method testAssignTuple (line 88) | def testAssignTuple(self):
    method testAugAssign (line 94) | def testAugAssign(self):
    method testAugAssignBitAnd (line 100) | def testAugAssignBitAnd(self):
    method testAugAssignPow (line 106) | def testAugAssignPow(self):
    method testClassDef (line 112) | def testClassDef(self):
    method testClassDefWithVar (line 118) | def testClassDefWithVar(self):
    method testDeleteAttribute (line 124) | def testDeleteAttribute(self):
    method testDeleteClassLocal (line 131) | def testDeleteClassLocal(self):
    method testDeleteGlobal (line 138) | def testDeleteGlobal(self):
    method testDeleteLocal (line 144) | def testDeleteLocal(self):
    method testDeleteNonexistentLocal (line 156) | def testDeleteNonexistentLocal(self):
    method testDeleteSubscript (line 161) | def testDeleteSubscript(self):
    method testExprCall (line 167) | def testExprCall(self):
    method testExprNameGlobal (line 173) | def testExprNameGlobal(self):
    method testExprNameLocal (line 178) | def testExprNameLocal(self):
    method testFor (line 185) | def testFor(self):
    method testForBreak (line 190) | def testForBreak(self):
    method testForContinue (line 196) | def testForContinue(self):
    method testForElse (line 203) | def testForElse(self):
    method testForElseBreakNotNested (line 210) | def testForElseBreakNotNested(self):
    method testForElseContinueNotNested (line 215) | def testForElseContinueNotNested(self):
    method testFunctionDecorator (line 220) | def testFunctionDecorator(self):
    method testFunctionDecoratorWithArg (line 229) | def testFunctionDecoratorWithArg(self):
    method testFunctionDef (line 240) | def testFunctionDef(self):
    method testFunctionDefGenerator (line 246) | def testFunctionDefGenerator(self):
    method testFunctionDefGeneratorReturnValue (line 253) | def testFunctionDefGeneratorReturnValue(self):
    method testFunctionDefLocal (line 258) | def testFunctionDefLocal(self):
    method testIf (line 266) | def testIf(self):
    method testIfElif (line 273) | def testIfElif(self):
    method testIfElse (line 284) | def testIfElse(self):
    method testImport (line 295) | def testImport(self):
    method testImportFutureLateRaises (line 300) | def testImportFutureLateRaises(self):
    method testFutureUnicodeLiterals (line 305) | def testFutureUnicodeLiterals(self):
    method testImportMember (line 311) | def testImportMember(self):
    method testImportConflictingPackage (line 316) | def testImportConflictingPackage(self):
    method testImportNative (line 321) | def testImportNative(self):
    method testImportGrumpy (line 326) | def testImportGrumpy(self):
    method testImportNativeType (line 331) | def testImportNativeType(self):
    method testImportWildcardMemberRaises (line 336) | def testImportWildcardMemberRaises(self):
    method testPrintStatement (line 343) | def testPrintStatement(self):
    method testPrintFunction (line 349) | def testPrintFunction(self):
    method testRaiseExitStatus (line 360) | def testRaiseExitStatus(self):
    method testRaiseInstance (line 363) | def testRaiseInstance(self):
    method testRaiseTypeAndArg (line 371) | def testRaiseTypeAndArg(self):
    method testRaiseAgain (line 379) | def testRaiseAgain(self):
    method testRaiseTraceback (line 389) | def testRaiseTraceback(self):
    method testReturn (line 403) | def testReturn(self):
    method testTryBareExcept (line 409) | def testTryBareExcept(self):
    method testTryElse (line 416) | def testTryElse(self):
    method testTryMultipleExcept (line 425) | def testTryMultipleExcept(self):
    method testTryFinally (line 436) | def testTryFinally(self):
    method testWhile (line 451) | def testWhile(self):
    method testWhileElse (line 458) | def testWhileElse(self):
    method testWith (line 465) | def testWith(self):
    method testWithAs (line 488) | def testWithAs(self):
    method testWriteExceptDispatcherBareExcept (line 500) | def testWriteExceptDispatcherBareExcept(self):
    method testWriteExceptDispatcherBareExceptionNotLast (line 510) | def testWriteExceptDispatcherBareExceptionNotLast(self):
    method testWriteExceptDispatcherMultipleExcept (line 518) | def testWriteExceptDispatcherMultipleExcept(self):
  function _MakeModuleBlock (line 531) | def _MakeModuleBlock():
  function _ParseAndVisit (line 536) | def _ParseAndVisit(source):
  function _GrumpRun (line 547) | def _GrumpRun(cmd):

FILE: compiler/util.py
  class CompileError (line 38) | class CompileError(Exception):
    method __init__ (line 40) | def __init__(self, node, msg):
  class ParseError (line 46) | class ParseError(CompileError):
  class ImportError (line 50) | class ImportError(CompileError):  # pylint: disable=redefined-builtin
  class LateFutureError (line 54) | class LateFutureError(ImportError):
    method __init__ (line 56) | def __init__(self, node):
  class Writer (line 61) | class Writer(object):
    method __init__ (line 64) | def __init__(self, out=None):
    method getvalue (line 68) | def getvalue(self):
    method indent_block (line 72) | def indent_block(self, n=1):
    method write (line 78) | def write(self, output):
    method write_block (line 83) | def write_block(self, block_, body):
    method write_label (line 103) | def write_label(self, label):
    method write_py_context (line 107) | def write_py_context(self, lineno, line):
    method write_tmpl (line 110) | def write_tmpl(self, tmpl, **kwargs):
    method write_checked_call2 (line 113) | def write_checked_call2(self, result, call, *args, **kwargs):
    method write_checked_call1 (line 119) | def write_checked_call1(self, call, *args, **kwargs):
    method write_temp_decls (line 125) | def write_temp_decls(self, block_):
    method indent (line 130) | def indent(self, n=1):
    method dedent (line 133) | def dedent(self, n=1):
  function go_str (line 137) | def go_str(value):
  function adjust_local_name (line 152) | def adjust_local_name(name):

FILE: compiler/util_test.py
  class WriterTest (line 28) | class WriterTest(unittest.TestCase):
    method testIndentBlock (line 30) | def testIndentBlock(self):
    method testWriteBlock (line 38) | def testWriteBlock(self):
    method testWriteMultiline (line 47) | def testWriteMultiline(self):
    method testWritePyContext (line 53) | def testWritePyContext(self):
    method testWriteSkipBlankLine (line 58) | def testWriteSkipBlankLine(self):
    method testWriteTmpl (line 63) | def testWriteTmpl(self):
    method testIndent (line 68) | def testIndent(self):
    method testDedent (line 74) | def testDedent(self):

FILE: lib/_random.py
  function _gorandom (line 31) | def _gorandom(nbytes):
  function _int_bit_length (line 45) | def _int_bit_length(n):
  function _int_from_bytes (line 54) | def _int_from_bytes(bytes):
  class GrumpyRandom (line 63) | class GrumpyRandom(object):
    method random (line 70) | def random(self):
    method getrandbits (line 74) | def getrandbits(self, k):
    method seed (line 84) | def seed(self, a=None):
    method _randbelow (line 90) | def _randbelow(self, n):
    method getstate (line 101) | def getstate(self, *args, **kwargs):
    method setstate (line 104) | def setstate(self, *args, **kwargs):
    method jumpahead (line 107) | def jumpahead(self, *args, **kwargs):

FILE: lib/_syscall.py
  function invoke (line 18) | def invoke(func, *args):

FILE: lib/itertools.py
  class chain (line 20) | class chain(object):
    method from_iterable (line 22) | def from_iterable(cls, iterables):
    method __init__ (line 29) | def __init__(self, *iterables):
    method __iter__ (line 36) | def __iter__(self):
    method next (line 39) | def next(self):
  function compress (line 50) | def compress(data, selectors):
  function count (line 54) | def count(start=0, step=1):
  function cycle (line 61) | def cycle(iterable):
  function dropwhile (line 71) | def dropwhile(predicate, iterable):
  class groupby (line 81) | class groupby(object):
    method __init__ (line 84) | def __init__(self, iterable, key=None):
    method __iter__ (line 91) | def __iter__(self):
    method next (line 94) | def next(self):
    method _grouper (line 101) | def _grouper(self, tgtkey):
  function ifilter (line 108) | def ifilter(predicate, iterable):
  function ifilterfalse (line 116) | def ifilterfalse(predicate, iterable):
  function imap (line 124) | def imap(function, *iterables):
  function islice (line 134) | def islice(iterable, *args):
  function izip (line 144) | def izip(*iterables):
  class ZipExhausted (line 150) | class ZipExhausted(Exception):
  function izip_longest (line 154) | def izip_longest(*args, **kwds):
  function product (line 172) | def product(*args, **kwds):
  function permutations (line 183) | def permutations(iterable, r=None):
  function combinations (line 192) | def combinations(iterable, r):
  function combinations_with_replacement (line 200) | def combinations_with_replacement(iterable, r):
  function repeat (line 208) | def repeat(object, times=None):
  function starmap (line 217) | def starmap(function, iterable):
  function takewhile (line 222) | def takewhile(predicate, iterable):
  function tee (line 230) | def tee(iterable, n=2):

FILE: lib/itertools_test.py
  function TestCycle (line 19) | def TestCycle():
  function TestDropwhile (line 39) | def TestDropwhile():
  function TestChain (line 51) | def TestChain():
  function TestFromIterable (line 63) | def TestFromIterable():
  function TestIFilter (line 75) | def TestIFilter():
  function TestIFilterFalse (line 88) | def TestIFilterFalse():
  function TestISlice (line 101) | def TestISlice():
  function TestIZipLongest (line 113) | def TestIZipLongest():
  function TestProduct (line 124) | def TestProduct():
  function TestPermutations (line 135) | def TestPermutations():
  function TestCombinations (line 149) | def TestCombinations():
  function TestCombinationsWithReplacement (line 158) | def TestCombinationsWithReplacement():
  function TestGroupBy (line 170) | def TestGroupBy():
  function TestTakewhile (line 180) | def TestTakewhile():

FILE: lib/math.py
  function ceil (line 30) | def ceil(x):
  function copysign (line 34) | def copysign(x, y):
  function fabs (line 38) | def fabs(x):
  function factorial (line 42) | def factorial(x):
  function floor (line 77) | def floor(x):
  function fmod (line 81) | def fmod(x):
  function frexp (line 85) | def frexp(x):
  function isinf (line 94) | def isinf(x):
  function isnan (line 98) | def isnan(x):
  function ldexp (line 102) | def ldexp(x, i):
  function modf (line 106) | def modf(x):
  function trunc (line 112) | def trunc(x):
  function exp (line 118) | def exp(x):
  function expm1 (line 122) | def expm1(x):
  function log (line 126) | def log(x, b=None):
  function log1p (line 135) | def log1p(x):
  function log10 (line 139) | def log10(x):
  function pow (line 143) | def pow(x, y):
  function sqrt (line 147) | def sqrt(x):
  function acos (line 153) | def acos(x):
  function asin (line 157) | def asin(x):
  function atan (line 161) | def atan(x):
  function atan2 (line 165) | def atan2(y, x):
  function cos (line 169) | def cos(x):
  function hypot (line 173) | def hypot(x, y):
  function sin (line 177) | def sin(x):
  function tan (line 181) | def tan(x):
  function degrees (line 187) | def degrees(x):
  function radians (line 191) | def radians(x):
  function acosh (line 197) | def acosh(x):
  function asinh (line 201) | def asinh(x):
  function atanh (line 205) | def atanh(x):
  function cosh (line 209) | def cosh(x):
  function sinh (line 213) | def sinh(x):
  function tanh (line 217) | def tanh(x):
  function erf (line 223) | def erf(x):
  function erfc (line 227) | def erfc(x):
  function gamma (line 231) | def gamma(x):
  function lgamma (line 235) | def lgamma(x):

FILE: lib/math_test.py
  function TestFactorial (line 23) | def TestFactorial():
  function TestFactorialError (line 32) | def TestFactorialError():
  function TestLdexp (line 48) | def TestLdexp():
  function TestLog (line 55) | def TestLog():
  function TestRadians (line 62) | def TestRadians():
  function TestDegrees (line 67) | def TestDegrees():

FILE: lib/os/__init__.py
  function mkdir (line 48) | def mkdir(path, mode=0o777):
  function chdir (line 54) | def chdir(path):
  function chmod (line 60) | def chmod(filepath, mode):
  function close (line 67) | def close(fd):
  function fdopen (line 73) | def fdopen(fd, mode='r'):  # pylint: disable=unused-argument
  function listdir (line 81) | def listdir(p):
  function getcwd (line 88) | def getcwd():
  class _Popen (line 95) | class _Popen(object):
    method __init__ (line 97) | def __init__(self, command, mode):
    method _thread_func (line 132) | def _thread_func(self):
    method close (line 138) | def close(self, _):
  function popen (line 148) | def popen(command, mode='r'):
  function remove (line 152) | def remove(filepath):
  function rmdir (line 160) | def rmdir(filepath):
  class StatResult (line 168) | class StatResult(object):
    method __init__ (line 170) | def __init__(self, info):
    method st_mode (line 173) | def st_mode(self):
    method st_mtime (line 179) | def st_mtime(self):
    method st_size (line 184) | def st_size(self):
  function stat (line 190) | def stat(filepath):
  function waitpid (line 200) | def waitpid(pid, options):
  function _encode_wait_result (line 206) | def _encode_wait_result(status):

FILE: lib/os/path.py
  function abspath (line 21) | def abspath(path):
  function basename (line 32) | def basename(path):
  function exists (line 36) | def exists(path):
  function isdir (line 41) | def isdir(path):
  function isfile (line 48) | def isfile(path):
  function join (line 60) | def join(*paths):
  function normpath (line 75) | def normpath(path):
  function split (line 82) | def split(path):

FILE: lib/os/path_test.py
  function _AssertEqual (line 25) | def _AssertEqual(a, b):
  function TestAbspath (line 30) | def TestAbspath():
  function TestBasename (line 38) | def TestBasename():
  function TestDirname (line 43) | def TestDirname():
  function TestExists (line 48) | def TestExists():
  function TestIsAbs (line 60) | def TestIsAbs():
  function TestIsDir (line 65) | def TestIsDir():
  function TestIsFile (line 77) | def TestIsFile():
  function TestJoin (line 89) | def TestJoin():
  function TestNormPath (line 105) | def TestNormPath():
  function TestSplit (line 118) | def TestSplit():

FILE: lib/os_test.py
  function TestChdirAndGetCwd (line 23) | def TestChdirAndGetCwd():
  function TestChmod (line 37) | def TestChmod():
  function TestChmodOSError (line 46) | def TestChmodOSError():
  function TestClose (line 56) | def TestClose():
  function TestCloseOSError (line 67) | def TestCloseOSError():
  function TestEnviron (line 78) | def TestEnviron():
  function TestFDOpen (line 82) | def TestFDOpen():
  function TestFDOpenOSError (line 93) | def TestFDOpenOSError():
  function TestMkdir (line 104) | def TestMkdir():
  function TestPopenRead (line 121) | def TestPopenRead():
  function TestPopenWrite (line 131) | def TestPopenWrite():
  function TestRemove (line 139) | def TestRemove():
  function TestRemoveNoExist (line 152) | def TestRemoveNoExist():
  function TestRemoveDir (line 164) | def TestRemoveDir():
  function TestRmDir (line 176) | def TestRmDir():
  function TestRmDirNoExist (line 188) | def TestRmDirNoExist():
  function TestRmDirFile (line 200) | def TestRmDirFile():
  function TestStatFile (line 213) | def TestStatFile():
  function TestStatDir (line 226) | def TestStatDir():
  function TestStatNoExist (line 234) | def TestStatNoExist():
  function TestWaitPid (line 246) | def TestWaitPid():

FILE: lib/random_test.py
  function TestGrumpyRandom (line 21) | def TestGrumpyRandom():
  function TestSeed (line 46) | def TestSeed():
  function TestRandom (line 56) | def TestRandom():
  function TestRandomUniform (line 65) | def TestRandomUniform():
  function TestRandomInt (line 72) | def TestRandomInt():
  function TestRandomChoice (line 96) | def TestRandomChoice():

FILE: lib/select_.py
  class error (line 25) | class error(Exception):
  function select (line 29) | def select(rlist, wlist, xlist, timeout=None):
  function _fdset_set (line 56) | def _fdset_set(fd, fds):
  function _fdset_isset (line 62) | def _fdset_isset(fd, fds):
  function _make_fdset (line 68) | def _make_fdset(fd_list):
  function _normalize_fd_list (line 75) | def _normalize_fd_list(fds):

FILE: lib/stat.py
  function S_ISDIR (line 21) | def S_ISDIR(mode):  # pylint: disable=invalid-name
  function S_IMODE (line 25) | def S_IMODE(mode):  # pylint: disable=invalid-name

FILE: lib/sys.py
  class _Flags (line 37) | class _Flags(object):
  function exc_clear (line 60) | def exc_clear():
  function exc_info (line 64) | def exc_info():
  function exit (line 72) | def exit(code=None):  # pylint: disable=redefined-builtin
  function _getframe (line 76) | def _getframe(depth=0):

FILE: lib/sys_test.py
  function TestArgv (line 23) | def TestArgv():
  function TestMaxInt (line 27) | def TestMaxInt():
  function TestSysModules (line 31) | def TestSysModules():
  function TestExcClear (line 35) | def TestExcClear():
  function TestExcInfoNoException (line 46) | def TestExcInfoNoException():
  function TestExcInfoWithException (line 50) | def TestExcInfoWithException():
  function TestExitEmpty (line 62) | def TestExitEmpty():
  function TestExitCode (line 71) | def TestExitCode():
  function TestExitInvalidArgs (line 80) | def TestExitInvalidArgs():
  function TestGetFrame (line 89) | def TestGetFrame():

FILE: lib/tempfile.py
  function mkdtemp (line 23) | def mkdtemp(suffix='', prefix='tmp', dir=None):
  function mkstemp (line 33) | def mkstemp(suffix='', prefix='tmp', dir=None, text=False):

FILE: lib/tempfile_test.py
  function TestMkdTemp (line 22) | def TestMkdTemp():
  function TestMkdTempDir (line 30) | def TestMkdTempDir():
  function TestMkdTempOSError (line 38) | def TestMkdTempOSError():
  function TestMkdTempPrefixSuffix (line 50) | def TestMkdTempPrefixSuffix():
  function TestMksTemp (line 58) | def TestMksTemp():
  function TestMksTempDir (line 70) | def TestMksTempDir():
  function TestMksTempOSError (line 79) | def TestMksTempOSError():
  function TestMksTempPerms (line 91) | def TestMksTempPerms():
  function TestMksTempPrefixSuffix (line 99) | def TestMksTempPrefixSuffix():

FILE: lib/thread.py
  class error (line 4) | class error(Exception):
  function get_ident (line 8) | def get_ident():
  class LockType (line 15) | class LockType(object):
    method __init__ (line 16) | def __init__(self):
    method acquire (line 19) | def acquire(self, waitflag=1):
    method release (line 25) | def release(self):
    method __enter__ (line 28) | def __enter__(self):
    method __exit__ (line 31) | def __exit__(self, *args):
  function allocate_lock (line 35) | def allocate_lock():
  function start_new_thread (line 40) | def start_new_thread(func, args, kwargs=None):
  function stack_size (line 55) | def stack_size(n=0):
  function _count (line 61) | def _count():

FILE: lib/time.py
  class struct_time (line 48) | class struct_time(tuple):  #pylint: disable=invalid-name,missing-docstring
    method __init__ (line 50) | def __init__(self, args):
    method __repr__ (line 62) | def __repr__(self):
    method __str__ (line 67) | def __str__(self):
  function gmtime (line 71) | def gmtime(seconds=None):
  function localtime (line 77) | def localtime(seconds=None):
  function mktime (line 83) | def mktime(t):
  function sleep (line 87) | def sleep(secs):
  function time (line 91) | def time():
  function strftime (line 95) | def strftime(format, tt=None):  # pylint: disable=missing-docstring,rede...

FILE: lib/weetest.py
  class _Benchmark (line 45) | class _Benchmark(object):
    method __init__ (line 48) | def __init__(self, bench_func, target_duration):
    method Run (line 55) | def Run(self):
    method _RunOnce (line 75) | def _RunOnce(self):
    method ResetTimer (line 80) | def ResetTimer(self):
  class _TestResult (line 85) | class _TestResult(object):
    method __init__ (line 88) | def __init__(self, name):
  function _RunOneBenchmark (line 95) | def _RunOneBenchmark(name, test_func):
  function _RunOneTest (line 117) | def _RunOneTest(name, test_func):
  function _WriteXmlFile (line 138) | def _WriteXmlFile(filename, suite_duration, results):
  function _RunAll (line 164) | def _RunAll(test_prefix, runner):
  function RunBenchmarks (line 183) | def RunBenchmarks():
  function RunTests (line 188) | def RunTests():

FILE: lib/weetest_test.py
  class _Timer (line 23) | class _Timer(object):
    method __init__ (line 25) | def __init__(self):
    method Reset (line 28) | def Reset(self):
    method time (line 31) | def time(self):  # pylint: disable=invalid-name
  function TestBenchmark (line 40) | def TestBenchmark():
  function TestBenchmarkResetTimer (line 54) | def TestBenchmarkResetTimer():
  function TestRunOneBenchmark (line 70) | def TestRunOneBenchmark():
  function TestRunOneBenchmarkError (line 85) | def TestRunOneBenchmarkError():
  function TestRunOneTest (line 92) | def TestRunOneTest():
  function TestWriteXmlFile (line 109) | def TestWriteXmlFile():
  function TestRunAll (line 134) | def TestRunAll():

FILE: runtime/baseexception.go
  type BaseException (line 22) | type BaseException struct
    method ToObject (line 32) | func (e *BaseException) ToObject() *Object {
  function toBaseExceptionUnsafe (line 27) | func toBaseExceptionUnsafe(o *Object) *BaseException {
  function baseExceptionInit (line 39) | func baseExceptionInit(f *Frame, o *Object, args Args, kwargs KWArgs) (*...
  function baseExceptionRepr (line 45) | func baseExceptionRepr(f *Frame, o *Object) (*Object, *BaseException) {
  function baseExceptionStr (line 58) | func baseExceptionStr(f *Frame, o *Object) (*Object, *BaseException) {
  function initBaseExceptionType (line 71) | func initBaseExceptionType(map[string]*Object) {

FILE: runtime/baseexception_test.go
  function TestBaseExceptionCreate (line 21) | func TestBaseExceptionCreate(t *testing.T) {
  function TestBaseExceptionInitRaise (line 42) | func TestBaseExceptionInitRaise(t *testing.T) {
  function TestBaseExceptionRepr (line 52) | func TestBaseExceptionRepr(t *testing.T) {
  function TestBaseExceptionStr (line 69) | func TestBaseExceptionStr(t *testing.T) {

FILE: runtime/basestring.go
  constant EncodeDefault (line 23) | EncodeDefault = "utf8"
  constant EncodeStrict (line 29) | EncodeStrict = "strict"
  constant EncodeReplace (line 31) | EncodeReplace = "replace"
  constant EncodeIgnore (line 33) | EncodeIgnore = "ignore"
  function initBaseStringType (line 50) | func initBaseStringType(map[string]*Object) {
  function normalizeEncoding (line 54) | func normalizeEncoding(encoding string) string {
  function escapeRune (line 58) | func escapeRune(r rune) []byte {

FILE: runtime/basestring_test.go
  function TestNormalizeEncoding (line 21) | func TestNormalizeEncoding(t *testing.T) {
  function BenchmarkEscapeRune (line 39) | func BenchmarkEscapeRune(b *testing.B) {

FILE: runtime/bool.go
  function GetBool (line 23) | func GetBool(v bool) *Int {
  function boolNative (line 33) | func boolNative(_ *Frame, o *Object) (reflect.Value, *BaseException) {
  function boolNew (line 37) | func boolNew(f *Frame, _ *Type, args Args, _ KWArgs) (*Object, *BaseExce...
  function boolRepr (line 52) | func boolRepr(_ *Frame, o *Object) (*Object, *BaseException) {
  function initBoolType (line 60) | func initBoolType(map[string]*Object) {

FILE: runtime/bool_test.go
  function TestBoolCompare (line 21) | func TestBoolCompare(t *testing.T) {
  function TestBoolCreate (line 37) | func TestBoolCreate(t *testing.T) {
  function TestBoolStrRepr (line 55) | func TestBoolStrRepr(t *testing.T) {

FILE: runtime/builtin_types.go
  function ellipsisRepr (line 53) | func ellipsisRepr(*Frame, *Object) (*Object, *BaseException) {
  function noneRepr (line 57) | func noneRepr(*Frame, *Object) (*Object, *BaseException) {
  function notImplementedRepr (line 61) | func notImplementedRepr(*Frame, *Object) (*Object, *BaseException) {
  function initEllipsisType (line 65) | func initEllipsisType(map[string]*Object) {
  function initNoneType (line 70) | func initNoneType(map[string]*Object) {
  function initNotImplementedType (line 75) | func initNotImplementedType(map[string]*Object) {
  function initUnboundLocalType (line 80) | func initUnboundLocalType(map[string]*Object) {
  type typeState (line 84) | type typeState
  constant typeStateNotReady (line 87) | typeStateNotReady typeState = iota
  constant typeStateInitializing (line 88) | typeStateInitializing
  constant typeStateReady (line 89) | typeStateReady
  type builtinTypeInit (line 92) | type builtinTypeInit
  type builtinTypeInfo (line 94) | type builtinTypeInfo struct
  function initBuiltinType (line 193) | func initBuiltinType(typ *Type, info *builtinTypeInfo) {
  function builtinAbs (line 215) | func builtinAbs(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
  function builtinMapFn (line 222) | func builtinMapFn(f *Frame, args Args, _ KWArgs) (*Object, *BaseExceptio...
  function builtinAll (line 251) | func builtinAll(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
  function builtinAny (line 269) | func builtinAny(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
  function builtinBin (line 287) | func builtinBin(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
  function builtinCallable (line 302) | func builtinCallable(f *Frame, args Args, _ KWArgs) (*Object, *BaseExcep...
  function builtinChr (line 313) | func builtinChr(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
  function builtinCmp (line 324) | func builtinCmp(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
  function builtinDelAttr (line 331) | func builtinDelAttr(f *Frame, args Args, _ KWArgs) (*Object, *BaseExcept...
  function builtinDir (line 338) | func builtinDir(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseExcep...
  function builtinDivMod (line 374) | func builtinDivMod(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseEx...
  function builtinFrame (line 381) | func builtinFrame(f *Frame, args Args, _ KWArgs) (*Object, *BaseExceptio...
  function builtinGetAttr (line 389) | func builtinGetAttr(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseE...
  function builtinGlobals (line 405) | func builtinGlobals(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseE...
  function builtinHasAttr (line 412) | func builtinHasAttr(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseE...
  function builtinHash (line 426) | func builtinHash(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseExce...
  function builtinHex (line 437) | func builtinHex(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
  function builtinID (line 445) | func builtinID(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseExcept...
  function builtinIsInstance (line 452) | func builtinIsInstance(f *Frame, args Args, kwargs KWArgs) (*Object, *Ba...
  function builtinIsSubclass (line 463) | func builtinIsSubclass(f *Frame, args Args, kwargs KWArgs) (*Object, *Ba...
  function builtinIter (line 474) | func builtinIter(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseExce...
  function builtinLen (line 481) | func builtinLen(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseExcep...
  function builtinMax (line 492) | func builtinMax(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseExcep...
  function builtinMin (line 496) | func builtinMin(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseExcep...
  function builtinNext (line 500) | func builtinNext(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseExce...
  function builtinOct (line 514) | func builtinOct(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
  function builtinOpen (line 522) | func builtinOpen(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseExce...
  function builtinOrd (line 526) | func builtinOrd(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
  function builtinPrint (line 549) | func builtinPrint(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseExc...
  function builtinRange (line 576) | func builtinRange(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseExc...
  function builtinRawInput (line 584) | func builtinRawInput(f *Frame, args Args, kwargs KWArgs) (*Object, *Base...
  function builtinRepr (line 615) | func builtinRepr(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseExce...
  function builtinRound (line 626) | func builtinRound(f *Frame, args Args, _ KWArgs) (*Object, *BaseExceptio...
  function builtinSetAttr (line 665) | func builtinSetAttr(f *Frame, args Args, _ KWArgs) (*Object, *BaseExcept...
  function builtinSorted (line 672) | func builtinSorted(f *Frame, args Args, _ KWArgs) (*Object, *BaseExcepti...
  function builtinSum (line 685) | func builtinSum(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
  function builtinUniChr (line 714) | func builtinUniChr(f *Frame, args Args, _ KWArgs) (*Object, *BaseExcepti...
  function builtinZip (line 725) | func builtinZip(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
  function init (line 755) | func init() {
  function builtinMinMax (line 822) | func builtinMinMax(f *Frame, doMax bool, args Args, kwargs KWArgs) (*Obj...
  function numberToBase (line 885) | func numberToBase(prefix string, base int, o *Object) string {
  function initIters (line 905) | func initIters(f *Frame, items []*Object) ([]*Object, *BaseException) {
  function zipLongest (line 921) | func zipLongest(f *Frame, args Args) ([][]*Object, *BaseException) {

FILE: runtime/builtin_types_test.go
  function TestBuiltinDelAttr (line 26) | func TestBuiltinDelAttr(t *testing.T) {
  function TestBuiltinFuncs (line 54) | func TestBuiltinFuncs(t *testing.T) {
  function TestBuiltinGlobals (line 367) | func TestBuiltinGlobals(t *testing.T) {
  function TestEllipsisRepr (line 381) | func TestEllipsisRepr(t *testing.T) {
  function TestNoneRepr (line 388) | func TestNoneRepr(t *testing.T) {
  function TestNotImplementedRepr (line 395) | func TestNotImplementedRepr(t *testing.T) {
  function captureStdout (line 404) | func captureStdout(f *Frame, fn func() *BaseException) (string, *BaseExc...
  function TestBuiltinSetAttr (line 455) | func TestBuiltinSetAttr(t *testing.T) {
  function newTestIndexObject (line 540) | func newTestIndexObject(index int) *Object {

FILE: runtime/bytearray.go
  type ByteArray (line 30) | type ByteArray struct
    method ToObject (line 41) | func (a *ByteArray) ToObject() *Object {
    method Value (line 46) | func (a *ByteArray) Value() []byte {
  function toByteArrayUnsafe (line 36) | func toByteArrayUnsafe(o *Object) *ByteArray {
  function byteArrayEq (line 50) | func byteArrayEq(f *Frame, v, w *Object) (*Object, *BaseException) {
  function byteArrayGE (line 54) | func byteArrayGE(f *Frame, v, w *Object) (*Object, *BaseException) {
  function byteArrayGetItem (line 58) | func byteArrayGetItem(f *Frame, o, key *Object) (result *Object, raised ...
  function byteArrayGT (line 96) | func byteArrayGT(f *Frame, v, w *Object) (*Object, *BaseException) {
  function byteArrayInit (line 100) | func byteArrayInit(f *Frame, o *Object, args Args, _ KWArgs) (*Object, *...
  function byteArrayLE (line 111) | func byteArrayLE(f *Frame, v, w *Object) (*Object, *BaseException) {
  function byteArrayLT (line 115) | func byteArrayLT(f *Frame, v, w *Object) (*Object, *BaseException) {
  function byteArrayNative (line 119) | func byteArrayNative(f *Frame, o *Object) (reflect.Value, *BaseException) {
  function byteArrayNE (line 127) | func byteArrayNE(f *Frame, v, w *Object) (*Object, *BaseException) {
  function byteArrayRepr (line 131) | func byteArrayRepr(f *Frame, o *Object) (*Object, *BaseException) {
  function byteArrayStr (line 142) | func byteArrayStr(f *Frame, o *Object) (*Object, *BaseException) {
  function initByteArrayType (line 150) | func initByteArrayType(dict map[string]*Object) {
  function byteArrayCompare (line 164) | func byteArrayCompare(v, w *Object, ltResult, eqResult, gtResult *Int) *...

FILE: runtime/bytearray_test.go
  function TestByteArrayCompare (line 21) | func TestByteArrayCompare(t *testing.T) {
  function TestByteArrayGetItem (line 41) | func TestByteArrayGetItem(t *testing.T) {
  function TestByteArrayInit (line 69) | func TestByteArrayInit(t *testing.T) {
  function TestByteArrayNative (line 81) | func TestByteArrayNative(t *testing.T) {
  function TestByteArrayRepr (line 92) | func TestByteArrayRepr(t *testing.T) {
  function TestByteArrayStr (line 104) | func TestByteArrayStr(t *testing.T) {
  function newTestByteArray (line 116) | func newTestByteArray(s string) *ByteArray {

FILE: runtime/code.go
  type CodeFlag (line 25) | type CodeFlag
  constant CodeFlagVarArg (line 29) | CodeFlagVarArg CodeFlag = 4
  constant CodeFlagKWArg (line 31) | CodeFlagKWArg CodeFlag = 8
  type Code (line 35) | type Code struct
    method Eval (line 57) | func (c *Code) Eval(f *Frame, globals *Dict, args Args, kwargs KWArgs)...
  function NewCode (line 47) | func NewCode(name, filename string, params []Param, flags CodeFlag, fn f...
  function toCodeUnsafe (line 52) | func toCodeUnsafe(o *Object) *Code {

FILE: runtime/code_test.go
  function TestXxx (line 21) | func TestXxx(t *testing.T) {
  function TestNewCodeKeywordsCheck (line 24) | func TestNewCodeKeywordsCheck(t *testing.T) {
  function TestNewCode (line 37) | func TestNewCode(t *testing.T) {
  function TestCodeEvalRestoreExc (line 78) | func TestCodeEvalRestoreExc(t *testing.T) {

FILE: runtime/complex.go
  type Complex (line 32) | type Complex struct
    method ToObject (line 47) | func (c *Complex) ToObject() *Object {
    method Value (line 52) | func (c *Complex) Value() complex128 {
  function NewComplex (line 38) | func NewComplex(value complex128) *Complex {
  function toComplexUnsafe (line 42) | func toComplexUnsafe(o *Object) *Complex {
  function complexAbs (line 56) | func complexAbs(f *Frame, o *Object) (*Object, *BaseException) {
  function complexAdd (line 61) | func complexAdd(f *Frame, v, w *Object) (*Object, *BaseException) {
  function complexCompareNotSupported (line 67) | func complexCompareNotSupported(f *Frame, v, w *Object) (*Object, *BaseE...
  function complexComplex (line 74) | func complexComplex(f *Frame, o *Object) (*Object, *BaseException) {
  function complexDiv (line 78) | func complexDiv(f *Frame, v, w *Object) (*Object, *BaseException) {
  function complexDivMod (line 87) | func complexDivMod(f *Frame, v, w *Object) (*Object, *BaseException) {
  function complexEq (line 96) | func complexEq(f *Frame, v, w *Object) (*Object, *BaseException) {
  function complexFloorDiv (line 104) | func complexFloorDiv(f *Frame, v, w *Object) (*Object, *BaseException) {
  function complexHash (line 113) | func complexHash(f *Frame, o *Object) (*Object, *BaseException) {
  function complexMod (line 122) | func complexMod(f *Frame, v, w *Object) (*Object, *BaseException) {
  function complexMul (line 131) | func complexMul(f *Frame, v, w *Object) (*Object, *BaseException) {
  function complexNE (line 137) | func complexNE(f *Frame, v, w *Object) (*Object, *BaseException) {
  function complexNeg (line 145) | func complexNeg(f *Frame, o *Object) (*Object, *BaseException) {
  function complexNew (line 150) | func complexNew(f *Frame, t *Type, args Args, _ KWArgs) (*Object, *BaseE...
  function complexNonZero (line 212) | func complexNonZero(f *Frame, o *Object) (*Object, *BaseException) {
  function complexPos (line 216) | func complexPos(f *Frame, o *Object) (*Object, *BaseException) {
  function complexPow (line 220) | func complexPow(f *Frame, v, w *Object) (*Object, *BaseException) {
  function complexRAdd (line 226) | func complexRAdd(f *Frame, v, w *Object) (*Object, *BaseException) {
  function complexRDiv (line 232) | func complexRDiv(f *Frame, v, w *Object) (*Object, *BaseException) {
  function complexRDivMod (line 241) | func complexRDivMod(f *Frame, v, w *Object) (*Object, *BaseException) {
  function complexRepr (line 250) | func complexRepr(f *Frame, o *Object) (*Object, *BaseException) {
  function complexRFloorDiv (line 271) | func complexRFloorDiv(f *Frame, v, w *Object) (*Object, *BaseException) {
  function complexRMod (line 280) | func complexRMod(f *Frame, v, w *Object) (*Object, *BaseException) {
  function complexRMul (line 289) | func complexRMul(f *Frame, v, w *Object) (*Object, *BaseException) {
  function complexRPow (line 295) | func complexRPow(f *Frame, v, w *Object) (*Object, *BaseException) {
  function complexRSub (line 301) | func complexRSub(f *Frame, v, w *Object) (*Object, *BaseException) {
  function complexSub (line 307) | func complexSub(f *Frame, v, w *Object) (*Object, *BaseException) {
  function initComplexType (line 313) | func initComplexType(dict map[string]*Object) {
  function complex128Convert (line 346) | func complex128Convert(f *Frame, o *Object) (complex128, *BaseException) {
  function complexArithmeticOp (line 364) | func complexArithmeticOp(f *Frame, method string, v, w *Object, fun func...
  function complexCoerce (line 386) | func complexCoerce(o *Object) (complex128, bool) {
  function complexCompare (line 400) | func complexCompare(v *Complex, w *Object) (bool, bool) {
  function complexConvert (line 409) | func complexConvert(complexSlot *unaryOpSlot, f *Frame, o *Object) (*Com...
  function complexDivModOp (line 421) | func complexDivModOp(f *Frame, method string, v, w *Object, fun func(v, ...
  function complexDivAndModOp (line 436) | func complexDivAndModOp(f *Frame, method string, v, w *Object, fun func(...
  function complexFloorDivOp (line 451) | func complexFloorDivOp(v, w complex128) complex128 {
  function complexModOp (line 455) | func complexModOp(v, w complex128) complex128 {
  constant blank (line 460) | blank = iota
  constant real1 (line 461) | real1
  constant imag1 (line 462) | imag1
  constant real2 (line 463) | real2
  constant sign2 (line 464) | sign2
  constant imag3 (line 465) | imag3
  constant real4 (line 466) | real4
  constant sign5 (line 467) | sign5
  constant onlyJ (line 468) | onlyJ
  function parseComplex (line 476) | func parseComplex(s string) (complex128, error) {
  function unsignNaN (line 530) | func unsignNaN(s string) string {

FILE: runtime/complex_test.go
  function TestComplexAbs (line 25) | func TestComplexAbs(t *testing.T) {
  function TestComplexEq (line 55) | func TestComplexEq(t *testing.T) {
  function TestComplexBinaryOps (line 82) | func TestComplexBinaryOps(t *testing.T) {
  function TestComplexCompareNotSupported (line 216) | func TestComplexCompareNotSupported(t *testing.T) {
  function TestComplexDivMod (line 231) | func TestComplexDivMod(t *testing.T) {
  function TestComplexNE (line 266) | func TestComplexNE(t *testing.T) {
  function TestComplexNew (line 289) | func TestComplexNew(t *testing.T) {
  function TestComplexNonZero (line 394) | func TestComplexNonZero(t *testing.T) {
  function TestComplexPos (line 411) | func TestComplexPos(t *testing.T) {
  function TestComplexRepr (line 430) | func TestComplexRepr(t *testing.T) {
  function TestParseComplex (line 447) | func TestParseComplex(t *testing.T) {
  function TestComplexHash (line 499) | func TestComplexHash(t *testing.T) {
  function floatsAreSame (line 514) | func floatsAreSame(a, b float64) bool {
  function complexesAreSame (line 518) | func complexesAreSame(a, b complex128) bool {
  function tupleComplexesAreSame (line 522) | func tupleComplexesAreSame(got, want *Object) bool {

FILE: runtime/core.go
  function Abs (line 33) | func Abs(f *Frame, o *Object) (*Object, *BaseException) {
  function Add (line 43) | func Add(f *Frame, v, w *Object) (*Object, *BaseException) {
  function And (line 49) | func And(f *Frame, v, w *Object) (*Object, *BaseException) {
  function Assert (line 56) | func Assert(f *Frame, cond *Object, msg *Object) *BaseException {
  function Compare (line 79) | func Compare(f *Frame, v, w *Object) (*Object, *BaseException) {
  function Contains (line 99) | func Contains(f *Frame, seq, value *Object) (bool, *BaseException) {
  function DelAttr (line 132) | func DelAttr(f *Frame, o *Object, name *Str) *BaseException {
  function DelVar (line 142) | func DelVar(f *Frame, namespace *Dict, name *Str) *BaseException {
  function DelItem (line 154) | func DelItem(f *Frame, o, key *Object) *BaseException {
  function Div (line 164) | func Div(f *Frame, v, w *Object) (*Object, *BaseException) {
  function DivMod (line 170) | func DivMod(f *Frame, v, w *Object) (*Object, *BaseException) {
  function Eq (line 175) | func Eq(f *Frame, v, w *Object) (*Object, *BaseException) {
  function FloorDiv (line 187) | func FloorDiv(f *Frame, v, w *Object) (*Object, *BaseException) {
  function FormatExc (line 193) | func FormatExc(f *Frame) (s string) {
  function GE (line 222) | func GE(f *Frame, v, w *Object) (*Object, *BaseException) {
  function GetItem (line 234) | func GetItem(f *Frame, o, key *Object) (*Object, *BaseException) {
  function GetAttr (line 244) | func GetAttr(f *Frame, o *Object, name *Str, def *Object) (*Object, *Bas...
  function GT (line 260) | func GT(f *Frame, v, w *Object) (*Object, *BaseException) {
  function Hash (line 272) | func Hash(f *Frame, o *Object) (*Int, *BaseException) {
  function Hex (line 289) | func Hex(f *Frame, o *Object) (*Object, *BaseException) {
  function IAdd (line 307) | func IAdd(f *Frame, v, w *Object) (*Object, *BaseException) {
  function IAnd (line 313) | func IAnd(f *Frame, v, w *Object) (*Object, *BaseException) {
  function IDiv (line 319) | func IDiv(f *Frame, v, w *Object) (*Object, *BaseException) {
  function IFloorDiv (line 325) | func IFloorDiv(f *Frame, v, w *Object) (*Object, *BaseException) {
  function ILShift (line 331) | func ILShift(f *Frame, v, w *Object) (*Object, *BaseException) {
  function IMod (line 337) | func IMod(f *Frame, v, w *Object) (*Object, *BaseException) {
  function IMul (line 343) | func IMul(f *Frame, v, w *Object) (*Object, *BaseException) {
  function Invert (line 349) | func Invert(f *Frame, o *Object) (*Object, *BaseException) {
  function IOr (line 358) | func IOr(f *Frame, v, w *Object) (*Object, *BaseException) {
  function IPow (line 363) | func IPow(f *Frame, v, w *Object) (*Object, *BaseException) {
  function IRShift (line 369) | func IRShift(f *Frame, v, w *Object) (*Object, *BaseException) {
  function IsInstance (line 377) | func IsInstance(f *Frame, o *Object, classinfo *Object) (bool, *BaseExce...
  function IsSubclass (line 385) | func IsSubclass(f *Frame, o *Object, classinfo *Object) (bool, *BaseExce...
  function IsTrue (line 409) | func IsTrue(f *Frame, o *Object) (bool, *BaseException) {
  function ISub (line 440) | func ISub(f *Frame, v, w *Object) (*Object, *BaseException) {
  function Iter (line 450) | func Iter(f *Frame, o *Object) (*Object, *BaseException) {
  function IXor (line 464) | func IXor(f *Frame, v, w *Object) (*Object, *BaseException) {
  function LE (line 469) | func LE(f *Frame, v, w *Object) (*Object, *BaseException) {
  function Len (line 481) | func Len(f *Frame, o *Object) (*Int, *BaseException) {
  function LShift (line 498) | func LShift(f *Frame, v, w *Object) (*Object, *BaseException) {
  function LT (line 503) | func LT(f *Frame, v, w *Object) (*Object, *BaseException) {
  function Mod (line 516) | func Mod(f *Frame, v, w *Object) (*Object, *BaseException) {
  function Mul (line 522) | func Mul(f *Frame, v, w *Object) (*Object, *BaseException) {
  function Pow (line 528) | func Pow(f *Frame, v, w *Object) (*Object, *BaseException) {
  function Or (line 534) | func Or(f *Frame, v, w *Object) (*Object, *BaseException) {
  function Index (line 540) | func Index(f *Frame, o *Object) (*Object, *BaseException) {
  function IndexInt (line 562) | func IndexInt(f *Frame, o *Object) (i int, raised *BaseException) {
  function Invoke (line 588) | func Invoke(f *Frame, callable *Object, args Args, varargs *Object, keyw...
  function NE (line 648) | func NE(f *Frame, v, w *Object) (*Object, *BaseException) {
  function Next (line 662) | func Next(f *Frame, iter *Object) (*Object, *BaseException) {
  function Oct (line 672) | func Oct(f *Frame, o *Object) (*Object, *BaseException) {
  function Pos (line 690) | func Pos(f *Frame, o *Object) (*Object, *BaseException) {
  function Print (line 701) | func Print(f *Frame, args Args, nl bool) *BaseException {
  function Repr (line 714) | func Repr(f *Frame, o *Object) (*Str, *BaseException) {
  function ResolveClass (line 739) | func ResolveClass(f *Frame, class *Dict, local *Object, name *Str) (*Obj...
  function ResolveGlobal (line 754) | func ResolveGlobal(f *Frame, name *Str) (*Object, *BaseException) {
  function RShift (line 770) | func RShift(f *Frame, v, w *Object) (*Object, *BaseException) {
  function CheckLocal (line 776) | func CheckLocal(f *Frame, value *Object, name string) *BaseException {
  function SetAttr (line 786) | func SetAttr(f *Frame, o *Object, name *Str, value *Object) *BaseExcepti...
  function SetItem (line 795) | func SetItem(f *Frame, o, key, value *Object) *BaseException {
  function StartThread (line 804) | func StartThread(callable *Object) {
  function Sub (line 818) | func Sub(f *Frame, v, w *Object) (*Object, *BaseException) {
  type TieTarget (line 832) | type TieTarget struct
  function Tie (line 845) | func Tie(f *Frame, t TieTarget, o *Object) *BaseException {
  function ToInt (line 878) | func ToInt(f *Frame, o *Object) (*Object, *BaseException) {
  function ToIntValue (line 899) | func ToIntValue(f *Frame, o *Object) (int, *BaseException) {
  function ToNative (line 912) | func ToNative(f *Frame, o *Object) (reflect.Value, *BaseException) {
  function ToStr (line 920) | func ToStr(f *Frame, o *Object) (*Str, *BaseException) {
  function Neg (line 933) | func Neg(f *Frame, o *Object) (*Object, *BaseException) {
  function Xor (line 943) | func Xor(f *Frame, v, w *Object) (*Object, *BaseException) {
  constant errResultTooLarge (line 948) | errResultTooLarge     = "result too large"
  constant errUnsupportedOperand (line 949) | errUnsupportedOperand = "unsupported operand type(s) for %s: '%s' and '%s'"
  function binaryOp (line 955) | func binaryOp(f *Frame, v, w *Object, op, vrop, wrop *binaryOpSlot, opNa...
  function inplaceOp (line 990) | func inplaceOp(f *Frame, v, w *Object, slot *binaryOpSlot, fallback bina...
  type compareOp (line 997) | type compareOp
    method swapped (line 1017) | func (op compareOp) swapped() compareOp {
    method slot (line 1021) | func (op compareOp) slot(t *Type) *binaryOpSlot {
  constant compareOpLT (line 1000) | compareOpLT compareOp = iota
  constant compareOpLE (line 1001) | compareOpLE
  constant compareOpEq (line 1002) | compareOpEq
  constant compareOpNE (line 1003) | compareOpNE
  constant compareOpGE (line 1004) | compareOpGE
  constant compareOpGT (line 1005) | compareOpGT
  function compareRich (line 1039) | func compareRich(f *Frame, op compareOp, v, w *Object) (*Object, *BaseEx...
  function convert3wayToObject (line 1053) | func convert3wayToObject(op compareOp, c int) *Object {
  function try3wayToRichCompare (line 1075) | func try3wayToRichCompare(f *Frame, op compareOp, v, w *Object) (*Object...
  function tryRichCompare (line 1092) | func tryRichCompare(f *Frame, op compareOp, v, w *Object) (*Object, *Bas...
  function compareDefault (line 1126) | func compareDefault(f *Frame, v, w *Object) int {
  function tryRichCompareBool (line 1161) | func tryRichCompareBool(f *Frame, op compareOp, v, w *Object) (bool, *Ba...
  function halfCompare (line 1179) | func halfCompare(f *Frame, v, w *Object) (*Object, *BaseException) {
  function try3wayCompare (line 1195) | func try3wayCompare(f *Frame, v, w *Object) (*Object, *BaseException) {
  function tryRichTo3wayCompare (line 1214) | func tryRichTo3wayCompare(f *Frame, v, w *Object) (*Object, *BaseExcepti...
  function checkFunctionArgs (line 1235) | func checkFunctionArgs(f *Frame, function string, args Args, types ...*T...
  function checkFunctionVarArgs (line 1249) | func checkFunctionVarArgs(f *Frame, function string, args Args, types .....
  function checkMethodArgs (line 1256) | func checkMethodArgs(f *Frame, method string, args Args, types ...*Type)...
  function checkMethodVarArgs (line 1270) | func checkMethodVarArgs(f *Frame, method string, args Args, types ...*Ty...
  function hashNotImplemented (line 1277) | func hashNotImplemented(f *Frame, o *Object) (*Object, *BaseException) {
  function pyPrint (line 1282) | func pyPrint(f *Frame, args Args, sep, end string, file *File) *BaseExce...

FILE: runtime/core_test.go
  function TestAssert (line 26) | func TestAssert(t *testing.T) {
  function TestBinaryOps (line 57) | func TestBinaryOps(t *testing.T) {
  function TestCompare (line 164) | func TestCompare(t *testing.T) {
  function TestCompareDefault (line 243) | func TestCompareDefault(t *testing.T) {
  function TestContains (line 288) | func TestContains(t *testing.T) {
  function TestDelItem (line 306) | func TestDelItem(t *testing.T) {
  function TestFormatException (line 329) | func TestFormatException(t *testing.T) {
  function TestGetAttr (line 353) | func TestGetAttr(t *testing.T) {
  function TestGetItem (line 399) | func TestGetItem(t *testing.T) {
  function TestHash (line 412) | func TestHash(t *testing.T) {
  function TestHex (line 434) | func TestHex(t *testing.T) {
  function TestIndex (line 460) | func TestIndex(t *testing.T) {
  function TestInvert (line 506) | func TestInvert(t *testing.T) {
  function TestIsInstanceIsSubclass (line 520) | func TestIsInstanceIsSubclass(t *testing.T) {
  function TestIsTrue (line 560) | func TestIsTrue(t *testing.T) {
  function TestIter (line 604) | func TestIter(t *testing.T) {
  function TestNeg (line 629) | func TestNeg(t *testing.T) {
  function TestNext (line 643) | func TestNext(t *testing.T) {
  function TestLen (line 674) | func TestLen(t *testing.T) {
  function TestLenRaise (line 695) | func TestLenRaise(t *testing.T) {
  function TestInvokePositionalArgs (line 714) | func TestInvokePositionalArgs(t *testing.T) {
  function TestInvokeKeywordArgs (line 740) | func TestInvokeKeywordArgs(t *testing.T) {
  function TestOct (line 774) | func TestOct(t *testing.T) {
  function TestPos (line 800) | func TestPos(t *testing.T) {
  function TestPyPrint (line 820) | func TestPyPrint(t *testing.T) {
  function TestReprRaise (line 859) | func TestReprRaise(t *testing.T) {
  function TestReprMethodReturnsNonStr (line 883) | func TestReprMethodReturnsNonStr(t *testing.T) {
  function TestResolveClass (line 898) | func TestResolveClass(t *testing.T) {
  function TestResolveGlobal (line 926) | func TestResolveGlobal(t *testing.T) {
  function TestRichCompare (line 943) | func TestRichCompare(t *testing.T) {
  function TestCheckLocal (line 984) | func TestCheckLocal(t *testing.T) {
  function TestSetItem (line 997) | func TestSetItem(t *testing.T) {
  function TestStartThread (line 1019) | func TestStartThread(t *testing.T) {
  function TestStartThreadRaises (line 1030) | func TestStartThreadRaises(t *testing.T) {
  function TestTie (line 1043) | func TestTie(t *testing.T) {
  function TestToInt (line 1115) | func TestToInt(t *testing.T) {
  function TestToIntValue (line 1134) | func TestToIntValue(t *testing.T) {
  function TestToNative (line 1147) | func TestToNative(t *testing.T) {
  function BenchmarkGetAttr (line 1169) | func BenchmarkGetAttr(b *testing.B) {
  function exceptionsAreEquivalent (line 1185) | func exceptionsAreEquivalent(e1 *BaseException, e2 *BaseException) bool {
  function getFuncName (line 1209) | func getFuncName(f interface{}) string {
  function wrapFuncForTest (line 1216) | func wrapFuncForTest(fun interface{}) *Object {
  function mustCreateException (line 1230) | func mustCreateException(t *Type, msg string) *BaseException {
  function mustNotRaise (line 1243) | func mustNotRaise(o *Object, raised *BaseException) *Object {

FILE: runtime/descriptor.go
  type fieldDescriptorType (line 22) | type fieldDescriptorType
  constant fieldDescriptorRO (line 25) | fieldDescriptorRO fieldDescriptorType = iota
  constant fieldDescriptorRW (line 26) | fieldDescriptorRW
  type Property (line 30) | type Property struct
    method ToObject (line 44) | func (p *Property) ToObject() *Object {
  function newProperty (line 35) | func newProperty(get, set, del *Object) *Property {
  function toPropertyUnsafe (line 39) | func toPropertyUnsafe(o *Object) *Property {
  function initPropertyType (line 51) | func initPropertyType(map[string]*Object) {
  function propertyDelete (line 58) | func propertyDelete(f *Frame, desc, inst *Object) *BaseException {
  function propertyGet (line 67) | func propertyGet(f *Frame, desc, instance *Object, _ *Type) (*Object, *B...
  function propertyInit (line 75) | func propertyInit(f *Frame, o *Object, args Args, _ KWArgs) (*Object, *B...
  function propertySet (line 97) | func propertySet(f *Frame, desc, inst, value *Object) *BaseException {
  function makeStructFieldDescriptor (line 108) | func makeStructFieldDescriptor(t *Type, fieldName, propertyName string, ...

FILE: runtime/descriptor_test.go
  function TestPropertyDelete (line 21) | func TestPropertyDelete(t *testing.T) {
  function TestPropertyGet (line 35) | func TestPropertyGet(t *testing.T) {
  function TestPropertyInit (line 49) | func TestPropertyInit(t *testing.T) {
  function TestPropertySet (line 72) | func TestPropertySet(t *testing.T) {
  function TestMakeStructFieldDescriptor (line 86) | func TestMakeStructFieldDescriptor(t *testing.T) {
  function TestMakeStructFieldDescriptorRWGet (line 114) | func TestMakeStructFieldDescriptorRWGet(t *testing.T) {
  function TestMakeStructFieldDescriptorRWSet (line 138) | func TestMakeStructFieldDescriptorRWSet(t *testing.T) {

FILE: runtime/dict.go
  constant maxDictSize (line 38) | maxDictSize = 1 << 30
  constant minDictSize (line 39) | minDictSize = 8
  type dictEntry (line 44) | type dictEntry struct
  type dictTable (line 51) | type dictTable struct
    method loadEntry (line 84) | func (t *dictTable) loadEntry(i int) *dictEntry {
    method storeEntry (line 90) | func (t *dictTable) storeEntry(i int, entry *dictEntry) {
    method loadUsed (line 95) | func (t *dictTable) loadUsed() int {
    method incUsed (line 99) | func (t *dictTable) incUsed(n int) {
    method insertAbsentEntry (line 106) | func (t *dictTable) insertAbsentEntry(entry *dictEntry) {
    method lookupEntry (line 125) | func (t *dictTable) lookupEntry(f *Frame, hash int, key *Object) (int,...
    method writeEntry (line 174) | func (t *dictTable) writeEntry(f *Frame, index int, entry *dictEntry) ...
  function newDictTable (line 68) | func newDictTable(minCapacity int) *dictTable {
  type dictEntryIterator (line 212) | type dictEntryIterator struct
    method next (line 226) | func (iter *dictEntryIterator) next() *dictEntry {
  function newDictEntryIterator (line 219) | func newDictEntryIterator(d *Dict) dictEntryIterator {
  type dictVersionGuard (line 247) | type dictVersionGuard struct
    method check (line 258) | func (g *dictVersionGuard) check() bool {
  function newDictVersionGuard (line 252) | func newDictVersionGuard(d *Dict) dictVersionGuard {
  type Dict (line 264) | type Dict struct
    method loadTable (line 297) | func (d *Dict) loadTable() *dictTable {
    method storeTable (line 303) | func (d *Dict) storeTable(table *dictTable) {
    method loadVersion (line 309) | func (d *Dict) loadVersion() int64 {
    method incVersion (line 318) | func (d *Dict) incVersion() {
    method DelItem (line 328) | func (d *Dict) DelItem(f *Frame, key *Object) (bool, *BaseException) {
    method DelItemString (line 338) | func (d *Dict) DelItemString(f *Frame, key string) (bool, *BaseExcepti...
    method GetItem (line 344) | func (d *Dict) GetItem(f *Frame, key *Object) (*Object, *BaseException) {
    method GetItemString (line 361) | func (d *Dict) GetItemString(f *Frame, key string) (*Object, *BaseExce...
    method Pop (line 367) | func (d *Dict) Pop(f *Frame, key *Object) (*Object, *BaseException) {
    method Keys (line 372) | func (d *Dict) Keys(f *Frame) *List {
    method Len (line 387) | func (d *Dict) Len() int {
    method putItem (line 393) | func (d *Dict) putItem(f *Frame, key, value *Object, overwrite bool) (...
    method SetItem (line 437) | func (d *Dict) SetItem(f *Frame, key, value *Object) *BaseException {
    method SetItemString (line 443) | func (d *Dict) SetItemString(f *Frame, key string, value *Object) *Bas...
    method ToObject (line 448) | func (d *Dict) ToObject() *Object {
    method Update (line 453) | func (d *Dict) Update(f *Frame, o *Object) (raised *BaseException) {
  function NewDict (line 276) | func NewDict() *Dict {
  function newStringDict (line 280) | func newStringDict(items map[string]*Object) *Dict {
  function toDictUnsafe (line 292) | func toDictUnsafe(o *Object) *Dict {
  function dictsAreEqual (line 482) | func dictsAreEqual(f *Frame, d1, d2 *Dict) (bool, *BaseException) {
  function dictClear (line 522) | func dictClear(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
  function dictContains (line 534) | func dictContains(f *Frame, seq, value *Object) (*Object, *BaseException) {
  function dictCopy (line 542) | func dictCopy(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
  function dictDelItem (line 549) | func dictDelItem(f *Frame, o, key *Object) *BaseException {
  function dictEq (line 560) | func dictEq(f *Frame, v, w *Object) (*Object, *BaseException) {
  function dictGet (line 571) | func dictGet(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseExceptio...
  function dictHasKey (line 590) | func dictHasKey(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
  function dictItems (line 597) | func dictItems(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseExcept...
  function dictIterItems (line 608) | func dictIterItems(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseEx...
  function dictIterKeys (line 619) | func dictIterKeys(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseExc...
  function dictIterValues (line 626) | func dictIterValues(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseE...
  function dictKeys (line 637) | func dictKeys(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseExcepti...
  function dictGetItem (line 644) | func dictGetItem(f *Frame, o, key *Object) (*Object, *BaseException) {
  function dictInit (line 655) | func dictInit(f *Frame, o *Object, args Args, kwargs KWArgs) (*Object, *...
  function dictIter (line 678) | func dictIter(f *Frame, o *Object) (*Object, *BaseException) {
  function dictLen (line 686) | func dictLen(f *Frame, o *Object) (*Object, *BaseException) {
  function dictNE (line 692) | func dictNE(f *Frame, v, w *Object) (*Object, *BaseException) {
  function dictNew (line 703) | func dictNew(f *Frame, t *Type, _ Args, _ KWArgs) (*Object, *BaseExcepti...
  function dictPop (line 709) | func dictPop(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
  function dictPopItem (line 731) | func dictPopItem(f *Frame, args Args, _ KWArgs) (item *Object, raised *B...
  function dictRepr (line 751) | func dictRepr(f *Frame, o *Object) (*Object, *BaseException) {
  function dictSetDefault (line 785) | func dictSetDefault(f *Frame, args Args, _ KWArgs) (*Object, *BaseExcept...
  function dictSetItem (line 815) | func dictSetItem(f *Frame, o, key, value *Object) *BaseException {
  function dictUpdate (line 819) | func dictUpdate(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseExcep...
  function dictValues (line 842) | func dictValues(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseExcep...
  function initDictType (line 853) | func initDictType(dict map[string]*Object) {
  type dictItemIterator (line 882) | type dictItemIterator struct
    method ToObject (line 902) | func (iter *dictItemIterator) ToObject() *Object {
  function newDictItemIterator (line 890) | func newDictItemIterator(d *Dict) *dictItemIterator {
  function toDictItemIteratorUnsafe (line 898) | func toDictItemIteratorUnsafe(o *Object) *dictItemIterator {
  function dictItemIteratorIter (line 906) | func dictItemIteratorIter(f *Frame, o *Object) (*Object, *BaseException) {
  function dictItemIteratorNext (line 910) | func dictItemIteratorNext(f *Frame, o *Object) (ret *Object, raised *Bas...
  function initDictItemIteratorType (line 919) | func initDictItemIteratorType(map[string]*Object) {
  type dictKeyIterator (line 925) | type dictKeyIterator struct
    method ToObject (line 945) | func (iter *dictKeyIterator) ToObject() *Object {
  function newDictKeyIterator (line 933) | func newDictKeyIterator(d *Dict) *dictKeyIterator {
  function toDictKeyIteratorUnsafe (line 941) | func toDictKeyIteratorUnsafe(o *Object) *dictKeyIterator {
  function dictKeyIteratorIter (line 949) | func dictKeyIteratorIter(f *Frame, o *Object) (*Object, *BaseException) {
  function dictKeyIteratorNext (line 953) | func dictKeyIteratorNext(f *Frame, o *Object) (*Object, *BaseException) {
  function initDictKeyIteratorType (line 962) | func initDictKeyIteratorType(map[string]*Object) {
  type dictValueIterator (line 968) | type dictValueIterator struct
    method ToObject (line 988) | func (iter *dictValueIterator) ToObject() *Object {
  function newDictValueIterator (line 976) | func newDictValueIterator(d *Dict) *dictValueIterator {
  function toDictValueIteratorUnsafe (line 984) | func toDictValueIteratorUnsafe(o *Object) *dictValueIterator {
  function dictValueIteratorIter (line 992) | func dictValueIteratorIter(f *Frame, o *Object) (*Object, *BaseException) {
  function dictValueIteratorNext (line 996) | func dictValueIteratorNext(f *Frame, o *Object) (*Object, *BaseException) {
  function initDictValueIteratorType (line 1005) | func initDictValueIteratorType(map[string]*Object) {
  function raiseKeyError (line 1011) | func raiseKeyError(f *Frame, key *Object) *BaseException {
  function dictNextIndex (line 1019) | func dictNextIndex(i, perturb uint) (uint, uint) {
  function dictIteratorNext (line 1023) | func dictIteratorNext(f *Frame, iter *dictEntryIterator, guard *dictVers...

FILE: runtime/dict_test.go
  function TestNewStringDict (line 31) | func TestNewStringDict(t *testing.T) {
  function TestDictClear (line 50) | func TestDictClear(t *testing.T) {
  function TestDictContains (line 73) | func TestDictContains(t *testing.T) {
  function TestDictDelItem (line 86) | func TestDictDelItem(t *testing.T) {
  function TestDictDelItemString (line 112) | func TestDictDelItemString(t *testing.T) {
  function TestDictEqNE (line 134) | func TestDictEqNE(t *testing.T) {
  function TestDictGet (line 185) | func TestDictGet(t *testing.T) {
  function TestDictGetItem (line 198) | func TestDictGetItem(t *testing.T) {
  function BenchmarkDictGetItem (line 238) | func BenchmarkDictGetItem(b *testing.B) {
  function BenchmarkDictIterItems (line 259) | func BenchmarkDictIterItems(b *testing.B) {
  function BenchmarkDictIterKeys (line 298) | func BenchmarkDictIterKeys(b *testing.B) {
  function BenchmarkDictIterValues (line 337) | func BenchmarkDictIterValues(b *testing.B) {
  function TestDictGetItemString (line 376) | func TestDictGetItemString(t *testing.T) {
  function TestDictHasKey (line 400) | func TestDictHasKey(t *testing.T) {
  function TestDictItemIteratorIter (line 413) | func TestDictItemIteratorIter(t *testing.T) {
  function TestDictItemIterModified (line 421) | func TestDictItemIterModified(t *testing.T) {
  function TestDictIter (line 438) | func TestDictIter(t *testing.T) {
  function TestDictIterKeys (line 465) | func TestDictIterKeys(t *testing.T) {
  function TestDictIterValues (line 486) | func TestDictIterValues(t *testing.T) {
  function TestDictItems (line 508) | func TestDictItems(t *testing.T) {
  function TestDictKeyIteratorIter (line 539) | func TestDictKeyIteratorIter(t *testing.T) {
  function TestDictKeyIterModified (line 547) | func TestDictKeyIterModified(t *testing.T) {
  function TestDictKeys (line 563) | func TestDictKeys(t *testing.T) {
  function TestDictPop (line 575) | func TestDictPop(t *testing.T) {
  function TestDictPopItem (line 588) | func TestDictPopItem(t *testing.T) {
  function TestDictNewInit (line 619) | func TestDictNewInit(t *testing.T) {
  function TestDictNewRaises (line 636) | func TestDictNewRaises(t *testing.T) {
  function TestDictSetDefault (line 649) | func TestDictSetDefault(t *testing.T) {
  function TestDictSetItem (line 673) | func TestDictSetItem(t *testing.T) {
  function TestDictSetItemString (line 716) | func TestDictSetItemString(t *testing.T) {
  function TestDictStrRepr (line 741) | func TestDictStrRepr(t *testing.T) {
  function TestDictUpdate (line 782) | func TestDictUpdate(t *testing.T) {
  function TestDictValues (line 816) | func TestDictValues(t *testing.T) {
  function TestParallelDictUpdates (line 829) | func TestParallelDictUpdates(t *testing.T) {
  function newTestDict (line 905) | func newTestDict(elems ...interface{}) *Dict {

FILE: runtime/exceptions.go
  function systemExitInit (line 106) | func systemExitInit(f *Frame, o *Object, args Args, kwargs KWArgs) (*Obj...
  function initSystemExitType (line 118) | func initSystemExitType(map[string]*Object) {

FILE: runtime/file.go
  type File (line 30) | type File struct
    method name (line 66) | func (f *File) name() string {
    method ToObject (line 75) | func (f *File) ToObject() *Object {
    method readLine (line 79) | func (f *File) readLine(maxBytes int) (string, error) {
    method writeString (line 110) | func (f *File) writeString(s string) error {
  function NewFileFromFD (line 47) | func NewFileFromFD(fd uintptr, close *Object) *File {
  function toFileUnsafe (line 62) | func toFileUnsafe(o *Object) *File {
  function fileInit (line 126) | func fileInit(f *Frame, o *Object, args Args, _ KWArgs) (*Object, *BaseE...
  function fileEnter (line 173) | func fileEnter(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
  function fileExit (line 180) | func fileExit(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
  function fileClose (line 195) | func fileClose(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
  function fileClosed (line 220) | func fileClosed(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
  function fileFileno (line 231) | func fileFileno(f *Frame, args Args, _ KWArgs) (ret *Object, raised *Bas...
  function fileGetName (line 246) | func fileGetName(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
  function fileIter (line 257) | func fileIter(f *Frame, o *Object) (*Object, *BaseException) {
  function fileNext (line 261) | func fileNext(f *Frame, o *Object) (ret *Object, raised *BaseException) {
  function fileRead (line 278) | func fileRead(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
  function fileReadLine (line 304) | func fileReadLine(f *Frame, args Args, _ KWArgs) (*Object, *BaseExceptio...
  function fileReadLines (line 321) | func fileReadLines(f *Frame, args Args, _ KWArgs) (*Object, *BaseExcepti...
  function fileRepr (line 352) | func fileRepr(f *Frame, o *Object) (*Object, *BaseException) {
  function fileWrite (line 371) | func fileWrite(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
  function initFileType (line 387) | func initFileType(dict map[string]*Object) {
  function fileParseReadArgs (line 405) | func fileParseReadArgs(f *Frame, method string, args Args) (*File, int, ...

FILE: runtime/file_test.go
  function TestFileInit (line 30) | func TestFileInit(t *testing.T) {
  function TestFileClosed (line 46) | func TestFileClosed(t *testing.T) {
  function TestFileCloseExit (line 65) | func TestFileCloseExit(t *testing.T) {
  function TestFileGetName (line 86) | func TestFileGetName(t *testing.T) {
  function TestFileIter (line 103) | func TestFileIter(t *testing.T) {
  function TestFileNext (line 130) | func TestFileNext(t *testing.T) {
  function TestFileRead (line 158) | func TestFileRead(t *testing.T) {
  function TestFileReadLine (line 181) | func TestFileReadLine(t *testing.T) {
  function TestFileReadLines (line 224) | func TestFileReadLines(t *testing.T) {
  function TestFileStrRepr (line 267) | func TestFileStrRepr(t *testing.T) {
  function TestFileWrite (line 305) | func TestFileWrite(t *testing.T) {
  type testFile (line 369) | type testFile struct
    method cleanup (line 388) | func (f *testFile) cleanup() {
    method open (line 395) | func (f *testFile) open(mode string) *File {
  function newTestFile (line 374) | func newTestFile(contents string) *testFile {
  type testFileSlice (line 406) | type testFileSlice
    method cleanup (line 419) | func (files testFileSlice) cleanup() {
  function makeTestFiles (line 408) | func makeTestFiles() testFileSlice {

FILE: runtime/float.go
  type Float (line 33) | type Float struct
    method ToObject (line 49) | func (f *Float) ToObject() *Object {
    method Value (line 54) | func (f *Float) Value() float64 {
  function NewFloat (line 40) | func NewFloat(value float64) *Float {
  function toFloatUnsafe (line 44) | func toFloatUnsafe(o *Object) *Float {
  function floatAbs (line 58) | func floatAbs(f *Frame, o *Object) (*Object, *BaseException) {
  function floatAdd (line 63) | func floatAdd(f *Frame, v, w *Object) (*Object, *BaseException) {
  function floatDiv (line 67) | func floatDiv(f *Frame, v, w *Object) (*Object, *BaseException) {
  function floatDivMod (line 76) | func floatDivMod(f *Frame, v, w *Object) (*Object, *BaseException) {
  function floatEq (line 86) | func floatEq(f *Frame, v, w *Object) (*Object, *BaseException) {
  function floatFloat (line 90) | func floatFloat(f *Frame, o *Object) (*Object, *BaseException) {
  function floatFloorDiv (line 94) | func floatFloorDiv(f *Frame, v, w *Object) (*Object, *BaseException) {
  function floatGE (line 103) | func floatGE(f *Frame, v, w *Object) (*Object, *BaseException) {
  function floatGetNewArgs (line 107) | func floatGetNewArgs(f *Frame, args Args, _ KWArgs) (*Object, *BaseExcep...
  function floatGT (line 114) | func floatGT(f *Frame, v, w *Object) (*Object, *BaseException) {
  function floatHash (line 118) | func floatHash(f *Frame, o *Object) (*Object, *BaseException) {
  function floatInt (line 134) | func floatInt(f *Frame, o *Object) (*Object, *BaseException) {
  function floatLong (line 150) | func floatLong(f *Frame, o *Object) (*Object, *BaseException) {
  function floatLE (line 162) | func floatLE(f *Frame, v, w *Object) (*Object, *BaseException) {
  function floatLT (line 166) | func floatLT(f *Frame, v, w *Object) (*Object, *BaseException) {
  function floatMod (line 170) | func floatMod(f *Frame, v, w *Object) (*Object, *BaseException) {
  function floatMul (line 174) | func floatMul(f *Frame, v, w *Object) (*Object, *BaseException) {
  function floatNative (line 178) | func floatNative(f *Frame, o *Object) (reflect.Value, *BaseException) {
  function floatNE (line 182) | func floatNE(f *Frame, v, w *Object) (*Object, *BaseException) {
  function floatNeg (line 186) | func floatNeg(f *Frame, o *Object) (*Object, *BaseException) {
  function floatNew (line 191) | func floatNew(f *Frame, t *Type, args Args, _ KWArgs) (*Object, *BaseExc...
  function floatNonZero (line 229) | func floatNonZero(f *Frame, o *Object) (*Object, *BaseException) {
  function floatPos (line 233) | func floatPos(f *Frame, o *Object) (*Object, *BaseException) {
  function floatPow (line 237) | func floatPow(f *Frame, v, w *Object) (*Object, *BaseException) {
  function floatRAdd (line 241) | func floatRAdd(f *Frame, v, w *Object) (*Object, *BaseException) {
  function floatRDiv (line 245) | func floatRDiv(f *Frame, v, w *Object) (*Object, *BaseException) {
  function floatRDivMod (line 254) | func floatRDivMod(f *Frame, v, w *Object) (*Object, *BaseException) {
  constant floatReprPrecision (line 265) | floatReprPrecision = 16
  constant floatStrPrecision (line 266) | floatStrPrecision  = 12
  function floatRepr (line 269) | func floatRepr(f *Frame, o *Object) (*Object, *BaseException) {
  function floatRFloorDiv (line 273) | func floatRFloorDiv(f *Frame, v, w *Object) (*Object, *BaseException) {
  function floatRMod (line 282) | func floatRMod(f *Frame, v, w *Object) (*Object, *BaseException) {
  function floatRMul (line 288) | func floatRMul(f *Frame, v, w *Object) (*Object, *BaseException) {
  function floatRPow (line 292) | func floatRPow(f *Frame, v, w *Object) (*Object, *BaseException) {
  function floatRSub (line 296) | func floatRSub(f *Frame, v, w *Object) (*Object, *BaseException) {
  function floatStr (line 300) | func floatStr(f *Frame, o *Object) (*Object, *BaseException) {
  function floatSub (line 304) | func floatSub(f *Frame, v, w *Object) (*Object, *BaseException) {
  function initFloatType (line 308) | func initFloatType(dict map[string]*Object) {
  function floatArithmeticOp (line 346) | func floatArithmeticOp(f *Frame, method string, v, w *Object, fun func(v...
  function floatCompare (line 357) | func floatCompare(v *Float, w *Object, ltResult, eqResult, gtResult *Int...
  function floatCoerce (line 395) | func floatCoerce(o *Object) (float64, bool) {
  function floatConvert (line 413) | func floatConvert(floatSlot *unaryOpSlot, f *Frame, o *Object) (*Float, ...
  function floatDivModOp (line 425) | func floatDivModOp(f *Frame, method string, v, w *Object, fun func(v, w ...
  function floatDivAndModOp (line 440) | func floatDivAndModOp(f *Frame, method string, v, w *Object, fun func(v,...
  function hashFloat (line 455) | func hashFloat(v float64) int {
  function floatModFunc (line 489) | func floatModFunc(v, w float64) (float64, bool) {
  function floatToString (line 506) | func floatToString(f float64, p int) string {
  function unsignPositiveInf (line 517) | func unsignPositiveInf(s string) string {

FILE: runtime/float_test.go
  function TestFloatArithmeticOps (line 38) | func TestFloatArithmeticOps(t *testing.T) {
  function TestFloatDivMod (line 114) | func TestFloatDivMod(t *testing.T) {
  function isNaNTupleFloat (line 143) | func isNaNTupleFloat(got, want *Object) bool {
  function TestFloatCompare (line 156) | func TestFloatCompare(t *testing.T) {
  function TestFloatInt (line 176) | func TestFloatInt(t *testing.T) {
  function TestFloatLong (line 191) | func TestFloatLong(t *testing.T) {
  function TestFloatHash (line 206) | func TestFloatHash(t *testing.T) {
  function TestFloatIsTrue (line 222) | func TestFloatIsTrue(t *testing.T) {
  function TestFloatNew (line 235) | func TestFloatNew(t *testing.T) {
  function TestFloatRepr (line 301) | func TestFloatRepr(t *testing.T) {
  function TestFloatStr (line 323) | func TestFloatStr(t *testing.T) {

FILE: runtime/frame.go
  type RunState (line 23) | type RunState
  constant notBaseExceptionMsg (line 26) | notBaseExceptionMsg = "exceptions must be derived from BaseException, no...
  type Frame (line 30) | type Frame struct
    method release (line 68) | func (f *Frame) release() {
    method pushFrame (line 82) | func (f *Frame) pushFrame(back *Frame) {
    method Globals (line 96) | func (f *Frame) Globals() *Dict {
    method ToObject (line 101) | func (f *Frame) ToObject() *Object {
    method SetLineno (line 106) | func (f *Frame) SetLineno(lineno int) {
    method State (line 111) | func (f *Frame) State() RunState {
    method PushCheckpoint (line 116) | func (f *Frame) PushCheckpoint(state RunState) {
    method PopCheckpoint (line 122) | func (f *Frame) PopCheckpoint() {
    method Raise (line 139) | func (f *Frame) Raise(typ *Object, inst *Object, tb *Object) *BaseExce...
    method RaiseType (line 200) | func (f *Frame) RaiseType(t *Type, msg string) *BaseException {
    method ExcInfo (line 206) | func (f *Frame) ExcInfo() (*BaseException, *Traceback) {
    method RestoreExc (line 212) | func (f *Frame) RestoreExc(e *BaseException, tb *Traceback) (*BaseExce...
    method reprEnter (line 218) | func (f *Frame) reprEnter(o *Object) bool {
    method reprLeave (line 229) | func (f *Frame) reprLeave(o *Object) {
    method MakeArgs (line 235) | func (f *Frame) MakeArgs(n int) Args {
    method FreeArgs (line 254) | func (f *Frame) FreeArgs(args Args) {
  function NewRootFrame (line 46) | func NewRootFrame() *Frame {
  function newChildFrame (line 53) | func newChildFrame(back *Frame) *Frame {
  function toFrameUnsafe (line 91) | func toFrameUnsafe(o *Object) *Frame {
  function frameExcClear (line 273) | func frameExcClear(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseEx...
  function frameExcInfo (line 281) | func frameExcInfo(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseExc...
  function initFrameType (line 296) | func initFrameType(dict map[string]*Object) {

FILE: runtime/frame_test.go
  constant testRunStateInvalid (line 24) | testRunStateInvalid RunState = -1
  constant testRunStateStart (line 25) | testRunStateStart            = 0
  constant testRunStateDone (line 26) | testRunStateDone             = 1
  function TestFrameArgsCache (line 29) | func TestFrameArgsCache(t *testing.T) {
  function TestFramePopCheckpoint (line 65) | func TestFramePopCheckpoint(t *testing.T) {
  function TestFramePushCheckpoint (line 91) | func TestFramePushCheckpoint(t *testing.T) {
  function TestFrameRaise (line 104) | func TestFrameRaise(t *testing.T) {
  function TestFrameRaiseType (line 155) | func TestFrameRaiseType(t *testing.T) {
  function TestReprEnterLeave (line 174) | func TestReprEnterLeave(t *testing.T) {
  function TestFrameRoot (line 198) | func TestFrameRoot(t *testing.T) {
  function TestFrameExcInfo (line 209) | func TestFrameExcInfo(t *testing.T) {
  type checkInvokeResultType (line 225) | type checkInvokeResultType
  constant checkInvokeResultOk (line 228) | checkInvokeResultOk                  checkInvokeResultType = iota
  constant checkInvokeResultExceptionMismatch (line 229) | checkInvokeResultExceptionMismatch                         = iota
  constant checkInvokeResultReturnValueMismatch (line 230) | checkInvokeResultReturnValueMismatch                       = iota
  function checkResult (line 233) | func checkResult(got, want *Object, gotExc, wantExc *BaseException) chec...
  function checkInvokeResult (line 263) | func checkInvokeResult(callable *Object, args Args, wantRet *Object, wan...
  function checkInvokeResultKwargs (line 267) | func checkInvokeResultKwargs(callable *Object, args Args, kwargs KWArgs,...
  type invokeTestCase (line 282) | type invokeTestCase struct
  function runInvokeTestCase (line 289) | func runInvokeTestCase(callable *Object, cas *invokeTestCase) string {
  function runInvokeMethodTestCase (line 311) | func runInvokeMethodTestCase(t *Type, methodName string, cas *invokeTest...

FILE: runtime/function.go
  type Args (line 34) | type Args
    method makeCopy (line 36) | func (a Args) makeCopy() Args {
  type KWArg (line 43) | type KWArg struct
  type KWArgs (line 50) | type KWArgs
    method String (line 53) | func (k KWArgs) String() string {
    method get (line 57) | func (k KWArgs) get(name string, def *Object) *Object {
    method makeDict (line 66) | func (k KWArgs) makeDict() *Dict {
  type Func (line 75) | type Func
  type Function (line 78) | type Function struct
    method ToObject (line 106) | func (f *Function) ToObject() *Object {
    method Name (line 111) | func (f *Function) Name() string {
  function NewFunction (line 91) | func NewFunction(c *Code, globals *Dict) *Function {
  function newBuiltinFunction (line 97) | func newBuiltinFunction(name string, fn Func) *Function {
  function toFunctionUnsafe (line 101) | func toFunctionUnsafe(o *Object) *Function {
  function functionCall (line 115) | func functionCall(f *Frame, callable *Object, args Args, kwargs KWArgs) ...
  function functionGet (line 124) | func functionGet(f *Frame, desc, instance *Object, owner *Type) (*Object...
  function functionRepr (line 134) | func functionRepr(_ *Frame, o *Object) (*Object, *BaseException) {
  function initFunctionType (line 139) | func initFunctionType(map[string]*Object) {
  type staticMethod (line 147) | type staticMethod struct
    method ToObject (line 161) | func (m *staticMethod) ToObject() *Object {
  function newStaticMethod (line 152) | func newStaticMethod(callable *Object) *staticMethod {
  function toStaticMethodUnsafe (line 156) | func toStaticMethodUnsafe(o *Object) *staticMethod {
  function staticMethodGet (line 165) | func staticMethodGet(f *Frame, desc, _ *Object, _ *Type) (*Object, *Base...
  function staticMethodInit (line 173) | func staticMethodInit(f *Frame, o *Object, args Args, _ KWArgs) (*Object...
  function initStaticMethodType (line 181) | func initStaticMethodType(map[string]*Object) {
  type classMethod (line 187) | type classMethod struct
    method ToObject (line 201) | func (m *classMethod) ToObject() *Object {
  function newClassMethod (line 192) | func newClassMethod(callable *Object) *classMethod {
  function toClassMethodUnsafe (line 196) | func toClassMethodUnsafe(o *Object) *classMethod {
  function classMethodGet (line 205) | func classMethodGet(f *Frame, desc, _ *Object, owner *Type) (*Object, *B...
  function classMethodInit (line 219) | func classMethodInit(f *Frame, o *Object, args Args, _ KWArgs) (*Object,...
  function initClassMethodType (line 227) | func initClassMethodType(map[string]*Object) {

FILE: runtime/function_test.go
  function TestFunctionCall (line 22) | func TestFunctionCall(t *testing.T) {
  function TestFunctionGet (line 42) | func TestFunctionGet(t *testing.T) {
  function TestFunctionName (line 49) | func TestFunctionName(t *testing.T) {
  function TestFunctionStrRepr (line 59) | func TestFunctionStrRepr(t *testing.T) {
  function TestStaticMethodGet (line 93) | func TestStaticMethodGet(t *testing.T) {
  function TestStaticMethodInit (line 105) | func TestStaticMethodInit(t *testing.T) {
  function TestClassMethodGet (line 128) | func TestClassMethodGet(t *testing.T) {
  function TestClassMethodInit (line 155) | func TestClassMethodInit(t *testing.T) {

FILE: runtime/generator.go
  type generatorState (line 27) | type generatorState
  constant generatorStateCreated (line 30) | generatorStateCreated generatorState = iota
  constant generatorStateReady (line 31) | generatorStateReady
  constant generatorStateRunning (line 32) | generatorStateRunning
  constant generatorStateDone (line 33) | generatorStateDone
  type Generator (line 37) | type Generator struct
    method resume (line 60) | func (g *Generator) resume(f *Frame, sendValue *Object) (*Object, *Bas...
    method ToObject (line 102) | func (g *Generator) ToObject() *Object {
  function NewGenerator (line 46) | func NewGenerator(f *Frame, fn func(*Object) (*Object, *BaseException)) ...
  function toGeneratorUnsafe (line 56) | func toGeneratorUnsafe(o *Object) *Generator {
  function generatorIter (line 106) | func generatorIter(f *Frame, o *Object) (*Object, *BaseException) {
  function generatorNext (line 110) | func generatorNext(f *Frame, o *Object) (*Object, *BaseException) {
  function generatorSend (line 114) | func generatorSend(f *Frame, args Args, _ KWArgs) (*Object, *BaseExcepti...
  function initGeneratorType (line 121) | func initGeneratorType(dict map[string]*Object) {

FILE: runtime/generator_test.go
  function TestGeneratorNext (line 21) | func TestGeneratorNext(t *testing.T) {
  function TestGeneratorSend (line 48) | func TestGeneratorSend(t *testing.T) {
  function TestGeneratorSimple (line 63) | func TestGeneratorSimple(t *testing.T) {

FILE: runtime/int.go
  constant internedIntMin (line 26) | internedIntMin = -2
  constant internedIntMax (line 27) | internedIntMax = 300
  type Int (line 35) | type Int struct
    method ToObject (line 53) | func (i *Int) ToObject() *Object {
    method Value (line 58) | func (i *Int) Value() int {
    method IsTrue (line 63) | func (i *Int) IsTrue() bool {
  function NewInt (line 41) | func NewInt(value int) *Int {
  function toIntUnsafe (line 48) | func toIntUnsafe(o *Object) *Int {
  function intAbs (line 70) | func intAbs(f *Frame, o *Object) (*Object, *BaseException) {
  function intAdd (line 78) | func intAdd(f *Frame, v, w *Object) (*Object, *BaseException) {
  function intAnd (line 82) | func intAnd(f *Frame, v, w *Object) (*Object, *BaseException) {
  function intDiv (line 89) | func intDiv(f *Frame, v, w *Object) (*Object, *BaseException) {
  function intDivMod (line 93) | func intDivMod(f *Frame, v, w *Object) (*Object, *BaseException) {
  function intEq (line 97) | func intEq(f *Frame, v, w *Object) (*Object, *BaseException) {
  function intGE (line 101) | func intGE(f *Frame, v, w *Object) (*Object, *BaseException) {
  function intGetNewArgs (line 105) | func intGetNewArgs(f *Frame, args Args, _ KWArgs) (*Object, *BaseExcepti...
  function intGT (line 112) | func intGT(f *Frame, v, w *Object) (*Object, *BaseException) {
  function intFloat (line 116) | func intFloat(f *Frame, o *Object) (*Object, *BaseException) {
  function intHash (line 121) | func intHash(f *Frame, o *Object) (*Object, *BaseException) {
  function intHex (line 125) | func intHex(f *Frame, o *Object) (*Object, *BaseException) {
  function intIndex (line 130) | func intIndex(f *Frame, o *Object) (*Object, *BaseException) {
  function intInt (line 134) | func intInt(f *Frame, o *Object) (*Object, *BaseException) {
  function intInvert (line 141) | func intInvert(f *Frame, o *Object) (*Object, *BaseException) {
  function intLE (line 145) | func intLE(f *Frame, v, w *Object) (*Object, *BaseException) {
  function intLong (line 149) | func intLong(f *Frame, o *Object) (*Object, *BaseException) {
  function intLShift (line 153) | func intLShift(f *Frame, v, w *Object) (*Object, *BaseException) {
  function intLT (line 157) | func intLT(f *Frame, v, w *Object) (*Object, *BaseException) {
  function intMod (line 161) | func intMod(f *Frame, v, w *Object) (*Object, *BaseException) {
  function intMul (line 165) | func intMul(f *Frame, v, w *Object) (*Object, *BaseException) {
  function intNative (line 169) | func intNative(f *Frame, o *Object) (reflect.Value, *BaseException) {
  function intNE (line 173) | func intNE(f *Frame, v, w *Object) (*Object, *BaseException) {
  function intNeg (line 177) | func intNeg(f *Frame, o *Object) (*Object, *BaseException) {
  function intNew (line 186) | func intNew(f *Frame, t *Type, args Args, _ KWArgs) (*Object, *BaseExcep...
  function intNonZero (line 252) | func intNonZero(f *Frame, o *Object) (*Object, *BaseException) {
  function intOct (line 256) | func intOct(f *Frame, o *Object) (*Object, *BaseException) {
  function intOr (line 264) | func intOr(f *Frame, v, w *Object) (*Object, *BaseException) {
  function intPos (line 271) | func intPos(f *Frame, o *Object) (*Object, *BaseException) {
  function intPow (line 275) | func intPow(f *Frame, v, w *Object) (*Object, *BaseException) {
  function intRAdd (line 312) | func intRAdd(f *Frame, v, w *Object) (*Object, *BaseException) {
  function intRDiv (line 316) | func intRDiv(f *Frame, v, w *Object) (*Object, *BaseException) {
  function intRDivMod (line 324) | func intRDivMod(f *Frame, v, w *Object) (*Object, *BaseException) {
  function intRepr (line 332) | func intRepr(f *Frame, o *Object) (*Object, *BaseException) {
  function intRMod (line 336) | func intRMod(f *Frame, v, w *Object) (*Object, *BaseException) {
  function intRMul (line 344) | func intRMul(f *Frame, v, w *Object) (*Object, *BaseException) {
  function intRLShift (line 348) | func intRLShift(f *Frame, v, w *Object) (*Object, *BaseException) {
  function intRRShift (line 352) | func intRRShift(f *Frame, v, w *Object) (*Object, *BaseException) {
  function intRShift (line 356) | func intRShift(f *Frame, v, w *Object) (*Object, *BaseException) {
  function intRSub (line 360) | func intRSub(f *Frame, v, w *Object) (*Object, *BaseException) {
  function intSub (line 368) | func intSub(f *Frame, v, w *Object) (*Object, *BaseException) {
  function intXor (line 372) | func intXor(f *Frame, v, w *Object) (*Object, *BaseException) {
  function initIntType (line 379) | func initIntType(dict map[string]*Object) {
  type divModResult (line 429) | type divModResult
  constant divModOK (line 432) | divModOK           divModResult = iota
  constant divModOverflow (line 433) | divModOverflow                  = iota
  constant divModZeroDivision (line 434) | divModZeroDivision              = iota
  function intCompare (line 437) | func intCompare(op compareOp, v *Int, w *Object) *Object {
  function intAddMulOp (line 460) | func intAddMulOp(f *Frame, method string, v, w *Object, fun func(v, w in...
  function intCheckedDiv (line 471) | func intCheckedDiv(v, w int) (int, divModResult) {
  function intCheckedDivMod (line 476) | func intCheckedDivMod(v, w int) (int, int, divModResult) {
  function intCheckedAdd (line 502) | func intCheckedAdd(v, w int) (int, bool) {
  function intCheckedMod (line 509) | func intCheckedMod(v, w int) (int, divModResult) {
  function intCheckedMul (line 514) | func intCheckedMul(v, w int) (int, bool) {
  function intCheckedSub (line 534) | func intCheckedSub(v, w int) (int, bool) {
  function intDivModOp (line 541) | func intDivModOp(f *Frame, method string, v, w *Object, fun func(v, w in...
  function intDivAndModOp (line 555) | func intDivAndModOp(f *Frame, method string, v, w *Object, fun func(v, w...
  function intShiftOp (line 569) | func intShiftOp(f *Frame, v, w *Object, fun func(int, int) (int, int, bo...
  function intToLong (line 590) | func intToLong(o *Int) *Long {
  function makeInternedInts (line 594) | func makeInternedInts() [internedIntMax - internedIntMin + 1]Int {

FILE: runtime/int_test.go
  function TestIntBinaryOps (line 23) | func TestIntBinaryOps(t *testing.T) {
  function TestIntCompare (line 99) | func TestIntCompare(t *testing.T) {
  function TestIntInvert (line 113) | func TestIntInvert(t *testing.T) {
  function TestIntNew (line 128) | func TestIntNew(t *testing.T) {
  function TestIntNewInterned (line 195) | func TestIntNewInterned(t *testing.T) {
  function BenchmarkIntNew (line 217) | func BenchmarkIntNew(b *testing.B) {
  function TestIntStrRepr (line 235) | func TestIntStrRepr(t *testing.T) {
  function TestIntCheckedAddMul (line 251) | func TestIntCheckedAddMul(t *testing.T) {
  function TestIntCheckedDivMod (line 279) | func TestIntCheckedDivMod(t *testing.T) {
  function TestIntCheckedSub (line 326) | func TestIntCheckedSub(t *testing.T) {

FILE: runtime/list.go
  type List (line 29) | type List struct
    method ToObject (line 51) | func (l *List) ToObject() *Object {
    method Append (line 56) | func (l *List) Append(o *Object) {
    method DelItem (line 65) | func (l *List) DelItem(f *Frame, index int) *BaseException {
    method DelSlice (line 78) | func (l *List) DelSlice(f *Frame, s *Slice) *BaseException {
    method SetItem (line 105) | func (l *List) SetItem(f *Frame, index int, value *Object) *BaseExcept...
    method SetSlice (line 117) | func (l *List) SetSlice(f *Frame, s *Slice, value *Object) *BaseExcept...
    method Sort (line 147) | func (l *List) Sort(f *Frame) (raised *BaseException) {
    method resize (line 167) | func (l *List) resize(newLen int) {
  function NewList (line 36) | func NewList(elems ...*Object) *List {
  function toListUnsafe (line 46) | func toListUnsafe(o *Object) *List {
  function listAdd (line 184) | func listAdd(f *Frame, v, w *Object) (ret *Object, raised *BaseException) {
  function listAppend (line 200) | func listAppend(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseExcep...
  function listCount (line 208) | func listCount(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseExcept...
  function listDelItem (line 215) | func listDelItem(f *Frame, o *Object, key *Object) *BaseException {
  function listRemove (line 231) | func listRemove(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseExcep...
  function listExtend (line 253) | func listExtend(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
  function listContains (line 261) | func listContains(f *Frame, l, v *Object) (*Object, *BaseException) {
  function listEq (line 265) | func listEq(f *Frame, v, w *Object) (*Object, *BaseException) {
  function listGE (line 269) | func listGE(f *Frame, v, w *Object) (*Object, *BaseException) {
  function listGetItem (line 273) | func listGetItem(f *Frame, o, key *Object) (*Object, *BaseException) {
  function listGT (line 290) | func listGT(f *Frame, v, w *Object) (*Object, *BaseException) {
  function listIAdd (line 294) | func listIAdd(f *Frame, v, w *Object) (*Object, *BaseException) {
  function listIMul (line 306) | func listIMul(f *Frame, v, w *Object) (*Object, *BaseException) {
  function listInsert (line 323) | func listInsert(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseExcep...
  function listIter (line 341) | func listIter(f *Frame, o *Object) (*Object, *BaseException) {
  function listLE (line 345) | func listLE(f *Frame, v, w *Object) (*Object, *BaseException) {
  function listLen (line 349) | func listLen(f *Frame, o *Object) (*Object, *BaseException) {
  function listNew (line 357) | func listNew(f *Frame, t *Type, args Args, _ KWArgs) (*Object, *BaseExce...
  function listLT (line 367) | func listLT(f *Frame, v, w *Object) (*Object, *BaseException) {
  function listMul (line 371) | func listMul(f *Frame, v, w *Object) (*Object, *BaseException) {
  function listNE (line 385) | func listNE(f *Frame, v, w *Object) (*Object, *BaseException) {
  function listIndex (line 389) | func listIndex(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
  function listPop (line 433) | func listPop(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
  function listRepr (line 468) | func listRepr(f *Frame, o *Object) (*Object, *BaseException) {
  function listReverse (line 483) | func listReverse(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
  function listSetItem (line 498) | func listSetItem(f *Frame, o, key, value *Object) *BaseException {
  function listSort (line 513) | func listSort(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
  function initListType (line 523) | func initListType(dict map[string]*Object) {
  type listIterator (line 555) | type listIterator struct
  function newListIterator (line 562) | func newListIterator(l *List) *Object {
  function toListIteratorUnsafe (line 567) | func toListIteratorUnsafe(o *Object) *listIterator {
  function listIteratorIter (line 573) | func listIteratorIter(f *Frame, o *Object) (*Object, *BaseException) {
  function listIteratorNext (line 577) | func listIteratorNext(f *Frame, o *Object) (ret *Object, raised *BaseExc...
  function initListIteratorType (line 596) | func initListIteratorType(map[string]*Object) {
  function listCompare (line 602) | func listCompare(f *Frame, v *List, w *Object, cmp binaryOpFunc) (*Objec...
  type listSorter (line 616) | type listSorter struct
    method Len (line 622) | func (s *listSorter) Len() int {
    method Less (line 626) | func (s *listSorter) Less(i, j int) bool {
    method Swap (line 640) | func (s *listSorter) Swap(i, j int) {

FILE: runtime/list_test.go
  function TestNewList (line 23) | func TestNewList(t *testing.T) {
  function TestListBinaryOps (line 37) | func TestListBinaryOps(t *testing.T) {
  function TestListCompare (line 65) | func TestListCompare(t *testing.T) {
  function TestListCount (line 82) | func TestListCount(t *testing.T) {
  function TestListDelItem (line 95) | func TestListDelItem(t *testing.T) {
  function TestListIndex (line 133) | func TestListIndex(t *testing.T) {
  function TestListRemove (line 165) | func TestListRemove(t *testing.T) {
  function BenchmarkListContains (line 189) | func BenchmarkListContains(b *testing.B) {
  function TestListGetItem (line 241) | func TestListGetItem(t *testing.T) {
  function TestListInplaceOps (line 263) | func TestListInplaceOps(t *testing.T) {
  function TestListIsTrue (line 291) | func TestListIsTrue(t *testing.T) {
  function TestListAppend (line 303) | func TestListAppend(t *testing.T) {
  function TestListExtend (line 330) | func TestListExtend(t *testing.T) {
  function TestListLen (line 361) | func TestListLen(t *testing.T) {
  function TestListNew (line 373) | func TestListNew(t *testing.T) {
  function TestListReverse (line 387) | func TestListReverse(t *testing.T) {
  function TestListStrRepr (line 408) | func TestListStrRepr(t *testing.T) {
  function TestListInsert (line 427) | func TestListInsert(t *testing.T) {
  function TestListIter (line 454) | func TestListIter(t *testing.T) {
  function TestListIteratorIter (line 486) | func TestListIteratorIter(t *testing.T) {
  function TestListPop (line 494) | func TestListPop(t *testing.T) {
  function TestListSetItem (line 523) | func TestListSetItem(t *testing.T) {
  function TestListSort (line 561) | func TestListSort(t *testing.T) {
  function newTestRange (line 585) | func newTestRange(n int) *List {
  function newTestList (line 593) | func newTestList(elems ...interface{}) *List {

FILE: runtime/long.go
  type Long (line 37) | type Long struct
    method IntValue (line 65) | func (l *Long) IntValue(f *Frame) (int, *BaseException) {
    method ToObject (line 73) | func (l *Long) ToObject() *Object {
    method Value (line 78) | func (l *Long) Value() *big.Int {
    method IsTrue (line 83) | func (l *Long) IsTrue() bool {
    method Neg (line 88) | func (l *Long) Neg() *Long {
  function NewLong (line 45) | func NewLong(x *big.Int) *Long {
  function NewLongFromBytes (line 53) | func NewLongFromBytes(b []byte) *Long {
  function toLongUnsafe (line 59) | func toLongUnsafe(o *Object) *Long {
  function longAbs (line 98) | func longAbs(z, x *big.Int) {
  function longAdd (line 102) | func longAdd(z, x, y *big.Int) {
  function longAnd (line 106) | func longAnd(z, x, y *big.Int) {
  function longDiv (line 110) | func longDiv(z, x, y *big.Int) {
  function longDivAndMod (line 115) | func longDivAndMod(z, m, x, y *big.Int) {
  function longEq (line 119) | func longEq(x, y *big.Int) bool {
  function longGE (line 123) | func longGE(x, y *big.Int) bool {
  function longGetNewArgs (line 127) | func longGetNewArgs(f *Frame, args Args, _ KWArgs) (*Object, *BaseExcept...
  function longGT (line 134) | func longGT(x, y *big.Int) bool {
  function longFloat (line 138) | func longFloat(f *Frame, o *Object) (*Object, *BaseException) {
  function hashBigInt (line 146) | func hashBigInt(x *big.Int) int {
  function longHex (line 151) | func longHex(f *Frame, o *Object) (*Object, *BaseException) {
  function longHash (line 156) | func longHash(f *Frame, o *Object) (*Object, *BaseException) {
  function longIndex (line 168) | func longIndex(_ *Frame, o *Object) (*Object, *BaseException) {
  function longInt (line 172) | func longInt(f *Frame, o *Object) (*Object, *BaseException) {
  function longInvert (line 179) | func longInvert(z, x *big.Int) {
  function longLE (line 183) | func longLE(x, y *big.Int) bool {
  function longLShift (line 187) | func longLShift(z, x *big.Int, n uint) {
  function longLong (line 191) | func longLong(f *Frame, o *Object) (*Object, *BaseException) {
  function longLT (line 200) | func longLT(x, y *big.Int) bool {
  function longMul (line 204) | func longMul(z, x, y *big.Int) {
  function longMod (line 208) | func longMod(m, x, y *big.Int) {
  function longNative (line 213) | func longNative(f *Frame, o *Object) (reflect.Value, *BaseException) {
  function longNE (line 217) | func longNE(x, y *big.Int) bool {
  function longNeg (line 221) | func longNeg(z, x *big.Int) {
  function longNew (line 225) | func longNew(f *Frame, t *Type, args Args, _ KWArgs) (*Object, *BaseExce...
  function longNonZero (line 298) | func longNonZero(x *big.Int) bool {
  function longOct (line 302) | func longOct(f *Frame, o *Object) (*Object, *BaseException) {
  function longOr (line 310) | func longOr(z, x, y *big.Int) {
  function longPos (line 314) | func longPos(z, x *big.Int) {
  function longRepr (line 318) | func longRepr(f *Frame, o *Object) (*Object, *BaseException) {
  function longRShift (line 322) | func longRShift(z, x *big.Int, n uint) {
  function longStr (line 326) | func longStr(f *Frame, o *Object) (*Object, *BaseException) {
  function longSub (line 330) | func longSub(z, x, y *big.Int) {
  function longXor (line 334) | func longXor(z, x, y *big.Int) {
  function initLongType (line 338) | func initLongType(dict map[string]*Object) {
  function longCallUnary (line 392) | func longCallUnary(fun func(z, x *big.Int), v *Long) *Object {
  function longCallUnaryBool (line 398) | func longCallUnaryBool(fun func(x *big.Int) bool, v *Long) *Object {
  function longCallBinary (line 402) | func longCallBinary(fun func(z, x, y *big.Int), v, w *Long) *Object {
  function longCallBinaryTuple (line 408) | func longCallBinaryTuple(fun func(z, m, x, y *big.Int), v, w *Long) *Obj...
  function longCallBinaryBool (line 415) | func longCallBinaryBool(fun func(x, y *big.Int) bool, v, w *Long) *Object {
  function longCallShift (line 419) | func longCallShift(fun func(z, x *big.Int, n uint), f *Frame, v, w *Long...
  function longCallDivMod (line 431) | func longCallDivMod(fun func(z, x, y *big.Int), f *Frame, v, w *Long) (*...
  function longCallDivAndMod (line 438) | func longCallDivAndMod(fun func(z, m, x, y *big.Int), f *Frame, v, w *Lo...
  function longUnaryOpSlot (line 445) | func longUnaryOpSlot(fun func(z, x *big.Int)) *unaryOpSlot {
  function longUnaryBoolOpSlot (line 452) | func longUnaryBoolOpSlot(fun func(x *big.Int) bool) *unaryOpSlot {
  function longBinaryOpSlot (line 459) | func longBinaryOpSlot(fun func(z, x, y *big.Int)) *binaryOpSlot {
  function longRBinaryOpSlot (line 471) | func longRBinaryOpSlot(fun func(z, x, y *big.Int)) *binaryOpSlot {
  function longDivModOpSlot (line 483) | func longDivModOpSlot(fun func(z, x, y *big.Int)) *binaryOpSlot {
  function longRDivModOpSlot (line 495) | func longRDivModOpSlot(fun func(z, x, y *big.Int)) *binaryOpSlot {
  function longDivAndModOpSlot (line 507) | func longDivAndModOpSlot(fun func(z, m, x, y *big.Int)) *binaryOpSlot {
  function longRDivAndModOpSlot (line 519) | func longRDivAndModOpSlot(fun func(z, m, x, y *big.Int)) *binaryOpSlot {
  function longShiftOpSlot (line 531) | func longShiftOpSlot(fun func(z, x *big.Int, n uint)) *binaryOpSlot {
  function longRShiftOpSlot (line 543) | func longRShiftOpSlot(fun func(z, x *big.Int, n uint)) *binaryOpSlot {
  function longBinaryBoolOpSlot (line 555) | func longBinaryBoolOpSlot(fun func(x, y *big.Int) bool) *binaryOpSlot {
  function longRBinaryBoolOpSlot (line 567) | func longRBinaryBoolOpSlot(fun func(x, y *big.Int) bool) *binaryOpSlot {
  function longPow (line 579) | func longPow(f *Frame, v, w *Object) (*Object, *BaseException) {
  function longRPow (line 618) | func longRPow(f *Frame, v, w *Object) (*Object, *BaseException) {
  function longDivMod (line 629) | func longDivMod(x, y, z, m *big.Int) {

FILE: runtime/long_test.go
  function TestLongBasis (line 13) | func TestLongBasis(t *testing.T) {
  function TestNewLongFromBytes (line 21) | func TestNewLongFromBytes(t *testing.T) {
  function TestLongReprStr (line 39) | func TestLongReprStr(t *testing.T) {
  function TestLongNew (line 64) | func TestLongNew(t *testing.T) {
  function TestLongBinaryOps (line 117) | func TestLongBinaryOps(t *testing.T) {
  function TestLongCompare (line 221) | func TestLongCompare(t *testing.T) {
  function TestLongInvert (line 255) | func TestLongInvert(t *testing.T) {
  function TestLongInt (line 275) | func TestLongInt(t *testing.T) {
  function TestLongFloat (line 294) | func TestLongFloat(t *testing.T) {

FILE: runtime/method.go
  type Method (line 23) | type Method struct
    method ToObject (line 36) | func (m *Method) ToObject() *Object {
  function toMethodUnsafe (line 31) | func toMethodUnsafe(o *Object) *Method {
  function methodCall (line 43) | func methodCall(f *Frame, callable *Object, args Args, kwargs KWArgs) (*...
  function methodGet (line 81) | func methodGet(f *Frame, desc, instance *Object, owner *Type) (*Object, ...
  function methodNew (line 100) | func methodNew(f *Frame, t *Type, args Args, _ KWArgs) (*Object, *BaseEx...
  function methodRepr (line 130) | func methodRepr(f *Frame, o *Object) (*Object, *BaseException) {
  function initMethodType (line 153) | func initMethodType(map[string]*Object) {
  function methodGetMemberName (line 161) | func methodGetMemberName(f *Frame, o *Object) (string, *BaseException) {

FILE: runtime/method_test.go
  function TestMethodCall (line 21) | func TestMethodCall(t *testing.T) {
  function TestMethodGet (line 46) | func TestMethodGet(t *testing.T) {
  function TestMethodNew (line 79) | func TestMethodNew(t *testing.T) {
  function TestMethodStrRepr (line 92) | func TestMethodStrRepr(t *testing.T) {
  function newTestMethod (line 110) | func newTestMethod(function, self, class *Object) *Method {

FILE: runtime/module.go
  type moduleState (line 26) | type moduleState
  constant moduleStateNew (line 29) | moduleStateNew moduleState = iota
  constant moduleStateInitializing (line 30) | moduleStateInitializing
  constant moduleStateReady (line 31) | moduleStateReady
  type Module (line 44) | type Module struct
    method GetFilename (line 197) | func (m *Module) GetFilename(f *Frame) (*Str, *BaseException) {
    method GetName (line 210) | func (m *Module) GetName(f *Frame) (*Str, *BaseException) {
    method ToObject (line 222) | func (m *Module) ToObject() *Object {
  type ModuleInit (line 53) | type ModuleInit
  function RegisterModule (line 57) | func RegisterModule(name string, c *Code) {
  function ImportModule (line 89) | func ImportModule(f *Frame, name string) ([]*Object, *BaseException) {
  function importOne (line 118) | func importOne(f *Frame, name string) (*Object, *BaseException) {
  function newModule (line 183) | func newModule(name, filename string) *Module {
  function toModuleUnsafe (line 191) | func toModuleUnsafe(o *Object) *Module {
  function moduleInit (line 226) | func moduleInit(f *Frame, o *Object, args Args, _ KWArgs) (*Object, *Bas...
  function moduleRepr (line 246) | func moduleRepr(f *Frame, o *Object) (*Object, *BaseException) {
  function initModuleType (line 265) | func initModuleType(map[string]*Object) {
  function RunMain (line 276) | func RunMain(code *Code) int {

FILE: runtime/module_test.go
  function TestImportModule (line 23) | func TestImportModule(t *testing.T) {
  function TestModuleGetNameAndFilename (line 188) | func TestModuleGetNameAndFilename(t *testing.T) {
  function TestModuleInit (line 212) | func TestModuleInit(t *testing.T) {
  function TestModuleStrRepr (line 241) | func TestModuleStrRepr(t *testing.T) {
  function TestRunMain (line 258) | func TestRunMain(t *testing.T) {
  function runMainAndCaptureStderr (line 290) | func runMainAndCaptureStderr(code *Code) (int, string, error) {
  function init (line 315) | func init() {
  function newTestModule (line 363) | func newTestModule(name, filename string) *Module {

FILE: runtime/native.go
  type nativeMetaclass (line 61) | type nativeMetaclass struct
  function toNativeMetaclassUnsafe (line 66) | func toNativeMetaclassUnsafe(o *Object) *nativeMetaclass {
  function newNativeType (line 70) | func newNativeType(rtype reflect.Type, base *Type) *Type {
  function nativeTypedefNative (line 87) | func nativeTypedefNative(f *Frame, o *Object) (reflect.Value, *BaseExcep...
  function nativeMetaclassNew (line 100) | func nativeMetaclassNew(f *Frame, args Args, kwargs KWArgs) (*Object, *B...
  function initNativeMetaclassType (line 107) | func initNativeMetaclassType(dict map[string]*Object) {
  type nativeBoolMetaclass (line 112) | type nativeBoolMetaclass struct
  function toNativeBoolMetaclassUnsafe (line 118) | func toNativeBoolMetaclassUnsafe(o *Object) *nativeBoolMetaclass {
  function newNativeBoolType (line 122) | func newNativeBoolType(rtype reflect.Type) *Type {
  function nativeBoolNative (line 142) | func nativeBoolNative(f *Frame, o *Object) (reflect.Value, *BaseExceptio...
  function nativeBoolNew (line 147) | func nativeBoolNew(f *Frame, t *Type, args Args, kwargs KWArgs) (*Object...
  function initNativeBoolMetaclassType (line 166) | func initNativeBoolMetaclassType(dict map[string]*Object) {
  type native (line 171) | type native struct
    method ToObject (line 181) | func (n *native) ToObject() *Object {
  function toNativeUnsafe (line 176) | func toNativeUnsafe(o *Object) *native {
  function nativeNative (line 185) | func nativeNative(f *Frame, o *Object) (reflect.Value, *BaseException) {
  function initNativeType (line 189) | func initNativeType(map[string]*Object) {
  function nativeFuncCall (line 194) | func nativeFuncCall(f *Frame, callable *Object, args Args, kwargs KWArgs...
  function nativeFuncGetName (line 198) | func nativeFuncGetName(f *Frame, args Args, _ KWArgs) (*Object, *BaseExc...
  function nativeFuncRepr (line 206) | func nativeFuncRepr(f *Frame, o *Object) (*Object, *BaseException) {
  function initNativeFuncType (line 219) | func initNativeFuncType(dict map[string]*Object) {
  function nativeSliceGetItem (line 225) | func nativeSliceGetItem(f *Frame, o, key *Object) (*Object, *BaseExcepti...
  function nativeSliceIter (line 255) | func nativeSliceIter(f *Frame, o *Object) (*Object, *BaseException) {
  function nativeSliceLen (line 259) | func nativeSliceLen(f *Frame, o *Object) (*Object, *BaseException) {
  function nativeSliceRepr (line 263) | func nativeSliceRepr(f *Frame, o *Object) (*Object, *BaseException) {
  function nativeSliceSetItem (line 286) | func nativeSliceSetItem(f *Frame, o, key, value *Object) *BaseException {
  function initNativeSliceType (line 334) | func initNativeSliceType(map[string]*Object) {
  function nativeSliceGetIndex (line 342) | func nativeSliceGetIndex(f *Frame, slice reflect.Value, key *Object) (re...
  type sliceIterator (line 354) | type sliceIterator struct
  function newSliceIterator (line 362) | func newSliceIterator(slice reflect.Value) *Object {
  function toSliceIteratorUnsafe (line 367) | func toSliceIteratorUnsafe(o *Object) *sliceIterator {
  function sliceIteratorIter (line 371) | func sliceIteratorIter(f *Frame, o *Object) (*Object, *BaseException) {
  function sliceIteratorNext (line 375) | func sliceIteratorNext(f *Frame, o *Object) (ret *Object, raised *BaseEx...
  function initSliceIteratorType (line 388) | func initSliceIteratorType(map[string]*Object) {
  function WrapNative (line 408) | func WrapNative(f *Frame, v reflect.Value) (*Object, *BaseException) {
  function getNativeType (line 512) | func getNativeType(rtype reflect.Type) *Type {
  function newNativeField (line 569) | func newNativeField(name string, i int, t *Type) *Object {
  function newNativeMethod (line 603) | func newNativeMethod(name string, fun reflect.Value) *Object {
  function maybeConvertValue (line 609) | func maybeConvertValue(f *Frame, o *Object, expectedRType reflect.Type) ...
  function nativeFuncTypeName (line 647) | func nativeFuncTypeName(rtype reflect.Type) string {
  function nativeInvoke (line 675) | func nativeInvoke(f *Frame, fun reflect.Value, args Args) (ret *Object, ...
  function nativeTypeName (line 738) | func nativeTypeName(rtype reflect.Type) string {

FILE: runtime/native_test.go
  function TestNativeMetaclassNew (line 26) | func TestNativeMetaclassNew(t *testing.T) {
  function TestNativeFuncCall (line 60) | func TestNativeFuncCall(t *testing.T) {
  function TestNativeFuncName (line 81) | func TestNativeFuncName(t *testing.T) {
  function TestNativeFuncStrRepr (line 112) | func TestNativeFuncStrRepr(t *testing.T) {
  function TestNativeNew (line 146) | func TestNativeNew(t *testing.T) {
  function TestNativeSliceIter (line 179) | func TestNativeSliceIter(t *testing.T) {
  function TestSliceIteratorIter (line 200) | func TestSliceIteratorIter(t *testing.T) {
  function TestWrapNative (line 208) | func TestWrapNative(t *testing.T) {
  function TestWrapNativeFunc (line 249) | func TestWrapNativeFunc(t *testing.T) {
  function TestWrapNativeInterface (line 257) | func TestWrapNativeInterface(t *testing.T) {
  function TestWrapNativeOpaque (line 279) | func TestWrapNativeOpaque(t *testing.T) {
  function TestGetNativeTypeCaches (line 302) | func TestGetNativeTypeCaches(t *testing.T) {
  function TestGetNativeTypeFunc (line 310) | func TestGetNativeTypeFunc(t *testing.T) {
  type testNativeType (line 318) | type testNativeType struct
    method Int64 (line 322) | func (n *testNativeType) Int64() int64 {
  function TestGetNativeTypeMethods (line 326) | func TestGetNativeTypeMethods(t *testing.T) {
  function TestGetNativeTypeSlice (line 343) | func TestGetNativeTypeSlice(t *testing.T) {
  function TestGetNativeTypeTypedefs (line 351) | func TestGetNativeTypeTypedefs(t *testing.T) {
  function TestGetNativeTypeBigInts (line 372) | func TestGetNativeTypeBigInts(t *testing.T) {
  function TestMaybeConvertValue (line 387) | func TestMaybeConvertValue(t *testing.T) {
  function TestNativeTypedefNative (line 426) | func TestNativeTypedefNative(t *testing.T) {
  function TestNativeTypeName (line 449) | func TestNativeTypeName(t *testing.T) {
  function TestNewNativeFieldChecksInstanceType (line 473) | func TestNewNativeFieldChecksInstanceType(t *testing.T) {
  function TestNativeSliceGetItem (line 500) | func TestNativeSliceGetItem(t *testing.T) {
  function TestNativeSliceGetItemSlice (line 524) | func TestNativeSliceGetItemSlice(t *testing.T) {
  function TestNativeSliceLen (line 559) | func TestNativeSliceLen(t *testing.T) {
  function TestNativeSliceStrRepr (line 571) | func TestNativeSliceStrRepr(t *testing.T) {
  function TestNativeSliceSetItemSlice (line 591) | func TestNativeSliceSetItemSlice(t *testing.T) {
  function TestNativeStructFieldGet (line 632) | func TestNativeStructFieldGet(t *testing.T) {
  function TestNativeStructFieldSet (line 652) | func TestNativeStructFieldSet(t *testing.T) {
  function wrapArgs (line 676) | func wrapArgs(elems ...interface{}) Args {
  function wrapKWArgs (line 689) | func wrapKWArgs(elems ...interface{}) KWArgs {

FILE: runtime/numeric.go
  constant _maxuint (line 25) | _maxuint = 1<<(^uint(0)/0xff%15*8) - 1
  constant MaxInt (line 28) | MaxInt = _maxuint >> 1
  constant MinInt (line 31) | MinInt = -(_maxuint + 1) >> 1
  function numParseInteger (line 39) | func numParseInteger(z *big.Int, s string, base int) (*big.Int, bool) {
  function numInIntRange (line 68) | func numInIntRange(i *big.Int) bool {

FILE: runtime/object.go
  type Object (line 41) | type Object struct
    method Call (line 60) | func (o *Object) Call(f *Frame, args Args, kwargs KWArgs) (*Object, *B...
    method Dict (line 69) | func (o *Object) Dict() *Dict {
    method setDict (line 74) | func (o *Object) setDict(d *Dict) {
    method String (line 80) | func (o *Object) String() string {
    method Type (line 92) | func (o *Object) Type() *Type {
    method toPointer (line 96) | func (o *Object) toPointer() unsafe.Pointer {
    method isInstance (line 100) | func (o *Object) isInstance(t *Type) bool {
  function newObject (line 47) | func newObject(t *Type) *Object {
  function objectBasisFunc (line 104) | func objectBasisFunc(o *Object) reflect.Value {
  function objectDelAttr (line 108) | func objectDelAttr(f *Frame, o *Object, name *Str) *BaseException {
  function objectGetAttribute (line 135) | func objectGetAttribute(f *Frame, o *Object, name *Str) (*Object, *BaseE...
  function objectHash (line 167) | func objectHash(f *Frame, o *Object) (*Object, *BaseException) {
  function objectNew (line 171) | func objectNew(f *Frame, t *Type, _ Args, _ KWArgs) (*Object, *BaseExcep...
  function objectReduce (line 179) | func objectReduce(f *Frame, args Args, _ KWArgs) (*Object, *BaseExceptio...
  function objectReduceEx (line 191) | func objectReduceEx(f *Frame, args Args, _ KWArgs) (*Object, *BaseExcept...
  function objectSetAttr (line 211) | func objectSetAttr(f *Frame, o *Object, name *Str, value *Object) *BaseE...
  function initObjectType (line 227) | func initObjectType(dict map[string]*Object) {
  function objectReconstructor (line 242) | func objectReconstructor(f *Frame, args Args, _ KWArgs) (*Object, *BaseE...
  function objectReduceCommon (line 269) | func objectReduceCommon(f *Frame, args Args) (*Object, *BaseException) {
  function objectGetDict (line 347) | func objectGetDict(f *Frame, args Args, _ KWArgs) (*Object, *BaseExcepti...
  function objectSetDict (line 360) | func objectSetDict(f *Frame, args Args, _ KWArgs) (*Object, *BaseExcepti...

FILE: runtime/object_test.go
  function TestObjectCall (line 24) | func TestObjectCall(t *testing.T) {
  function TestNewObject (line 65) | func TestNewObject(t *testing.T) {
  function TestObjectString (line 74) | func TestObjectString(t *testing.T) {
  function TestObjectDelAttr (line 99) | func TestObjectDelAttr(t *testing.T) {
  function TestObjectGetAttribute (line 145) | func TestObjectGetAttribute(t *testing.T) {
  function TestObjectGetDict (line 208) | func TestObjectGetDict(t *testing.T) {
  function TestObjectSetDict (line 229) | func TestObjectSetDict(t *testing.T) {
  function TestObjectNew (line 254) | func TestObjectNew(t *testing.T) {
  function TestObjectReduce (line 272) | func TestObjectReduce(t *testing.T) {
  function TestObjectSetAttr (line 375) | func TestObjectSetAttr(t *testing.T) {
  function TestObjectStrRepr (line 415) | func TestObjectStrRepr(t *testing.T) {

FILE: runtime/param.go
  type Param (line 22) | type Param struct
  type ParamSpec (line 31) | type ParamSpec struct
    method Validate (line 71) | func (s *ParamSpec) Validate(f *Frame, validated []*Object, args Args,...
  function NewParamSpec (line 42) | func NewParamSpec(name string, params []Param, varArg bool, kwArg bool) ...

FILE: runtime/param_test.go
  function TestParamSpecValidate (line 21) | func TestParamSpecValidate(t *testing.T) {

FILE: runtime/range.go
  type enumerate (line 32) | type enumerate struct
  function toEnumerateUnsafe (line 39) | func toEnumerateUnsafe(o *Object) *enumerate {
  function enumerateIter (line 43) | func enumerateIter(f *Frame, o *Object) (*Object, *BaseException) {
  function enumerateNew (line 47) | func enumerateNew(f *Frame, t *Type, args Args, _ KWArgs) (*Object, *Bas...
  function enumerateNext (line 94) | func enumerateNext(f *Frame, o *Object) (ret *Object, raised *BaseExcept...
  function initEnumerateType (line 114) | func initEnumerateType(map[string]*Object) {
  type rangeIterator (line 121) | type rangeIterator struct
  function toRangeIteratorUnsafe (line 128) | func toRangeIteratorUnsafe(o *Object) *rangeIterator {
  function rangeIteratorIter (line 132) | func rangeIteratorIter(f *Frame, o *Object) (*Object, *BaseException) {
  function rangeIteratorNext (line 136) | func rangeIteratorNext(f *Frame, o *Object) (*Object, *BaseException) {
  function initRangeIteratorType (line 146) | func initRangeIteratorType(map[string]*Object) {
  type xrange (line 152) | type xrange struct
  function toXRangeUnsafe (line 159) | func toXRangeUnsafe(o *Object) *xrange {
  function xrangeGetItem (line 163) | func xrangeGetItem(f *Frame, o, key *Object) (*Object, *BaseException) {
  function xrangeIter (line 180) | func xrangeIter(f *Frame, o *Object) (*Object, *BaseException) {
  function xrangeLen (line 185) | func xrangeLen(f *Frame, o *Object) (*Object, *BaseException) {
  function xrangeNew (line 190) | func xrangeNew(f *Frame, _ *Type, args Args, _ KWArgs) (*Object, *BaseEx...
  function xrangeRepr (line 220) | func xrangeRepr(_ *Frame, o *Object) (*Object, *BaseException) {
  function initXRangeType (line 233) | func initXRangeType(map[string]*Object) {

FILE: runtime/range_test.go
  function TestEnumerate (line 21) | func TestEnumerate(t *testing.T) {
  function TestRangeIteratorIter (line 46) | func TestRangeIteratorIter(t *testing.T) {
  function TestXRangeGetItem (line 73) | func TestXRangeGetItem(t *testing.T) {
  function TestXRangeLen (line 88) | func TestXRangeLen(t *testing.T) {
  function TestXRangeNew (line 102) | func TestXRangeNew(t *testing.T) {
  function TestXRangeRepr (line 131) | func TestXRangeRepr(t *testing.T) {
  function newTestXRange (line 162) | func newTestXRange(args ...interface{}) *Object {

FILE: runtime/seq.go
  function seqAdd (line 30) | func seqAdd(f *Frame, elems1, elems2 []*Object) ([]*Object, *BaseExcepti...
  function seqCompare (line 38) | func seqCompare(f *Frame, elems1, elems2 []*Object, cmp binaryOpFunc) (*...
  function seqApply (line 65) | func seqApply(f *Frame, seq *Object, fun func([]*Object, bool) *BaseExce...
  function seqCheckedIndex (line 90) | func seqCheckedIndex(f *Frame, seqLen, index int) (int, *BaseException) {
  function seqClampIndex (line 100) | func seqClampIndex(i, seqLen int) int {
  function seqContains (line 113) | func seqContains(f *Frame, iterable *Object, v *Object) (*Object, *BaseE...
  function seqCount (line 132) | func seqCount(f *Frame, iterable *Object, v *Object) (*Object, *BaseExce...
  function seqFindFirst (line 154) | func seqFindFirst(f *Frame, iterable *Object, pred func(*Object) (bool, ...
  function seqFindElem (line 176) | func seqFindElem(f *Frame, elems []*Object, o *Object) (int, *BaseExcept...
  function seqForEach (line 193) | func seqForEach(f *Frame, iterable *Object, callback func(*Object) *Base...
  function seqGetItem (line 214) | func seqGetItem(f *Frame, elems []*Object, index *Object) (*Object, []*O...
  function seqMul (line 243) | func seqMul(f *Frame, elems []*Object, n int) ([]*Object, *BaseException) {
  function seqNew (line 259) | func seqNew(f *Frame, args Args) ([]*Object, *BaseException) {
  type seqRangeResult (line 282) | type seqRangeResult
  constant seqRangeOK (line 285) | seqRangeOK seqRangeResult = iota
  constant seqRangeOverflow (line 286) | seqRangeOverflow
  constant seqRangeZeroStep (line 287) | seqRangeZeroStep
  function seqRange (line 300) | func seqRange(start, stop, step int) (int, int, seqRangeResult) {
  function seqRepr (line 321) | func seqRepr(f *Frame, elems []*Object) (string, *BaseException) {
  function seqWrapEach (line 337) | func seqWrapEach(f *Frame, elems ...interface{}) ([]*Object, *BaseExcept...
  type seqIterator (line 348) | type seqIterator struct
  function newSeqIterator (line 355) | func newSeqIterator(seq *Object) *Object {
  function toSeqIteratorUnsafe (line 360) | func toSeqIteratorUnsafe(o *Object) *seqIterator {
  function seqIteratorIter (line 364) | func seqIteratorIter(f *Frame, o *Object) (*Object, *BaseException) {
  function seqIteratorNext (line 368) | func seqIteratorNext(f *Frame, o *Object) (item *Object, raised *BaseExc...
  function initSeqIteratorType (line 383) | func initSeqIteratorType(map[string]*Object) {

FILE: runtime/seq_test.go
  function TestSeqApply (line 21) | func TestSeqApply(t *testing.T) {
  function TestSeqCount (line 46) | func TestSeqCount(t *testing.T) {
  function TestSeqForEach (line 78) | func TestSeqForEach(t *testing.T) {
  function TestSeqIterator (line 102) | func TestSeqIterator(t *testing.T) {
  function TestSeqNew (line 120) | func TestSeqNew(t *testing.T) {

FILE: runtime/set.go
  type setBase (line 29) | type setBase struct
    method contains (line 34) | func (s *setBase) contains(f *Frame, key *Object) (bool, *BaseExceptio...
    method isSubset (line 42) | func (s *setBase) isSubset(f *Frame, o *Object) (*Object, *BaseExcepti...
    method isSuperset (line 50) | func (s *setBase) isSuperset(f *Frame, o *Object) (*Object, *BaseExcep...
    method repr (line 58) | func (s *setBase) repr(f *Frame) (*Object, *BaseException) {
  type Set (line 71) | type Set
    method Add (line 83) | func (s *Set) Add(f *Frame, key *Object) (bool, *BaseException) {
    method Contains (line 92) | func (s *Set) Contains(f *Frame, key *Object) (bool, *BaseException) {
    method Remove (line 97) | func (s *Set) Remove(f *Frame, key *Object) (bool, *BaseException) {
    method ToObject (line 102) | func (s *Set) ToObject() *Object {
    method Update (line 107) | func (s *Set) Update(f *Frame, o *Object) *BaseException {
  function NewSet (line 74) | func NewSet() *Set {
  function toSetUnsafe (line 78) | func toSetUnsafe(o *Object) *Set {
  function setAdd (line 114) | func setAdd(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
  function setContains (line 124) | func setContains(f *Frame, seq, value *Object) (*Object, *BaseException) {
  function setDiscard (line 132) | func setDiscard(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
  function setEq (line 142) | func setEq(f *Frame, v, w *Object) (*Object, *BaseException) {
  function setGE (line 146) | func setGE(f *Frame, v, w *Object) (*Object, *BaseException) {
  function setGT (line 150) | func setGT(f *Frame, v, w *Object) (*Object, *BaseException) {
  function setInit (line 154) | func setInit(f *Frame, o *Object, args Args, _ KWArgs) (*Object, *BaseEx...
  function setIsSubset (line 168) | func setIsSubset(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
  function setIsSuperset (line 175) | func setIsSuperset(f *Frame, args Args, _ KWArgs) (*Object, *BaseExcepti...
  function setIter (line 182) | func setIter(f *Frame, o *Object) (*Object, *BaseException) {
  function setLE (line 190) | func setLE(f *Frame, v, w *Object) (*Object, *BaseException) {
  function setLen (line 194) | func setLen(f *Frame, o *Object) (*Object, *BaseException) {
  function setLT (line 198) | func setLT(f *Frame, v, w *Object) (*Object, *BaseException) {
  function setNE (line 202) | func setNE(f *Frame, v, w *Object) (*Object, *BaseException) {
  function setNew (line 206) | func setNew(f *Frame, t *Type, _ Args, _ KWArgs) (*Object, *BaseExceptio...
  function setRemove (line 212) | func setRemove(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
  function setRepr (line 225) | func setRepr(f *Frame, o *Object) (*Object, *BaseException) {
  function setUpdate (line 229) | func setUpdate(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
  function initSetType (line 239) | func initSetType(dict map[string]*Object) {
  type FrozenSet (line 262) | type FrozenSet
    method Contains (line 269) | func (s *FrozenSet) Contains(f *Frame, key *Object) (bool, *BaseExcept...
    method ToObject (line 274) | func (s *FrozenSet) ToObject() *Object {
  function toFrozenSetUnsafe (line 264) | func toFrozenSetUnsafe(o *Object) *FrozenSet {
  function frozenSetContains (line 278) | func frozenSetContains(f *Frame, seq, value *Object) (*Object, *BaseExce...
  function frozenSetEq (line 286) | func frozenSetEq(f *Frame, v, w *Object) (*Object, *BaseException) {
  function frozenSetGE (line 290) | func frozenSetGE(f *Frame, v, w *Object) (*Object, *BaseException) {
  function frozenSetGT (line 294) | func frozenSetGT(f *Frame, v, w *Object) (*Object, *BaseException) {
  function frozenSetIsSubset (line 298) | func frozenSetIsSubset(f *Frame, args Args, _ KWArgs) (*Object, *BaseExc...
  function frozenSetIsSuperset (line 305) | func frozenSetIsSuperset(f *Frame, args Args, _ KWArgs) (*Object, *BaseE...
  function frozenSetIter (line 312) | func frozenSetIter(f *Frame, o *Object) (*Object, *BaseException) {
  function frozenSetLE (line 320) | func frozenSetLE(f *Frame, v, w *Object) (*Object, *BaseException) {
  function frozenSetLen (line 324) | func frozenSetLen(f *Frame, o *Object) (*Object, *BaseException) {
  function frozenSetLT (line 328) | func frozenSetLT(f *Frame, v, w *Object) (*Object, *BaseException) {
  function frozenSetNE (line 332) | func frozenSetNE(f *Frame, v, w *Object) (*Object, *BaseException) {
  function frozenSetNew (line 336) | func frozenSetNew(f *Frame, t *Type, args Args, _ KWArgs) (*Object, *Bas...
  function frozenSetRepr (line 355) | func frozenSetRepr(f *Frame, o *Object) (*Object, *BaseException) {
  function initFrozenSetType (line 359) | func initFrozenSetType(dict map[string]*Object) {
  function setCompare (line 377) | func setCompare(f *Frame, op compareOp, v *setBase, w *Object) (*Object,...
  function setFromSeq (line 431) | func setFromSeq(f *Frame, seq *Object) (*setBase, *BaseException) {

FILE: runtime/set_test.go
  function TestSetAdd (line 22) | func TestSetAdd(t *testing.T) {
  function TestSetContains (line 46) | func TestSetContains(t *testing.T) {
  function TestSetDiscard (line 63) | func TestSetDiscard(t *testing.T) {
  function TestSetCompare (line 87) | func TestSetCompare(t *testing.T) {
  function TestSetIsSubset (line 117) | func TestSetIsSubset(t *testing.T) {
  function TestSetIsSuperset (line 138) | func TestSetIsSuperset(t *testing.T) {
  function TestSetIsTrue (line 157) | func TestSetIsTrue(t *testing.T) {
  function TestSetIter (line 172) | func TestSetIter(t *testing.T) {
  function TestSetLen (line 199) | func TestSetLen(t *testing.T) {
  function TestSetNewInit (line 214) | func TestSetNewInit(t *testing.T) {
  function TestSetRemove (line 232) | func TestSetRemove(t *testing.T) {
  function TestSetStrRepr (line 257) | func TestSetStrRepr(t *testing.T) {
  function TestSetUpdate (line 276) | func TestSetUpdate(t *testing.T) {
  function newTestSet (line 302) | func newTestSet(elems ...interface{}) *Set {
  function newTestFrozenSet (line 317) | func newTestFrozenSet(elems ...interface{}) *FrozenSet {

FILE: runtime/slice.go
  constant errBadSliceIndex (line 19) | errBadSliceIndex = "slice indices must be integers or None or have an __...
  type Slice (line 27) | type Slice struct
    method calcSlice (line 43) | func (s *Slice) calcSlice(f *Frame, numElems int) (int, int, int, int,...
    method ToObject (line 80) | func (s *Slice) ToObject() *Object {
  function toSliceUnsafe (line 34) | func toSliceUnsafe(o *Object) *Slice {
  function sliceEq (line 84) | func sliceEq(f *Frame, v, w *Object) (*Object, *BaseException) {
  function sliceGE (line 88) | func sliceGE(f *Frame, v, w *Object) (*Object, *BaseException) {
  function sliceGT (line 92) | func sliceGT(f *Frame, v, w *Object) (*Object, *BaseException) {
  function sliceLE (line 96) | func sliceLE(f *Frame, v, w *Object) (*Object, *BaseException) {
  function sliceLT (line 100) | func sliceLT(f *Frame, v, w *Object) (*Object, *BaseException) {
  function sliceNE (line 104) | func sliceNE(f *Frame, v, w *Object) (*Object, *BaseException) {
  function sliceNew (line 108) | func sliceNew(f *Frame, t *Type, args Args, _ KWArgs) (*Object, *BaseExc...
  function sliceRepr (line 130) | func sliceRepr(f *Frame, o *Object) (*Object, *BaseException) {
  function initSliceType (line 146) | func initSliceType(map[string]*Object) {
  function sliceClampIndex (line 159) | func sliceClampIndex(f *Frame, index *Object, def, seqLen int) (int, *Ba...
  function sliceCompare (line 173) | func sliceCompare(f *Frame, v *Slice, w *Object, cmp binaryOpFunc) (*Obj...

FILE: runtime/slice_test.go
  function TestSliceCalcSize (line 21) | func TestSliceCalcSize(t *testing.T) {
  function TestSliceCompare (line 46) | func TestSliceCompare(t *testing.T) {
  function TestSliceNew (line 61) | func TestSliceNew(t *testing.T) {
  function TestSliceStrRepr (line 76) | func TestSliceStrRepr(t *testing.T) {
  function newTestSlice (line 92) | func newTestSlice(args ...interface{}) *Object {

FILE: runtime/slots.go
  type slot (line 29) | type slot interface
  type basisSlot (line 40) | type basisSlot struct
    method makeCallable (line 44) | func (s *basisSlot) makeCallable(t *Type, slotName string) *Object {
    method wrapCallable (line 48) | func (s *basisSlot) wrapCallable(callable *Object) bool {
  type binaryOpFunc (line 52) | type binaryOpFunc
  type binaryOpSlot (line 54) | type binaryOpSlot struct
    method makeCallable (line 58) | func (s *binaryOpSlot) makeCallable(t *Type, slotName string) *Object {
    method wrapCallable (line 67) | func (s *binaryOpSlot) wrapCallable(callable *Object) bool {
  type callSlot (line 74) | type callSlot struct
    method makeCallable (line 78) | func (s *callSlot) makeCallable(t *Type, _ string) *Object {
    method wrapCallable (line 87) | func (s *callSlot) wrapCallable(callable *Object) bool {
  type delAttrSlot (line 97) | type delAttrSlot struct
    method makeCallable (line 101) | func (s *delAttrSlot) makeCallable(t *Type, slotName string) *Object {
    method wrapCallable (line 113) | func (s *delAttrSlot) wrapCallable(callable *Object) bool {
  type deleteSlot (line 121) | type deleteSlot struct
    method makeCallable (line 125) | func (s *deleteSlot) makeCallable(t *Type, slotName string) *Object {
    method wrapCallable (line 137) | func (s *deleteSlot) wrapCallable(callable *Object) bool {
  type delItemSlot (line 145) | type delItemSlot struct
    method makeCallable (line 149) | func (s *delItemSlot) makeCallable(t *Type, slotName string) *Object {
    method wrapCallable (line 161) | func (s *delItemSlot) wrapCallable(callable *Object) bool {
  type getAttributeSlot (line 169) | type getAttributeSlot struct
    method makeCallable (line 173) | func (s *getAttributeSlot) makeCallable(t *Type, slotName string) *Obj...
    method wrapCallable (line 182) | func (s *getAttributeSlot) wrapCallable(callable *Object) bool {
  type getSlot (line 189) | type getSlot struct
    method makeCallable (line 193) | func (s *getSlot) makeCallable(t *Type, slotName string) *Object {
    method wrapCallable (line 202) | func (s *getSlot) wrapCallable(callable *Object) bool {
  type initSlot (line 209) | type initSlot struct
    method makeCallable (line 213) | func (s *initSlot) makeCallable(t *Type, _ string) *Object {
    method wrapCallable (line 222) | func (s *initSlot) wrapCallable(callable *Object) bool {
  type nativeSlot (line 232) | type nativeSlot struct
    method makeCallable (line 236) | func (s *nativeSlot) makeCallable(t *Type, slotName string) *Object {
    method wrapCallable (line 240) | func (s *nativeSlot) wrapCallable(callable *Object) bool {
  type newSlot (line 244) | type newSlot struct
    method makeCallable (line 248) | func (s *newSlot) makeCallable(t *Type, _ string) *Object {
    method wrapCallable (line 262) | func (s *newSlot) wrapCallable(callable *Object) bool {
  type setAttrSlot (line 272) | type setAttrSlot struct
    method makeCallable (line 276) | func (s *setAttrSlot) makeCallable(t *Type, slotName string) *Object {
    method wrapCallable (line 288) | func (s *setAttrSlot) wrapCallable(callable *Object) bool {
  type setItemSlot (line 296) | type setItemSlot struct
    method makeCallable (line 300) | func (s *setItemSlot) makeCallable(t *Type, slotName string) *Object {
    method wrapCallable (line 312) | func (s *setItemSlot) wrapCallable(callable *Object) bool {
  type setSlot (line 320) | type setSlot struct
    method makeCallable (line 324) | func (s *setSlot) makeCallable(t *Type, slotName string) *Object {
    method wrapCallable (line 336) | func (s *setSlot) wrapCallable(callable *Object) bool {
  type unaryOpSlot (line 344) | type unaryOpSlot struct
    method makeCallable (line 348) | func (s *unaryOpSlot) makeCallable(t *Type, slotName string) *Object {
    method wrapCallable (line 357) | func (s *unaryOpSlot) wrapCallable(callable *Object) bool {
  type typeSlots (line 371) | type typeSlots struct
  function calcSlotNames (line 454) | func calcSlotNames() []string {

FILE: runtime/slots_test.go
  function TestSlotMakeCallable (line 22) | func TestSlotMakeCallable(t *testing.T) {
  function TestSlotWrapCallable (line 81) | func TestSlotWrapCallable(t *testing.T) {
  function prepareTestSlot (line 161) | func prepareTestSlot(s slot, gotArgs **Object, ret *Object) {

FILE: runtime/str.go
  type stripSide (line 42) | type stripSide
  constant stripSideLeft (line 45) | stripSideLeft stripSide = iota
  constant stripSideRight (line 46) | stripSideRight
  constant stripSideBoth (line 47) | stripSideBoth
  function InternStr (line 53) | func InternStr(s string) *Str {
  type Str (line 63) | type Str struct
    method Decode (line 89) | func (s *Str) Decode(f *Frame, encoding, errors string) (*Unicode, *Ba...
    method ToObject (line 116) | func (s *Str) ToObject() *Object {
    method Value (line 121) | func (s *Str) Value() string {
  function NewStr (line 70) | func NewStr(value string) *Str {
  function toStrUnsafe (line 77) | func toStrUnsafe(o *Object) *Str {
  function hashString (line 125) | func hashString(s string) int {
  function strAdd (line 141) | func strAdd(f *Frame, v, w *Object) (*Object, *BaseException) {
  function strCapitalize (line 163) | func strCapitalize(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseEx...
  function strCenter (line 180) | func strCenter(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseExcept...
  function strContains (line 193) | func strContains(f *Frame, o *Object, value *Object) (*Object, *BaseExce...
  function strCount (line 208) | func strCount(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseExcepti...
  function strDecode (line 218) | func strDecode(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseExcept...
  function strEndsWith (line 243) | func strEndsWith(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
  function strEq (line 247) | func strEq(f *Frame, v, w *Object) (*Object, *BaseException) {
  function strFind (line 253) | func strFind(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
  function strGE (line 259) | func strGE(f *Frame, v, w *Object) (*Object, *BaseException) {
  function strGetItem (line 265) | func strGetItem(f *Frame, o, key *Object) (*Object, *BaseException) {
  function strGetNewArgs (line 296) | func strGetNewArgs(f *Frame, args Args, _ KWArgs) (*Object, *BaseExcepti...
  function strGT (line 303) | func strGT(f *Frame, v, w *Object) (*Object, *BaseException) {
  function strHash (line 307) | func strHash(f *Frame, o *Object) (*Object, *BaseException) {
  function strIndex (line 318) | func strIndex(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
  function strIsAlNum (line 328) | func strIsAlNum(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseExcep...
  function strIsAlpha (line 344) | func strIsAlpha(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseExcep...
  function strIsDigit (line 360) | func strIsDigit(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseExcep...
  function strIsLower (line 376) | func strIsLower(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseExcep...
  function strIsSpace (line 392) | func strIsSpace(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseExcep...
  function strIsTitle (line 408) | func strIsTitle(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseExcep...
  function strIsUpper (line 446) | func strIsUpper(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseExcep...
  function strJoin (line 462) | func strJoin(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
  function strLE (line 512) | func strLE(f *Frame, v, w *Object) (*Object, *BaseException) {
  function strLen (line 516) | func strLen(f *Frame, o *Object) (*Object, *BaseException) {
  function strLJust (line 520) | func strLJust(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseExcepti...
  function strLower (line 531) | func strLower(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseExcepti...
  function strLStrip (line 548) | func strLStrip(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
  function strLT (line 552) | func strLT(f *Frame, v, w *Object) (*Object, *BaseException) {
  function strMod (line 556) | func strMod(f *Frame, v, w *Object) (*Object, *BaseException) {
  function strMul (line 568) | func strMul(f *Frame, v, w *Object) (*Object, *BaseException) {
  function strNative (line 580) | func strNative(f *Frame, o *Object) (reflect.Value, *BaseException) {
  function strNE (line 584) | func strNE(f *Frame, v, w *Object) (*Object, *BaseException) {
  function strNew (line 588) | func strNew(f *Frame, t *Type, args Args, _ KWArgs) (*Object, *BaseExcep...
  function strReplace (line 631) | func strReplace(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
  function strRepr (line 691) | func strRepr(_ *Frame, o *Object) (*Object, *BaseException) {
  function strRFind (line 710) | func strRFind(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
  function strRIndex (line 716) | func strRIndex(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
  function strRJust (line 726) | func strRJust(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseExcepti...
  function strSplit (line 737) | func strSplit(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseExcepti...
  function strSplitLines (line 782) | func strSplitLines(f *Frame, args Args, _ KWArgs) (*Object, *BaseExcepti...
  function strStrip (line 834) | func strStrip(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
  function strRStrip (line 838) | func strRStrip(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
  function strStripImpl (line 842) | func strStripImpl(f *Frame, args Args, side stripSide) (*Object, *BaseEx...
  function strStartsWith (line 902) | func strStartsWith(f *Frame, args Args, _ KWArgs) (*Object, *BaseExcepti...
  function strStr (line 906) | func strStr(_ *Frame, o *Object) (*Object, *BaseException) {
  function strSwapCase (line 913) | func strSwapCase(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseExce...
  function initStrType (line 935) | func initStrType(dict map[string]*Object) {
  function strCompare (line 988) | func strCompare(v, w *Object, ltResult, eqResult, gtResult *Int) *Object {
  function strInterpolate (line 1006) | func strInterpolate(f *Frame, format string, values *Tuple) (*Object, *B...
  function strRepeatCount (line 1128) | func strRepeatCount(f *Frame, numChars int, mult *Object) (int, bool, *B...
  function adjustIndex (line 1151) | func adjustIndex(start, end, length int) (int, int) {
  function strStartsEndsWith (line 1169) | func strStartsEndsWith(f *Frame, method string, args Args) (*Object, *Ba...
  function strTitle (line 1231) | func strTitle(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseExcepti...
  function strUpper (line 1264) | func strUpper(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseExcepti...
  function strZFill (line 1281) | func strZFill(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
  function init (line 1293) | func init() {
  function toLower (line 1300) | func toLower(b byte) byte {
  function toUpper (line 1307) | func toUpper(b byte) byte {
  function isAlNum (line 1314) | func isAlNum(c byte) bool {
  function isAlpha (line 1318) | func isAlpha(c byte) bool {
  function isDigit (line 1322) | func isDigit(c byte) bool {
  function isLower (line 1326) | func isLower(c byte) bool {
  function isSpace (line 1330) | func isSpace(c byte) bool {
  function isUpper (line 1339) | func isUpper(c byte) bool {
  function pad (line 1343) | func pad(s string, left int, right int, fillchar string) string {
  function strLeftPad (line 1369) | func strLeftPad(s string, width int, fillchar string) string {
  type indexFunc (line 1388) | type indexFunc
  function strFindOrIndex (line 1390) | func strFindOrIndex(f *Frame, args Args, fn indexFunc) (*Object, *BaseEx...
  function strJustDecodeArgs (line 1435) | func strJustDecodeArgs(f *Frame, args Args, name string) (string, int, s...

FILE: runtime/str_test.go
  function TestNewStr (line 25) | func TestNewStr(t *testing.T) {
  function BenchmarkNewStr (line 33) | func BenchmarkNewStr(b *testing.B) {
  function TestHashString (line 48) | func TestHashString(t *testing.T) {
  function TestStrBinaryOps (line 65) | func TestStrBinaryOps(t *testing.T) {
  function TestStrCompare (line 125) | func TestStrCompare(t *testing.T) {
  function TestStrContains (line 140) | func TestStrContains(t *testing.T) {
  function TestStrDecode (line 155) | func TestStrDecode(t *testing.T) {
  function TestStrGetItem (line 177) | func TestStrGetItem(t *testing.T) {
  function TestStrNew (line 212) | func TestStrNew(t *testing.T) {
  function TestStrRepr (line 261) | func TestStrRepr(t *testing.T) {
  function TestStrMethods (line 274) | func TestStrMethods(t *testing.T) {
  function TestStrStr (line 700) | func TestStrStr(t *testing.T) {

FILE: runtime/super.go
  type super (line 26) | type super struct
  function toSuperUnsafe (line 33) | func toSuperUnsafe(o *Object) *super {
  function superInit (line 37) | func superInit(f *Frame, o *Object, args Args, _ KWArgs) (*Object, *Base...
  function superGetAttribute (line 59) | func superGetAttribute(f *Frame, o *Object, name *Str) (*Object, *BaseEx...
  function initSuperType (line 96) | func initSuperType(map[string]*Object) {

FILE: runtime/super_test.go
  function TestSuperInitErrors (line 21) | func TestSuperInitErrors(t *testing.T) {
  function TestSuperGetAttribute (line 35) | func TestSuperGetAttribute(t *testing.T) {

FILE: runtime/threading.go
  constant argsCacheSize (line 24) | argsCacheSize = 16
  constant argsCacheArgc (line 25) | argsCacheArgc = 6
  type threadState (line 28) | type threadState struct
  function newThreadState (line 45) | func newThreadState() *threadState {
  type recursiveMutex (line 51) | type recursiveMutex struct
    method Lock (line 57) | func (m *recursiveMutex) Lock(f *Frame) {
    method Unlock (line 72) | func (m *recursiveMutex) Unlock(f *Frame) {
  type TryableMutex (line 89) | type TryableMutex struct
    method Lock (line 101) | func (m *TryableMutex) Lock() {
    method TryLock (line 107) | func (m *TryableMutex) TryLock() bool {
    method Unlock (line 117) | func (m *TryableMutex) Unlock() {
  function NewTryableMutex (line 94) | func NewTryableMutex() *TryableMutex {

FILE: runtime/threading_test.go
  function TestRecursiveMutex (line 21) | func TestRecursiveMutex(t *testing.T) {
  function TestRecursiveMutexUnlockedTooManyTimes (line 30) | func TestRecursiveMutexUnlockedTooManyTimes(t *testing.T) {
  function TestRecursiveMutexUnlockFrameMismatch (line 46) | func TestRecursiveMutexUnlockFrameMismatch(t *testing.T) {

FILE: runtime/traceback.go
  type Traceback (line 22) | type Traceback struct
    method ToObject (line 39) | func (f *Traceback) ToObject() *Object {
  function newTraceback (line 29) | func newTraceback(f *Frame, next *Traceback) *Traceback {
  function toTracebackUnsafe (line 34) | func toTracebackUnsafe(o *Object) *Traceback {
  function initTracebackType (line 46) | func initTracebackType(map[string]*Object) {

FILE: runtime/tuple.go
  type Tuple (line 25) | type Tuple struct
    method GetItem (line 143) | func (t *Tuple) GetItem(i int) *Object {
    method Len (line 148) | func (t *Tuple) Len() int {
    method ToObject (line 153) | func (t *Tuple) ToObject() *Object {
  function NewTuple (line 31) | func NewTuple(elems ...*Object) *Tuple {
  function NewTuple0 (line 57) | func NewTuple0() *Tuple { return emptyTuple }
  function NewTuple1 (line 60) | func NewTuple1(elem0 *Object) *Tuple {
  function NewTuple2 (line 73) | func NewTuple2(elem0, elem1 *Object) *Tuple {
  function NewTuple3 (line 86) | func NewTuple3(elem0, elem1, elem2 *Object) *Tuple {
  function NewTuple4 (line 99) | func NewTuple4(elem0, elem1, elem2, elem3 *Object) *Tuple {
  function NewTuple5 (line 112) | func NewTuple5(elem0, elem1, elem2, elem3, elem4 *Object) *Tuple {
  function NewTuple6 (line 125) | func NewTuple6(elem0, elem1, elem2, elem3, elem4, elem5 *Object) *Tuple {
  function toTupleUnsafe (line 137) | func toTupleUnsafe(o *Object) *Tuple {
  function tupleAdd (line 162) | func tupleAdd(f *Frame, v, w *Object) (*Object, *BaseException) {
  function tupleContains (line 173) | func tupleContains(f *Frame, t, v *Object) (*Object, *BaseException) {
  function tupleCount (line 177) | func tupleCount(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseExcep...
  function tupleEq (line 184) | func tupleEq(f *Frame, v, w *Object) (*Object, *BaseException) {
  function tupleGE (line 188) | func tupleGE(f *Frame, v, w *Object) (*Object, *BaseException) {
  function tupleGetItem (line 192) | func tupleGetItem(f *Frame, o, key *Object) (*Object, *BaseException) {
  function tupleGetNewArgs (line 204) | func tupleGetNewArgs(f *Frame, args Args, _ KWArgs) (*Object, *BaseExcep...
  function tupleGT (line 211) | func tupleGT(f *Frame, v, w *Object) (*Object, *BaseException) {
  function tupleIter (line 215) | func tupleIter(f *Frame, o *Object) (*Object, *BaseException) {
  function tupleLE (line 219) | func tupleLE(f *Frame, v, w *Object) (*Object, *BaseException) {
  function tupleLen (line 223) | func tupleLen(f *Frame, o *Object) (*Object, *BaseException) {
  function tupleLT (line 227) | func tupleLT(f *Frame, v, w *Object) (*Object, *BaseException) {
  function tupleMul (line 231) | func tupleMul(f *Frame, v, w *Object) (*Object, *BaseException) {
  function tupleNE (line 242) | func tupleNE(f *Frame, v, w *Object) (*Object, *BaseException) {
  function tupleNew (line 246) | func tupleNew(f *Frame, t *Type, args Args, _ KWArgs) (*Object, *BaseExc...
  function tupleRepr (line 260) | func tupleRepr(f *Frame, o *Object) (*Object, *BaseException) {
  function tupleRMul (line 278) | func tupleRMul(f *Frame, v, w *Object) (*Object, *BaseException) {
  function initTupleType (line 289) | func initTupleType(dict map[string]*Object) {
  function tupleCompare (line 309) | func tupleCompare(f *Frame, v *Tuple, w *Object, cmp binaryOpFunc) (*Obj...

FILE: runtime/tuple_test.go
  function TestNewTuple (line 22) | func TestNewTuple(t *testing.T) {
  function TestTupleBinaryOps (line 36) | func TestTupleBinaryOps(t *testing.T) {
  function TestTupleCompare (line 61) | func TestTupleCompare(t *testing.T) {
  function TestTupleCompareNotImplemented (line 78) | func TestTupleCompareNotImplemented(t *testing.T) {
  function TestTupleContains (line 85) | func TestTupleContains(t *testing.T) {
  function TestTupleCount (line 105) | func TestTupleCount(t *testing.T) {
  function BenchmarkTupleContains (line 118) | func BenchmarkTupleContains(b *testing.B) {
  function TestTupleGetItem (line 170) | func TestTupleGetItem(t *testing.T) {
  function TestTupleLen (line 188) | func TestTupleLen(t *testing.T) {
  function TestTupleNew (line 195) | func TestTupleNew(t *testing.T) {
  function TestTupleStrRepr (line 209) | func TestTupleStrRepr(t *testing.T) {
  function TestTupleIter (line 233) | func TestTupleIter(t *testing.T) {
  function newTestTuple (line 246) | func newTestTuple(elems ...interface{}) *Tuple {

FILE: runtime/type.go
  type typeFlag (line 22) | type typeFlag
  constant typeFlagInstantiable (line 29) | typeFlagInstantiable typeFlag = 1 << iota
  constant typeFlagBasetype (line 32) | typeFlagBasetype typeFlag = 1 << iota
  constant typeFlagDefault (line 33) | typeFlagDefault           = typeFlagInstantiable | typeFlagBasetype
  type Type (line 37) | type Type struct
    method ToObject (line 279) | func (t *Type) ToObject() *Object {
    method Name (line 284) | func (t *Type) Name() string {
    method FullName (line 289) | func (t *Type) FullName(f *Frame) (string, *BaseException) {
    method isSubclass (line 305) | func (t *Type) isSubclass(super *Type) bool {
    method mroLookup (line 314) | func (t *Type) mroLookup(f *Frame, name *Str) (*Object, *BaseException) {
  function newClass (line 54) | func newClass(f *Frame, meta *Type, name string, bases []*Type, dict *Di...
  function newType (line 102) | func newType(meta *Type, name string, basis reflect.Type, bases []*Type,...
  function newBasisType (line 112) | func newBasisType(name string, basis reflect.Type, basisFunc interface{}...
  function newSimpleType (line 139) | func newSimpleType(name string, base *Type) *Type {
  function prepareBuiltinType (line 145) | func prepareBuiltinType(typ *Type, init builtinTypeInit) {
  function prepareType (line 183) | func prepareType(typ *Type) string {
  function mroMerge (line 214) | func mroMerge(seqs [][]*Type) []*Type {
  function mroCalc (line 265) | func mroCalc(t *Type) []*Type {
  function toTypeUnsafe (line 274) | func toTypeUnsafe(o *Object) *Type {
  function typeBasisFunc (line 326) | func typeBasisFunc(o *Object) reflect.Value {
  function typeCall (line 342) | func typeCall(f *Frame, callable *Object, args Args, kwargs KWArgs) (*Ob...
  function typeGetAttribute (line 363) | func typeGetAttribute(f *Frame, o *Object, name *Str) (*Object, *BaseExc...
  function typeNew (line 401) | func typeNew(f *Frame, t *Type, args Args, kwargs KWArgs) (*Object, *Bas...
  function typeRepr (line 443) | func typeRepr(f *Frame, o *Object) (*Object, *BaseException) {
  function initTypeType (line 451) | func initTypeType(map[string]*Object) {
  function basisParent (line 461) | func basisParent(basis reflect.Type) reflect.Type {
  function basisSelect (line 470) | func basisSelect(b1, b2 reflect.Type) reflect.Type {

FILE: runtime/type_test.go
  function TestNewClass (line 24) | func TestNewClass(t *testing.T) {
  function TestNewBasisType (line 60) | func TestNewBasisType(t *testing.T) {
  function TestNewSimpleType (line 90) | func TestNewSimpleType(t *testing.T) {
  function TestInvalidBasisType (line 107) | func TestInvalidBasisType(t *testing.T) {
  function TestPrepareType (line 137) | func TestPrepareType(t *testing.T) {
  function makeTestType (line 163) | func makeTestType(name string, bases ...*Type) *Type {
  function TestMroCalc (line 167) | func TestMroCalc(t *testing.T) {
  function TestTypeIsSubclass (line 192) | func TestTypeIsSubclass(t *testing.T) {
  function TestTypeCall (line 217) | func TestTypeCall(t *testing.T) {
  function TestNewWithSubclass (line 236) | func TestNewWithSubclass(t *testing.T) {
  function TestTypeGetAttribute (line 291) | func TestTypeGetAttribute(t *testing.T) {
  function TestTypeName (line 359) | func TestTypeName(t *testing.T) {
  function TestTypeNew (line 370) | func TestTypeNew(t *testing.T) {
  function TestTypeNewResult (line 414) | func TestTypeNewResult(t *testing.T) {
  function TestTypeStrRepr (line 440) | func TestTypeStrRepr(t *testing.T) {
  function TestTypeModule (line 467) | func TestTypeModule(t *testing.T) {
  function newTestClass (line 493) | func newTestClass(name string, bases []*Type, dict *Dict) *Type {
  function newTestClassStrictEq (line 505) | func newTestClassStrictEq(name string, base *Type) *Type {

FILE: runtime/unicode.go
  type Unicode (line 32) | type Unicode struct
    method Encode (line 56) | func (s *Unicode) Encode(f *Frame, encoding, errors string) (*Str, *Ba...
    method ToObject (line 83) | func (s *Unicode) ToObject() *Object {
    method Value (line 88) | func (s *Unicode) Value() []rune {
  function NewUnicode (line 39) | func NewUnicode(value string) *Unicode {
  function NewUnicodeFromRunes (line 44) | func NewUnicodeFromRunes(value []rune) *Unicode {
  function toUnicodeUnsafe (line 48) | func toUnicodeUnsafe(o *Object) *Unicode {
  function unicodeAdd (line 92) | func unicodeAdd(f *Frame, v, w *Object) (*Object, *BaseException) {
  function unicodeContains (line 109) | func unicodeContains(f *Frame, o *Object, value *Object) (*Object, *Base...
  function unicodeEncode (line 126) | func unicodeEncode(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseEx...
  function unicodeEq (line 151) | func unicodeEq(f *Frame, v, w *Object) (*Object, *BaseException) {
  function unicodeGE (line 155) | func unicodeGE(f *Frame, v, w *Object) (*Object, *BaseException) {
  function unicodeGetItem (line 162) | func unicodeGetItem(f *Frame, o, key *Object) (*Object, *BaseException) {
  function unicodeGetNewArgs (line 189) | func unicodeGetNewArgs(f *Frame, args Args, _ KWArgs) (*Object, *BaseExc...
  function unicodeGT (line 196) | func unicodeGT(f *Frame, v, w *Object) (*Object, *BaseException) {
  function unicodeHash (line 200) | func unicodeHash(f *Frame, o *Object) (*Object, *BaseException) {
  function unicodeJoin (line 217) | func unicodeJoin(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
  function unicodeLE (line 232) | func unicodeLE(f *Frame, v, w *Object) (*Object, *BaseException) {
  function unicodeLen (line 236) | func unicodeLen(f *Frame, o *Object) (*Object, *BaseException) {
  function unicodeLT (line 240) | func unicodeLT(f *Frame, v, w *Object) (*Object, *BaseException) {
  function unicodeMul (line 244) | func unicodeMul(f *Frame, v, w *Object) (*Object, *BaseException) {
  function unicodeNative (line 262) | func unicodeNative(f *Frame, o *Object) (reflect.Value, *BaseException) {
  function unicodeNE (line 271) | func unicodeNE(f *Frame, v, w *Object) (*Object, *BaseException) {
  function unicodeNew (line 275) | func unicodeNew(f *Frame, t *Type, args Args, _ KWArgs) (ret *Object, ra...
  function unicodeRepr (line 341) | func unicodeRepr(_ *Frame, o *Object) (*Object, *BaseException) {
  function unicodeStr (line 357) | func unicodeStr(f *Frame, o *Object) (*Object, *BaseException) {
  function unicodeStrip (line 365) | func unicodeStrip(f *Frame, args Args, _ KWArgs) (*Object, *BaseExceptio...
  function initUnicodeType (line 413) | func initUnicodeType(dict map[string]*Object) {
  function unicodeCompare (line 437) | func unicodeCompare(f *Frame, v *Unicode, w *Object, ltResult, eqResult,...
  function runeSliceCmp (line 460) | func runeSliceCmp(lhs []rune, rhs []rune) int {
  function unicodeCompareEq (line 487) | func unicodeCompareEq(f *Frame, v *Unicode, w *Object, eq bool) (*Object...
  function unicodeCoerce (line 511) | func unicodeCoerce(f *Frame, o *Object) (*Unicode, *BaseException) {
  function unicodeJoinParts (line 523) | func unicodeJoinParts(f *Frame, s *Unicode, parts []*Object) (*Object, *...

FILE: runtime/unicode_test.go
  function TestUnicodeNewUnicode (line 24) | func TestUnicodeNewUnicode(t *testing.T) {
  function TestUnicodeBinaryOps (line 45) | func TestUnicodeBinaryOps(t *testing.T) {
  function TestUnicodeCompare (line 72) | func TestUnicodeCompare(t *testing.T) {
  function TestUnicodeContains (line 95) | func TestUnicodeContains(t *testing.T) {
  function TestUnicodeEncode (line 109) | func TestUnicodeEncode(t *testing.T) {
  function TestUnicodeGetItem (line 128) | func TestUnicodeGetItem(t *testing.T) {
  function TestUnicodeHash (line 149) | func TestUnicodeHash(t *testing.T) {
  function TestUnicodeLen (line 164) | func TestUnicodeLen(t *testing.T) {
  function TestUnicodeMethods (line 177) | func TestUnicodeMethods(t *testing.T) {
  function TestUnicodeNative (line 205) | func TestUnicodeNative(t *testing.T) {
  function TestUnicodeRepr (line 227) | func TestUnicodeRepr(t *testing.T) {
  function TestUnicodeNew (line 242) | func TestUnicodeNew(t *testing.T) {
  function TestUnicodeNewNotSubtype (line 273) | func TestUnicodeNewNotSubtype(t *testing.T) {
  function TestUnicodeNewSubclass (line 280) | func TestUnicodeNewSubclass(t *testing.T) {
  function TestUnicodeStr (line 310) | func TestUnicodeStr(t *testing.T) {

FILE: runtime/weakref.go
  type weakRefState (line 31) | type weakRefState
  constant weakRefStateNew (line 34) | weakRefStateNew weakRefState = iota
  constant weakRefStateUsed (line 35) | weakRefStateUsed
  constant weakRefStateDead (line 36) | weakRefStateDead
  type WeakRef (line 40) | type WeakRef struct
    method get (line 54) | func (r *WeakRef) get() *Object {
    method ToObject (line 63) | func (r *WeakRef) ToObject() *Object {
  function toWeakRefUnsafe (line 49) | func toWeakRefUnsafe(o *Object) *WeakRef {
  function weakRefCall (line 67) | func weakRefCall(f *Frame, callable *Object, args Args, _ KWArgs) (*Obje...
  function weakRefHash (line 81) | func weakRefHash(f *Frame, o *Object) (result *Object, raised *BaseExcep...
  function weakRefNew (line 106) | func weakRefNew(f *Frame, t *Type, args Args, _ KWArgs) (*Object, *BaseE...
  function weakRefRepr (line 141) | func weakRefRepr(f *Frame, o *Object) (*Object, *BaseException) {
  function initWeakRefType (line 153) | func initWeakRefType(map[string]*Object) {
  function weakRefFinalizeReferent (line 160) | func weakRefFinalizeReferent(o *Object) {

FILE: runtime/weakref_test.go
  function TestWeakRefCall (line 24) | func TestWeakRefCall(t *testing.T) {
  function TestWeakRefHash (line 41) | func TestWeakRefHash(t *testing.T) {
  function TestWeakRefNew (line 67) | func TestWeakRefNew(t *testing.T) {
  function TestWeakRefNewCallback (line 83) | func TestWeakRefNewCallback(t *testing.T) {
  function TestWeakRefNewCallbackRaises (line 98) | func TestWeakRefNewCallbackRaises(t *testing.T) {
  function TestWeakRefStrRepr (line 112) | func TestWeakRefStrRepr(t *testing.T) {
  function newTestWeakRef (line 129) | func newTestWeakRef(o, callback *Object) *WeakRef {
  function makeWeakRefsForTest (line 137) | func makeWeakRefsForTest() (*WeakRef, *Object, *WeakRef) {
  function weakRefMustDie (line 147) | func weakRefMustDie(r *WeakRef) {

FILE: testing/assign_test.py
  class Foo (line 18) | class Foo(object):
  function foo (line 98) | def foo():  # pylint: disable=function-redefined

FILE: testing/builtin_test.py
  function foo (line 103) | def foo(x):
  class bar (line 109) | class bar(object):
    method __call__ (line 111) | def __call__(self, *args, **kwargs):
  class Lt (line 125) | class Lt(object):
    method __init__ (line 127) | def __init__(self, x):
    method __lt__ (line 131) | def __lt__(self, other):
  class Eq (line 136) | class Eq(object):
    method __init__ (line 138) | def __init__(self, x):
    method __eq__ (line 142) | def __eq__(self, other):
  class Gt (line 147) | class Gt(object):
    method __init__ (line 149) | def __init__(self, x):
    method __gt__ (line 153) | def __gt__(self, other):
  class RichCmp (line 158) | class RichCmp(Lt, Eq, Gt):
    method __init__ (line 160) | def __init__(self, x):
  class Cmp (line 164) | class Cmp(object):
    method __init__ (line 166) | def __init__(self, x):
    method __cmp__ (line 170) | def __cmp__(self, other):
  class NoCmp (line 180) | class NoCmp(object):
    method __init__ (line 182) | def __init__(self, x):
  class Foo (line 262) | class Foo(object):

FILE: testing/class_test.py
  class Foo (line 16) | class Foo(object):
    method bar (line 21) | def bar(self):

FILE: testing/compare_test.py
  class RichCmp (line 27) | class RichCmp(object):
    method __init__ (line 28) | def __init__(self, x):
    method __lt__ (line 36) | def __lt__(self, other):
    method __le__ (line 40) | def __le__(self, other):
    method __eq__ (line 44) | def __eq__(self, other):
    method __ge__ (line 48) | def __ge__(self, other):
    method __gt__ (line 52) | def __gt__(self, other):
  class Cmp (line 56) | class Cmp(object):
    method __init__ (line 57) | def __init__(self, x):
    method __cmp__ (line 61) | def __cmp__(self, other):

FILE: testing/function_test.py
  function foo (line 18) | def foo(a):
  function foo (line 43) | def foo(a, b):
  function foo (line 62) | def foo(a, b=None):
  function foo (line 72) | def foo(a, *args):
  function foo (line 80) | def foo(a, **kwargs):

FILE: testing/generator_test.py
  function gen1 (line 18) | def gen1():
  function gen2 (line 28) | def gen2():
  function gen3 (line 37) | def gen3():
  function gen4 (line 48) | def gen4():
  function gen5 (line 59) | def gen5():
  function gen6 (line 70) | def gen6():

FILE: testing/global_test.py
  function f1 (line 18) | def f1():
  function f2 (line 26) | def f2():
  class C1 (line 36) | class C1(object):
  function f3 (line 43) | def f3():
  function f4 (line 55) | def f4():
  function f5 (line 67) | def f5():

FILE: testing/op_test.py
  function TestBoolOps (line 22) | def TestBoolOps():
  function TestBoolOpsLazyEval (line 31) | def TestBoolOpsLazyEval():
  function TestNeg (line 61) | def TestNeg():
  function TestPos (line 84) | def TestPos():

FILE: testing/scope_test.py
  function f (line 23) | def f():
  function g (line 43) | def g():
  class Foo (line 69) | class Foo(object):

FILE: testing/str_test.py
  class Foo (line 83) | class Foo(object):
    method __index__ (line 85) | def __index__(self):
  class IntIndexType (line 121) | class IntIndexType(object):
    method __index__ (line 122) | def __index__(self):
  class LongIndexType (line 125) | class LongIndexType(object):
    method __index__ (line 126) | def __index__(self):
  class IntIntType (line 129) | class IntIntType(object):
    method __int__ (line 130) | def __int__(self):
  class LongIntType (line 133) | class LongIntType(object):
    method __int__ (line 134) | def __int__(self):
  class S (line 272) | class S(str):
  class A (line 301) | class A(object):
    method __int__ (line 302) | def __int__(self):
    method __int__ (line 362) | def __int__(self):
  class AL (line 304) | class AL(object):
    method __int__ (line 305) | def __int__(self):
  class B (line 308) | class B(object):
    method __index__ (line 309) | def __index__(self):
  class BL (line 311) | class BL(object):
    method __index__ (line 312) | def __index__(self):
  class A (line 361) | class A(object):
    method __int__ (line 302) | def __int__(self):
    method __int__ (line 362) | def __int__(self):

FILE: testing/try_test.py
  function f (line 108) | def f():
  function foo (line 119) | def foo():
  function foo (line 226) | def foo():
  function foo (line 239) | def foo():

FILE: testing/with_test.py
  class ContextManager (line 18) | class ContextManager(object):
    method __init__ (line 20) | def __init__(self):
    method __enter__ (line 23) | def __enter__(self):
    method __exit__ (line 26) | def __exit__(self, exc_type, value, traceback):
  class ExceptionSwallower (line 92) | class ExceptionSwallower(object):
    method __init__ (line 94) | def __init__(self):
    method __enter__ (line 97) | def __enter__(self):
    method __exit__ (line 100) | def __exit__(self, exc_type, value, traceback):
  class NoExit (line 121) | class NoExit(object):
    method __enter__ (line 123) | def __enter__(self):
  class NoEnter (line 137) | class NoEnter(object):
    method __exit__ (line 139) | def __exit__(self, exc_type, value, traceback):
  class EnterResult (line 161) | class EnterResult(object):
    method __init__ (line 163) | def __init__(self, value):
    method __enter__ (line 166) | def __enter__(self):
    method __exit__ (line 169) | def __exit__(self, *args):
  class Foo (line 185) | class Foo(object):
    method __enter__ (line 187) | def __enter__(self):
    method __exit__ (line 189) | def __exit__(self, *args):
  function bar (line 207) | def bar():

FILE: third_party/ouroboros/operator.py
  function lt (line 25) | def lt(a, b):
  function le (line 29) | def le(a, b):
  function eq (line 33) | def eq(a, b):
  function ne (line 37) | def ne(a, b):
  function ge (line 41) | def ge(a, b):
  function gt (line 45) | def gt(a, b):
  function not_ (line 51) | def not_(a):
  function truth (line 55) | def truth(a):
  function is_ (line 59) | def is_(a, b):
  function is_not (line 63) | def is_not(a, b):
  function abs (line 69) | def abs(a):
  function add (line 73) | def add(a, b):
  function and_ (line 77) | def and_(a, b):
  function floordiv (line 81) | def floordiv(a, b):
  function index (line 85) | def index(a):
  function inv (line 89) | def inv(a):
  function lshift (line 94) | def lshift(a, b):
  function mod (line 98) | def mod(a, b):
  function mul (line 102) | def mul(a, b):
  function neg (line 106) | def neg(a):
  function or_ (line 110) | def or_(a, b):
  function pos (line 114) | def pos(a):
  function pow (line 118) | def pow(a, b):
  function rshift (line 122) | def rshift(a, b):
  function sub (line 126) | def sub(a, b):
  function truediv (line 130) | def truediv(a, b):
  function xor (line 136) | def xor(a, b):
  function concat (line 142) | def concat(a, b):
  function contains (line 149) | def contains(a, b):
  function countOf (line 153) | def countOf(a, b):
  function delitem (line 161) | def delitem(a, b):
  function getitem (line 165) | def getitem(a, b):
  function indexOf (line 169) | def indexOf(a, b):
  function setitem (line 177) | def setitem(a, b, c):
  function length_hint (line 181) | def length_hint(obj, default=0):
  class attrgetter (line 222) | class attrgetter(object):
    method __init__ (line 230) | def __init__(self, attr, *attrs):
    method __call__ (line 246) | def __call__(self, obj):
  class itemgetter (line 250) | class itemgetter(object):
    method __init__ (line 256) | def __init__(self, item, *items):
    method __call__ (line 267) | def __call__(self, obj):
  class methodcaller (line 271) | class methodcaller(object):
    method __init__ (line 279) | def __init__(*args, **kwargs):
    method __call__ (line 288) | def __call__(self, obj):
  function iadd (line 293) | def iadd(a, b):
  function iand (line 298) | def iand(a, b):
  function iconcat (line 303) | def iconcat(a, b):
  function ifloordiv (line 311) | def ifloordiv(a, b):
  function ilshift (line 316) | def ilshift(a, b):
  function imod (line 321) | def imod(a, b):
  function imul (line 326) | def imul(a, b):
  function ior (line 331) | def ior(a, b):
  function ipow (line 336) | def ipow(a, b):
  function irshift (line 341) | def irshift(a, b):
  function isub (line 346) | def isub(a, b):
  function itruediv (line 351) | def itruediv(a, b):
  function ixor (line 358) | def ixor(a, b):

FILE: third_party/ouroboros/test/test_operator.py
  class Seq1 (line 5) | class Seq1(object):
    method __init__ (line 6) | def __init__(self, lst):
    method __len__ (line 8) | def __len__(self):
    method __getitem__ (line 10) | def __getitem__(self, i):
    method __add__ (line 12) | def __add__(self, other):
    method __mul__ (line 14) | def __mul__(self, other):
    method __rmul__ (line 16) | def __rmul__(self, other):
  class Seq2 (line 19) | class Seq2(object):
    method __init__ (line 20) | def __init__(self, lst):
    method __len__ (line 22) | def __len__(self):
    method __getitem__ (line 24) | def __getitem__(self, i):
    method __add__ (line 26) | def __add__(self, other):
    method __mul__ (line 28) | def __mul__(self, other):
    method __rmul__ (line 30) | def __rmul__(self, other):
  class OperatorTestCase (line 33) | class OperatorTestCase(unittest.TestCase):
    method test_lt (line 34) | def test_lt(self):
    method test_le (line 44) | def test_le(self):
    method test_eq (line 54) | def test_eq(self):
    method test_ne (line 68) | def test_ne(self):
    method test_ge (line 82) | def test_ge(self):
    method test_gt (line 92) | def test_gt(self):
    method test_abs (line 102) | def test_abs(self):
    method test_add (line 109) | def test_add(self):
    method test_bitwise_and (line 115) | def test_bitwise_and(self):
    method test_concat (line 121) | def test_concat(self):
    method test_countOf (line 131) | def test_countOf(self):
    method test_delitem (line 139) | def test_delitem(self):
    method test_floordiv (line 147) | def test_floordiv(self):
    method test_truediv (line 153) | def test_truediv(self):
    method test_getitem (line 159) | def test_getitem(self):
    method test_indexOf (line 166) | def test_indexOf(self):
    method test_invert (line 173) | def test_invert(self):
    method test_lshift (line 179) | def test_lshift(self):
    method test_mod (line 187) | def test_mod(self):
    method test_mul (line 193) | def test_mul(self):
    method test_neg (line 199) | def test_neg(self):
    method test_bitwise_or (line 208) | def test_bitwise_or(self):
    method test_pos (line 214) | def test_pos(self):
    method test_pow (line 223) | def test_pow(self):
    method test_rshift (line 231) | def test_rshift(self):
    method test_contains (line 239) | def test_contains(self):
    method test_setitem (line 246) | def test_setitem(self):
    method test_sub (line 255) | def test_sub(self):
    method test_truth (line 262) | def test_truth(self):
    method test_bitwise_xor (line 274) | def test_bitwise_xor(self):
    method test_is (line 280) | def test_is(self):
    method test_is_not (line 289) | def test_is_not(self):
    method test_attrgetter (line 298) | def test_attrgetter(self):
    method test_itemgetter (line 349) | def test_itemgetter(self):
    method test_methodcaller (line 384) | def test_methodcaller(self):
    method test_inplace (line 408) | def test_inplace(self):
    method test_length_hint (line 440) | def test_length_hint(self):
    method test_dunder_is_original (line 465) | def test_dunder_is_original(self):
    method test_complex_operator (line 475) | def test_complex_operator(self):
  function test_main (line 480) | def test_main():

FILE: third_party/pypy/_collections.py
  class deque (line 31) | class deque(object):
    method __new__ (line 33) | def __new__(cls, iterable=(), *args, **kw):
    method __init__ (line 38) | def __init__(self, iterable=(), maxlen=None):
    method maxlen (line 49) | def maxlen(self):
    method clear (line 53) | def clear(self):
    method append (line 60) | def append(self, x):
    method appendleft (line 74) | def appendleft(self, x):
    method extend (line 88) | def extend(self, iterable):
    method extendleft (line 94) | def extendleft(self, iterable):
    method pop (line 100) | def pop(self):
    method popleft (line 121) | def popleft(self):
    method count (line 142) | def count(self, value):
    method remove (line 149) | def remove(self, value):
    method rotate (line 163) | def rotate(self, n=1):
    method reverse (line 181) | def reverse(self):
    method __repr__ (line 209) | def __repr__(self):
    method __iter__ (line 223) | def __iter__(self):
    method _iter_impl (line 226) | def _iter_impl(self, original_state, giveup):
    method __reversed__ (line 242) | def __reversed__(self):
    method _reversed_impl (line 245) | def _reversed_impl(self, original_state, giveup):
    method __len__ (line 261) | def __len__(self):
    method __getref (line 270) | def __getref(self, index):
    method __getitem__ (line 299) | def __getitem__(self, index):
    method __setitem__ (line 303) | def __setitem__(self, index, value):
    method __delitem__ (line 307) | def __delitem__(self, index):
    method __reduce_ex__ (line 323) | def __reduce_ex__(self, proto):
    method __copy__ (line 328) | def __copy__(self):
    method __eq__ (line 332) | def __eq__(self, other):
    method __ne__ (line 338) | def __ne__(self, other):
    method __lt__ (line 344) | def __lt__(self, other):
    method __le__ (line 350) | def __le__(self, other):
    method __gt__ (line 356) | def __gt__(self, other):
    method __ge__ (line 362) | def __ge__(self, other):
    method __iadd__ (line 368) | def __iadd__(self, other):
  class deque_iterator (line 372) | class deque_iterator(object):
    method __init__ (line 374) | def __init__(self, deq, itergen):
    method next (line 381) | def next(self):
    method __iter__ (line 386) | def __iter__(self):
  class defaultdict (line 389) | class defaultdict(dict):
    method __init__ (line 391) | def __init__(self, *args, **kwds):
    method __missing__ (line 402) | def __missing__(self, key):
    method __repr__ (line 409) | def __repr__(self, recurse=set()):
    method copy (line 418) | def copy(self):
    method __copy__ (line 421) | def __copy__(self):
    method __reduce__ (line 424) | def __reduce__(self):

FILE: third_party/pypy/_csv.py
  class Error (line 73) | class Error(Exception):
  class Dialect (line 76) | class Dialect(object):
    method __new__ (line 85) | def __new__(cls, dialect, **kwargs):
  function _call_dialect (line 173) | def _call_dialect(dialect_inst, kwargs):
  function register_dialect (line 176) | def register_dialect(name, dialect=None, **kwargs):
  function unregister_dialect (line 185) | def unregister_dialect(name):
  function get_dialect (line 193) | def get_dialect(name):
  function list_dialects (line 201) | def list_dialects():
  class Reader (line 206) | class Reader(object):
    method __init__ (line 217) | def __init__(self, iterator, dialect=None, **kwargs):
    method _parse_reset (line 224) | def _parse_reset(self):
    method __iter__ (line 230) | def __iter__(self):
    method next (line 233) | def next(self):
    method _parse_process_char (line 260) | def _parse_process_char(self, line, pos):
    method _parse_eol (line 385) | def _parse_eol(self):
    method _parse_save_field (line 415) | def _parse_save_field(self):
    method _parse_add_char (line 422) | def _parse_add_char(self, c):
  class Writer (line 428) | class Writer(object):
    method __init__ (line 434) | def __init__(self, file, dialect=None, **kwargs):
    method _join_reset (line 440) | def _join_reset(self):
    method _join_append (line 444) | def _join_append(self, field, quoted, quote_empty):
    method writerow (line 491) | def writerow(self, row):
    method writerows (line 526) | def writerows(self, rows):
  function reader (line 530) | def reader(*args, **kwargs):
  function writer (line 548) | def writer(*args, **kwargs):
  function field_size_limit (line 566) | def field_size_limit(limit=undefined):

FILE: third_party/pypy/_functools.py
  function reduce (line 6) | def reduce(function, iterable, initializer=None):
  class partial (line 18) | class partial(object):
    method __init__ (line 26) | def __init__(*args, **keywords):
    method __delattr__ (line 37) | def __delattr__(self, key):
    method func (line 43) | def func(self):
    method args (line 49) | def args(self):
    method keywords (line 55) | def keywords(self):
    method __call__ (line 60) | def __call__(self, *fargs, **fkeywords):
    method __reduce__ (line 65) | def __reduce__(self):
    method __setstate__ (line 73) | def __setstate__(self, state):

FILE: third_party/pypy/_md5.py
  function _bytelist2long (line 48) | def _bytelist2long(list):
  function _rotateLeft (line 68) | def _rotateLeft(x, n):
  function F (line 83) | def F(x, y, z):
  function G (line 87) | def G(x, y, z):
  function H (line 91) | def H(x, y, z):
  function I (line 95) | def I(x, y, z):
  function XX (line 99) | def XX(func, a, b, c, d, x, s, ac):
  class MD5Type (line 119) | class MD5Type(object):
    method __init__ (line 125) | def __init__(self):
    method init (line 139) | def init(self):
    method _transform (line 152) | def _transform(self, inp):
    method update (line 256) | def update(self, inBuf):
    method digest (line 297) | def digest(self):
    method hexdigest (line 339) | def hexdigest(self):
    method copy (line 350) | def copy(self):
  function new (line 378) | def new(arg=None):

FILE: third_party/pypy/_sha.py
  function _long2bytesBigEndian (line 30) | def _long2bytesBigEndian(n, blocksize=0):
  function _bytelist2longBigEndian (line 64) | def _bytelist2longBigEndian(list):
  function _rotateLeft (line 84) | def _rotateLeft(x, n):
  function f0_19 (line 95) | def f0_19(B, C, D):
  function f20_39 (line 98) | def f20_39(B, C, D):
  function f40_59 (line 101) | def f40_59(B, C, D):
  function f60_79 (line 104) | def f60_79(B, C, D):
  class sha (line 118) | class sha(object):
    method __init__ (line 124) | def __init__(self):
    method init (line 139) | def init(self):
    method _transform (line 152) | def _transform(self, W):
    method update (line 218) | def update(self, inBuf):
    method digest (line 261) | def digest(self):
    method hexdigest (line 310) | def hexdigest(self):
    method copy (line 320) | def copy(self):
  function new (line 343) | def new(arg=None):

FILE: third_party/pypy/_sha256.py
  function new_shaobject (line 7) | def new_shaobject():
  function sha_transform (line 27) | def sha_transform(sha_info):
  function sha_init (line 116) | def sha_init():
  function sha224_init (line 125) | def sha224_init():
  function getbuf (line 134) | def getbuf(s):
  function sha_update (line 142) | def sha_update(sha_info, buffer):
  function sha_final (line 184) | def sha_final(sha_info):
  class sha256 (line 215) | class sha256(object):
    method __init__ (line 219) | def __init__(self, s=None):
    method update (line 224) | def update(self, s):
    method digest (line 227) | def digest(self):
    method hexdigest (line 230) | def hexdigest(self):
    method copy (line 233) | def copy(self):
  class sha224 (line 238) | class sha224(sha256):
    method __init__ (line 241) | def __init__(self, s=None):
    method copy (line 246) | def copy(self):
  function test (line 251) | def test():

FILE: third_party/pypy/_sha512.py
  function new_shaobject (line 11) | def new_shaobject():
  function sha_transform (line 31) | def sha_transform(sha_info):
  function sha_init (line 136) | def sha_init():
  function sha384_init (line 145) | def sha384_init():
  function getbuf (line 154) | def getbuf(s):
  function sha_update (line 162) | def sha_update(sha_info, buffer):
  function sha_final (line 203) | def sha_final(sha_info):
  class sha512 (line 243) | class sha512(object):
    method __init__ (line 247) | def __init__(self, s=None):
    method update (line 252) | def update(self, s):
    method digest (line 255) | def digest(self):
    method hexdigest (line 258) | def hexdigest(self):
    method copy (line 261) | def copy(self):
  class sha384 (line 266) | class sha384(sha512):
    method __init__ (line 269) | def __init__(self, s=None):
    method copy (line 274) | def copy(self):
  function test (line 279) | def test():

FILE: third_party/pypy/_sre.py
  function getcodesize (line 36) | def getcodesize():
  function compile (line 40) | def compile(pattern, flags, code, groups=0, groupindex={}, indexgroup=[N...
  function getlower (line 45) | def getlower(char_ord, flags):
  class SRE_Pattern (line 54) | class SRE_Pattern(object):
    method __init__ (line 56) | def __init__(self, pattern, flags, code, groups=0, groupindex={}, inde...
    method match (line 64) | def match(self, string, pos=0, endpos=sys.maxint):
    method search (line 74) | def search(self, string, pos=0, endpos=sys.maxint):
    method findall (line 85) | def findall(self, string, pos=0, endpos=sys.maxint):
    method _subx (line 106) | def _subx(self, template, string, count=0, subn=False):
    method sub (line 144) | def sub(self, repl, string, count=0):
    method subn (line 149) | def subn(self, repl, string, count=0):
    method split (line 155) | def split(self, string, maxsplit=0):
    method finditer (line 183) | def finditer(self, string, pos=0, endpos=sys.maxint):
    method scanner (line 188) | def scanner(self, string, start=0, end=sys.maxint):
    method __copy__ (line 191) | def __copy__(self):
    method __deepcopy__ (line 194) | def __deepcopy__(self):
  class SRE_Scanner (line 198) | class SRE_Scanner(object):
    method __init__ (line 201) | def __init__(self, pattern, string, start, end):
    method _match_search (line 205) | def _match_search(self, matcher):
    method match (line 218) | def match(self):
    method search (line 221) | def search(self):
  class SRE_Match (line 225) | class SRE_Match(object):
    method __init__ (line 227) | def __init__(self, pattern, state):
    method _create_regs (line 246) | def _create_regs(self, state):
    method _get_index (line 259) | def _get_index(self, group):
    method _get_slice (line 268) | def _get_slice(self, group, default):
    method start (line 275) | def start(self, group=0):
    method end (line 281) | def end(self, group=0):
    method span (line 287) | def span(self, group=0):
    method expand (line 291) | def expand(self, template):
    method groups (line 296) | def groups(self, default=None):
    method groupdict (line 308) | def groupdict(self, default=None):
    method group (line 317) | def group(self, *args):
    method __copy__ (line 330) | def __copy__():
    method __deepcopy__ (line 333) | def __deepcopy__():
  class _State (line 337) | class _State(object):
    method __init__ (line 339) | def __init__(self, string, start, end, flags):
    method reset (line 352) | def reset(self):
    method match (line 359) | def match(self, pattern_codes):
    method search (line 380) | def search(self, pattern_codes):
    method fast_search (line 419) | def fast_search(self, pattern_codes):
    method set_mark (line 455) | def set_mark(self, mark_nr, position):
    method get_marks (line 465) | def get_marks(self, group_index):
    method marks_push (line 472) | def marks_push(self):
    method marks_pop (line 475) | def marks_pop(self):
    method marks_pop_keep (line 481) | def marks_pop_keep(self):
    method marks_pop_discard (line 484) | def marks_pop_discard(self):
    method lower (line 488) | def lower(self, char_ord):
  class _MatchContext (line 492) | class _MatchContext(object):
    method __init__ (line 494) | def __init__(self, state, pattern_codes):
    method push_new_context (line 501) | def push_new_context(self, pattern_offset):
    method peek_char (line 510) | def peek_char(self, peek=0):
    method skip_char (line 513) | def skip_char(self, skip_count):
    method remaining_chars (line 516) | def remaining_chars(self):
    method peek_code (line 519) | def peek_code(self, peek=0):
    method skip_code (line 522) | def skip_code(self, skip_count):
    method remaining_codes (line 525) | def remaining_codes(self):
    method at_beginning (line 528) | def at_beginning(self):
    method at_end (line 531) | def at_end(self):
    method at_linebreak (line 534) | def at_linebreak(self):
    method at_boundary (line 537) | def at_boundary(self, word_checker):
  class _RepeatContext (line 545) | class _RepeatContext(_MatchContext):
    method __init__ (line 547) | def __init__(self, context):
  class _Dispatcher (line 555) | class _Dispatcher(object):
    method dispatch (line 559) | def dispatch(self, code, context):
    method unknown (line 563) | def unknown(self, code, ctx):
    method build_dispatch_table (line 566) | def build_dispatch_table(cls, code_dict, method_prefix):
  class _OpcodeDispatcher (line 578) | class _OpcodeDispatcher(_Dispatcher):
    method __init__ (line 580) | def __init__(self):
    method match (line 586) | def match(self, context):
    method dispatch (line 598) | def dispatch(self, opcode, context):
    method op_success (line 615) | def op_success(self, ctx):
    method op_failure (line 622) | def op_failure(self, ctx):
    method general_op_literal (line 628) | def general_op_literal(self, ctx, compare, decorate=lambda x: x):
    method op_literal (line 635) | def op_literal(self, ctx):
    method op_not_literal (line 642) | def op_not_literal(self, ctx):
    method op_literal_ignore (line 649) | def op_literal_ignore(self, ctx):
    method op_not_literal_ignore (line 656) | def op_not_literal_ignore(self, ctx):
    method op_at (line 663) | def op_at(self, ctx):
    method op_category (line 673) | def op_category(self, ctx):
    method op_any (line 684) | def op_any(self, ctx):
    method op_any_all (line 695) | def op_any_all(self, ctx):
    method general_op_in (line 706) | def general_op_in(self, ctx, decorate=lambda x: x):
    method op_in (line 719) | def op_in(self, ctx):
    method op_in_ignore (line 726) | def op_in_ignore(self, ctx):
    method op_jump (line 733) | def op_jump(self, ctx):
    method op_mark (line 744) | def op_mark(self, ctx):
    method op_branch (line 752) | def op_branch(self, ctx):
    method op_repeat_one (line 777) | def op_repeat_one(self, ctx):
    method op_min_repeat_one (line 840) | def op_min_repeat_one(self, ctx):
    method op_repeat (line 884) | def op_repeat(self, ctx):
    method op_max_until (line 898) | def op_max_until(self, ctx):
    method op_min_until (line 949) | def op_min_until(self, ctx):
    method general_op_groupref (line 997) | def general_op_groupref(self, ctx, decorate=lambda x: x):
    method op_groupref (line 1012) | def op_groupref(self, ctx):
    method op_groupref_ignore (line 1018) | def op_groupref_ignore(self, ctx):
    method op_groupref_exists (line 1024) | def op_groupref_exists(self, ctx):
    method op_assert (line 1034) | def op_assert(self, ctx):
    method op_assert_not (line 1050) | def op_assert_not(self, ctx):
    method unknown (line 1064) | def unknown(self, ctx):
    method check_charset (line 1068) | def check_charset(self, ctx, char):
    method count_repetitions (line 1079) | def count_repetitions(self, ctx, maxcount):
    method _log (line 1107) | def _log(self, context, opname, *args):
  class _CharsetDispatcher (line 1115) | class _CharsetDispatcher(_Dispatcher):
    method __init__ (line 1117) | def __init__(self):
    method reset (line 1120) | def reset(self, char):
    method set_failure (line 1124) | def set_failure(self, ctx):
    method set_literal (line 1126) | def set_literal(self, ctx):
    method set_category (line 1132) | def set_category(self, ctx):
    method set_charset (line 1138) | def set_charset(self, ctx):
    method set_range (line 1152) | def set_range(self, ctx):
    method set_negate (line 1157) | def set_negate(self, ctx):
    method set_bigcharset (line 1160) | def set_bigcharset(self, ctx):
    method unknown (line 1182) | def unknown(self, ctx):
  class _AtcodeDispatcher (line 1188) | class _AtcodeDispatcher(_Dispatcher):
    method at_beginning (line 1190) | def at_beginning(self, ctx):
    method at_beginning_line (line 1193) | def at_beginning_line(self, ctx):
    method at_end (line 1195) | def at_end(self, ctx):
    method at_end_line (line 1197) | def at_end_line(self, ctx):
    method at_end_string (line 1199) | def at_end_string(self, ctx):
    method at_boundary (line 1201) | def at_boundary(self, ctx):
    method at_non_boundary (line 1203) | def at_non_boundary(self, ctx):
    method at_loc_boundary (line 1205) | def at_loc_boundary(self, ctx):
    method at_loc_non_boundary (line 1207) | def at_loc_non_boundary(self, ctx):
    method at_uni_boundary (line 1209) | def at_uni_boundary(self, ctx):
    method at_uni_non_boundary (line 1211) | def at_uni_non_boundary(self, ctx):
    method unknown (line 1213) | def unknown(self, ctx):
  class _ChcodeDispatcher (line 1219) | class _ChcodeDispatcher(_Dispatcher):
    method category_digit (line 1221) | def category_digit(self, ctx):
    method category_not_digit (line 1223) | def category_not_digit(self, ctx):
    method category_space (line 1225) | def category_space(self, ctx):
    method category_not_space (line 1227) | def category_not_space(self, ctx):
    method category_word (line 1229) | def category_word(self, ctx):
    method category_not_word (line 1231) | def category_not_word(self, ctx):
    method category_linebreak (line 1233) | def category_linebreak(self, ctx):
    method category_not_linebreak (line 1235) | def category_not_linebreak(self, ctx):
    method category_loc_word (line 1237) | def category_loc_word(self, ctx):
    method category_loc_not_word (line 1239) | def category_loc_not_word(self, ctx):
    method category_uni_digit (line 1241) | def category_uni_digit(self, ctx):
    method category_uni_not_digit (line 1243) | def category_uni_not_digit(self, ctx):
    method category_uni_space (line 1245) | def category_uni_space(self, ctx):
    method category_uni_not_space (line 1247) | def category_uni_not_space(self, ctx):
    method category_uni_word (line 1249) | def category_uni_word(self, ctx):
    method category_uni_not_word (line 1251) | def category_uni_not_word(self, ctx):
    method category_uni_linebreak (line 1253) | def category_uni_linebreak(self, ctx):
    method category_uni_not_linebreak (line 1255) | def category_uni_not_linebreak(self, ctx):
    method unknown (line 1257) | def unknown(self, ctx):
  function _is_digit (line 1271) | def _is_digit(char):
  function _is_space (line 1275) | def _is_space(char):
  function _is_word (line 1279) | def _is_word(char):
  function _is_loc_word (line 1284) | def _is_loc_word(char):
  function _is_uni_word (line 1287) | def _is_uni_word(char):
  function _is_linebreak (line 1290) | def _is_linebreak(char):
  function _log (line 1296) | def _log(message):

FILE: third_party/pypy/_struct.py
  class StructError (line 50) | class StructError(Exception):
  function unpack_int (line 57) | def unpack_int(data, index, size, le):
  function unpack_signed_int (line 67) | def unpack_signed_int(data, index, size, le):
  function unpack_char (line 78) | def unpack_char(data, index, size, le):
  function pack_int (line 82) | def pack_int(number, size, le):
  function pack_signed_int (line 93) | def pack_signed_int(number, size, le):
  function pack_unsigned_int (line 101) | def pack_unsigned_int(number, size, le):
  function pack_char (line 111) | def pack_char(char, size, le):
  function isinf (line 115) | def isinf(x):
  function isnan (line 119) | def isnan(v):
  function pack_float (line 123) | def pack_float(x, size, le):
  function unpack_float (line 133) | def unpack_float(data, index, size, le):
  function round_to_nearest (line 144) | def round_to_nearest(x):
  function float_unpack (line 162) | def float_unpack(Q, size, le):
  function float_pack (line 200) | def float_pack(x, size):
  function getmode (line 287) | def getmode(fmt):
  function getNum (line 297) | def getNum(fmt, i):
  function calcsize (line 310) | def calcsize(fmt):
  function pack (line 334) | def pack(fmt, *args):
  function unpack (line 393) | def unpack(fmt, data):
  function pack_into (line 436) | def pack_into(fmt, buf, offset, *args):
  function unpack_from (line 441) | def unpack_from(fmt, buf, offset=0):
  function _clearcache (line 450) | def _clearcache():

FILE: third_party/pypy/binascii.py
  class Error (line 7) | class Error(Exception):
  class Done (line 10) | class Done(Exception):
  class Incomplete (line 13) | class Incomplete(Exception):
  function a2b_uu (line 16) | def a2b_uu(s):
  function b2a_uu (line 50) | def b2a_uu(s):
  function a2b_base64 (line 143) | def a2b_base64(s):
  function b2a_base64 (line 193) | def b2a_base64(s):
  function a2b_qp (line 232) | def a2b_qp(s, header=False):
  function b2a_qp (line 265) | def b2a_qp(data, quotetabs=False, istext=True, header=False):
  function hex (line 336) | def hex(n):
  function two_hex_digits (line 357) | def two_hex_digits(n):
  function strhex_to_int (line 361) | def strhex_to_int(s):
  function a2b_hqx (line 424) | def a2b_hqx(s):
  function b2a_hqx (line 464) | def b2a_hqx(s):
  function crc_hqx (line 534) | def crc_hqx(s, crc):
  function rlecode_hqx (line 540) | def rlecode_hqx(s):
  function rledecode_hqx (line 584) | def rledecode_hqx(s):
  function crc32 (line 655) | def crc32(s, crc=0):
  function b2a_hex (line 669) | def b2a_hex(s):
  function a2b_hex (line 700) | def a2b_hex(t):

FILE: third_party/pypy/datetime.py
  function divmod (line 25) | def divmod(x, y):
  function _cmp (line 31) | def _cmp(x, y):
  function _round (line 34) | def _round(x):
  function _is_leap (line 61) | def _is_leap(year):
  function _days_before_year (line 65) | def _days_before_year(year):
  function _days_in_month (line 70) | def _days_in_month(year, month):
  function _days_before_month (line 77) | def _days_before_month(year, month):
  function _ymd2ord (line 82) | def _ymd2ord(year, month, day):
  function _ord2ymd (line 116) | def _ord2ymd(n):
  function _build_struct_time (line 184) | def _build_struct_time(y, m, d, hh, mm, ss, dstflag):
  function _format_time (line 189) | def _format_time(hh, mm, ss, us):
  function _check_tzname (line 258) | def _check_tzname(name):
  function _check_utc_offset (line 269) | def _check_utc_offset(name, offset):
  function _check_int_field (line 290) | def _check_int_field(value):
  function _check_date_fields (line 307) | def _check_date_fields(year, month, day):
  function _check_time_fields (line 320) | def _check_time_fields(hour, minute, second, microsecond):
  function _check_tzinfo_arg (line 335) | def _check_tzinfo_arg(tz):
  function _cmperror (line 363) | def _cmperror(x, y):
  function _normalize_pair (line 367) | def _normalize_pair(hi, lo, factor):
  function _normalize_datetime (line 373) | def _normalize_datetime(y, m, d, hh, mm, ss, us, ignore_overflow=False):
  function _normalize_date (line 382) | def _normalize_date(year, month, day, ignore_overflow=False):
  function _accum (line 423) | def _accum(tag, sofar, num, factor, leftover):
  class timedelta (line 441) | class timedelta(object):
    method __new__ (line 460) | def __new__(cls, days=_SENTINEL, seconds=_SENTINEL, microseconds=_SENT...
    method _from_microseconds (line 483) | def _from_microseconds(cls, us):
    method _create (line 489) | def _create(cls, d, s, us, normalize):
    method _to_microseconds (line 504) | def _to_microseconds(self):
    method __repr__ (line 508) | def __repr__(self):
    method __str__ (line 521) | def __str__(self):
    method total_seconds (line 533) | def total_seconds(self):
    method days (line 540) | def days(self):
    method seconds (line 545) | def seconds(self):
    method microseconds (line 550) | def microseconds(self):
    method __add__ (line 554) | def __add__(self, other):
    method __sub__ (line 564) | def __sub__(self, other):
    method __neg__ (line 574) | def __neg__(self):
    method __pos__ (line 582) | def __pos__(self):
    method __abs__ (line 590) | def __abs__(self):
    method __mul__ (line 596) | def __mul__(self, other):
    method __div__ (line 604) | def __div__(self, other):
    method __eq__ (line 615) | def __eq__(self, other):
    method __ne__ (line 621) | def __ne__(self, other):
    method __le__ (line 627) | def __le__(self, other):
    method __lt__ (line 633) | def __lt__(self, other):
    method __ge__ (line 639) | def __ge__(self, other):
    method __gt__ (line 645) | def __gt__(self, other):
    method _cmp (line 651) | def _cmp(self, other):
    method __hash__ (line 655) | def __hash__(self):
    method __nonzero__ (line 660) | def __nonzero__(self):
    method _getstate (line 667) | def _getstate(self):
    method __reduce__ (line 670) | def __reduce__(self):
  class date (line 677) | class date(object):
    method __new__ (line 707) | def __new__(cls, year, month=None, day=None):
    method fromtimestamp (line 732) | def fromtimestamp(cls, t):
    method today (line 738) | def today(cls):
    method fromordinal (line 744) | def fromordinal(cls, n):
    method __repr__ (line 755) | def __repr__(self):
    method ctime (line 777) | def ctime(self):
    method __format__ (line 789) | def __format__(self, fmt):
    method isoformat (line 797) | def isoformat(self):
    method year (line 813) | def year(self):
    method month (line 818) | def month(self):
    method day (line 823) | def day(self):
    method timetuple (line 829) | def timetuple(self):
    method toordinal (line 834) | def toordinal(self):
    method replace (line 842) | def replace(self, year=None, month=None, day=None):
    method __eq__ (line 854) | def __eq__(self, other):
    method __ne__ (line 862) | def __ne__(self, other):
    method __le__ (line 870) | def __le__(self, other):
    method __lt__ (line 878) | def __lt__(self, other):
    method __ge__ (line 886) | def __ge__(self, other):
    method __gt__ (line 894) | def __gt__(self, other):
    method _cmp (line 902) | def _cmp(self, other):
    method __hash__ (line 908) | def __hash__(self):
    method _add_timedelta (line 916) | def _add_timedelta(self, other, factor):
    method __add__ (line 923) | def __add__(self, other):
    method __sub__ (line 931) | def __sub__(self, other):
    method weekday (line 941) | def weekday(self):
    method isoweekday (line 947) | def isoweekday(self):
    method isocalendar (line 952) | def isocalendar(self):
    method _getstate (line 981) | def _getstate(self):
    method __setstate (line 985) | def __setstate(self, string):
    method __reduce__ (line 990) | def __reduce__(self):
  class tzinfo (line 999) | class tzinfo(object):
    method tzname (line 1006) | def tzname(self, dt):
    method utcoffset (line 1010) | def utcoffset(self, dt):
    method dst (line 1014) | def dst(self, dt):
    method fromutc (line 1022) | def fromutc(self, dt):
    method __reduce__ (line 1054) | def __reduce__(self):
  class time (line 1072) | class time(object):
    method __new__ (line 1097) | def __new__(cls, hour=0, minute=0, second=0, microsecond=0, tzinfo=None):
    method hour (line 1126) | def hour(self):
    method minute (line 1131) | def minute(self):
    method second (line 1136) | def second(self):
    method microsecond (line 1141) | def microsecond(self):
    method tzinfo (line 1146) | def tzinfo(self):
    method __eq__ (line 1154) | def __eq__(self, other):
    method __ne__ (line 1160) | def __ne__(self, other):
    method __le__ (line 1166) | def __le__(self, other):
    method __lt__ (line 1172) | def __lt__(self, other):
    method __ge__ (line 1178) | def __ge__(self, other):
    method __gt__ (line 1184) | def __gt__(self, other):
    method _cmp (line 1190) | def _cmp(self, other):
    method __hash__ (line 1215) | def __hash__(self):
    method _tzstr (line 1231) | def _tzstr(self, sep=":"):
    method __repr__ (line 1245) | def __repr__(self):
    method isoformat (line 1261) | def isoformat(self):
    method __format__ (line 1287) | def __format__(self, fmt):
    method utcoffset (line 1297) | def utcoffset(self):
    method _utcoffset (line 1309) | def _utcoffset(self):
    method tzname (line 1316) | def tzname(self):
    method dst (line 1329) | def dst(self):
    method _dst (line 1347) | def _dst(self):
    method replace (line 1354) | def replace(self, hour=None, minute=None, second=None, microsecond=None,
    method __nonzero__ (line 1370) | def __nonzero__(self):
    method _getstate (line 1378) | def _getstate(self):
    method __setstate (line 1388) | def __setstate(self, string, tzinfo):
    method __reduce__ (line 1397) | def __reduce__(self):
  class datetime (line 1406) | class datetime(date):
    method __new__ (line 1414) | def __new__(cls, year, month=None, day=None, hour=0, minute=0, second=0,
    method hour (line 1441) | def hour(self):
    method minute (line 1446) | def minute(self):
    method second (line 1451) | def second(self):
    method microsecond (line 1456) | def microsecond(self):
    method tzinfo (line 1461) | def tzinfo(self):
    method fromtimestamp (line 1466) | def fromtimestamp(cls, timestamp, tz=None):
    method utcfromtimestamp (line 1479) | def utcfromtimestamp(cls, t):
    method _from_timestamp (line 1484) | def _from_timestamp(cls, converter, timestamp, tzinfo):
    method now (line 1502) | def now(cls, tz=None):
    method utcnow (line 1508) | def utcnow(cls):
    method combine (line 1514) | def combine(cls, date, time):
    method timetuple (line 1524) | def timetuple(self):
    method utctimetuple (line 1535) | def utctimetuple(self):
    method date (line 1546) | def date(self):
    method time (line 1550) | def time(self):
    method timetz (line 1554) | def timetz(self):
    method replace (line 1559) | def replace(self, year=None, month=None, day=None, hour=None,
    method astimezone (line 1582) | def astimezone(self, tz):
    method ctime (line 1604) | def ctime(self):
    method isoformat (line 1614) | def isoformat(self, sep='T'):
    method __repr__ (line 1640) | def __repr__(self):
    method __str__ (line 1656) | def __str__(self):
    method utcoffset (line 1670) | def utcoffset(self):
    method _utcoffset (line 1682) | def _utcoffset(self):
    method tzname (line 1689) | def tzname(self):
    method dst (line 1702) | def dst(self):
    method _dst (line 1720) | def _dst(self):
    method __eq__ (line 1729) | def __eq__(self, other):
    method __ne__ (line 1737) | def __ne__(self, other):
    method __le__ (line 1745) | def __le__(self, other):
    method __lt__ (line 1753) | def __lt__(self, other):
    method __ge__ (line 1761) | def __ge__(self, other):
    method __gt__ (line 1769) | def __gt__(self, other):
    method _cmp (line 1777) | def _cmp(self, other):
    method _add_timedelta (line 1807) | def _add_timedelta(self, other, factor):
    method __add__ (line 1818) | def __add__(self, other):
    method __sub__ (line 1826) | def __sub__(self, other):
    method __hash__ (line 1849) | def __hash__(self):
    method _getstate (line 1862) | def _getstate(self):
    method __setstate (line 1874) | def __setstate(self, string, tzinfo):
    method __reduce__ (line 1886) | def __reduce__(self):
  function _isoweek1monday (line 1895) | def _isoweek1monday(year):

FILE: third_party/pythonparser/__init__.py
  function parse_buffer (line 5) | def parse_buffer(buffer, mode="exec", flags=[], version=None, engine=None):
  function parse (line 35) | def parse(source, filename="<unknown>", mode="exec",

FILE: third_party/pythonparser/algorithm.py
  class Visitor (line 9) | class Visitor:
    method generic_visit (line 24) | def generic_visit(self, node):
    method _visit_one (line 29) | def _visit_one(self, node):
    method visit (line 36) | def visit(self, obj):
  class Transformer (line 43) | class Transformer:
    method generic_visit (line 65) | def generic_visit(self, node):
    method _visit_one (line 71) | def _visit_one(self, node):
    method visit (line 78) | def visit(self, obj):
  function compare (line 87) | def compare(left, right, compare_locs=False):

FILE: third_party/pythonparser/ast.py
  class commonloc (line 30) | class commonloc(object):
    method _reprfields (line 43) | def _reprfields(self):
    method __repr__ (line 46) | def __repr__(self):
    method lineno (line 61) | def lineno(self):
  class keywordloc (line 64) | class keywordloc(commonloc):
  class beginendloc (line 72) | class beginendloc(commonloc):
  class AST (line 83) | class AST(object):
    method __init__ (line 92) | def __init__(self, **fields):
  class alias (line 96) | class alias(AST, commonloc):
  class arg (line 109) | class arg(AST, commonloc):
  class arguments (line 121) | class arguments(AST, beginendloc):
  class boolop (line 142) | class boolop(AST, commonloc):
  class And (line 151) | class And(boolop):
  class Or (line 153) | class Or(boolop):
  class cmpop (line 156) | class cmpop(AST, commonloc):
  class Eq (line 158) | class Eq(cmpop):
  class Gt (line 160) | class Gt(cmpop):
  class GtE (line 162) | class GtE(cmpop):
  class In (line 164) | class In(cmpop):
  class Is (line 166) | class Is(cmpop):
  class IsNot (line 168) | class IsNot(cmpop):
  class Lt (line 170) | class Lt(cmpop):
  class LtE (line 172) | class LtE(cmpop):
  class NotEq (line 174) | class NotEq(cmpop):
  class NotIn (line 176) | class NotIn(cmpop):
  class comprehension (line 179) | class comprehension(AST, commonloc):
  class excepthandler (line 193) | class excepthandler(AST, commonloc):
  class ExceptHandler (line 195) | class ExceptHandler(excepthandler):
  class expr (line 211) | class expr(AST, commonloc):
  class Attribute (line 213) | class Attribute(expr):
  class BinOp (line 222) | class BinOp(expr):
  class BoolOp (line 231) | class BoolOp(expr):
  class Call (line 241) | class Call(expr, beginendloc):
  class Compare (line 255) | class Compare(expr):
  class Dict (line 264) | class Dict(expr, beginendloc):
  class DictComp (line 274) | class DictComp(expr, beginendloc):
  class Ellipsis (line 287) | class Ellipsis(expr):
  class GeneratorExp (line 289) | class GeneratorExp(expr, beginendloc):
  class IfExp (line 297) | class IfExp(expr):
  class Lambda (line 309) | class Lambda(expr):
  class List (line 320) | class List(expr, beginendloc):
  class ListComp (line 327) | class ListComp(expr, beginendloc):
  class Name (line 335) | class Name(expr):
  class NameConstant (line 342) | class NameConstant(expr):
  class Num (line 349) | class Num(expr):
  class Repr (line 356) | class Repr(expr, beginendloc):
  class Set (line 365) | class Set(expr, beginendloc):
  class SetComp (line 374) | class SetComp(expr, beginendloc):
  class Str (line 384) | class Str(expr, beginendloc):
  class Starred (line 391) | class Starred(expr):
  class Subscript (line 400) | class Subscript(expr, beginendloc):
  class Tuple (line 408) | class Tuple(expr, beginendloc):
  class UnaryOp (line 415) | class UnaryOp(expr):
  class Yield (line 423) | class Yield(expr):
  class YieldFrom (line 432) | class YieldFrom(expr):
  class keyword (line 451) | class keyword(AST, commonloc):
  class mod (line 462) | class mod(AST, commonloc):
  class Expression (line 465) | class Expression(mod):
  class Interactive (line 467) | class Interactive(mod):
  class Module (line 469) | class Module(mod):
  class operator (line 472) | class operator(AST, commonloc):
  class Add (line 474) | class Add(operator):
  class BitAnd (line 476) | class BitAnd(operator):
  class BitOr (line 478) | class BitOr(operator):
  class BitXor (line 480) | class BitXor(operator):
  class Div (line 482) | class Div(operator):
  class FloorDiv (line 484) | class FloorDiv(operator):
  class LShift (line 486) | class LShift(operator):
  class MatMult (line 488) | class MatMult(operator):
  class Mod (line 490) | class Mod(operator):
  class Mult (line 492) | class Mult(operator):
  class Pow (line 494) | class Pow(operator):
  class RShift (line 496) | class RShift(operator):
  class Sub (line 498) | class Sub(operator):
  class slice (line 501) | class slice(AST, commonloc):
  class ExtSlice (line 503) | class ExtSlice(slice):
  class Index (line 512) | class Index(slice):
  class Slice (line 519) | class Slice(slice):
  class stmt (line 532) | class stmt(AST, commonloc):
  class Assert (line 534) | class Assert(stmt, keywordloc):
  class Assign (line 542) | class Assign(stmt):
  class AugAssign (line 552) | class AugAssign(stmt):
  class Break (line 561) | class Break(stmt, keywordloc):
  class ClassDef (line 563) | class ClassDef(stmt, keywordloc):
  class Continue (line 587) | class Continue(stmt, keywordloc):
  class Delete (line 589) | class Delete(stmt, keywordloc):
  class Exec (line 596) | class Exec(stmt, keywordloc):
  class Expr (line 610) | class Expr(stmt):
  class For (line 617) | class For(stmt, keywordloc):
  class FunctionDef (line 633) | class FunctionDef(stmt, keywordloc):
  class Global (line 650) | class Global(stmt, keywordloc):
  class If (line 659) | class If(stmt, keywordloc):
  class Import (line 672) | class Import(stmt, keywordloc):
  class ImportFrom (line 679) | class ImportFrom(stmt, keywordloc):
  class Nonlocal (line 696) | class Nonlocal(stmt, keywordloc):
  class Pass (line 707) | class Pass(stmt, keywordloc):
  class Print (line 709) | class Print(stmt, keywordloc):
  class Raise (line 722) | class Raise(stmt, keywordloc):
  class Return (line 735) | class Return(stmt, keywordloc):
  class Try (line 742) | class Try(stmt, keywordloc):
  class While (line 761) | class While(stmt, keywordloc):
  class With (line 775) | class With(stmt, keywordloc):
  class unaryop (line 787) | class unaryop(AST, commonloc):
  class Invert (line 789) | class Invert(unaryop):
  class Not (line 791) | class Not(unaryop):
  class UAdd (line 793) | class UAdd(unaryop):
  class USub (line 795) | class USub(unaryop):
  class withitem (line 798) | class withitem(AST, commonloc):

FILE: third_party/pythonparser/diagnostic.py
  class Diagnostic (line 11) | class Diagnostic:
    method __init__ (line 41) | def __init__(self, level, reason, arguments, location,
    method message (line 60) | def message(self):
    method render (line 66) | def render(self, only_line=False, colored=False):
  class Error (line 132) | class Error(Exception):
    method __init__ (line 138) | def __init__(self, diagnostic):
    method __str__ (line 141) | def __str__(self):
  class Engine (line 144) | class Engine:
    method __init__ (line 152) | def __init__(self, all_errors_are_fatal=False):
    method process (line 156) | def process(self, diagnostic):
    method context (line 168) | def context(self, *notes):
    method render_diagnostic (line 177) | def render_diagnostic(self, diagnostic):

FILE: third_party/pythonparser/lexer.py
  class Token (line 17) | class Token:
    method __init__ (line 26) | def __init__(self, loc, kind, value=None):
    method __repr__ (line 29) | def __repr__(self):
  class Lexer (line 32) | class Lexer:
    method __init__ (line 105) | def __init__(self, source_buffer, version, diagnostic_engine, interact...
    method next (line 208) | def next(self, eof_token=False):
    method peek (line 232) | def peek(self, eof_token=False):
    method _refill (line 241) | def _refill(self, eof_token):
    method _string_literal (line 415) | def _string_literal(self, options, begin_span, data, data_span, end_sp...
    method _replace_escape (line 433) | def _replace_escape(self, range, mode, value):
    method _replace_escape_unicode (line 448) | def _replace_escape_unicode(self, range, value):
    method _replace_escape_bytes (line 512) | def _replace_escape_bytes(self, value):
    method _check_long_literal (line 554) | def _check_long_literal(self, range, literal):
    method _match_pair_delim (line 561) | def _match_pair_delim(self, range, kwop):
    method _check_innermost_pair_delim (line 578) | def _check_innermost_pair_delim(self, range, expected):
    method __iter__ (line 607) | def __iter__(self):
    method __next__ (line 610) | def __next__(self):

FILE: third_party/pythonparser/parser.py
  class Unmatched (line 49) | class Unmatched:
  function llrule (line 54) | def llrule(loc, expected, cases=1):
  function action (line 77) | def action(inner_rule, loc=None):
  function Eps (line 99) | def Eps(value=None, loc=None):
  function Tok (line 106) | def Tok(kind, loc=None):
  function Loc (line 113) | def Loc(kind, loc=None):
  function Rule (line 123) | def Rule(name, loc=None):
  function Expect (line 130) | def Expect(inner_rule, loc=None):
  function Seq (line 155) | def Seq(first_rule, *rest_of_rules, **kwargs):
  function SeqN (line 175) | def SeqN(n, *inner_rules, **kwargs):
  function Alt (line 185) | def Alt(*inner_rules, **kwargs):
  function Opt (line 218) | def Opt(inner_rule, loc=None):
  function Star (line 222) | def Star(inner_rule, loc=None):
  function Plus (line 239) | def Plus(inner_rule, loc=None):
  class commalist (line 260) | class commalist(list):
  function List (line 263) | def List(inner_rule, separator_tok, trailing, leading=True, loc=None):
  function Newline (line 301) | def Newline(loc=None):
  function Oper (line 311) | def Oper(klass, *kinds, **kwargs):
  function BinOper (line 322) | def BinOper(expr_rulename, op_rule, node=ast.BinOp, loc=None):
  function BeginEnd (line 331) | def BeginEnd(begin_tok, inner_rule, end_tok, empty=None, loc=None):
  class Parser (line 352) | class Parser:
    method __init__ (line 355) | def __init__(self, lexer, version, diagnostic_engine):
    method _save (line 366) | def _save(self):
    method _restore (line 369) | def _restore(self, data, rule):
    method _advance (line 385) | def _advance(self):
    method _accept (line 391) | def _accept(self, expected_kind):
    method _init_version (line 399) | def _init_version(self, version):
    method _arguments (line 460) | def _arguments(self, args=None, defaults=None, kwonlyargs=None, kw_def...
    method _arg (line 484) | def _arg(self, tok, colon_loc=None, annotation=None):
    method _empty_arglist (line 491) | def _empty_arglist(self):
    method _wrap_tuple (line 495) | def _wrap_tuple(self, elts):
    method _assignable (line 503) | def _assignable(self, node, is_delete=False):
    method add_flags (line 520) | def add_flags(self, flags):
    method single_input (line 530) | def single_input(self, body):
    method file_input (line 538) | def file_input(parser, body):
    method eval_input (line 547) | def eval_input(self, expr):
    method decorator (line 555) | def decorator(self, at_loc, idents, call_opt, newline_loc):
    method decorated (line 578) | def decorated(self, decorators, classfuncdef):
    method funcdef__26 (line 586) | def funcdef__26(self, def_loc, ident_tok, args, colon_loc, suite):
    method funcdef__30 (line 597) | def funcdef__30(self, def_loc, ident_tok, args, returns_opt, colon_loc...
    method varargslist__26_2 (line 617) | def varargslist__26_2(self, dstar_loc, kwarg_tok):
    method varargslist__26_3 (line 623) | def varargslist__26_3(self, star_loc, vararg_tok, kwarg_opt):
    method varargslist__26_4 (line 635) | def varargslist__26_4(self):
    method varargslist__26 (line 642) | def varargslist__26(self, fparams, args):
    method fpdef_1 (line 677) | def fpdef_1(self, ident_tok):
    method _argslist (line 686) | def _argslist(fpdef_rule, old_style=False):
    method tfpdef (line 803) | def tfpdef(self, ident_tok, annotation_opt):
    method fplist (line 814) | def fplist(self, elts):
    method expr_stmt_2 (line 841) | def expr_stmt_2(self, augassign, rhs_expr):
    method expr_stmt_3 (line 845) | def expr_stmt_3(self, seq):
    method expr_stmt (line 853) | def expr_stmt(self, lhs, rhs):
    method print_stmt_1 (line 893) | def print_stmt_1(self, values):
    method print_stmt_2 (line 901) | def print_stmt_2(self, dest_loc, dest, comma_tok, values):
    method print_stmt_3 (line 909) | def print_stmt_3(self, eps):
    method print_stmt (line 914) | def print_stmt(self, print_loc, stmt):
    method del_stmt (line 928) | def del_stmt(self, stmt_loc, exprs):
    method pass_stmt (line 936) | def pass_stmt(self, stmt_loc):
    method break_stmt (line 945) | def break_stmt(self, stmt_loc):
    method continue_stmt (line 950) | def continue_stmt(self, stmt_loc):
    method return_stmt (line 955) | def return_stmt(self, stmt_loc, values):
    method yield_stmt (line 964) | def yield_stmt(self, expr):
    method raise_stmt__26 (line 971) | def raise_stmt__26(self, raise_loc, type_opt):
    method raise_stmt__30 (line 987) | def raise_stmt__30(self, raise_loc, exc_opt):
    method import_name (line 1004) | def import_name(self, import_loc, names):
    method import_from_1 (line 1010) | def import_from_1(self, loc):
    method import_from_2 (line 1014) | def import_from_2(self, loc):
    method import_from_3 (line 1018) | def import_from_3(self, dots, dotted_name):
    method import_from_4 (line 1026) | def import_from_4(self, dots):
    method import_from_5 (line 1032) | def import_from_5(self, star_loc):
    method import_from_7 (line 1039) | def import_from_7(self, string):
    method import_from_6 (line 1043) | def import_from_6(self, names):
    method import_from (line 1050) | def import_from(self, from_loc, module_name, import_loc, names):
    method import_as_name (line 1078) | def import_as_name(self, name_tok, as_name_opt):
    method dotted_as_name (line 1091) | def dotted_as_name(self, dotted_name, as_name_opt):
    method str_as_name (line 1105) | def str_as_name(self, string, as_name_opt):
    method dotted_name (line 1123) | def dotted_name(self, idents):
    method global_stmt (line 1129) | def global_stmt(self, global_loc, names):
    method exec_stmt (line 1138) | def exec_stmt(self, exec_loc, body, in_opt):
    method nonlocal_stmt (line 1152) | def nonlocal_stmt(self, nonlocal_loc, names):
    method assert_stmt (line 1159) | def assert_stmt(self, assert_loc, test, msg):
    method compound_stmt (line 1170) | def compound_stmt(self, stmt):
    method if_stmt (line 1178) | def if_stmt(self, if_loc, test, if_colon_loc, body, elifs, else_opt):
    method while_stmt (line 1203) | def while_stmt(self, while_loc, test, while_colon_loc, body, else_opt):
    method for_stmt (line 1218) | def for_stmt(self, for_loc, target, in_loc, iter, for_colon_loc, body,...
    method try_stmt_1 (line 1233) | def try_stmt_1(self, clauses, else_opt, finally_opt):
    method try_stmt_2 (line 1257) | def try_stmt_2(self, finally_loc, finally_colon_loc, finalbody):
    method try_stmt (line 1264) | def try_stmt(self, try_loc, try_colon_loc, body, stmt):
    method with_stmt__26 (line 1278) | def with_stmt__26(self, with_loc, context, with_var, colon_loc, body):
    method with_stmt__27 (line 1296) | def with_stmt__27(self, with_loc, items, colon_loc, body):
    method with_item (line 1303) | def with_item(self, context, as_opt):
    method except_clause_1__26 (line 1314) | def except_clause_1__26(self, as_loc, name):
    method except_clause_1__30 (line 1318) | def except_clause_1__30(self, as_loc, name):
    method except_clause (line 1324) | def except_clause(self, except_loc, exc_opt):
    method suite_1 (line 1348) | def suite_1(self, stmts):
    method old_lambdef (line 1363) | def old_lambdef(self, lambda_loc, args_opt, colon_loc, body):
    method test_1 (line 1375) | def test_1(self, lhs, rhs_opt):
    method lambdef_action (line 1388) | def lambdef_action(self, lambda_loc, args_opt, colon_loc, body):
    method or_test (line 1407) | def or_test(self, lhs, rhs):
    method and_test (line 1418) | def and_test(self, lhs, rhs):
    method not_test_1 (line 1429) | def not_test_1(self, op, operand):
    method comparison (line 1441) | def comparison(self, lhs, rhs):
    method star_expr__30 (line 1455) | def star_expr__30(self, star_opt, expr):
    method star_expr__32 (line 1463) | def star_expr__32(self, star_loc, expr):
    method factor_1 (line 1500) | def factor_1(self, op, factor):
    method power (line 1508) | def power(self, atom, trailers, factor_opt):
    method atom_1 (line 1524) | def atom_1(self, expr):
    method atom_2 (line 1528) | def atom_2(self, tok):
    method atom_3 (line 1532) | def atom_3(self, tok):
    method atom_4 (line 1536) | def atom_4(self, begin_tok, data_tok, end_tok):
    method atom_5 (line 1542) | def atom_5(self, strings):
    method atom_7 (line 1578) | def atom_7(self, loc):
    method atom_8 (line 1582) | def atom_8(self, tok):
    method list_gen_action (line 1607) | def list_gen_action(self, lhs, rhs):
    method listmaker_1 (line 1618) | def listmaker_1(self, compose):
    method listmaker_2 (line 1622) | def listmaker_2(self, elts):
    method testlist_comp_2 (line 1635) | def testlist_comp_2(self, compose):
    method testlist_comp_3 (line 1639) | def testlist_comp_3(self, elts):
    method testlist_comp__list_1 (line 1655) | def testlist_comp__list_1(self, compose):
    method testlist_comp__list_2 (line 1659) | def testlist_comp__list_2(self, elts):
    method trailer_1 (line 1668) | def trailer_1(self, dot_loc, ident_tok):
    method subscriptlist (line 1680) | def subscriptlist(self, subscripts):
    method subscript_1 (line 1697) | def subscript_1(self, dot_1_loc, dot_2_loc, dot_3_loc):
    method subscript_2 (line 1701) | def subscript_2(self, lower_opt, colon_loc, upper_opt, step_opt):
    method subscript_3 (line 1717) | def subscript_3(self, expr):
    method exprlist (line 1734) | def exprlist(self, exprs):
    method testlist (line 1743) | def testlist(self, exprs):
    method dictmaker (line 1748) | def dictmaker(self, elts):
    method dictorsetmaker_2 (line 1760) | def dictorsetmaker_2(self, first, elts):
    method dictorsetmaker_3 (line 1775) | def dictorsetmaker_3(self, first, elts):
    method classdef__26 (line 1793) | def classdef__26(self, class_loc, name_tok, bases_opt, colon_loc, body):
    method classdef__30 (line 1810) | def classdef__30(self, class_loc, name_tok, arglist_opt, colon_loc, bo...
    method arglist_1 (line 1831) | def arglist_1(self, star_loc, stararg, postargs, kwarg_opt):
    method arglist_2 (line 1848) | def arglist_2(self, dstar_loc, kwarg):
    method arglist_3 (line 1859) | def arglist_3(self, arg, cont):
    method arglist (line 1869) | def arglist(self, args, call):
    method argument_1 (line 1886) | def argument_1(self, equals_loc, rhs):
    method argument_2 (line 1898) | def argument_2(self, compose_opt):
    method argument (line 1909) | def argument(self, lhs, thunk):
    method list_comp_for_action (line 1920) | def list_comp_for_action(self, for_loc, target, in_loc, iter, next_opt):
    method list_comp_if_action (line 1932) | def list_comp_if_action(self, if_loc, cond, next_opt):
    method yield_expr__26 (line 1988) | def yield_expr__26(self, yield_loc, exprs):
    method yield_expr__33 (line 1998) | def yield_expr__33(self, yield_loc, arg):
    method yield_arg_1 (line 2012) | def yield_arg_1(self, from_loc, value):

FILE: third_party/pythonparser/source.py
  class Buffer (line 12) | class Buffer:
    method __init__ (line 21) | def __init__(self, source, name="<input>", first_line=1):
    method __repr__ (line 31) | def __repr__(self):
    method source_line (line 34) | def source_line(self, lineno):
    method decompose_position (line 49) | def decompose_position(self, offset):
    method _extract_line_begins (line 61) | def _extract_line_begins(self):
    method _extract_encoding (line 76) | def _extract_encoding(self, source):
  class Range (line 96) | class Range:
    method __init__ (line 105) | def __init__(self, source_buffer, begin_pos, end_pos, expanded_from=No...
    method __repr__ (line 111) | def __repr__(self):
    method chain (line 118) | def chain(self, expanded_from):
    method begin (line 126) | def begin(self):
    method end (line 133) | def end(self):
    method size (line 140) | def size(self):
    method column (line 146) | def column(self):
    method column_range (line 153) | def column_range(self):
    method line (line 164) | def line(self):
    method join (line 171) | def join(self, other):
    method source (line 188) | def source(self):
    method source_line (line 194) | def source_line(self):
    method source_lines (line 200) | def source_lines(self):
    method __str__ (line 207) | def __str__(self):
    method __eq__ (line 219) | def __eq__(self, other):
    method __ne__ (line 229) | def __ne__(self, other):
    method __hash__ (line 235) | def __hash__(self):
  class Comment (line 238) | class Comment:
    method __init__ (line 246) | def __init__(self, loc, text):
  class RewriterConflict (line 249) | class RewriterConflict(Exception):
    method __init__ (line 257) | def __init__(self, first, second):
  class Rewriter (line 261) | class Rewriter:
    method __init__ (line 270) | def __init__(self, buffer):
    method replace (line 274) | def replace(self, range, replacement):
    method remove (line 278) | def remove(self, range):
    method insert_before (line 282) | def insert_before(self, range, text):
    method insert_after (line 286) | def insert_after(self, range, text):
    method rewrite (line 290) | def rewrite(self):
    method _sort (line 304) | def _sort(self):
    method _check (line 307) | def _check(self):

FILE: third_party/stdlib/Queue.py
  class Empty (line 13) | class Empty(Exception):
  class Full (line 17) | class Full(Exception):
  class Queue (line 21) | class Queue(object):
    method __init__ (line 26) | def __init__(self, maxsize=0):
    method task_done (line 45) | def task_done(self):
    method join (line 70) | def join(self):
    method qsize (line 86) | def qsize(self):
    method empty (line 93) | def empty(self):
    method full (line 100) | def full(self):
    method put (line 107) | def put(self, item, block=True, timeout=None):
    method put_nowait (line 142) | def put_nowait(self, item):
    method get (line 150) | def get(self, block=True, timeout=None):
    method get_nowait (line 184) | def get_nowait(self):
    method _init (line 197) | def _init(self, maxsize):
    method _qsize (line 200) | def _qsize(self, len=len):
    method _put (line 204) | def _put(self, item):
    method _get (line 208) | def _get(self):
  class PriorityQueue (line 212) | class PriorityQueue(Queue):
    method _init (line 218) | def _init(self, maxsize):
    method _qsize (line 221) | def _qsize(self, len=len):
    method _put (line 224) | def _put(self, item, heappush=heapq.heappush):
    method _get (line 227) | def _get(self, heappop=heapq.heappop):
  class LifoQueue (line 231) | class LifoQueue(Queue):
    method _init (line 234) | def _init(self, maxsize):
    method _qsize (line 237) | def _qsize(self, len=len):
    method _put (line 240) | def _put(self, item):
    method _get (line 243) | def _get(self):

FILE: third_party/stdlib/StringIO.py
  function _complain_ifclosed (line 39) | def _complain_ifclosed(closed):
  class StringIO (line 43) | class StringIO(object):
    method __init__ (line 55) | def __init__(self, buf = ''):
    method __iter__ (line 66) | def __iter__(self):
    method next (line 69) | def next(self):
    method close (line 82) | def close(self):
    method isatty (line 89) | def isatty(self):
    method seek (line 96) | def seek(self, pos, mode = 0):
    method tell (line 115) | def tell(self):
    method read (line 120) | def read(self, n = -1):
    method readline (line 140) | def readline(self, length=None):
    method readlines (line 169) | def readlines(self, sizehint = 0):
    method truncate (line 188) | def truncate(self, size=None):
    method write (line 209) | def write(self, s):
    method writelines (line 242) | def writelines(self, iterable):
    method flush (line 254) | def flush(self):
    method getvalue (line 259) | def getvalue(self):
  function test (line 279) | def test():

FILE: third_party/stdlib/UserDict.py
  class UserDict (line 3) | class UserDict(object):
    method __init__ (line 4) | def __init__(*args, **kwargs):
    method __repr__ (line 27) | def __repr__(self): return repr(self.data)
    method __cmp__ (line 28) | def __cmp__(self, dict):
    method __len__ (line 34) | def __len__(self): return len(self.data)
    method __getitem__ (line 35) | def __getitem__(self, key):
    method __setitem__ (line 41) | def __setitem__(self, key, item): self.data[key] = item
    method __delitem__ (line 42) | def __delitem__(self, key): del self.data[key]
    method clear (line 43) | def clear(self): self.data.clear()
    method copy (line 44) | def copy(self):
    method keys (line 56) | def keys(self): return self.data.keys()
    method items (line 57) | def items(self): return self.data.items()
    method iteritems (line 58) | def iteritems(self): return self.data.iteritems()
    method iterkeys (line 59) | def iterkeys(self): return self.data.iterkeys()
    method itervalues (line 60) | def itervalues(self): return self.data.itervalues()
    method values (line 61) | def values(self): return self.data.values()
    method has_key (line 62) | def has_key(self, key): return key in self.data
    method update (line 63) | def update(*args, **kwargs):
    method get (line 91) | def get(self, key, failobj=None):
    method setdefault (line 95) | def setdefault(self, key, failobj=None):
    method pop (line 99) | def pop(self, key, *args):
    method popitem (line 101) | def popitem(self):
    method __contains__ (line 103) | def __contains__(self, key):
    method fromkeys (line 105) | def fromkeys(cls, iterable, value=None):
  class IterableUserDict (line 113) | class IterableUserDict(UserDict):
    method __iter__ (line 114) | def __iter__(self):
  class DictMixin (line 121) | class DictMixin(object):
    method __iter__ (line 130) | def __iter__(self):
    method has_key (line 133) | def has_key(self, key):
    method __contains__ (line 139) | def __contains__(self, key):
    method iteritems (line 143) | def iteritems(self):
    method iterkeys (line 146) | def iterkeys(self):
    method itervalues (line 150) | def itervalues(self):
    method values (line 153) | def values(self):
    method items (line 155) | def items(self):
    method clear (line 157) | def clear(self):
    method setdefault (line 160) | def setdefault(self, key, default=None):
    method pop (line 166) | def pop(self, key, *args):
    method popitem (line 178) | def popitem(self):
    method update (line 185) | def update(self, other=None, **kwargs):
    method get (line 200) | def get(self, key, default=None):
    method __repr__ (line 205) | def __repr__(self):
    method __cmp__ (line 207) | def __cmp__(self, other):
    method __len__ (line 213) | def __len__(self):

FILE: third_party/stdlib/UserList.py
  class UserList (line 5) | class UserList(collections.MutableSequence):
    method __init__ (line 6) | def __init__(self, initlist=None):
    method __repr__ (line 16) | def __repr__(self): return repr(self.data)
    method __lt__ (line 17) | def __lt__(self, other): return self.data <  self.__cast(other)
    method __le__ (line 18) | def __le__(self, other): return self.data <= self.__cast(other)
    method __eq__ (line 19) | def __eq__(self, other): return self.data == self.__cast(other)
    method __ne__ (line 20) | def __ne__(self, other): return self.data != self.__cast(other)
    method __gt__ (line 21) | def __gt__(self, other): return self.data >  self.__cast(other)
    method __ge__ (line 22) | def __ge__(self, other): return self.data >= self.__cast(other)
    method __cast (line 23) | def __cast(self, other):
    method __cmp__ (line 26) | def __cmp__(self, other):
    method __contains__ (line 29) | def __contains__(self, item): return item in self.data
    method __len__ (line 30) | def __len__(self): return len(self.data)
    method __getitem__ (line 31) | def __getitem__(self, i): return self.data[i]
    method __setitem__ (line 32) | def __setitem__(self, i, item): self.data[i] = item
    method __delitem__ (line 33) | def __delitem__(self, i): del self.data[i]
    method __getslice__ (line 34) | def __getslice__(self, i, j):
    method __setslice__ (line 37) | def __setslice__(self, i, j, other):
    method __delslice__ (line 45) | def __delslice__(self, i, j):
    method __add__ (line 48) | def __add__(self, other):
    method __radd__ (line 55) | def __radd__(self, other):
    method __iadd__ (line 62) | def __iadd__(self, other):
    method __mul__ (line 70) | def __mul__(self, n):
    method __imul__ (line 73) | def __imul__(self, n):
    method append (line 76) | def append(self, item): self.data.append(item)
    method insert (line 77) | def insert(self, i, item): self.data.insert(i, item)
    method pop (line 78) | def pop(self, i=-1): return self.data.pop(i)
    method remove (line 79) | def remove(self, item): self.data.remove(item)
    method count (line 80) | def count(self, item): return self.data.count(item)
    method index (line 81) | def index(self, item, *args): return self.data.index(item, *args)
    method reverse (line 82) | def reverse(self): self.data.reverse()
    method sort (line 83) | def sort(self, *args, **kwds): self.data.sort(*args, **kwds)
    method extend (line 84) | def extend(self, other):

FILE: third_party/stdlib/UserString.py
  class UserString (line 13) | class UserString(collections.Sequence):
    method __init__ (line 14) | def __init__(self, seq):
    method __str__ (line 21) | def __str__(self): return str(self.data)
    method __repr__ (line 22) | def __repr__(self): return repr(self.data)
    method __int__ (line 23) | def __int__(self): return int(self.data)
    method __long__ (line 24) | def __long__(self): return long(self.data)
    method __float__ (line 25) | def __float__(self): return float(self.data)
    method __complex__ (line 26) | def __complex__(self): return complex(self.data)
    method __hash__ (line 27) | def __hash__(self): return hash(self.data)
    method __cmp__ (line 29) | def __cmp__(self, string):
    method __contains__ (line 34) | def __contains__(self, char):
    method __len__ (line 37) | def __len__(self): return len(self.data)
    method __getitem__ (line 38) | def __getitem__(self, index): return self.__class__(self.data[index])
    method __getslice__ (line 39) | def __getslice__(self, start, end):
    method __add__ (line 43) | def __add__(self, other):
    method __radd__ (line 50) | def __radd__(self, other):
    method __mul__ (line 55) | def __mul__(self, n):
    method __mod__ (line 58) | def __mod__(self, args):
    method capitalize (line 62) | def capitalize(self): return self.__class__(self.data.capitalize())
    method center (line 63) | def center(self, width, *args):
    method count (line 65) | def count(self, sub, start=0, end=sys.maxint):
    method decode (line 67) | def decode(self, encoding=None, errors=None): # XXX improve this?
    method encode (line 75) | def encode(self, encoding=None, errors=None): # XXX improve this?
    method endswith (line 83) | def endswith(self, suffix, start=0, end=sys.maxint):
    method expandtabs (line 85) | def expandtabs(self, tabsize=8):
    method find (line 87) | def find(self, sub, start=0, end=sys.maxint):
    method index (line 89) | def index(self, sub, start=0, end=sys.maxint):
    method isalpha (line 91) | def isalpha(self): return self.data.isalpha()
    method isalnum (line 92) | def isalnum(self): return self.data.isalnum()
    method isdecimal (line 93) | def isdecimal(self): return self.data.isdecimal()
    method isdigit (line 94) | def isdigit(self): return self.data.isdigit()
    method islower (line 95) | def islower(self): return self.data.islower()
    method isnumeric (line 96) | def isnumeric(self): return self.data.isnumeric()
    method isspace (line 97) | def isspace(self): return self.data.isspace()
    method istitle (line 98) | def istitle(self): return self.data.istitle()
    method isupper (line 99) | def isupper(self): return self.data.isupper()
    method join (line 100) | def join(self, seq): return self.data.join(seq)
    method ljust (line 101) | def ljust(self, width, *args):
    method lower (line 103) | def lower(self): return self.__class__(self.data.lower())
    method lstrip (line 104) | def lstrip(self, chars=None): return self.__class__(self.data.lstrip(c...
    method partition (line 105) | def partition(self, sep):
    method replace (line 107) | def replace(self, old, new, maxsplit=-1):
    method rfind (line 109) | def rfind(self, sub, start=0, end=sys.maxint):
    method rindex (line 111) | def rindex(self, sub, start=0, end=sys.maxint):
    method rjust (line 113) | def rjust(self, width, *args):
    method rpartition (line 115) | def rpartition(self, sep):
    method rstrip (line 117) | def rstrip(self, chars=None): return self.__class__(self.data.rstrip(c...
    method split (line 118) | def split(self, sep=None, maxsplit=-1):
    method rsplit (line 120) | def rsplit(self, sep=None, maxsplit=-1):
    method splitlines (line 122) | def splitlines(self, keepends=0): return self.data.splitlines(keepends)
    method startswith (line 123) | def startswith(self, prefix, start=0, end=sys.maxint):
    method strip (line 125) | def strip(self, chars=None): return self.__class__(self.data.strip(cha...
    method swapcase (line 126) | def swapcase(self): return self.__class__(self.data.swapcase())
    method title (line 127) | def title(self): return self.__class__(self.data.title())
    method translate (line 128) | def translate(self, *args):
    method upper (line 130) | def upper(self): return self.__class__(self.data.upper())
    method zfill (line 131) | def zfill(self, width): return self.__class__(self.data.zfill(width))
  class MutableString (line 133) | class MutableString(UserString, collections.MutableSequence):
    method __init__ (line 148) | def __init__(self, string=""):
    method __setitem__ (line 159) | def __setitem__(self, index, sub):
    method __delitem__ (line 180) | def __delitem__(self, index):
    method __setslice__ (line 195) | def __setslice__(self, start, end, sub):
    method __delslice__ (line 203) | def __delslice__(self, start, end):
    method immutable (line 206) | def immutable(self):
    method __iadd__ (line 208) | def __iadd__(self, other):
    method __imul__ (line 216) | def __imul__(self, n):
    method insert (line 219) | def insert(self, index, value):

FILE: third_party/stdlib/_abcoll.py
  function _hasattr (line 26) | def _hasattr(C, attr):
  class Hashable (line 34) | class Hashable(object):
    method __hash__ (line 38) | def __hash__(self):
    method __subclasshook__ (line 42) | def __subclasshook__(cls, C):
  class Iterable (line 57) | class Iterable(object):
    method __iter__ (line 61) | def __iter__(self):
    method __subclasshook__ (line 66) | def __subclasshook__(cls, C):
  class Iterator (line 75) | class Iterator(Iterable):
    method next (line 78) | def next(self):
    method __iter__ (line 82) | def __iter__(self):
    method __subclasshook__ (line 86) | def __subclasshook__(cls, C):
  class Sized (line 93) | class Sized(object):
    method __len__ (line 97) | def __len__(self):
    method __subclasshook__ (line 101) | def __subclasshook__(cls, C):
  class Container (line 108) | class Container(object):
    method __contains__ (line 112) | def __contains__(self, x):
    method __subclasshook__ (line 116) | def __subclasshook__(cls, C):
  class Callable (line 123) | class Callable(object):
    method __call__ (line 127) | def __call__(self, *args, **kwds):
    method __subclasshook__ (line 131) | def __subclasshook__(cls, C):
  class Set (line 141) | class Set(Sized, Iterable, Container):
    method __le__ (line 152) | def __le__(self, other):
    method __lt__ (line 162) | def __lt__(self, other):
    method __gt__ (line 167) | def __gt__(self, other):
    method __ge__ (line 172) | def __ge__(self, other):
    method __eq__ (line 182) | def __eq__(self, other):
    method __ne__ (line 187) | def __ne__(self, other):
    method _from_iterable (line 191) | def _from_iterable(cls, it):
    method __and__ (line 199) | def __and__(self, other):
    method isdisjoint (line 206) | def isdisjoint(self, other):
    method __or__ (line 213) | def __or__(self, other):
    method __sub__ (line 221) | def __sub__(self, other):
    method __rsub__ (line 229) | def __rsub__(self, other):
    method __xor__ (line 237) | def __xor__(self, other):
    method _hash (line 249) | def _hash(self):
  class MutableSet (line 284) | class MutableSet(Set):
    method add (line 297) | def add(self, value):
    method discard (line 302) | def discard(self, value):
    method remove (line 306) | def remove(self, value):
    method pop (line 312) | def pop(self):
    method clear (line 322) | def clear(self):
    method __ior__ (line 330) | def __ior__(self, it):
    method __iand__ (line 335) | def __iand__(self, it):
    method __ixor__ (line 340) | def __ixor__(self, it):
    method __isub__ (line 353) | def __isub__(self, it):
  class Mapping (line 367) | class Mapping(Sized, Iterable, Container):
    method __getitem__ (line 378) | def __getitem__(self, key):
    method get (line 381) | def get(self, key, default=None):
    method __contains__ (line 388) | def __contains__(self, key):
    method iterkeys (line 396) | def iterkeys(self):
    method itervalues (line 400) | def itervalues(self):
    method iteritems (line 405) | def iteritems(self):
    method keys (line 410) | def keys(self):
    method items (line 414) | def items(self):
    method values (line 418) | def values(self):
    method __eq__ (line 425) | def __eq__(self, other):
    method __ne__ (line 430) | def __ne__(self, other):
  class MappingView (line 433) | class MappingView(Sized):
    method __init__ (line 435) | def __init__(self, mapping):
    method __len__ (line 438) | def __len__(self):
    method __repr__ (line 441) | def __repr__(self):
  class MutableMapping (line 496) | class MutableMapping(Mapping):
    method __setitem__ (line 508) | def __setitem__(self, key, value):
    method __delitem__ (line 512) | def __delitem__(self, key):
    method pop (line 517) | def pop(self, key, default=__marker):
    method popitem (line 531) | def popitem(self):
    method clear (line 543) | def clear(self):
    method update (line 551) | def update(*args, **kwds):
    method setdefault (line 579) | def setdefault(self, key, default=None):
  class Sequence (line 593) | class Sequence(Sized, Iterable, Container):
    method __getitem__ (line 601) | def __getitem__(self, index):
    method __iter__ (line 604) | def __iter__(self):
    method __contains__ (line 614) | def __contains__(self, value):
    method __reversed__ (line 620) | def __reversed__(self):
    method index (line 624) | def index(self, value):
    method count (line 633) | def count(self, value):
  class MutableSequence (line 643) | class MutableSequence(Sequence):
    method __setitem__ (line 653) | def __setitem__(self, index, value):
    method __delitem__ (line 657) | def __delitem__(self, index):
    method insert (line 661) | def insert(self, index, value):
    method append (line 665) | def append(self, value):
    method reverse (line 669) | def reverse(self):
    method extend (line 675) | def extend(self, values):
    method pop (line 680) | def pop(self, index=-1):
    method remove (line 688) | def remove(self, value):
    method __iadd__ (line 694) | def __iadd__(self, values):

FILE: third_party/stdlib/_weakrefset.py
  class _IterationGuard (line 10) | class _IterationGuard(object):
    method __init__ (line 16) | def __init__(self, weakcontainer):
    method __enter__ (line 20) | def __enter__(self):
    method __exit__ (line 26) | def __exit__(self, e, t, b):
  class WeakSet (line 35) | class WeakSet(object):
    method __init__ (line 36) | def __init__(self, data=None):
    method _commit_removals (line 52) | def _commit_removals(self):
    method __iter__ (line 58) | def __iter__(self):
    method __len__ (line 67) | def __len__(self):
    method __contains__ (line 70) | def __contains__(self, item):
    method __reduce__ (line 77) | def __reduce__(self):
    method add (line 83) | def add(self, item):
    method clear (line 88) | def clear(self):
    method copy (line 93) | def copy(self):
    method pop (line 96) | def pop(self):
    method remove (line 108) | def remove(self, item):
    method discard (line 113) | def discard(self, item):
    method update (line 118) | def update(self, other):
    method __ior__ (line 124) | def __ior__(self, other):
    method difference (line 128) | def difference(self, other):
    method difference_update (line 134) | def difference_update(self, other):
    method __isub__ (line 136) | def __isub__(self, other):
    method intersection (line 145) | def intersection(self, other):
    method intersection_update (line 149) | def intersection_update(self, other):
    method __iand__ (line 151) | def __iand__(self, other):
    method issubset (line 157) | def issubset(self, other):
    method __lt__ (line 161) | def __lt__(self, other):
    method issuperset (line 164) | def issuperset(self, other):
    method __gt__ (line 168) | def __gt__(self, other):
    method __eq__ (line 171) | def __eq__(self, other):
    method __ne__ (line 176) | def __ne__(self, other):
    method symmetric_difference (line 182) | def symmetric_difference(self, other):
    method symmetric_difference_update (line 188) | def symmetric_difference_update(self, other):
    method __ixor__ (line 190) | def __ixor__(self, other):
    method union (line 199) | def union(self, other):
    method isdisjoint (line 203) | def isdisjoint(self, other):

FILE: third_party/stdlib/abc.py
  function abstractmethod (line 15) | def abstractmethod(funcobj):
  class abstractproperty (line 36) | class abstractproperty(property):
  class ABCMeta (line 65) | class ABCMeta(type):
    method __new__ (line 86) | def __new__(mcls, name, bases, namespace):
    method register (line 105) | def register(cls, subclass):
    method _dump_registry (line 119) | def _dump_registry(cls, file=None):
    method __instancecheck__ (line 128) | def __instancecheck__(cls, instance):
    method __subclasscheck__ (line 148) | def __subclasscheck__(cls, subclass):

FILE: third_party/stdlib/argparse.py
  function setdefault (line 95) | def setdefault(d, k, default=None):
  function dict_pop (line 100) | def dict_pop(d, k, default=None):
  function list_remove (line 108) | def list_remove(l, x):
  function _callable (line 116) | def _callable(obj):
  class _AttributeHolder (line 133) | class _AttributeHolder(object):
    method __repr__ (line 142) | def __repr__(self):
    method _get_kwargs (line 151) | def _get_kwargs(self):
    method _get_args (line 154) | def _get_args(self):
  function _ensure_value (line 158) | def _ensure_value(namespace, name, value):
  class HelpFormatter (line 168) | class HelpFormatter(object):
    method __init__ (line 175) | def __init__(self,
    method _indent (line 209) | def _indent(self):
    method _dedent (line 213) | def _dedent(self):
    class _Section (line 218) | class _Section(object):
      method __init__ (line 220) | def __init__(self, formatter, parent, heading=None):
      method format_help (line 226) | def format_help(self):
    method _add_item (line 252) | def _add_item(self, func, args):
    method start_section (line 258) | def start_section(self, heading):
    method end_section (line 264) | def end_section(self):
    method add_text (line 268) | def add_text(self, text):
    method add_usage (line 272) | def add_usage(self, usage, actions, groups, prefix=None):
    method add_argument (line 277) | def add_argument(self, action):
    method add_arguments (line 295) | def add_arguments(self, actions):
    method format_help (line 302) | def format_help(self):
    method _join_parts (line 309) | def _join_parts(self, part_strings):
    method _format_usage (line 314) | def _format_usage(self, usage, actions, groups, prefix):
    method _format_actions_usage (line 412) | def _format_actions_usage(self, actions, groups):
    method _format_text (line 522) | def _format_text(self, text):
    method _format_action (line 530) | def _format_action(self, action):
    method _format_action_invocation (line 582) | def _format_action_invocation(self, action):
    method _metavar_formatter (line 606) | def _metavar_formatter(self, action, default_metavar):
    method _format_args (line 623) | def _format_args(self, action, default_metavar):
    method _expand_help (line 642) | def _expand_help(self, action):
    method _iter_indented_subactions (line 659) | def _iter_indented_subactions(self, action):
    method _split_lines (line 670) | def _split_lines(self, text, width):
    method _fill_text (line 674) | def _fill_text(self, text, width, indent):
    method _get_help_string (line 679) | def _get_help_string(self, action):
  class RawDescriptionHelpFormatter (line 683) | class RawDescriptionHelpFormatter(HelpFormatter):
    method _fill_text (line 690) | def _fill_text(self, text, width, indent):
  class RawTextHelpFormatter (line 694) | class RawTextHelpFormatter(RawDescriptionHelpFormatter):
    method _split_lines (line 701) | def _split_lines(self, text, width):
  class ArgumentDefaultsHelpFormatter (line 705) | class ArgumentDefaultsHelpFormatter(HelpFormatter):
    method _get_help_string (line 712) | def _get_help_string(self, action):
  function _get_action_name (line 726) | def _get_action_name(argument):
  class ArgumentError (line 739) | class ArgumentError(Exception):
    method __init__ (line 746) | def __init__(self, argument, message):
    method __str__ (line 750) | def __str__(self):
  class ArgumentTypeError (line 760) | class ArgumentTypeError(Exception):
  class Action (line 769) | class Action(_AttributeHolder):
    method __init__ (line 820) | def __init__(self,
    method _get_kwargs (line 842) | def _get_kwargs(self):
    method __call__ (line 856) | def __call__(self, parser, namespace, values, option_string=None):
  class _StoreAction (line 860) | class _StoreAction(Action):
    method __init__ (line 862) | def __init__(self,
    method __call__ (line 891) | def __call__(self, parser, namespace, values, option_string=None):
  class _StoreConstAction (line 895) | class _StoreConstAction(Action):
    method __init__ (line 897) | def __init__(self,
    method __call__ (line 914) | def __call__(self, parser, namespace, values, option_string=None):
  class _StoreTrueAction (line 918) | class _StoreTrueAction(_StoreConstAction):
    method __init__ (line 920) | def __init__(self,
  class _StoreFalseAction (line 935) | class _StoreFalseAction(_StoreConstAction):
    method __init__ (line 937) | def __init__(self,
  class _AppendAction (line 952) | class _AppendAction(Action):
    method __init__ (line 954) | def __init__(self,
    method __call__ (line 983) | def __call__(self, parser, namespace, values, option_string=None):
  class _AppendConstAction (line 990) | class _AppendConstAction(Action):
    method __init__ (line 992) | def __init__(self,
    method __call__ (line 1010) | def __call__(self, parser, namespace, values, option_string=None):
  class _CountAction (line 1017) | class _CountAction(Action):
    method __init__ (line 1019) | def __init__(self,
    method __call__ (line 1033) | def __call__(self, parser, namespace, values, option_string=None):
  class _HelpAction (line 1038) | class _HelpAction(Action):
    method __init__ (line 1040) | def __init__(self,
    method __call__ (line 1052) | def __call__(self, parser, namespace, values, option_string=None):
  class _VersionAction (line 1057) | class _VersionAction(Action):
    method __init__ (line 1059) | def __init__(self,
    method __call__ (line 1073) | def __call__(self, parser, namespace, values, option_string=None):
  class _SubParsersAction (line 1082) | class _SubParsersAction(Action):
    class _ChoicesPseudoAction (line 1084) | class _ChoicesPseudoAction(Action):
      method __init__ (line 1086) | def __init__(self, name, help):
    method __init__ (line 1090) | def __init__(self,
    method add_parser (line 1111) | def add_parser(self, name, **kwargs):
    method _get_subactions (line 1129) | def _get_subactions(self):
    method __call__ (line 1132) | def __call__(self, parser, namespace, values, option_string=None):
  class FileType (line 1171) | class FileType(object):
    method __init__ (line 1184) | def __init__(self, mode='r', bufsize=-1):
    method __call__ (line 1188) | def __call__(self, string):
    method __repr__ (line 1206) | def __repr__(self):
  class Namespace (line 1215) | class Namespace(_AttributeHolder):
    method __init__ (line 1222) | def __init__(self, **kwargs):
    method __eq__ (line 1228) | def __eq__(self, other):
    method __ne__ (line 1234) | def __ne__(self, other):
    method __contains__ (line 1239) | def __contains__(self, key):
  class _ActionsContainer (line 1243) | class _ActionsContainer(object):
    method __init__ (line 1245) | def __init__(self,
    method register (line 1297) | def register(self, registry_name, value, object):
    method _registry_get (line 1302) | def _registry_get(self, registry_name, value, default=None):
    method set_defaults (line 1308) | def set_defaults(self, **kwargs):
    method get_default (line 1317) | def get_default(self, dest):
    method add_argument (line 1327) | def add_argument(self, *args, **kwargs):
    method add_argument_group (line 1374) | def add_argument_group(self, *args, **kwargs):
    method add_mutually_exclusive_group (line 1379) | def add_mutually_exclusive_group(self, **kwargs):
    method _add_action (line 1384) | def _add_action(self, action):
    method _remove_action (line 1405) | def _remove_action(self, action):
    method _add_container_actions (line 1409) | def _add_container_actions(self, container):
    method _get_positional_kwargs (line 1449) | def _get_positional_kwargs(self, dest, **kwargs):
    method _get_optional_kwargs (line 1465) | def _get_optional_kwargs(self, *args, **kwargs):
    method _pop_action_class (line 1501) | def _pop_action_class(self, kwargs, default=None):
    method _get_handler (line 1506) | def _get_handler(self):
    method _check_conflict (line 1515) | def _check_conflict(self, action):
    method _handle_conflict_error (line 1529) | def _handle_conflict_error(self, action, conflicting_actions):
    method _handle_conflict_resolve (line 1536) | def _handle_conflict_resolve(self, action, conflicting_actions):
  class _ArgumentGroup (line 1553) | class _ArgumentGroup(_ActionsContainer):
    method __init__ (line 1555) | def __init__(self, container, title=None, description=None, **kwargs):
    method _add_action (line 1580) | def _add_action(self, action):
    method _remove_action (line 1585) | def _remove_action(self, action):
  class _MutuallyExclusiveGroup (line 1591) | class _MutuallyExclusiveGroup(_ArgumentGroup):
    method __init__ (line 1593) | def __init__(self, container, required=False):
    method _add_action (line 1598) | def _add_action(self, action):
    method _remove_action (line 1606) | def _remove_action(self, action):
  class ArgumentParser (line 1612) | class ArgumentParser(_AttributeHolder, _ActionsContainer):
    method __init__ (line 1630) | def __init__(self,
    method _get_kwargs (line 1708) | def _get_kwargs(self):
    method add_subparsers (line 1723) | def add_subparsers(self, **kwargs):
    method _add_action (line 1757) | def _add_action(self, action):
    method _get_optional_actions (line 1764) | def _get_optional_actions(self):
    method _get_positional_actions (line 1769) | def _get_positional_actions(self):
    method parse_args (line 1777) | def parse_args(self, args=None, namespace=None):
    method parse_known_args (line 1784) | def parse_known_args(self, args=None, namespace=None):
    method _parse_known_args (line 1821) | def _parse_known_args(self, arg_strings, namespace):
    method _read_args_from_files (line 2072) | def _read_args_from_files(self, arg_strings):
    method convert_arg_line_to_args (line 2102) | def convert_arg_line_to_args(self, arg_line):
    method _match_argument (line 2105) | def _match_argument(self, action, arg_strings_pattern):
    method _match_arguments_partial (line 2124) | def _match_arguments_partial(self, actions, arg_strings_pattern):
    method _parse_optional (line 2141) | def _parse_optional(self, arg_string):
    method _get_option_tuples (line 2198) | def _get_option_tuples(self, option_string):
    method _get_nargs_pattern (line 2242) | def _get_nargs_pattern(self, action):
    method _get_values (line 2286) | def _get_values(self, action, arg_strings):
    method _get_value (line 2339) | def _get_value(self, action, arg_string):
    method _check_value (line 2364) | def _check_value(self, action, value):
    method format_usage (line 2374) | def format_usage(self):
    method format_help (line 2380) | def format_help(self):
    method format_version (line 2403) | def format_version(self):
    method _get_formatter (line 2413) | def _get_formatter(self):
    method print_usage (line 2419) | def print_usage(self, file=None):
    method print_help (line 2424) | def print_help(self, file=None):
    method print_version (line 2429) | def print_version(self, file=None):
    method _print_message (line 2437) | def _print_message(self, message, file=None):
    method exit (line 2446) | def exit(self, status=0, message=None):
    method error (line 2451) | def error(self, message):

FILE: third_party/stdlib/base64.py
  function _translate (line 34) | def _translate(s, altchars):
  function b64encode (line 44) | def b64encode(s, altchars=None):
  function b64decode (line 61) | def b64decode(s, altchars=None):
  function standard_b64encode (line 82) | def standard_b64encode(s):
  function standard_b64decode (line 89) | def standard_b64decode(s):
  function urlsafe_b64encode (line 102) | def urlsafe_b64encode(s):
  function urlsafe_b64decode (line 110) | def urlsafe_b64decode(s):
  function b32encode (line 143) | def b32encode(s):
  function b32decode (line 185) | def b32decode(s, casefold=False, map01=None):
  function b16encode (line 259) | def b16encode(s):
  function b16decode (line 267) | def b16decode(s, casefold=False):
  function encode (line 293) | def encode(input, output):
  function decode (line 308) | def decode(input, output):
  function encodestring (line 318) | def encodestring(s):
  function decodestring (line 327) | def decodestring(s):
  function test (line 334) | def test():
  function test1 (line 360) | def test1():

FILE: third_party/stdlib/bisect.py
  function insort_right (line 3) | def insort_right(a, x, lo=0, hi=None):
  function bisect_right (line 24) | def bisect_right(a, x, lo=0, hi=None):
  function insort_left (line 47) | def insort_left(a, x, lo=0, hi=None):
  function bisect_left (line 67) | def bisect_left(a, x, lo=0, hi=None):

FILE: third_party/stdlib/collections.py
  class OrderedDict (line 48) | class OrderedDict(dict):
    method __init__ (line 60) | def __init__(*args, **kwds):
    method __setitem__ (line 81) | def __setitem__(self, key, value, dict_setitem=dict.__setitem__):
    method __delitem__ (line 91) | def __delitem__(self, key, dict_delitem=dict.__delitem__):
    method __iter__ (line 100) | def __iter__(self):
    method __reversed__ (line 109) | def __reversed__(self):
    method clear (line 118) | def clear(self):
    method keys (line 127) | def keys(self):
    method values (line 131) | def values(self):
    method items (line 135) | def items(self):
    method iterkeys (line 139) | def iterkeys(self):
    method itervalues (line 143) | def itervalues(self):
    method iteritems (line 148) | def iteritems(self):
    method pop (line 159) | def pop(self, key, default=__marker):
    method setdefault (line 173) | def setdefault(self, key, default=None):
    method popitem (line 180) | def popitem(self, last=True):
    method __repr__ (line 191) | def __repr__(self, _repr_running={}):
    method __reduce__ (line 204) | def __reduce__(self):
    method copy (line 214) | def copy(self):
    method fromkeys (line 219) | def fromkeys(cls, iterable, value=None):
    method __eq__ (line 229) | def __eq__(self, other):
    method __ne__ (line 238) | def __ne__(self, other):
    method viewkeys (line 244) | def viewkeys(self):
    method viewvalues (line 248) | def viewvalues(self):
    method viewitems (line 252) | def viewitems(self):
  class Counter (line 417) | class Counter(dict):
    method __init__ (line 468) | def __init__(*args, **kwds):
    method __missing__ (line 489) | def __missing__(self, key):
    method most_common (line 494) | def most_common(self, n=None):
    method elements (line 507) | def elements(self):
    method fromkeys (line 532) | def fromkeys(cls, iterable, v=None):
    method update (line 538) | def update(*args, **kwds):
    method subtract (line 581) | def subtract(*args, **kwds):
    method copy (line 616) | def copy(self):
    method __reduce__ (line 620) | def __reduce__(self):
    method __delitem__ (line 623) | def __delitem__(self, elem):
    method __repr__ (line 628) | def __repr__(self):
    method __add__ (line 643) | def __add__(self, other):
    method __sub__ (line 662) | def __sub__(self, other):
    method __or__ (line 681) | def __or__(self, other):
    method __and__ (line 701) | def __and__(self, other):

FILE: third_party/stdlib/colorsys.py
  function rgb_to_yiq (line 36) | def rgb_to_yiq(r, g, b):
  function yiq_to_rgb (line 42) | def yiq_to_rgb(y, i, q):
  function rgb_to_hls (line 71) | def rgb_to_hls(r, g, b):
  function hls_to_rgb (line 94) | def hls_to_rgb(h, l, s):
  function _v (line 104) | def _v(m1, m2, hue):
  function rgb_to_hsv (line 120) | def rgb_to_hsv(r, g, b):
  function hsv_to_rgb (line 139) | def hsv_to_rgb(h, s, v):

FILE: third_party/stdlib/contextlib.py
  class GeneratorContextManager (line 14) | class GeneratorContextManager(object):
    method __init__ (line 17) | def __init__(self, gen):
    method __enter__ (line 20) | def __enter__(self):
    method __exit__ (line 26) | def __exit__(self, t, value, tb):
  function contextmanager (line 60) | def contextmanager(func):
  function nested (line 95) | def nested(*managers):
  class closing (line 138) | class closing(object):
    method __init__ (line 155) | def __init__(self, thing):
    method __enter__ (line 157) | def __enter__(self):
    method __exit__ (line 159) | def __exit__(self, *exc_info):

FILE: third_party/stdlib/copy.py
  class Error (line 58) | class Error(Exception):
  function copy (line 69) | def copy(x):
  function _copy_immutable (line 104) | def _copy_immutable(x):
  function _copy_with_constructor (line 116) | def _copy_with_constructor(x):
  function _copy_with_copy_method (line 121) | def _copy_with_copy_method(x):
  function deepcopy (line 148) | def deepcopy(x, memo=None, _nil=[]):
  function _deepcopy_atomic (line 201) | def _deepcopy_atomic(x, memo):
  function _deepcopy_list (line 229) | def _deepcopy_list(x, memo):
  function _deepcopy_tuple (line 237) | def _deepcopy_tuple(x, memo):
  function _deepcopy_dict (line 256) | def _deepcopy_dict(x, memo):
  function _deepcopy_method (line 266) | def _deepcopy_method(x, memo): # Copy instance methods
  function _keep_alive (line 270) | def _keep_alive(x, memo):
  function _reconstruct (line 309) | def _reconstruct(x, info, deep, memo=None):
  function _test (line 372) | def _test():

FILE: third_party/stdlib/copy_reg.py
  function pickle (line 14) | def pickle(ob_type, pickle_function, constructor_ob=None):
  function constructor (line 27) | def constructor(object):
  function pickle_complex (line 39) | def pickle_complex(c):
  function _reconstructor (line 46) | def _reconstructor(cls, base, state):
  function _reduce_ex (line 59) | def _reduce_ex(self, proto):
  function __newobj__ (line 92) | def __newobj__(cls, *args):
  function _slotnames (line 95) | def _slotnames(cls):
  function add_extension (line 157) | def add_extension(module, name, code):
  function remove_extension (line 175) | def remove_extension(module, name, code):
  function clear_extension_cache (line 187) | def clear_extension_cache():

FILE: third_party/stdlib/csv.py
  class Dialect (line 37) | class Dialect(object):
    method __init__ (line 56) | def __init__(self):
    method _validate (line 61) | def _validate(self):
  class excel (line 68) | class excel(Dialect):
  class excel_tab (line 78) | class excel_tab(excel):
  class DictReader (line 84) | class DictReader(object):
    method __init__ (line 85) | def __init__(self, f, fieldnames=None, restkey=None, restval=None,
    method __iter__ (line 94) | def __iter__(self):
    method fieldnames (line 98) | def fieldnames(self):
    method fieldnames (line 113) | def fieldnames(self, value):
    method next (line 116) | def next(self):
  class DictWriter (line 139) | class DictWriter(object):
    method __init__ (line 140) | def __init__(self, f, fieldnames, restval="", extrasaction="raise",
    method writeheader (line 151) | def writeheader(self):
    method _dict_to_list (line 155) | def _dict_to_list(self, rowdict):
    method writerow (line 163) | def writerow(self, rowdict):
    method writerows (line 166) | def writerows(self, rowdicts):
  class Sniffer (line 179) | class Sniffer(object):
    method __init__ (line 184) | def __init__(self):
    method sniff (line 189) | def sniff(self, sample, delimiters=None):
    method _guess_quote_and_delimiter (line 218) | def _guess_quote_and_delimiter(self, data, delimiters):
    method _guess_delimiter (line 295) | def _guess_delimiter(self, data, delimiters):
    method has_header (line 400) | def has_header(self, sample):

FILE: third_party/stdlib/difflib.py
  function setdefault (line 44) | def setdefault(d, k, default=None):
  class Match (line 50) | class Match(tuple):
    method __new__ (line 57) | def __new__(_cls, a, b, size):
    method _make (line 62) | def _make(cls, iterable, new=tuple.__new__, len=len):
    method __repr__ (line 70) | def __repr__(self):
    method _asdict (line 74) | def _asdict(self):
    method _replace (line 78) | def _replace(_self, **kwds):
    method __getnewargs__ (line 85) | def __getnewargs__(self):
    method __getstate__ (line 91) | def __getstate__(self):
  function _calculate_ratio (line 101) | def _calculate_ratio(matches, length):
  class SequenceMatcher (line 106) | class SequenceMatcher(object):
    method __init__ (line 214) | def __init__(self, isjunk=None, a='', b='', autojunk=True):
    method set_seqs (line 283) | def set_seqs(self, a, b):
    method set_seq1 (line 295) | def set_seq1(self, a):
    method set_seq2 (line 321) | def set_seq2(self, b):
    method __chain_b (line 366) | def __chain_b(self):
    method find_longest_match (line 411) | def find_longest_match(self, alo, ahi, blo, bhi):
    method get_matching_blocks (line 521) | def get_matching_blocks(self):
    method get_opcodes (line 592) | def get_opcodes(self):
    method get_grouped_opcodes (line 647) | def get_grouped_opcodes(self, n=3):
    method ratio (line 697) | def ratio(self):
    method quick_ratio (line 723) | def quick_ratio(self):
    method real_quick_ratio (line 752) | def real_quick_ratio(self):
  function get_close_matches (line 764) | def get_close_matches(word, possibilities, n=3, cutoff=0.6):
  function _count_leading (line 812) | def _count_leading(line, ch):
  class Differ (line 827) | class Differ(object):
    method __init__ (line 921) | def __init__(self, linejunk=None, charjunk=None):
    method compare (line 945) | def compare(self, a, b):
    method _dump (line 986) | def _dump(self, tag, x, lo, hi):
    method _plain_replace (line 991) | def _plain_replace(self, a, alo, ahi, b, blo, bhi):
    method _fancy_replace (line 1006) | def _fancy_replace(self, a, alo, ahi, b, blo, bhi):
    method _fancy_helper (line 1104) | def _fancy_helper(self, a, alo, ahi, b, blo, bhi):
    method _qformat (line 1117) | def _qformat(self, aline, bline, atags, btags):
  function IS_LINE_JUNK (line 1169) | def IS_LINE_JUNK(line, pat=re.compile(r"\s*#?\s*$").match):
  function IS_CHARACTER_JUNK (line 1185) | def IS_CHARACTER_JUNK(ch, ws=" \t"):
  function _format_range_unified (line 1208) | def _format_range_unified(start, stop):
  function unified_diff (line 1220) | def unified_diff(a, b, fromfile='', tofile='', fromfiledate='',
  function _format_range_context (line 1297) | def _format_range_context(start, stop):
  function context_diff (line 1311) | def context_diff(a, b, fromfile='', tofile='',
  function ndiff (line 1391) | def ndiff(a, b, linejunk=None, charjunk=IS_CHARACTER_JUNK):
  function _mdiff (line 1427) | def _mdiff(fromlines, tolines, context=None, linejunk=None,
  class HtmlDiff (line 1747) | class HtmlDiff(object):
    method __init__ (line 1769) | def __init__(self,tabsize=8,wrapcolumn=None,linejunk=None,
    method make_file (line 1786) | def make_file(self,fromlines,tolines,fromdesc='',todesc='',context=False,
    method _tab_newline_replace (line 1810) | def _tab_newline_replace(self,fromlines,tolines):
    method _split_line (line 1833) | def _split_line(self,data_list,line_num,text):
    method _line_wrapper (line 1888) | def _line_wrapper(self,diffs):
    method _collect_lines (line 1916) | def _collect_lines(self,diffs):
    method _format_line (line 1937) | def _format_line(self,side,flag,linenum,text):
    method _make_prefix (line 1960) | def _make_prefix(self):
    method _convert_flags (line 1971) | def _convert_flags(self,fromlist,tolist,flaglist,context,numlines):
    method make_table (line 2018) | def make_table(self,fromlines,tolines,fromdesc='',todesc='',context=Fa...
  function restore (line 2097) | def restore(delta, which):

FILE: third_party/stdlib/dircache.py
  function reset (line 16) | def reset():
  function listdir (line 21) | def listdir(path):
  function annotate (line 37) | def annotate(head, list):

FILE: third_party/stdlib/dummy_thread.py
  class error (line 21) | class error(Exception):
    method __init__ (line 24) | def __init__(self, *args):
  function start_new_thread (line 27) | def start_new_thread(function, args, kwargs={}):
  function exit (line 58) | def exit():
  function get_ident (line 62) | def get_ident():
  function allocate_lock (line 71) | def allocate_lock():
  function stack_size (line 75) | def stack_size(size=None):
  class LockType (line 81) | class LockType(object):
    method __init__ (line 92) | def __init__(self):
    method acquire (line 95) | def acquire(self, waitflag=None):
    method __exit__ (line 118) | def __exit__(self, typ, val, tb):
    method release (line 121) | def release(self):
    method locked (line 130) | def locked(self):
  function interrupt_main (line 138) | def interrupt_main():

FILE: third_party/stdlib/fnmatch.py
  function _purge (line 20) | def _purge():
  function fnmatch (line 25) | def fnmatch(name, pat):
  function filter (line 46) | def filter(names, pat):
  function fnmatchcase (line 73) | def fnmatchcase(name, pat):
  function translate (line 90) | def translate(pat):

FILE: third_party/stdlib/fpformat.py
  class NotANumber (line 30) | class NotANumber(ValueError):
  function extract (line 35) | def extract(s):
  function unexpo (line 50) | def unexpo(intpart, fraction, expo):
  function roundfrac (line 64) | def roundfrac(intpart, fraction, digs):
  function fix (line 90) | def fix(x, digs):
  function sci (line 106) | def sci(x, digs):
  function test (line 138) | def test():

FILE: third_party/stdlib/functools.py
  function setattr (line 15) | def setattr(d, k, v):
  function update_wrapper (line 23) | def update_wrapper(wrapper,
  function wraps (line 45) | def wraps(wrapped,
  function total_ordering (line 59) | def total_ordering(cls):
  function cmp_to_key (line 86) | def cmp_to_key(mycmp):

FILE: third_party/stdlib/genericpath.py
  class _unicode (line 18) | class _unicode(object):
  function exists (line 23) | def exists(path):
  function isfile (line 34) | def isfile(path):
  function isdir (line 46) | def isdir(s):
  function getsize (line 55) | def getsize(filename):
  function getmtime (line 60) | def getmtime(filename):
  function getatime (line 65) | def getatime(filename):
  function getctime (line 70) | def getctime(filename):
  function commonprefix (line 76) | def commonprefix(m):
  function _splitext (line 93) | def _splitext(p, sep, altsep, extsep):

FILE: third_party/stdlib/getopt.py
  class GetoptError (line 38) | class GetoptError(Exception):
    method __init__ (line 41) | def __init__(self, msg, opt=''):
    method __str__ (line 46) | def __str__(self):
  function getopt (line 51) | def getopt(args, shortopts, longopts = []):
  function gnu_getopt (line 94) | def gnu_getopt(args, shortopts, longopts = []):
  function do_longs (line 144) | def do_longs(opts, opt, longopts, args):
  function long_has_args (line 166) | def long_has_args(opt, longopts):
  function do_shorts (line 187) | def do_shorts(opts, optstring, shortopts, args):
  function short_has_arg (line 202) | def short_has_arg(opt, shortopts):

FILE: third_party/stdlib/glob.py
  class _unicode (line 13) | class _unicode(object):
  function glob (line 18) | def glob(pathname):
  function iglob (line 29) | def iglob(pathname):
  function glob1 (line 71) | def glob1(dirname, pattern):
  function glob0 (line 86) | def glob0(dirname, basename):
  function has_magic (line 100) | def has_magic(s):

FILE: third_party/stdlib/heapq.py
  function cmp_lt (line 142) | def cmp_lt(x, y):
  function heappush (line 147) | def heappush(heap, item):
  function heappop (line 152) | def heappop(heap):
  function heapreplace (line 163) | def heapreplace(heap, item):
  function heappushpop (line 179) | def heappushpop(heap, item):
  function heapify (line 186) | def heapify(x):
  function _heappushpop_max (line 197) | def _heappushpop_max(heap, item):
  function _heapify_max (line 204) | def _heapify_max(x):
  function nlargest (line 210) | def nlargest(n, iterable):
  function nsmallest (line 228) | def nsmallest(n, iterable):
  function _siftdown (line 249) | def _siftdown(heap, startpos, pos):
  function _siftup (line 302) | def _siftup(heap, pos):
  function _siftdown_max (line 322) | def _siftdown_max(heap, startpos, pos):
  function _siftup_max (line 337) | def _siftup_max(heap, pos):
  function merge (line 364) | def merge(*iterables):
  function nsmallest (line 406) | def nsmallest(n, iterable, key=None):
  function nlargest (line 443) | def nlargest(n, iterable, key=None):

FILE: third_party/stdlib/json/__init__.py
  function dump (line 128) | def dump(obj, fp, skipkeys=False, ensure_ascii=True, check_circular=True,
  function dumps (line 199) | def dumps(obj, skipkeys=False, ensure_ascii=True, check_circular=True,
  function load (line 264) | def load(fp, encoding=None, cls=None, object_hook=None, parse_float=None,
  function loads (line 300) | def loads(s, encoding=None, cls=None, object_hook=None, parse_float=None,

FILE: third_party/stdlib/json/decoder.py
  function _floatconstants (line 20) | def _floatconstants():
  function linecol (line 28) | def linecol(doc, pos):
  function errmsg (line 37) | def errmsg(msg, doc, pos, end=None):
  function _decode_uXXXX (line 66) | def _decode_uXXXX(s, pos):
  function py_scanstring (line 76) | def py_scanstring(s, end, encoding=None, strict=True,
  function JSONObject (line 151) | def JSONObject(s_and_end, encoding, strict, scan_once, object_hook,
  function JSONArray (line 239) | def JSONArray(s_and_end, scan_once, _w=WHITESPACE.match, _ws=WHITESPACE_...
  class JSONDecoder (line 275) | class JSONDecoder(object):
    method __init__ (line 305) | def __init__(self, encoding=None, object_hook=None, parse_float=None,
    method decode (line 362) | def decode(self, s, _w=WHITESPACE.match):
    method raw_decode (line 373) | def raw_decode(self, s, idx=0):

FILE: third_party/stdlib/json/encoder.py
  function x4 (line 17) | def x4(i):
  function encode_basestring (line 41) | def encode_basestring(s):
  function py_encode_basestring_ascii (line 50) | def py_encode_basestring_ascii(s):
  class JSONEncoder (line 80) | class JSONEncoder(object):
    method __init__ (line 111) | def __init__(self, skipkeys=False, ensure_ascii=True,
    method default (line 175) | def default(self, o):
    method encode (line 196) | def encode(self, o):
    method iterencode (line 222) | def iterencode(self, o, _one_shot=False):
  function _make_iterencode (line 282) | def _make_iterencode(markers, _default, _encoder, _indent, _floatstr,

FILE: third_party/stdlib/json_scanner.py
  function py_make_scanner (line 16) | def py_make_scanner(context):

FILE: third_party/stdlib/keyword.py
  function main (line 53) | def main():

FILE: third_party/stdlib/linecache.py
  function getline (line 13) | def getline(filename, lineno, module_globals=None):
  function clearcache (line 26) | def clearcache():
  function getlines (line 33) | def getlines(filename, module_globals=None):
  function checkcache (line 47) | def checkcache(filename=None):
  function updatecache (line 72) | def updatecache(filename, module_globals=None):

FILE: third_party/stdlib/mimetools.py
  class Message (line 20) | class Message(rfc822.Message):
    method __init__ (line 24) | def __init__(self, fp, seekable = 1):
    method parsetype (line 33) | def parsetype(self):
    method parseplist (line 50) | def parseplist(self):
    method getplist (line 68) | def getplist(self):
    method getparam (line 71) | def getparam(self, name):
    method getparamnames (line 79) | def getparamnames(self):
    method getencoding (line 87) | def getencoding(self):
    method gettype (line 92) | def gettype(self):
    method getmaintype (line 95) | def getmaintype(self):
    method getsubtype (line 98) | def getsubtype(self):
  function _get_next_counter (line 115) | def _get_next_counter():
  function decode (line 157) | def decode(input, output, encoding):
  function encode (line 176) | def encode(input, output, encoding):
  function pipeto (line 224) | def pipeto(input, command):
  function pipethrough (line 229) | def pipethrough(input, command, output):
  function copyliteral (line 239) | def copyliteral(input, output):
  function copybinary (line 245) | def copybinary(input, output):

FILE: third_party/stdlib/mutex.py
  class mutex (line 20) | class mutex(object):
    method __init__ (line 21) | def __init__(self):
    method test (line 26) | def test(self):
    method testandset (line 30) | def testandset(self):
    method lock (line 39) | def lock(self, function, argument):
    method unlock (line 48) | def unlock(self):

FILE: third_party/stdlib/optparse.py
  function _repr (line 79) | def _repr(self):
  function setattr (line 82) | def setattr(self, attr, value):
  function gettext (line 98) | def gettext(message):
  class OptParseError (line 103) | class OptParseError (Exception):
    method __init__ (line 104) | def __init__(self, msg):
    method __str__ (line 107) | def __str__(self):
  class OptionError (line 111) | class OptionError (OptParseError):
    method __init__ (line 117) | def __init__(self, msg, option):
    method __str__ (line 121) | def __str__(self):
  class OptionConflictError (line 127) | class OptionConflictError (OptionError):
  class OptionValueError (line 132) | class OptionValueError (OptParseError):
  class BadOptionError (line 138) | class BadOptionError (OptParseError):
    method __init__ (line 142) | def __init__(self, opt_str):
    method __str__ (line 145) | def __str__(self):
  class AmbiguousOptionError (line 148) | class AmbiguousOptionError (BadOptionError):
    method __init__ (line 152) | def __init__(self, opt_str, possibilities):
    method __str__ (line 156) | def __str__(self):
  class HelpFormatter (line 161) | class HelpFormatter(object):
    method __init__ (line 206) | def __init__(self,
    method set_parser (line 231) | def set_parser(self, parser):
    method set_short_opt_delimiter (line 234) | def set_short_opt_delimiter(self, delim):
    method set_long_opt_delimiter (line 240) | def set_long_opt_delimiter(self, delim):
    method indent (line 246) | def indent(self):
    method dedent (line 250) | def dedent(self):
    method format_usage (line 255) | def format_usage(self, usage):
    method format_heading (line 258) | def format_heading(self, heading):
    method _format_text (line 261) | def _format_text(self, text):
    method format_description (line 273) | def format_description(self, description):
    method format_epilog (line 279) | def format_epilog(self, epilog):
    method expand_default (line 286) | def expand_default(self, option):
    method format_option (line 297) | def format_option(self, option):
    method store_option_strings (line 338) | def store_option_strings(self, parser):
    method format_option_strings (line 356) | def format_option_strings(self, option):
  class IndentedHelpFormatter (line 375) | class IndentedHelpFormatter (HelpFormatter):
    method __init__ (line 379) | def __init__(self,
    method format_usage (line 387) | def format_usage(self, usage):
    method format_heading (line 390) | def format_heading(self, heading):
  class TitledHelpFormatter (line 395) | class TitledHelpFormatter (HelpFormatter):
    method __init__ (line 399) | def __init__(self,
    method format_usage (line 407) | def format_usage(self, usage):
    method format_heading (line 410) | def format_heading(self, heading):
  function _parse_num (line 414) | def _parse_num(val, type):
  function _parse_int (line 427) | def _parse_int(val):
  function _parse_long (line 430) | def _parse_long(val):
  function check_builtin (line 438) | def check_builtin(option, opt, value):
  function check_choice (line 446) | def check_choice(option, opt, value):
  class Option (line 460) | class Option(object):
    method __init__ (line 575) | def __init__(self, *opts, **attrs):
    method _check_opt_strings (line 594) | def _check_opt_strings(self, opts):
    method _set_opt_strings (line 604) | def _set_opt_strings(self, opts):
    method _set_attrs (line 625) | def _set_attrs(self, attrs):
    method _check_action (line 645) | def _check_action(self):
    method _check_type (line 651) | def _check_type(self):
    method _check_choice (line 681) | def _check_choice(self):
    method _check_dest (line 694) | def _check_dest(self):
    method _check_const (line 710) | def _check_const(self):
    method _check_nargs (line 716) | def _check_nargs(self):
    method _check_callback (line 725) | def _check_callback(self):
    method __str__ (line 764) | def __str__(self):
    method takes_value (line 769) | def takes_value(self):
    method get_opt_string (line 772) | def get_opt_string(self):
    method check_value (line 781) | def check_value(self, opt, value):
    method convert_value (line 788) | def convert_value(self, opt, value):
    method process (line 795) | def process(self, opt, value, values, parser):
    method take_action (line 807) | def take_action(self, action, dest, opt, value, values, parser):
  function isbasestring (line 846) | def isbasestring(x):
  function isbasestring (line 849) | def isbasestring(x):
  class Values (line 852) | class Values(object):
    method __init__ (line 854) | def __init__(self, defaults=None):
    method __str__ (line 859) | def __str__(self):
    method __cmp__ (line 864) | def __cmp__(self, other):
    method _update_careful (line 872) | def _update_careful(self, dict):
    method _update_loose (line 885) | def _update_loose(self, dict):
    method _update (line 893) | def _update(self, dict, mode):
    method read_module (line 901) | def read_module(self, modname, mode="careful"):
    method read_file (line 906) | def read_file(self, filename, mode="careful"):
    method ensure_value (line 911) | def ensure_value(self, attr, value):
  class OptionContainer (line 917) | class OptionContainer(object):
    method __init__ (line 949) | def __init__(self, option_class, conflict_handler, description):
    method _create_option_mappings (line 960) | def _create_option_mappings(self):
    method _share_option_mappings (line 969) | def _share_option_mappings(self, parser):
    method set_conflict_handler (line 976) | def set_conflict_handler(self, handler):
    method set_description (line 981) | def set_description(self, description):
    method get_description (line 984) | def get_description(self):
    method destroy (line 988) | def destroy(self):
    method _check_conflict (line 997) | def _check_conflict(self, option):
    method add_option (line 1024) | def add_option(self, *args, **kwargs):
    method add_options (line 1054) | def add_options(self, option_list):
    method get_option (line 1060) | def get_option(self, opt_str):
    method has_option (line 1064) | def has_option(self, opt_str):
    method remove_option (line 1068) | def remove_option(self, opt_str):
    method format_option_help (line 1084) | def format_option_help(self, formatter):
    method format_description (line 1093) | def format_description(self, formatter):
    method format_help (line 1096) | def format_help(self, formatter):
  class OptionGroup (line 1105) | class OptionGroup (OptionContainer):
    method __init__ (line 1107) | def __init__(self, parser, title, description=None):
    method _create_option_list (line 1113) | def _create_option_list(self):
    method set_title (line 1117) | def set_title(self, title):
    method destroy (line 1120) | def destroy(self):
    method format_help (line 1127) | def format_help(self, formatter):
  class OptionParser (line 1135) | class OptionParser (OptionContainer):
    method __init__ (line 1207) | def __init__(self,
    method destroy (line 1241) | def destroy(self):
    method _create_option_list (line 1259) | def _create_option_list(self):
    method _add_help_option (line 1264) | def _add_help_option(self):
    method _add_version_option (line 1269) | def _add_version_option(self):
    method _populate_option_list (line 1274) | def _populate_option_list(self, option_list, add_help=True):
    method _init_parsing_state (line 1284) | def _init_parsing_state(self):
    method set_usage (line 1293) | def set_usage(self, usage):
    method enable_interspersed_args (line 1304) | def enable_interspersed_args(self):
    method disable_interspersed_args (line 1312) | def disable_interspersed_args(self):
    method set_process_default_values (line 1320) | def set_process_default_values(self, process):
    method set_default (line 1323) | def set_default(self, dest, value):
    method set_defaults (line 1326) | def set_defaults(self, **kwargs):
    method _get_all_options (line 1329) | def _get_all_options(self):
    method get_default_values (line 1336) | def get_default_values(self):
    method add_option_group (line 1354) | def add_option_group(self, *args, **kwargs):
    method get_option_group (line 1370) | def get_option_group(self, opt_str):
    method _get_args (line 1380) | def _get_args(self, args):
    method parse_args (line 1386) | def parse_args(self, args=None, values=None):
    method check_values (line 1425) | def check_values(self, values, args):
    method _process_args (line 1438) | def _process_args(self, largs, rargs, values):
    method _match_long_opt (line 1489) | def _match_long_opt(self, opt):
    method _process_long_opt (line 1498) | def _process_long_opt(self, rargs, values):
    method _process_short_opts (line 1539) | def _process_short_opts(self, rargs, values):
    method get_prog_name (line 1585) | def get_prog_name(self):
    method expand_prog_name (line 1593) | def expand_prog_name(self, s):
    method get_description (line 1597) | def get_description(self):
    method exit (line 1600) | def exit(self, status=0, msg=None):
    method error (line 1605) | def error(self, msg):
    method get_usage (line 1615) | def get_usage(self):
    method print_usage (line 1622) | def print_usage(self, file=None):
    method get_version (line 1634) | def get_version(self):
    method print_version (line 1640) | def print_version(self, file=None):
    method format_option_help (line 1651) | def format_option_help(self, formatter=None):
    method format_epilog (line 1668) | def format_epilog(self, formatter):
    method format_help (line 1671) | def format_help(self, formatter=None):
    method _get_encoding (line 1684) | def _get_encoding(self, file):
    method print_help (line 1691) | def print_help(self, file=None):
  function _match_abbrev (line 1706) | def _match_abbrev(s, wordmap):

FILE: third_party/stdlib/pprint.py
  function pprint (line 57) | def pprint(o, stream=None, indent=1, width=80, depth=None):
  function pformat (line 63) | def pformat(o, indent=1, width=80, depth=None):
  function saferepr (line 67) | def saferepr(o):
  function isreadable (line 71) | def isreadable(o):
  function isrecursive (line 75) | def isrecursive(o):
  function _sorted (line 79) | def _sorted(iterable):
  class PrettyPrinter (line 86) | class PrettyPrinter(object):
    method __init__ (line 87) | def __init__(self, indent=1, width=80, depth=None, stream=None):
    method pprint (line 118) | def pprint(self, o):
    method pformat (line 122) | def pformat(self, o):
    method isrecursive (line 127) | def isrecursive(self, o):
    method isreadable (line 130) | def isreadable(self, o):
    method _format (line 134) | def _format(self, o, stream, indent, allowance, context, level):
    method _repr (line 230) | def _repr(self, o, context, level):
    method format (line 239) | def format(self, o, context, maxlevels, level):
  function _safe_repr (line 249) | def _safe_repr(o, context, maxlevels, level):
  function _recursion (line 336) | def _recursion(o):

FILE: third_party/stdlib/quopri.py
  function needsquoting (line 21) | def needsquoting(c, quotetabs, header):
  function quote (line 35) | def quote(c):
  function encode (line 42) | def encode(input, output, quotetabs, header = 0):
  function encodestring (line 105) | def encodestring(s, quotetabs = 0, header = 0):
  function decode (line 116) | def decode(input, output, header = 0):
  function decodestring (line 159) | def decodestring(s, header = 0):
  function ishex (line 171) | def ishex(c):
  function unhex (line 175) | def unhex(s):
  function main (line 192) | def main():

FILE: third_party/stdlib/random.py
  class Random (line 70) | class Random(_random.GrumpyRandom):
    method __init__ (line 89) | def __init__(self, x=None):
    method seed (line 98) | def seed(self, a=None):
    method randrange (line 117) | def randrange(self, start, stop=None, step=1, _int=int, _maxwidth=1L<<...
    method randint (line 180) | def randint(self, a, b):
    method choice (line 188) | def choice(self, seq):
    method shuffle (line 192) | def shuffle(self, x, random=None):
    method uniform (line 273) | def uniform(self, a, b):
  function _test_generator (line 570) | def _test_generator(n, func, args):
  function _test (line 592) | def _test(N=2000):
  function _notimplemented (line 628) | def _notimplemented(*args, **kwargs):

FILE: third_party/stdlib/re.py
  function match (line 141) | def match(pattern, string, flags=0):
  function search (line 146) | def search(pattern, string, flags=0):
  function sub (line 151) | def sub(pattern, repl, string, count=0, flags=0):
  function subn (line 160) | def subn(pattern, repl, string, count=0, flags=0):
  function split (line 171) | def split(pattern, string, maxsplit=0, flags=0):
  function findall (line 176) | def findall(pattern, string, flags=0):
  function compile (line 195) | def compile(pattern, flags=0):
  function purge (line 199) | def purge():
  function template (line 204) | def template(pattern, flags=0):
  function escape (line 211) | def escape(pattern):
  function _compile (line 233) | def _compile(*key):
  function _compile_repl (line 267) | def _compile_repl(*key):
  function _expand (line 282) | def _expand(pattern, match, template):
  function _subx (line 287) | def _subx(pattern, template):
  function _pickle (line 301) | def _pickle(p):
  class Scanner (line 309) | class Scanner(object):
    method __init__ (line 310) | def __init__(self, lexicon, flags=0):
    method scan (line 323) | def scan(self, string):

FILE: third_party/stdlib/repr.py
  class Repr (line 8) | class Repr(object):
    method __init__ (line 10) | def __init__(self):
    method repr (line 23) | def repr(self, x):
    method repr1 (line 26) | def repr1(self, x, level):
    method _repr_iterable (line 41) | def _repr_iterable(self, x, level, left, right, maxiter, trail=''):
    method repr_tuple (line 54) | def repr_tuple(self, x, level):
    method repr_list (line 57) | def repr_list(self, x, level):
    method repr_array (line 60) | def repr_array(self, x, level):
    method repr_set (line 64) | def repr_set(self, x, level):
    method repr_frozenset (line 68) | def repr_frozenset(self, x, level):
    method repr_deque (line 73) | def repr_deque(self, x, level):
    method repr_dict (line 76) | def repr_dict(self, x, level):
    method repr_str (line 91) | def repr_str(self, x, level):
    method repr_long (line 100) | def repr_long(self, x, level):
    method repr_instance (line 108) | def repr_instance(self, x, level):
  function _possibly_sorted (line 122) | def _possibly_sorted(x):

FILE: third_party/stdlib/rfc822.py
  class Message (line 85) | class Message(object):
    method __init__ (line 88) | def __init__(self, fp, seekable = 1):
    method rewindbody (line 116) | def rewindbody(self):
    method readheaders (line 122) | def readheaders(self):
    method isheader (line 202) | def isheader(self, line):
    method islast (line 214) | def islast(self, line):
    method iscomment (line 224) | def iscomment(self, line):
    method getallmatchingheaders (line 233) | def getallmatchingheaders(self, name):
    method getfirstmatchingheader (line 255) | def getfirstmatchingheader(self, name):
    method getrawheader (line 275) | def getrawheader(self, name):
    method getheader (line 290) | def getheader(self, name, default=None):
    method getheaders (line 300) | def getheaders(self, name):
    method getaddr (line 325) | def getaddr(self, name):
    method getaddrlist (line 338) | def getaddrlist(self, name):
    method getdate (line 360) | def getdate(self, name):
    method getdate_tz (line 372) | def getdate_tz(self, name):
    method __len__ (line 387) | def __len__(self):
    method __getitem__ (line 391) | def __getitem__(self, name):
    method __setitem__ (line 395) | def __setitem__(self, name, value):
    method __delitem__ (line 408) | def __delitem__(self, name):
    method setdefault (line 429) | def setdefault(self, name, default=""):
    method has_key (line 440) | def has_key(self, name):
    method __contains__ (line 444) | def __contains__(self, name):
    method __iter__ (line 448) | def __iter__(self):
    method keys (line 451) | def keys(self):
    method values (line 455) | def values(self):
    method items (line 459) | def items(self):
    method __str__ (line 466) | def __str__(self):
  function unquote (line 477) | def unquote(s):
  function quote (line 487) | def quote(s):
  function parseaddr (line 492) | def parseaddr(address):
  class AddrlistClass (line 501) | class AddrlistClass(object):
    method __init__ (line 513) | def __init__(self, field):
    method gotonext (line 531) | def gotonext(self):
    method getaddrlist (line 540) | def getaddrlist(self):
    method getaddress (line 552) | def getaddress(self):
    method getrouteaddr (line 610) | def getrouteaddr(self):
    method getaddrspec (line 642) | def getaddrspec(self):
    method getdomain (line 666) | def getdomain(self):
    method getdelimited (line 684) | def getdelimited(self, beginchar, endchars, allowcomments = 1):
    method getquote (line 721) | def getquote(self):
    method getcomment (line 725) | def getcomment(self):
    method getdomainliteral (line 729) | def getdomainliteral(self):
    method getatom (line 733) | def getatom(self, atomends=None):
    method getphraselist (line 752) | def getphraselist(self):
  class AddressList (line 775) | class AddressList(AddrlistClass):
    method __init__ (line 777) | def __init__(self, field):
    method __len__ (line 784) | def __len__(self):
    method __str__ (line 787) | def __str__(self):
    method __add__ (line 790) | def __add__(self, other):
    method __iadd__ (line 799) | def __iadd__(self, other):
    method __sub__ (line 806) | def __sub__(self, other):
    method __isub__ (line 814) | def __isub__(self, other):
    method __getitem__ (line 821) | def __getitem__(self, index):
  function dump_address_pair (line 825) | def dump_address_pair(pair):
  function parsedate_tz (line 855) | def parsedate_tz(data):
  function parsedate (line 940) | def parsedate(data):
  function mktime_tz (line 948) | def mktime_tz(data):
  function formatdate (line 957) | def formatdate(timeval=None):

FILE: third_party/stdlib/sched.py
  class Event (line 37) | class Event(object):
    method __init__ (line 41) | def __init__(self, time, priority, action, argument):
    method get_fields (line 47) | def get_fields(self):
    method __eq__ (line 50) | def __eq__(s, o): return (s.time, s.priority) == (o.time, o.priority)
    method __lt__ (line 51) | def __lt__(s, o): return (s.time, s.priority) <  (o.time, o.priority)
    method __le__ (line 52) | def __le__(s, o): return (s.time, s.priority) <= (o.time, o.priority)
    method __gt__ (line 53) | def __gt__(s, o): return (s.time, s.priority) >  (o.time, o.priority)
    method __ge__ (line 54) | def __ge__(s, o): return (s.time, s.priority) >= (o.time, o.priority)
  class scheduler (line 56) | class scheduler(object):
    method __init__ (line 57) | def __init__(self, timefunc, delayfunc):
    method enterabs (line 64) | def enterabs(self, time, priority, action, argument):
    method enter (line 73) | def enter(self, delay, priority, action, argument):
    method cancel (line 80) | def cancel(self, event):
    method empty (line 88) | def empty(self):
    method run (line 92) | def run(self):
    method queue (line 133) | def queue(self):

FILE: third_party/stdlib/sre_compile.py
  function _compile (line 69) | def _compile(code, pattern, flags):
  function _compile_charset (line 233) | def _compile_charset(charset, flags, code, fixup=None, fixes=None):
  function _optimize_charset (line 263) | def _optimize_charset(charset, fixup, fixes, isunicode):
  function _fixup_range (line 411) | def _fixup_range(lo, hi, ranges, fixup):
  function _mk_bitmap (line 436) | def _mk_bitmap(bits):
  function _bytes_to_codes (line 454) | def _bytes_to_codes(b):
  function _simple (line 467) | def _simple(av):
  function _compile_info (line 472) | def _compile_info(code, pattern, flags):
  function isstring (line 587) | def isstring(obj):
  function _code (line 593) | def _code(p, flags):
  function compile (line 608) | def compile(p, flags=0):

FILE: third_party/stdlib/sre_constants.py
  class error (line 53) | class error(Exception):
  function makedict (line 175) | def makedict(list):

FILE: third_party/stdlib/sre_parse.py
  class Pattern (line 68) | class Pattern(object):
    method __init__ (line 70) | def __init__(self):
    method opengroup (line 77) | def opengroup(self, name=None):
    method closegroup (line 88) | def closegroup(self, gid):
    method checkgroup (line 91) | def checkgroup(self, gid):
  class SubPattern (line 94) | class SubPattern(object):
    method __init__ (line 96) | def __init__(self, pattern, data=None):
    method dump (line 102) | def dump(self, level=0):
    method __repr__ (line 139) | def __repr__(self):
    method __len__ (line 141) | def __len__(self):
    method __delitem__ (line 143) | def __delitem__(self, index):
    method __getitem__ (line 146) | def __getitem__(self, index):
    method __setitem__ (line 150) | def __setitem__(self, index, code):
    method insert (line 152) | def insert(self, index, code):
    method append (line 154) | def append(self, code):
    method getwidth (line 156) | def getwidth(self):
  class Tokenizer (line 193) | class Tokenizer(object):
    method __init__ (line 194) | def __init__(self, string):
    method __next (line 198) | def __next(self):
    method match (line 211) | def match(self, char, skip=1):
    method get (line 217) | def get(self):
    method tell (line 221) | def tell(self):
    method seek (line 223) | def seek(self, index):
  function isident (line 226) | def isident(char):
  function isdigit (line 229) | def isdigit(char):
  function isname (line 232) | def isname(name):
  function _class_escape (line 241) | def _class_escape(source, escape):
  function _escape (line 273) | def _escape(source, escape, state):
  function _parse_sub (line 322) | def _parse_sub(source, state, nested=1):
  function _parse_sub_cond (line 387) | def _parse_sub_cond(source, state, condgroup):
  function _parse (line 406) | def _parse(source, state):
  function parse (line 719) | def parse(str, flags=0, pattern=None):
  function parse_template (line 747) | def parse_template(source, pattern):
  function expand_template (line 836) | def expand_template(template, match):

FILE: third_party/stdlib/string.py
  function capwords (line 47) | def capwords(s, sep=None):
  function maketrans (line 63) | def maketrans(fromstr, tostr):
  class _multimap (line 87) | class _multimap(object):
    method __init__ (line 93) | def __init__(self, primary, secondary):
    method __getitem__ (line 97) | def __getitem__(self, key):
  class _TemplateMetaclass (line 104) | class _TemplateMetaclass(type):
    method __init__ (line 122) | def __init__(cls, name, bases, dct):
  class Template (line 137) | class Template(object):
    method __init__ (line 144) | def __init__(self, template, *arg):
    method _invalid (line 149) | def _invalid(self, mo):
    method substitute (line 161) | def substitute(*args, **kws):
    method safe_substitute (line 191) | def safe_substitute(*args, **kws):
  function lower (line 235) | def lower(s):
  function upper (line 244) | def upper(s):
  function swapcase (line 253) | def swapcase(s):
  function strip (line 263) | def strip(s, chars=None):
  function lstrip (line 275) | def lstrip(s, chars=None):
  function rstrip (line 285) | def rstrip(s, chars=None):
  function split (line 296) | def split(s, sep=None, maxsplit=-1):
  function rsplit (line 311) | def rsplit(s, sep=None, maxsplit=-1):
  function join (line 323) | def join(words, sep = ' '):
  function index (line 337) | def index(s, *args):
  function rindex (line 346) | def rindex(s, *args):
  function count (line 355) | def count(s, *args):
  function find (line 366) | def find(s, *args):
  function rfind (line 379) | def rfind(s, *args):
  function atof (line 397) | def atof(s):
  function atoi (line 407) | def atoi(s , base=10):
  function atol (line 422) | def atol(s, base=10):
  function ljust (line 438) | def ljust(s, width, *args):
  function rjust (line 449) | def rjust(s, width, *args):
  function center (line 460) | def center(s, width, *args):
  function zfill (line 473) | def zfill(x, width):
  function expandtabs (line 486) | def expandtabs(s, tabsize=8):
  function translate (line 497) | def translate(s, table, deletions=""):
  function capitalize (line 516) | def capitalize(s):
  function replace (line 526) | def replace(s, old, new, maxreplace=-1):
  class Formatter (line 558) | class Formatter(object):
    method format (line 559) | def format(*args, **kwargs):
    method vformat (line 574) | def vformat(self, format_string, args, kwargs):
    method _vformat (line 580) | def _vformat(self, format_string, args, kwargs, used_args, recursion_d...
    method get_value (line 614) | def get_value(self, key, args, kwargs):
    method check_unused_args (line 621) | def check_unused_args(self, used_args, args, kwargs):
    method format_field (line 625) | def format_field(self, value, format_spec):
    method convert_field (line 629) | def convert_field(self, value, conversion):
    method parse (line 647) | def parse(self, format_string):
    method get_field (line 656) | def get_field(self, field_name, args, kwargs):

FILE: third_party/stdlib/test/list_tests.py
  class CommonTest (line 10) | class CommonTest(seq_tests.CommonTest):
    method test_set_subscript (line 67) | def test_set_subscript(self):
    method test_setitem (line 88) | def test_setitem(self):
    method test_delitem (line 121) | def test_delitem(self):
    method test_delslice (line 191) | def test_delslice(self):
    method test_append (line 232) | def test_append(self):
    method test_insert (line 262) | def test_insert(self):
    method test_pop (line 277) | def test_pop(self):
    method test_remove (line 290) | def test_remove(self):
    method test_count (line 335) | def test_count(self):
    method test_reverse (line 411) | def test_reverse(self):
    method _test_sort (line 426) | def _test_sort(self):
    method test_slice (line 459) | def test_slice(self):
    method test_iadd (line 464) | def test_iadd(self):
    method test_imul (line 477) | def test_imul(self):
    method test_constructor_exception_handling (line 529) | def test_constructor_exception_handling(self):
    method test_exhausted_iterator (line 536) | def test_exhausted_iterator(self):

FILE: third_party/stdlib/test/lock_tests.py
  function _wait (line 14) | def _wait():
  class Bunch (line 18) | class Bunch(object):
    method __init__ (line 22) | def __init__(self, f, n, wait_before_exit=False):
    method wait_for_started (line 49) | def wait_for_started(self):
    method wait_for_finished (line 53) | def wait_for_finished(self):
    method do_finish (line 57) | def do_finish(self):
  class BaseTestCase (line 61) | class BaseTestCase(unittest.TestCase):
    method setUp (line 62) | def setUp(self):
    method tearDown (line 65) | def tearDown(self):
  class BaseLockTests (line 70) | class BaseLockTests(BaseTestCase):
    method test_constructor (line 75) | def test_constructor(self):
    method test_acquire_destroy (line 79) | def test_acquire_destroy(self):
    method test_acquire_release (line 84) | def test_acquire_release(self):
    method test_try_acquire (line 90) | def test_try_acquire(self):
    method test_try_acquire_contended (line 95) | def test_try_acquire_contended(self):
    method test_acquire_contended (line 105) | def test_acquire_contended(self):
    method test_with (line 121) | def test_with(self):
    method test_thread_leak (line 137) | def test_thread_leak(self):
  class LockTests (line 151) | class LockTests(BaseLockTests):
    method test_reacquire (line 156) | def test_reacquire(self):
    method test_different_thread (line 175) | def test_different_thread(self):
  class RLockTests (line 187) | class RLockTests(BaseLockTests):
    method test_reacquire (line 191) | def test_reacquire(self):
    method test_release_unacquired (line 200) | def test_release_unacquired(self):
    method test_different_thread (line 212) | def test_different_thread(self):
    method test__is_owned (line 223) | def test__is_owned(self):
  class EventTests (line 241) | class EventTests(BaseTestCase):
    method test_is_set (line 246) | def test_is_set(self):
    method _check_notify (line 258) | def _check_notify(self, evt):
    method test_notify (line 275) | def test_notify(self):
    method test_timeout (line 283) | def test_timeout(self):
    method test_reset_internal_locks (line 309) | def test_reset_internal_locks(self):
  class ConditionTests (line 318) | class ConditionTests(BaseTestCase):
    method test_acquire (line 323) | def test_acquire(self):
    method test_unacquired_wait (line 342) | def test_unacquired_wait(self):
    method test_unacquired_notify (line 346) | def test_unacquired_notify(self):
    method _check_notify (line 350) | def _check_notify(self, cond):
    method test_notify (line 424) | def test_notify(self):
    method test_timeout (line 430) | def test_timeout(self):
  class BaseSemaphoreTests (line 447) | class BaseSemaphoreTests(BaseTestCase):
    method test_constructor (line 452) | def test_constructor(self):
    method test_acquire (line 456) | def test_acquire(self):
    method test_acquire_destroy (line 466) | def test_acquire_destroy(self):
    method test_acquire_contended (line 471) | def test_acquire_contended(self):
    method test_try_acquire (line 506) | def test_try_acquire(self):
    method test_try_acquire_contended (line 514) | def test_try_acquire_contended(self):
    method test_default_value (line 527) | def test_default_value(self):
    method test_with (line 541) | def test_with(self):
  class SemaphoreTests (line 558) | class SemaphoreTests(BaseSemaphoreTests):
    method test_release_unacquired (line 563) | def test_release_unacquired(self):
  class BoundedSemaphoreTests (line 572) | class BoundedSemaphoreTests(BaseSemaphoreTests):
    method test_release_unacquired (line 577) | def test_release_unacquired(self):

FILE: third_party/stdlib/test/mapping_tests.py
  class BasicTestMappingProtocol (line 7) | class BasicTestMappingProtocol(unittest.TestCase):
    method _reference (line 15) | def _reference(self):
    method _empty_mapping (line 19) | def _empty_mapping(self):
    method _full_mapping (line 22) | def _full_mapping(self, data):
    method __init__ (line 30) | def __init__(self, *args, **kw):
    method test_read (line 44) | def test_read(self):
    method test_write (line 95) | def test_write(self):
    method test_constructor (line 137) | def test_constructor(self):
    method test_bool (line 140) | def test_bool(self):
    method test_keys (line 146) | def test_keys(self):
    method test_values (line 154) | def test_values(self):
    method test_items (line 160) | def test_items(self):
    method test_len (line 166) | def test_len(self):
    method test_getitem (line 170) | def test_getitem(self):
    method test_update (line 177) | def test_update(self):
    method test_get (line 280) | def test_get(self):
    method test_setdefault (line 292) | def test_setdefault(self):
    method test_popitem (line 296) | def test_popitem(self):
    method test_pop (line 301) | def test_pop(self):
  class TestMappingProtocol (line 313) | class TestMappingProtocol(BasicTestMappingProtocol):
    method test_constructor (line 314) | def test_constructor(self):
    method test_bool (line 319) | def test_bool(self):
    method test_keys (line 326) | def test_keys(self):
    method test_values (line 336) | def test_values(self):
    method test_items (line 341) | def test_items(self):
    method test_has_key (line 347) | def test_has_key(self):
    method test_contains (line 357) | def test_contains(self):
    method test_len (line 369) | def test_len(self):
    method test_getitem (line 374) | def test_getitem(self):
    method test_clear (line 388) | def test_clear(self):
    method test_update (line 395) | def test_update(self):
    method test_fromkeys (line 441) | def test_fromkeys(self):
    method test_copy (line 490) | def test_copy(self):
    method test_get (line 498) | def test_get(self):
    method test_setdefault (line 509) | def test_setdefault(self):
    method test_popitem (line 520) | def test_popitem(self):
    method test_pop (line 545) | def test_pop(self):
  class TestHashMappingProtocol (line 564) | class TestHashMappingProtocol(TestMappingProtocol):
    method test_getitem (line 566) | def test_getitem(self):
    method test_fromkeys (line 594) | def test_fromkeys(self):
    method test_pop (line 603) | def test_pop(self):
    method test_mutatingiteration (line 622) | def test_mutatingiteration(self):
    method test_repr (line 633) | def test_repr(self):
    method test_le (line 651) | def test_le(self):
    method test_setdefault (line 672) | def test_setdefault(self):

FILE: third_party/stdlib/test/seq_tests.py
  function iterfunc (line 11) | def iterfunc(seqn):
  class Sequence (line 16) | class Sequence(object):
    method __init__ (line 18) | def __init__(self, seqn):
    method __getitem__ (line 20) | def __getitem__(self, i):
  class IterFunc (line 23) | class IterFunc(object):
    method __init__ (line 25) | def __init__(self, seqn):
    method __iter__ (line 28) | def __iter__(self):
    method next (line 30) | def next(self):
  class IterGen (line 36) | class IterGen(object):
    method __init__ (line 38) | def __init__(self, seqn):
    method __iter__ (line 41) | def __iter__(self):
  class IterNextOnly (line 45) | class IterNextOnly(object):
    method __init__ (line 47) | def __init__(self, seqn):
    method next (line 50) | def next(self):
  class IterNoNext (line 56) | class IterNoNext(object):
    method __init__ (line 58) | def __init__(self, seqn):
    method __iter__ (line 61) | def __iter__(self):
  class IterGenExc (line 64) | class IterGenExc(object):
    method __init__ (line 66) | def __init__(self, seqn):
    method __iter__ (line 69) | def __iter__(self):
    method next (line 71) | def next(self):
  class IterFuncStop (line 74) | class IterFuncStop(object):
    method __init__ (line 76) | def __init__(self, seqn):
    method __iter__ (line 78) | def __iter__(self):
    method next (line 80) | def next(self):
  class LyingTuple (line 88) | class LyingTuple(tuple):
    method __iter__ (line 89) | def __iter__(self):
  class LyingList (line 92) | class LyingList(list):
    method __iter__ (line 93) | def __iter__(self):
  class CommonTest (line 96) | class CommonTest(unittest.TestCase):
    method test_constructors (line 100) | def test_constructors(self):
    method test_truth (line 147) | def test_truth(self):
    method test_getitem (line 151) | def test_getitem(self):
    method test_getslice (line 178) | def test_getslice(self):
    method test_contains (line 216) | def test_contains(self):
    method test_contains_fake (line 225) | def test_contains_fake(self):
    method test_contains_order (line 236) | def test_contains_order(self):
    method test_len (line 251) | def test_len(self):
    method test_minmax (line 257) | def test_minmax(self):
    method test_addmul (line 263) | def test_addmul(self):
    method test_iadd (line 291) | def test_iadd(self):
    method test_imul (line 304) | def test_imul(self):
    method test_getitemoverwriteiter (line 309) | def test_getitemoverwriteiter(self):
    method test_repeat (line 317) | def test_repeat(self):
    method test_bigrepeat (line 325) | def test_bigrepeat(self):
    method test_subscript (line 338) | def test_subscript(self):
    method test_count (line 354) | def test_count(self):
    method test_index (line 374) | def test_index(self):
    method test_free_after_iterating (line 417) | def test_free_after_iterating(self):

FILE: third_party/stdlib/test/string_tests.py
  class Sequence (line 13) | class Sequence(object):
    method __init__ (line 14) | def __init__(self, seq='wxyz'): self.seq = seq
    method __len__ (line 15) | def __len__(self): return len(self.seq)
    method __getitem__ (line 16) | def __getitem__(self, i): return self.seq[i]
  class BadSeq1 (line 18) | class BadSeq1(Sequence):
    method __init__ (line 19) | def __init__(self): self.seq = [7, 'hello', 123L]
  class BadSeq2 (line 21) | class BadSeq2(Sequence):
    method __init__ (line 22) | def __init__(self): self.seq = ['a', 'b', 'c']
    method __len__ (line 23) | def __len__(self): return 8
  class CommonTest (line 25) | class CommonTest(unittest.TestCase):
    method fixtype (line 37) | def fixtype(self, obj):
    method test_fixtype (line 52) | def test_fixtype(self):
    method checkequal (line 56) | def checkequal(self, result, object, methodname, *args):
    method checkraises (line 75) | def checkraises(self, exc, obj, methodname, *args):
    method checkcall (line 83) | def checkcall(self, object, methodname, *args):
    method test_hash (line 88) | def test_hash(self):
    method test_strip_whitespace (line 538) | def test_strip_whitespace(self):
    method test_replace_overflow (line 807) | def test_replace_overflow(self):
  class NonStringModuleTest (line 831) | class NonStringModuleTest(object):
    method test_islower (line 835) | def test_islower(self):
    method test_isupper (line 845) | def test_isupper(self):
    method test_istitle (line 855) | def test_istitle(self):
    method test_isspace (line 869) | def test_isspace(self):
    method test_isalpha (line 880) | def test_isalpha(self):
    method test_isalnum (line 890) | def test_isalnum(self):
    method test_isdigit (line 901) | def test_isdigit(self):
    method test_title (line 910) | def test_title(self):
    method test_splitlines (line 919) | def test_splitlines(self):
  class MixinStrUnicodeUserStringTest (line 931) | class MixinStrUnicodeUserStringTest(NonStringModuleTest):
    method test_startswith (line 936) | def test_startswith(self):
    method test_endswith (line 981) | def test_endswith(self):
    method test___contains__ (line 1030) | def test___contains__(self):
    method test_subscript (line 1041) | def test_subscript(self):
    method test_slice (line 1052) | def test_slice(self):
    method test_extended_getslice (line 1065) | def test_extended_getslice(self):
    method test_mul (line 1077) | def test_mul(self):
    method test_join (line 1088) | def test_join(self):
    method test_formatting (line 1129) | def test_formatting(self):
    method test_floatformatting (line 1198) | def test_floatformatting(self):
    method test_inplace_rewrites (line 1207) | def test_inplace_rewrites(self):
    method test_partition (line 1226) | def test_partition(self):
    method test_rpartition (line 1244) | def test_rpartition(self):
    method test_none_arguments (line 1262) | def test_none_arguments(self):
    method test_find_etc_raise_correct_error_messages (line 1300) | def test_find_etc_raise_correct_error_messages(self):
  class MixinStrStringUserStringTest (line 1319) | class MixinStrStringUserStringTest(object):
    method test_maketrans (line 1323) | def test_maketrans(self):
  class MixinStrUserStringTest (line 1345) | class MixinStrUserStringTest(object):
    method test_encoding_decoding (line 1350) | def test_encoding_decoding(self):
  class MixinStrUnicodeTest (line 1376) | class MixinStrUnicodeTest(object):
    method test_bug1001011 (line 1379) | def test_bug1001011(self):

FILE: third_party/stdlib/test/test_argparse.py
  class StdIOBuffer (line 18) | class StdIOBuffer(StringIO):
  class TestCase (line 23) | class TestCase(unittest.TestCase):
    method assertEqual (line 25) | def assertEqual(self, obj1, obj2):
    method setUp (line 34) | def setUp(self):
  class Sig (line 66) | class Sig(object):
    method __init__ (line 68) | def __init__(self, *args, **kwargs):
  class NS (line 73) | class NS(object):
    method __init__ (line 75) | def __init__(self, **kwargs):
    method __repr__ (line 78) | def __repr__(self):
    method __eq__ (line 85) | def __eq__(self, other):
    method __ne__ (line 89) | def __ne__(self, other):
  class ArgumentParserError (line 93) | class ArgumentParserError(Exception):
    method __init__ (line 95) | def __init__(self, message, stdout=None, stderr=None, error_code=None):
  function stderr_to_parser_error (line 103) | def stderr_to_parser_error(parse_args, *args, **kwargs):
  class ErrorRaisingArgumentParser (line 147) | class ErrorRaisingArgumentParser(argparse.ArgumentParser):
    method parse_args (line 149) | def parse_args(self, *args, **kwargs):
    method exit (line 153) | def exit(self, *args, **kwargs):
    method error (line 157) | def error(self, *args, **kwargs):
  class ParserTesterMetaclass (line 162) | class ParserTesterMetaclass(type):
    method __init__ (line 178) | def __init__(cls, name, bases, bodydict):
  class TestOptionalsSingleDash (line 283) | class TestOptionalsSingleDash(ParserTestCase):
  class TestOptionalsSingleDashCombined (line 297) | class TestOptionalsSingleDashCombined(ParserTestCase):
  class TestOptionalsSingleDashLong (line 323) | class TestOptionalsSingleDashLong(ParserTestCase):
  class TestOptionalsSingleDashSubsetAmbiguous (line 337) | class TestOptionalsSingleDashSubsetAmbiguous(ParserTestCase):
  class TestOptionalsSingleDashAmbiguous (line 353) | class TestOptionalsSingleDashAmbiguous(ParserTestCase):
  class TestOptionalsNumeric (line 369) | class TestOptionalsNumeric(ParserTestCase):
  class TestOptionalsDoubleDash (line 382) | class TestOptionalsDoubleDash(ParserTestCase):
  class TestOptionalsDoubleDashPartialMatch (line 396) | class TestOptionalsDoubleDashPartialMatch(ParserTestCase):
  class TestOptionalsDoubleDashPrefixMatch (line 414) | class TestOptionalsDoubleDashPrefixMatch(ParserTestCase):
  class TestOptionalsSingleDoubleDash (line 433) | class TestOptionalsSingleDoubleDash(ParserTestCase):
  class TestOptionalsAlternatePrefixChars (line 452) | class TestOptionalsAlternatePrefixChars(ParserTestCase):
  class TestOptionalsAlternatePrefixCharsAddedHelp (line 472) | class TestOptionalsAlternatePrefixCharsAddedHelp(ParserTestCase):
  class TestOptionalsAlternatePrefixCharsMultipleShortArgs (line 494) | class TestOptionalsAlternatePrefixCharsMultipleShortArgs(ParserTestCase):
  class TestOptionalsShortLong (line 517) | class TestOptionalsShortLong(ParserTestCase):
  class TestOptionalsDest (line 533) | class TestOptionalsDest(ParserTestCase):
  class TestOptionalsDefault (line 546) | class TestOptionalsDefault(ParserTestCase):
  class TestOptionalsNargsDefault (line 558) | class TestOptionalsNargsDefault(ParserTestCase):
  class TestOptionalsNargs1 (line 569) | class TestOptionalsNargs1(ParserTestCase):
  class TestOptionalsNargs3 (line 580) | class TestOptionalsNargs3(ParserTestCase):
  class TestOptionalsNargsOptional (line 591) | class TestOptionalsNargsOptional(ParserTestCase):
  class TestOptionalsNargsZeroOrMore (line 614) | class TestOptionalsNargsZeroOrMore(ParserTestCase):
  class TestOptionalsNargsOneOrMore (line 633) | class TestOptionalsNargsOneOrMore(ParserTestCase):
  class TestOptionalsChoices (line 650) | class TestOptionalsChoices(ParserTestCase):
  class TestOptionalsRequired (line 667) | class TestOptionalsRequired(ParserTestCase):
  class TestOptionalsActionStore (line 680) | class TestOptionalsActionStore(ParserTestCase):
  class TestOptionalsActionStoreConst (line 691) | class TestOptionalsActionStoreConst(ParserTestCase):
  class TestOptionalsActionStoreFalse (line 702) | class TestOptionalsActionStoreFalse(ParserTestCase):
  class TestOptionalsActionStoreTrue (line 713) | class TestOptionalsActionStoreTrue(ParserTestCase):
  class TestOptionalsActionAppend (line 724) | class TestOptionalsActionAppend(ParserTestCase):
  class TestOptionalsActionAppendWithDefault (line 736) | class TestOptionalsActionAppendWithDefault(ParserTestCase):
  class TestOptionalsActionAppendConst (line 748) | class TestOptionalsActionAppendConst(ParserTestCase):
  class TestOptionalsActionAppendConstWithDefault (line 763) | class TestOptionalsActionAppendConstWithDefault(ParserTestCase):
  class TestOptionalsActionCount (line 778) | class TestOptionalsActionCount(ParserTestCase):
  class TestPositionalsNargsNone (line 793) | class TestPositionalsNargsNone(ParserTestCase):
  class TestPositionalsNargs1 (line 803) | class TestPositionalsNargs1(ParserTestCase):
  class TestPositionalsNargs2 (line 813) | class TestPositionalsNargs2(ParserTestCase):
  class TestPositionalsNargsZeroOrMore (line 823) | class TestPositionalsNargsZeroOrMore(ParserTestCase):
  class TestPositionalsNargsZeroOrMoreDefault (line 835) | class TestPositionalsNargsZeroOrMoreDefault(ParserTestCase):
  class TestPositionalsNargsOneOrMore (line 847) | class TestPositionalsNargsOneOrMore(ParserTestCase):
  class TestPositionalsNargsOptional (line 858) | class TestPositionalsNargsOptional(ParserTestCase):
  class TestPositionalsNargsOptionalDefault (line 869) | class TestPositionalsNargsOptionalDefault(ParserTestCase):
  class TestPositionalsNargsOptionalConvertedDefault (line 880) | class TestPositionalsNargsOptionalConvertedDefault(ParserTestCase):
  class TestPositionalsNargsNoneNone (line 895) | class TestPositionalsNargsNoneNone(ParserTestCase):
  class TestPositionalsNargsNone1 (line 905) | class TestPositionalsNargsNone1(ParserTestCase):
  class TestPositionalsNargs2None (line 915) | class TestPositionalsNargs2None(ParserTestCase):
  class TestPositionalsNargsNoneZeroOrMore (line 925) | class TestPositionalsNargsNoneZeroOrMore(ParserTestCase):
  class TestPositionalsNargsNoneOneOrMore (line 937) | class TestPositionalsNargsNoneOneOrMore(ParserTestCase):
  class TestPositionalsNargsNoneOptional (line 948) | class TestPositionalsNargsNoneOptional(ParserTestCase):
  class TestPositionalsNargsZeroOrMoreNone (line 959) | class TestPositionalsNargsZeroOrMoreNone(ParserTestCase):
  class TestPositionalsNargsOneOrMoreNone (line 971) | class TestPositionalsNargsOneOrMoreNone(ParserTestCase):
  class TestPositionalsNargsOptionalNone (line 982) | class TestPositionalsNargsOptionalNone(ParserTestCase):
  class TestPositionalsNargs2ZeroOrMore (line 993) | class TestPositionalsNargs2ZeroOrMore(ParserTestCase):
  class TestPositionalsNargs2OneOrMore (line 1004) | class TestPositionalsNargs2OneOrMore(ParserTestCase):
  class TestPositionalsNargs2Optional (line 1014) | class TestPositionalsNargs2Optional(ParserTestCase):
  class TestPositionalsNargsZeroOrMore1 (line 1025) | class TestPositionalsNargsZeroOrMore1(ParserTestCase):
  class TestPositionalsNargsOneOrMore1 (line 1037) | class TestPositionalsNargsOneOrMore1(ParserTestCase):
  class TestPositionalsNargsOptional1 (line 1048) | class TestPositionalsNargsOptional1(ParserTestCase):
  class TestPositionalsNargsNoneZeroOrMore1 (line 1059) | class TestPositionalsNargsNoneZeroOrMore1(ParserTestCase):
  class TestPositionalsNargsNoneOneOrMore1 (line 1074) | class TestPositionalsNargsNoneOneOrMore1(ParserTestCase):
  class TestPositionalsNargsNoneOptional1 (line 1089) | class TestPositionalsNargsNoneOptional1(ParserTestCase):
  class TestPositionalsNargsOptionalOptional (line 1104) | class TestPositionalsNargsOptionalOptional(ParserTestCase):
  class TestPositionalsNargsOptionalZeroOrMore (line 1119) | class TestPositionalsNargsOptionalZeroOrMore(ParserTestCase):
  class TestPositionalsNargsOptionalOneOrMore (line 1132) | class TestPositionalsNargsOptionalOneOrMore(ParserTestCase):
  class TestPositionalsChoicesString (line 1144) | class TestPositionalsChoicesString(ParserTestCase):
  class TestPositionalsChoicesInt (line 1155) | class TestPositionalsChoicesInt(ParserTestCase):
  class TestPositionalsActionAppend (line 1166) | class TestPositionalsActionAppend(ParserTestCase):
  class TestOptionalsNumericAndPositionals (line 1182) | class TestOptionalsNumericAndPositionals(ParserTestCase):
  class TestOptionalsAlmostNumericAndPositionals (line 1198) | class TestOptionalsAlmostNumericAndPositionals(ParserTestCase):
  class TestEmptyAndSpaceContainingArguments (line 1215) | class TestEmptyAndSpaceContainingArguments(ParserTestCase):
  class TestPrefixCharacterOnlyArguments (line 1234) | class TestPrefixCharacterOnlyArguments(ParserTestCase):
  class TestNargsZeroOrMore (line 1253) | class TestNargsZeroOrMore(ParserTestCase):
  class TestNargsRemainder (line 1269) | class TestNargsRemainder(ParserTestCase):
  class TestOptionLike (line 1282) | class TestOptionLike(ParserTestCase):
  class TestDefaultSuppress (line 1309) | class TestDefaultSuppress(ParserTestCase):
  class TestParserDefaultSuppress (line 1328) | class TestParserDefaultSuppress(ParserTestCase):
  class TestParserDefault42 (line 1348) | class TestParserDefault42(ParserTestCase):
  class TestFileTypeRepr (line 1438) | class TestFileTypeRepr(TestCase):
    method test_r (line 1440) | def test_r(self):
    method test_wb_1 (line 1444) | def test_wb_1(self):
  class RFile (line 1449) | class RFile(object):
    method __init__ (line 1452) | def __init__(self, name):
    method __eq__ (line 1457) | def __eq__(self, other):
  class WFile (line 1532) | class WFile(object):
    method __init__ (line 1535) | def __init__(self, name):
    method __eq__ (line 1540) | def __eq__(self, other):
  class TestTypeUserDefined (line 1604) | class TestTypeUserDefined(ParserTestCase):
    class MyType (line 1607) | class MyType(TestCase):
      method __init__ (line 1609) | def __init__(self, value):
      method __eq__ (line 1614) | def __eq__(self, other):
  class TestTypeClassicClass (line 1628) | class TestTypeClassicClass(ParserTestCase):
    class C (line 1631) | class C(object):
      method __init__ (line 1633) | def __init__(self, value):
      method __eq__ (line 1638) | def __eq__(self, other):
  class TestTypeRegistration (line 1652) | class TestTypeRegistration(TestCase):
    method test (line 1655) | def test(self):
  class TestActionUserDefined (line 1675) | class TestActionUserDefined(ParserTestCase):
    class OptionalAction (line 1678) | class OptionalAction(argparse.Action):
      method __call__ (line 1680) | def __call__(self, parser, namespace, value, option_string=None):
    class PositionalAction (line 1701) | class PositionalAction(argparse.Action):
      method __call__ (line 1703) | def __call__(self, parser, namespace, value, option_string=None):
  class TestActionRegistration (line 1742) | class TestActionRegistration(TestCase):
    class MyAction (line 1745) | class MyAction(argparse.Action):
      method __call__ (line 1747) | def __call__(self, parser, namespace, values, option_string=None):
    method test (line 1750) | def test(self):
  class TestAddSubparsers (line 1764) | class TestAddSubparsers(TestCase):
    method assertArgumentParserError (line 1767) | def assertArgumentParserError(self, *args, **kwargs):
    method _get_parser (line 1770) | def _get_parser(self, subparser_help=False, prefix_chars=None):
    method setUp (line 1816) | def setUp(self):
    method test_parse_args_failures (line 1821) | def test_parse_args_failures(self):
    method test_parse_args (line 1828) | def test_parse_args(self):
    method test_parse_known_args (line 1847) | def test_parse_known_args(self):
    method test_dest (line 1869) | def test_dest(self):
    method test_help (line 1878) | def test_help(self):
    method test_help_extra_prefix_chars (line 1895) | def test_help_extra_prefix_chars(self):
    method test_help_alternate_prefix_chars (line 1915) | def test_help_alternate_prefix_chars(self):
    method test_parser_command_help (line 1933) | def test_parser_command_help(self):
    method test_subparser_title_help (line 1954) | def test_subparser_title_help(self):
    method _test_subparser_help (line 1984) | def _test_subparser_help(self, args_str, expected_help):
    method test_subparser1_help (line 1994) | def test_subparser1_help(self):
    method test_subparser2_help (line 2009) | def test_subparser2_help(self):
  class TestPositionalsGroups (line 2027) | class TestPositionalsGroups(TestCase):
    method test_nongroup_first (line 2030) | def test_nongroup_first(self):
    method test_group_first (line 2040) | def test_group_first(self):
    method test_interleaved_groups (line 2050) | def test_interleaved_groups(self):
  class TestParentParsers (line 2066) | class TestParentParsers(TestCase):
    method assertArgumentParserError (line 2069) | def assertArgumentParserError(self, *args, **kwargs):
    method setUp (line 2072) | def setUp(self):
    method test_single_parent (line 2100) | def test_single_parent(self):
    method test_single_parent_mutex (line 2105) | def test_single_parent_mutex(self):
    method test_single_granparent_mutex (line 2110) | def test_single_granparent_mutex(self):
    method _test_mutex_ab (line 2116) | def _test_mutex_ab(self, parse_args):
    method test_multiple_parents (line 2126) | def test_multiple_parents(self):
    method test_multiple_parents_mutex (line 2132) | def test_multiple_parents_mutex(self):
    method test_conflicting_parents (line 2142) | def test_conflicting_parents(self):
    method test_conflicting_parents_mutex (line 2148) | def test_conflicting_parents_mutex(self):
    method test_same_argument_name_parents (line 2154) | def test_same_argument_name_parents(self):
    method test_subparser_parents (line 2160) | def test_subparser_parents(self):
    method test_subparser_parents_mutex (line 2168) | def test_subparser_parents_mutex(self):
    method test_parent_help (line 2187) | def test_parent_help(self):
    method test_groups_parents (line 2212) | def test_groups_parents(self):
  class TestMutuallyExclusiveGroupErrors (line 2246) | class TestMutuallyExclusiveGroupErrors(TestCase):
    method test_invalid_add_argument_group (line 2248) | def test_invalid_add_argument_group(self):
    method test_invalid_add_argument (line 2253) | def test_invalid_add_argument(self):
    method test_help (line 2265) | def test_help(self):
  class MEMixin (line 2285) | class MEMixin(object):
    method test_failures_when_not_required (line 2287) | def test_failures_when_not_required(self):
    method test_failures_when_required (line 2293) | def test_failures_when_required(self):
    method test_successes_when_not_required (line 2299) | def test_successes_when_not_required(self):
    method test_successes_when_required (line 2306) | def test_successes_when_required(self):
    method test_usage_when_not_required (line 2312) | def test_usage_when_not_required(self):
    method test_usage_when_required (line 2317) | def test_usage_when_required(self):
    method test_help_when_not_required (line 2322) | def test_help_when_not_required(self):
    method test_help_when_required (line 2327) | def test_help_when_required(self):
  class TestMutuallyExclusiveSimple (line 2333) | class TestMutuallyExclusiveSimple(MEMixin, TestCase):
    method get_parser (line 2335) | def get_parser(self, required=None):
  class TestMutuallyExclusiveLong (line 2368) | class TestMutuallyExclusiveLong(MEMixin, TestCase):
    method get_parser (line 2370) | def get_parser(self, required=None):
  class TestMutuallyExclusiveFirstSuppressed (line 2411) | class TestMutuallyExclusiveFirstSuppressed(MEMixin, TestCase):
    method get_parser (line 2413) | def get_parser(self, required):
  class TestMutuallyExclusiveManySuppressed (line 2444) | class TestMutuallyExclusiveManySuppressed(MEMixin, TestCase):
    method get_parser (line 2446) | def get_parser(self, required):
  class TestMutuallyExclusiveOptionalAndPositional (line 2480) | class TestMutuallyExclusiveOptionalAndPositional(MEMixin, TestCase):
    method get_parser (line 2482) | def get_parser(self, required):
  class TestMutuallyExclusiveOptionalsMixed (line 2525) | class TestMutuallyExclusiveOptionalsMixed(MEMixin, TestCase):
    method get_parser (line 2527) | def get_parser(self, required):
  class TestMutuallyExclusiveInGroup (line 2567) | class TestMutuallyExclusiveInGroup(MEMixin, TestCase):
    method get_parser (line 2569) | def get_parser(self, required=None):
  class TestMutuallyExclusiveOptionalsAndPositionalsMixed (line 2607) | class TestMutuallyExclusiveOptionalsAndPositionalsMixed(MEMixin, TestCase):
    method get_parser (line 2609) | def get_parser(self, required):
  class MEPBase (line 2652) | class MEPBase(object):
    method get_parser (line 2654) | def get_parser(self, required=None):
  class TestMutuallyExclusiveGroupErrorsParent (line 2661) | class TestMutuallyExclusiveGroupErrorsParent(
  class TestMutuallyExclusiveSimpleParent (line 2666) | class TestMutuallyExclusiveSimpleParent(
  class TestMutuallyExclusiveLongParent (line 2671) | class TestMutuallyExclusiveLongParent(
  class TestMutuallyExclusiveFirstSuppressedParent (line 2676) | class TestMutuallyExclusiveFirstSuppressedParent(
  class TestMutuallyExclusiveManySuppressedParent (line 2681) | class TestMutuallyExclusiveManySuppressedParent(
  class TestMutuallyExclusiveOptionalAndPositionalParent (line 2686) | class TestMutuallyExclusiveOptionalAndPositionalParent(
  class TestMutuallyExclusiveOptionalsMixedParent (line 2691) | class TestMutuallyExclusiveOptionalsMixedParent(
  class TestMutuallyExclusiveOptionalsAndPositionalsMixedParent (line 2696) | class TestMutuallyExclusiveOptionalsAndPositionalsMixedParent(
  class TestSetDefaults (line 2704) | class TestSetDefaults(TestCase):
    method test_set_defaults_no_args (line 2706) | def test_set_defaults_no_args(self):
    method test_set_defaults_with_args (line 2719) | def test_set_defaults_with_args(self):
    method test_set_defaults_subparsers (line 2736) | def test_set_defaults_subparsers(self):
    method test_set_defaults_parents (line 2745) | def test_set_defaults_parents(self):
    method test_set_defaults_on_parent_and_subparser (line 2751) | def test_set_defaults_on_parent_and_subparser(self):
    method test_set_defaults_same_as_add_argument (line 2758) | def test_set_defaults_same_as_add_argument(self):
    method test_set_defaults_same_as_add_argument_group (line 2775) | def test_set_defaults_same_as_add_argument_group(self):
  class TestGetDefault (line 2798) | class TestGetDefault(TestCase):
    method test_get_default (line 2800) | def test_get_default(self):
  class TestNamespaceContainsSimple (line 2821) | class TestNamespaceContainsSimple(TestCase):
    method test_empty (line 2823) | def test_empty(self):
    method test_non_empty (line 2829) | def test_non_empty(self):
  class TestHelpFormattingMetaclass (line 2842) | class TestHelpFormattingMetaclass(type):
    method __init__ (line 2844) | def __init__(cls, name, bases, bodydict):
  class TestHelpBiggerOptionals (line 2936) | class TestHelpBiggerOptionals(HelpTestCase):
  class TestShortColumns (line 2971) | class TestShortColumns(HelpTestCase):
    method setUp (line 2977) | def setUp(self):
  class TestHelpBiggerOptionalGroups (line 3026) | class TestHelpBiggerOptionalGroups(HelpTestCase):
  class TestHelpBiggerPositionals (line 3072) | class TestHelpBiggerPositionals(HelpTestCase):
  class TestHelpReformatting (line 3103) | class TestHelpReformatting(HelpTestCase):
  class TestHelpWrappingShortNames (line 3155) | class TestHelpWrappingShortNames(HelpTestCase):
  class TestHelpWrappingLongNames (line 3195) | class TestHelpWrappingLongNames(HelpTestCase):
  class TestHelpUsage (line 3249) | class TestHelpUsage(HelpTestCase):
  class TestHelpOnlyUserGroups (line 3293) | class TestHelpOnlyUserGroups(HelpTestCase):
  class TestHelpUsageLongProg (line 3324) | class TestHelpUsageLongProg(HelpTestCase):
  class TestHelpUsageLongProgOptionsWrap (line 3353) | class TestHelpUsageLongProgOptionsWrap(HelpTestCase):
  class TestHelpUsageLongProgPositionalsWrap (line 3389) | class TestHelpUsageLongProgPositionalsWrap(HelpTestCase):
  class TestHelpUsageOptionalsWrap (line 3414) | class TestHelpUsageOptionalsWrap(HelpTestCase):
  class TestHelpUsagePositionalsWrap (line 3452) | class TestHelpUsagePositionalsWrap(HelpTestCase):
  class TestHelpUsageOptionalsPositionalsWrap (line 3486) | class TestHelpUsageOptionalsPositionalsWrap(HelpTestCase):
  class TestHelpUsageOptionalsOnlyWrap (line 3522) | class TestHelpUsageOptionalsOnlyWrap(HelpTestCase):
  class TestHelpUsagePositionalsOnlyWrap (line 3548) | class TestHelpUsagePositionalsOnlyWrap(HelpTestCase):
  class TestHelpVariableExpansion (line 3572) | class TestHelpVariableExpansion(HelpTestCase):
  class TestHelpVariableExpansionUsageSupplied (line 3618) | class TestHelpVariableExpansionUsageSupplied(HelpTestCase):
  class TestHelpVariableExpansionNoArguments (line 3635) | class TestHelpVariableExpansionNoArguments(HelpTestCase):
  class TestHelpSuppressUsage (line 3648) | class TestHelpSuppressUsage(HelpTestCase):
  class TestHelpSuppressOptional (line 3669) | class TestHelpSuppressOptional(HelpTestCase):
  class TestHelpSuppressOptionalGroup (line 3689) | class TestHelpSuppressOptionalGroup(HelpTestCase):
  class TestHelpSuppressPositional (line 3715) | class TestHelpSuppressPositional(HelpTestCase):
  class TestHelpRequiredOptional (line 3736) | class TestHelpRequiredOptional(HelpTestCase):
  class TestHelpAlternatePrefixChars (line 3756) | class TestHelpAlternatePrefixChars(HelpTestCase):
  class TestHelpNoHelpOptional (line 3777) | class TestHelpNoHelpOptional(HelpTestCase):
  class TestHelpVersionOptional (line 3800) | class TestHelpVersionOptional(HelpTestCase):
  class TestHelpNone (line 3827) | class TestHelpNone(HelpTestCase):
  class TestHelpTupleMetavar (line 3851) | class TestHelpTupleMetavar(HelpTestCase):
  class TestHelpRawText (line 3878) | class TestHelpRawText(HelpTestCase):
  class TestHelpRawDescription (line 3927) | class TestHelpRawDescription(HelpTestCase):
  class TestHelpArgumentDefaults (line 3975) | class TestHelpArgumentDefaults(HelpTestCase):
  class TestHelpVersionAction (line 4015) | class TestHelpVersionAction(HelpTestCase):
  class TestHelpSubparsersOrdering (line 4034) | class TestHelpSubparsersOrdering(HelpTestCase):
  class TestInvalidArgumentConstructors (line 4110) | class TestInvalidArgumentConstructors(TestCase):
    method assertTypeError (line 4113) | def assertTypeError(self, *args, **kwargs):
    method assertValueError (line 4118) | def assertValueError(self, *args, **kwargs):
    method test_invalid_keyword_arguments (line 4123) | def test_invalid_keyword_arguments(self):
    method test_missing_destination (line 4129) | def test_missing_destination(self):
    method test_invalid_option_strings (line 4134) | def test_invalid_option_strings(self):
    method test_invalid_type (line 4138) | def test_invalid_type(self):
    method test_invalid_action (line 4142) | def test_invalid_action(self):
    method test_multiple_dest (line 4155) | def test_multiple_dest(self):
    method test_no_argument_actions (line 4166) | def test_no_argument_actions(self):
    method test_no_argument_no_const_actions (line 4173) | def test_no_argument_no_const_actions(self):
    method test_more_than_one_argument_actions (line 4183) | def test_more_than_one_argument_actions(self):
    method test_required_const_actions (line 4197) | def test_required_const_actions(self):
    method test_parsers_action_missing_params (line 4203) | def test_parsers_action_missing_params(self):
    method test_required_positional (line 4209) | def test_required_positional(self):
    method test_user_defined_action (line 4212) | def test_user_defined_action(self):
  class TestActionsReturned (line 4243) | class TestActionsReturned(TestCase):
    method test_dest (line 4245) | def test_dest(self):
    method test_misc (line 4254) | def test_misc(self):
  class TestConflictHandling (line 4273) | class TestConflictHandling(TestCase):
    method test_bad_type (line 4275) | def test_bad_type(self):
    method test_conflict_error (line 4279) | def test_conflict_error(self):
    method test_resolve_error (line 4288) | def test_resolve_error(self):
  class TestOptionalsHelpVersionActions (line 4318) | class TestOptionalsHelpVersionActions(TestCase):
    method _get_error (line 4321) | def _get_error(self, func, *args, **kwargs):
    method assertPrintHelpExit (line 4329) | def assertPrintHelpExit(self, parser, args_str):
    method assertPrintVersionExit (line 4334) | def assertPrintVersionExit(self, parser, args_str):
    method assertArgumentParserError (line 4339) | def assertArgumentParserError(self, parser, *args):
    method test_version (line 4342) | def test_version(self):
    method test_version_format (line 4349) | def test_version_format(self):
    method test_version_no_help (line 4354) | def test_version_no_help(self):
    method test_version_action (line 4361) | def test_version_action(self):
    method test_no_help (line 4367) | def test_no_help(self):
    method test_alternate_help_version (line 4374) | def test_alternate_help_version(self):
    method test_help_version_extra_arguments (line 4383) | def test_help_version_extra_arguments(self):
  class TestStrings (line 4404) | class TestStrings(TestCase):
    method assertStringEqual (line 4407) | def assertStringEqual(self, obj, result_string):
    method test_optional (line 4411) | def test_optional(self):
    method test_argument (line 4427) | def test_argument(self):
    method test_namespace (line 4443) | def test_namespace(self):
    method test_parser (line 4448) | def test_parser(self):
  class TestNamespace (line 4460) | class TestNamespace(TestCase):
    method test_constructor (line 4462) | def test_constructor(self):
    method test_equality (line 4470) | def test_equality(self):
    method test_equality_returns_notimplemeted (line 4486) | def test_equality_returns_notimplemeted(self):
  class TestArgumentError (line 4515) | class TestArgumentError(TestCase):
    method test_argument_error (line 4517) | def test_argument_error(self):
  class TestArgumentTypeError (line 4526) | class TestArgumentTypeError(TestCase):
    method test_argument_type_error (line 4528) | def test_argument_type_error(self):
  class TestTypeFunctionCallOnlyOnce (line 4548) | class TestTypeFunctionCallOnlyOnce(TestCase):
    method test_type_function_call_only_once (line 4550) | def test_type_function_call_only_once(self):
  class TestTypeFunctionCalledOnDefault (line 4564) | class TestTypeFunctionCalledOnDefault(TestCase):
    method test_type_function_call_with_non_string_default (line 4566) | def test_type_function_call_with_non_string_default(self):
    method test_type_function_call_with_string_default (line 4577) | def test_type_function_call_with_string_default(self):
    method test_no_double_type_conversion_of_default (line 4587) | def test_no_double_type_conversion_of_default(self):
    method test_issue_15906 (line 4599) | def test_issue_15906(self):
  class TestParseKnownArgs (line 4613) | class TestParseKnownArgs(TestCase):
    method test_arguments_tuple (line 4615) | def test_arguments_tuple(self):
    method test_arguments_list (line 4619) | def test_arguments_list(self):
    method test_arguments_tuple_positional (line 4623) | def test_arguments_tuple_positional(self):
    method test_arguments_list_positional (line 4628) | def test_arguments_list_positional(self):
    method test_optionals (line 4633) | def test_optionals(self):
    method test_mixed (line 4640) | def test_mixed(self):
  class TestAddArgumentMetavar (line 4655) | class TestAddArgumentMetavar(TestCase):
    method do_test_no_exception (line 4659) | def do_test_no_exception(self, nargs, metavar):
    method do_test_exception (line 4663) | def do_test_exception(self, nargs, metavar):
    method test_nargs_None_metavar_string (line 4672) | def test_nargs_None_metavar_string(self):
    method test_nargs_None_metavar_length0 (line 4675) | def test_nargs_None_metavar_length0(self):
    method test_nargs_None_metavar_length1 (line 4678) | def test_nargs_None_metavar_length1(self):
    method test_nargs_None_metavar_length2 (line 4681) | def test_nargs_None_metavar_length2(self):
    method test_nargs_None_metavar_length3 (line 4684) | def test_nargs_None_metavar_length3(self):
    method test_nargs_optional_metavar_string (line 4689) | def test_nargs_optional_metavar_string(self):
    method test_nargs_optional_metavar_length0 (line 4692) | def test_nargs_optional_metavar_length0(self):
    method test_nargs_optional_metavar_length1 (line 4695) | def test_nargs_optional_metavar_length1(self):
    method test_nargs_optional_metavar_length2 (line 4698) | def test_nargs_optional_metavar_length2(self):
    method test_nargs_optional_metavar_length3 (line 4701) | def test_nargs_optional_metavar_length3(self):
    method test_nargs_zeroormore_metavar_string (line 4706) | def test_nargs_zeroormore_metavar_string(self):
    method test_nargs_zeroormore_metavar_length0 (line 4709) | def test_nargs_zeroormore_metavar_length0(self):
    method test_nargs_zeroormore_metavar_length1 (line 4712) | def test_nargs_zeroormore_metavar_length1(self):
    method test_nargs_zeroormore_metavar_length2 (line 4715) | def test_nargs_zeroormore_metavar_length2(self):
    method test_nargs_zeroormore_metavar_length3 (line 4718) | def test_nargs_zeroormore_metavar_length3(self):
    method test_nargs_oneormore_metavar_string (line 4723) | def test_nargs_oneormore_metavar_string(self):
    method test_nargs_oneormore_metavar_length0 (line 4726) | def test_nargs_oneormore_metavar_length0(self):
    method test_nargs_oneormore_metavar_length1 (line 4729) | def test_nargs_oneormore_metavar_length1(self):
    method test_nargs_oneormore_metavar_length2 (line 4732) | def test_nargs_oneormore_metavar_length2(self):
    method test_nargs_oneormore_metavar_length3 (line 4735) | def test_nargs_oneormore_metavar_length3(self):
    method test_nargs_remainder_metavar_string (line 4740) | def test_nargs_remainder_metavar_string(self):
    method test_nargs_remainder_metavar_length0 (line 4743) | def test_nargs_remainder_metavar_length0(self):
    method test_nargs_remainder_metavar_length1 (line 4746) | def test_nargs_remainder_metavar_length1(self):
    method test_nargs_remainder_metavar_length2 (line 4749) | def test_nargs_remainder_metavar_length2(self):
    method test_nargs_remainder_metavar_length3 (line 4752) | def test_nargs_remainder_metavar_length3(self):
    method test_nargs_parser_metavar_string (line 4757) | def test_nargs_parser_metavar_string(self):
    method test_nargs_parser_metavar_length0 (line 4760) | def test_nargs_parser_metavar_length0(self):
    method test_nargs_parser_metavar_length1 (line 4763) | def test_nargs_parser_metavar_length1(self):
    method test_nargs_parser_metavar_length2 (line 4766) | def test_nargs_parser_metavar_length2(self):
    method test_nargs_parser_metavar_length3 (line 4769) | def test_nargs_parser_metavar_length3(self):
    method test_nargs_1_metavar_string (line 4774) | def test_nargs_1_metavar_string(self):
    method test_nargs_1_metavar_length0 (line 4777) | def test_nargs_1_metavar_length0(self):
    method test_nargs_1_metavar_length1 (line 4780) | def test_nargs_1_metavar_length1(self):
    method test_nargs_1_metavar_length2 (line 4783) | def test_nargs_1_metavar_length2(self):
    method test_nargs_1_metavar_length3 (line 4786) | def test_nargs_1_metavar_length3(self):
    method test_nargs_2_metavar_string (line 4791) | def test_nargs_2_metavar_string(self):
    method test_nargs_2_metavar_length0 (line 4794) | def test_nargs_2_metavar_length0(self):
    method test_nargs_2_metavar_length1 (line 4797) | def test_nargs_2_metavar_length1(self):
    method test_nargs_2_metavar_length2 (line 4800) | def test_nargs_2_metavar_length2(self):
    method test_nargs_2_metavar_length3 (line 4803) | def test_nargs_2_metavar_length3(self):
    method test_nargs_3_metavar_string (line 4808) | def test_nargs_3_metavar_string(self):
    method test_nargs_3_metavar_length0 (line 4811) | def test_nargs_3_metavar_length0(self):
    method test_nargs_3_metavar_length1 (line 4814) | def test_nargs_3_metavar_length1(self):
    method test_nargs_3_metavar_length2 (line 4817) | def test_nargs_3_metavar_length2(self):
    method test_nargs_3_metavar_length3 (line 4820) | def test_nargs_3_metavar_length3(self):
  function test_main (line 4842) | def test_main():

FILE: third_party/stdlib/test/test_bisect.py
  class Range (line 28) | class Range(object):
    method __init__ (line 30) | def __init__(self, start, stop):
    method __len__ (line 35) | def __len__(self):
    method __getitem__ (line 38) | def __getitem__(self, idx):
    method insert (line 46) | def insert(self, idx, item):
  class TestBisect (line 50) | class TestBisect(unittest.TestCase):
    method setUp (line 54) | def setUp(self):
    method test_precomputed (line 137) | def test_precomputed(self):
    method test_negative_lo (line 142) | def test_negative_lo(self):
    method test_large_range (line 150) | def test_large_range(self):
    method test_large_pyrange (line 163) | def test_large_pyrange(self):
    method test_random (line 179) | def test_random(self, n=25):
    method test_optionalSlicing (line 199) | def test_optionalSlicing(self):
    method test_backcompatibility (line 217) | def test_backcompatibility(self):
    method test_keyword_args (line 220) | def test_keyword_args(self):
  class TestInsort (line 238) | class TestInsort(unittest.TestCase):
    method test_vsBuiltinSort (line 242) | def test_vsBuiltinSort(self, n=500):
    method test_backcompatibility (line 257) | def test_backcompatibility(self):
    method test_listDerived (line 260) | def test_listDerived(self):
  class LenOnly (line 280) | class LenOnly(object):
    method __len__ (line 282) | def __len__(self):
    method __getitem__ (line 288) | def __getitem__(self, ndx):
  class GetOnly (line 291) | class GetOnly(object):
    method __getitem__ (line 293) | def __getitem__(self, ndx):
    method __len__ (line 296) | def __len__(self):
  class CmpErr (line 299) | class CmpErr(object):
    method __cmp__ (line 301) | def __cmp__(self, other):
  class TestErrorHandling (line 304) | class TestErrorHandling(unittest.TestCase):
    method test_non_sequence (line 308) | def test_non_sequence(self):
    method test_len_only (line 313) | def test_len_only(self):
    method test_get_only (line 318) | def test_get_only(self):
    method test_cmp_err (line 323) | def test_cmp_err(self):
    method test_arg_parsing (line 329) | def test_arg_parsing(self):
  function test_main (line 364) | def test_main(verbose=None):

FILE: third_party/stdlib/test/test_colorsys.py
  function frange (line 5) | def frange(start, stop, step):
  class ColorsysTest (line 10) | class ColorsysTest(unittest.TestCase):
    method assertTripleEqual (line 12) | def assertTripleEqual(self, tr1, tr2):
    method test_hsv_roundtrip (line 19) | def test_hsv_roundtrip(self):
    method test_hsv_values (line 29) | def test_hsv_values(self):
    method test_hls_roundtrip (line 46) | def test_hls_roundtrip(self):
    method test_hls_values (line 56) | def test_hls_values(self):
    method test_yiq_roundtrip (line 73) | def test_yiq_roundtrip(self):
    method test_yiq_values (line 83) | def test_yiq_values(self):
  function test_main (line 100) | def test_main():

FILE: third_party/stdlib/test/test_datetime.py
  class TestModule (line 37) | class TestModule(unittest.TestCase):
    method test_constants (line 39) | def test_constants(self):
  class FixedOffset (line 47) | class FixedOffset(tzinfo):
    method __init__ (line 48) | def __init__(self, offset, name, dstoffset=42):
    method __repr__ (line 56) | def __repr__(self):
    method utcoffset (line 58) | def utcoffset(self, dt):
    method tzname (line 60) | def tzname(self, dt):
    method dst (line 62) | def dst(self, dt):
  class PicklableFixedOffset (line 65) | class PicklableFixedOffset(FixedOffset):
    method __init__ (line 66) | def __init__(self, offset=None, name=None, dstoffset=None):
  class TestTZInfo (line 69) | class TestTZInfo(unittest.TestCase):
    method test_non_abstractness (line 71) | def test_non_abstractness(self):
    method test_subclass_must_override (line 81) | def test_subclass_must_override(self):
    method test_normal (line 95) | def test_normal(self):
  class HarmlessMixedComparison (line 134) | class HarmlessMixedComparison(object):
    method test_harmless_mixed_comparison (line 140) | def test_harmless_mixed_comparison(self):
    method test_harmful_mixed_comparison (line 151) | def test_harmful_mixed_comparison(self):
  class TestTimeDelta (line 170) | class TestTimeDelta(HarmlessMixedComparison, unittest.TestCase):
    method test_constructor (line 174) | def test_constructor(self):
    method test_computations (line 199) | def test_computations(self):
    method test_disallowed_computations (line 245) | def test_disallowed_computations(self):
    method test_basic_attributes (line 270) | def test_basic_attributes(self):
    method test_total_seconds (line 278) | def test_total_seconds(self):
    method test_carries (line 292) | def test_carries(self):
    method test_hash_equality (line 303) | def test_hash_equality(self):
    method test_compare (line 331) | def test_compare(self):
    method test_str (line 375) | def test_str(self):
    method test_roundtrip (line 397) | def test_roundtrip(self):
    method test_resolution_info (line 414) | def test_resolution_info(self):
    method test_overflow (line 423) | def test_overflow(self):
    method test_microsecond_rounding (line 438) | def test_microsecond_rounding(self):
    method test_massive_normalization (line 459) | def test_massive_normalization(self):
    method test_bool (line 464) | def test_bool(self):
    method test_subclass_timedelta (line 471) | def test_subclass_timedelta(self):
  class TestDateOnly (line 505) | class TestDateOnly(unittest.TestCase):
    method test_delta_non_days_ignored (line 509) | def test_delta_non_days_ignored(self):
  class SubclassDate (line 538) | class SubclassDate(date):
  class TestDate (line 541) | class TestDate(HarmlessMixedComparison, unittest.TestCase):
    method test_basic_attributes (line 547) | def test_basic_attributes(self):
    method test_roundtrip (line 554) | def test_roundtrip(self):
    method test_ordinal_conversions (line 568) | def test_ordinal_conversions(self):
    method test_extreme_ordinals (line 615) | def test_extreme_ordinals(self):
    method test_bad_constructor_arguments (line 640) | def test_bad_constructor_arguments(self):
    method test_hash_equality (line 663) | def test_hash_equality(self):
    method test_computations (line 688) | def test_computations(self):
    method test_overflow (line 736) | def test_overflow(self):
    method test_fromtimestamp (line 750) | def test_fromtimestamp(self):
    method test_insane_fromtimestamp (line 761) | def test_insane_fromtimestamp(self):
    method test_today (line 770) | def test_today(self):
    method test_weekday (line 799) | def test_weekday(self):
    method test_isocalendar (line 808) | def test_isocalendar(self):
    method test_iso_long_years (line 825) | def test_iso_long_years(self):
    method test_isoformat (line 864) | def test_isoformat(self):
    method test_ctime (line 868) | def test_ctime(self):
    method test_strftime (line 873) | def test_strftime(self):
    method test_format (line 908) | def test_format(self):
    method test_resolution_info (line 934) | def test_resolution_info(self):
    method test_extreme_timedelta (line 940) | def test_extreme_timedelta(self):
    method test_timetuple (line 950) | def test_timetuple(self):
    method test_compare (line 983) | def test_compare(self):
    method test_mixed_compare (line 1026) | def test_mixed_compare(self):
    method test_bool (line 1065) | def test_bool(self):
    method test_strftime_out_of_range (line 1071) | def test_strftime_out_of_range(self):
    method test_replace (line 1079) | def test_replace(self):
    method test_subclass_date (line 1101) | def test_subclass_date(self):
  class SubclassDatetime (line 1160) | class SubclassDatetime(datetime):
  class TestDateTime (line 1163) | class TestDateTime(TestDate):
    method test_basic_attributes (line 1167) | def test_basic_attributes(self):
    method test_basic_attributes_nonzero (line 1177) | def test_basic_attributes_nonzero(self):
    method test_roundtrip (line 1190) | def test_roundtrip(self):
    method test_isoformat (line 1207) | def test_isoformat(self):
    method test_format (line 1224) | def test_format(self):
    method test_more_ctime (line 1251) | def test_more_ctime(self):
    method test_tz_independent_comparing (line 1267) | def test_tz_independent_comparing(self):
    method test_strftime_with_bad_tzname_replace (line 1286) | def test_strftime_with_bad_tzname_replace(self):
    method test_bad_constructor_arguments (line 1297) | def test_bad_constructor_arguments(self):
    method test_hash_equality (line 1342) | def test_hash_equality(self):
    method test_computations (line 1365) | def test_computations(self):
    method test_more_compare (line 1458) | def test_more_compare(self):
    method verify_field_equality (line 1495) | def verify_field_equality(self, expected, got):
    method test_fromtimestamp (line 1503) | def test_fromtimestamp(self):
    method test_utcfromtimestamp (line 1511) | def test_utcfromtimestamp(self):
    method test_microsecond_rounding (line 1519) | def test_microsecond_rounding(self):
    method test_insane_fromtimestamp (line 1526) | def test_insane_fromtimestamp(self):
    method test_insane_utcfromtimestamp (line 1536) | def test_insane_utcfromtimestamp(self):
    method test_utcnow (line 1556) | def test_utcnow(self):
    method test_more_timetuple (line 1580) | def test_more_timetuple(self):
    method test_more_strftime (line 1603) | def test_more_strftime(self):
    method test_extract (line 1609) | def test_extract(self):
    method test_combine (line 1614) | def test_combine(self):
    method test_replace (line 1636) | def test_replace(self):
    method test_astimezone (line 1661) | def test_astimezone(self):
    method test_subclass_datetime (line 1685) | def test_subclass_datetime(self):
  class SubclassTime (line 1712) | class SubclassTime(time):
  class TestTime (line 1715) | class TestTime(HarmlessMixedComparison, unittest.TestCase):
    method test_basic_attributes (line 1719) | def test_basic_attributes(self):
    method test_basic_attributes_nonzero (line 1726) | def test_basic_attributes_nonzero(self):
    method test_roundtrip (line 1736) | def test_roundtrip(self):
    method test_comparing (line 1751) | def test_comparing(self):
    method test_bad_constructor_arguments (line 1798) | def test_bad_constructor_arguments(self):
    method test_hash_equality (line 1820) | def test_hash_equality(self):
    method test_isoformat (line 1843) | def test_isoformat(self):
    method test_1653736 (line 1876) | def test_1653736(self):
    method test_strftime (line 1882) | def test_strftime(self):
    method test_format (line 1889) | def test_format(self):
    method test_str (line 1913) | def test_str(self):
    method test_repr (line 1920) | def test_repr(self):
    method test_resolution_info (line 1933) | def test_resolution_info(self):
    method test_bool (line 1955) | def test_bool(self):
    method test_replace (line 1965) | def test_replace(self):
    method test_subclass_time (line 1991) | def test_subclass_time(self):
    method test_backdoor_resistance (line 2017) | def test_backdoor_resistance(self):
  class TZInfoBase (line 2027) | class TZInfoBase(object):
    method test_argument_passing (line 2029) | def test_argument_passing(self):
    method test_bad_tzinfo_classes (line 2047) | def test_bad_tzinfo_classes(self):
    method test_utc_offset_out_of_bounds (line 2064) | def test_utc_offset_out_of_bounds(self):
    method test_tzinfo_classes (line 2092) | def test_tzinfo_classes(self):
    method test_aware_compare (line 2141) | def test_aware_compare(self):
  class TestTimeTZ (line 2189) | class TestTimeTZ(TestTime, TZInfoBase, unittest.TestCase):
    method test_empty (line 2192) | def test_empty(self):
    method test_zones (line 2201) | def test_zones(self):
    method test_hash_edge_cases (line 2283) | def test_hash_edge_cases(self):
    method test_more_bool (line 2313) | def test_more_bool(self):
    method test_replace (line 2342) | def test_replace(self):
    method test_mixed_compare (line 2382) | def test_mixed_compare(self):
    method test_subclass_timetz (line 2413) | def test_subclass_timetz(self):
  class TestDateTimeTZ (line 2442) | class TestDateTimeTZ(TestDateTime, TZInfoBase, unittest.TestCase):
    method test_trivial (line 2445) | def test_trivial(self):
    method test_even_more_compare (line 2456) | def test_even_more_compare(self):
    method test_extreme_hashes (line 2543) | def test_extreme_hashes(self):
    method test_zones (line 2558) | def test_zones(self):
    method test_combine (line 2588) | def test_combine(self):
    method test_extract (line 2596) | def test_extract(self):
    method test_tz_aware_arithmetic (line 2604) | def test_tz_aware_arithmetic(self):
    method test_tzinfo_now (line 2667) | def test_tzinfo_now(self):
    method test_tzinfo_fromtimestamp (line 2704) | def test_tzinfo_fromtimestamp(self):
    method test_tzinfo_utcnow (line 2739) | def test_tzinfo_utcnow(self):
    method test_tzinfo_utcfromtimestamp (line 2749) | def test_tzinfo_utcfromtimestamp(self):
    method test_tzinfo_timetuple (line 2761) | def test_tzinfo_timetuple(self):
    method test_utctimetuple (line 2797) | def test_utctimetuple(self):
    method test_tzinfo_isoformat (line 2862) | def test_tzinfo_isoformat(self):
    method test_replace (line 2883) | def test_replace(self):
    method test_more_astimezone (line 2923) | def test_more_astimezone(self):
    method test_aware_subtract (line 2955) | def test_aware_subtract(self):
    method test_mixed_compare (line 3000) | def test_mixed_compare(self):
    method test_subclass_datetimetz (line 3031) | def test_subclass_datetimetz(self):
  function first_sunday_on_or_after (line 3059) | def first_sunday_on_or_after(dt):
  class USTimeZone (line 3076) | class USTimeZone(tzinfo):
    method __init__ (line 3078) | def __init__(self, hours, reprname, stdname, dstname):
    method __repr__ (line 3084) | def __repr__(self):
    method tzname (line 3087) | def tzname(self, dt):
    method utcoffset (line 3093) | def utcoffset(self, dt):
    method dst (line 3096) | def dst(self, dt):
  class TestTimezoneConversions (line 3127) | class TestTimezoneConversions(unittest.TestCase):
    method checkinside (line 3135) | def checkinside(self, dt, tz, utc, dston, dstoff):
    method checkoutside (line 3187) | def checkoutside(self, dt, tz, utc):
    method convert_between_tz_and_utc (line 3198) | def convert_between_tz_and_utc(self, tz, utc):
    method test_easy (line 3221) | def test_easy(self):
    method test_tricky (line 3246) | def test_tricky(self):
    method test_bogus_dst (line 3298) | def test_bogus_dst(self):
    method test_fromutc (line 3313) | def test_fromutc(self):
  class Oddballs (line 3377) | class Oddballs(unittest.TestCase):
    method test_bug_1028306 (line 3380) | def test_bug_1028306(self):
  function test_main (line 3416) | def test_main():

FILE: third_party/stdlib/test/test_dict.py
  class DictTest (line 8) | class DictTest(unittest.TestCase):
    method test_constructor (line 9) | def test_constructor(self):
    method test_literal_constructor (line 15) | def test_literal_constructor(self):
    method test_bool (line 26) | def test_bool(self):
    method test_keys (line 33) | def test_keys(self):
    method test_values (line 45) | def test_values(self):
    method test_items (line 53) | def test_items(self):
    method test_has_key (line 63) | def test_has_key(self):
    method test_contains (line 73) | def test_contains(self):
    method test_len (line 85) | def test_len(self):
    method test_getitem (line 91) | def test_getitem(self):
    method test_clear (line 129) | def test_clear(self):
    method test_update (line 137) | def test_update(self):
    method test_fromkeys (line 214) | def test_fromkeys(self):
    method test_copy (line 273) | def test_copy(self):
    method test_get (line 279) | def test_get(self):
    method test_setdefault (line 291) | def test_setdefault(self):
    method test_setdefault_atomic (line 318) | def test_setdefault_atomic(self):
    method test_popitem (line 339) | def test_popitem(self):
    method test_pop (line 368) | def test_pop(self):
    method test_mutatingiteration (line 408) | def test_mutatingiteration(self):
    method test_repr (line 416) | def test_repr(self):
    method test_le (line 435) | def test_le(self):
    method test_missing (line 454) | def test_missing(self):
    method test_tuple_keyerror (line 498) | def test_tuple_keyerror(self):
    method test_resize1 (line 534) | def test_resize1(self):
    method test_resize2 (line 550) | def test_resize2(self):
    method test_empty_presized_dict_in_freelist (line 572) | def test_empty_presized_dict_in_freelist(self):
    method test_track_literals (line 607) | def test_track_literals(self):
    method test_track_dynamic (line 625) | def test_track_dynamic(self):
    method test_track_subtypes (line 689) | def test_track_subtypes(self):
  class GeneralMappingTests (line 707) | class GeneralMappingTests(mapping_tests.BasicTestMappingProtocol):
  class Dict (line 710) | class Dict(dict):
  class SubclassMappingTests (line 713) | class SubclassMappingTests(mapping_tests.BasicTestMappingProtocol):
  function test_main (line 716) | def test_main():

FILE: third_party/stdlib/test/test_dircache.py
  class DircacheTests (line 13) | class DircacheTests(unittest.TestCase):
    method setUp (line 14) | def setUp(self):
    method tearDown (line 17) | def tearDown(self):
    method writeTemp (line 22) | def writeTemp(self, fname):
    method mkdirTemp (line 26) | def mkdirTemp(self, fname):
    method delTemp (line 29) | def delTemp(self, fname):
    method test_listdir (line 36) | def test_listdir(self):
    method test_annotate (line 62) | def test_annotate(self):
  function test_main (line 70) | def test_main():

FILE: third_party/stdlib/test/test_dummy_thread.py
  class LockTests (line 18) | class LockTests(unittest.TestCase):
    method setUp (line 21) | def setUp(self):
    method test_initlock (line 25) | def test_initlock(self):
    method test_release (line 30) | def test_release(self):
    method test_improper_release (line 37) | def test_improper_release(self):
    method test_cond_acquire_success (line 41) | def test_cond_acquire_success(self):
    method test_cond_acquire_fail (line 46) | def test_cond_acquire_fail(self):
    method test_uncond_acquire_success (line 53) | def test_uncond_acquire_success(self):
    method test_uncond_acquire_return_val (line 59) | def test_uncond_acquire_return_val(self):
    method test_uncond_acquire_blocking (line 65) | def test_uncond_acquire_blocking(self):
  class MiscTests (line 86) | class MiscTests(unittest.TestCase):
    method test_exit (line 89) | def test_exit(self):
    method test_ident (line 93) | def test_ident(self):
    method test_LockType (line 100) | def test_LockType(self):
    method test_interrupt_main (line 106) | def test_interrupt_main(self):
    method test_interrupt_in_main (line 114) | def test_interrupt_in_main(self):
  class ThreadTests (line 119) | class ThreadTests(unittest.TestCase):
    method test_arg_passing (line 122) | def test_arg_passing(self):
    method test_multi_creation (line 144) | def test_multi_creation(self):
  function test_main (line 171) | def test_main(imported_module=None):

FILE: third_party/stdlib/test/test_fpformat.py
  class FpformatTest (line 22) | class FpformatTest(unittest.TestCase):
    method checkFix (line 24) | def checkFix(self, n, digits):
    method checkSci (line 32) | def checkSci(self, n, digits):
    method test_basic_cases (line 45) | def test_basic_cases(self):
    method test_reasonable_values (line 50) | def test_reasonable_values(self):
    method test_failing_values (line 57) | def test_failing_values(self):
  function test_main (line 73) | def test_main():

FILE: third_party/stdlib/test/test_genericpath.py
  function safe_rmdir (line 12) | def safe_rmdir(dirname):
  class GenericTest (line 19) | class GenericTest(unittest.TestCase):
    method test_no_argument (line 26) | def test_no_argument(self):
    method test_commonprefix (line 33) | def test_commonprefix(self):
    method test_getsize (line 75) | def test_getsize(self):
    method test_time (line 87) | def test_time(self):
    method test_exists (line 109) | def test_exists(self):
    method test_isdir (line 124) | def test_isdir(self):
    method test_isfile (line 142) | def test_isfile(self):
  class CommonTest (line 163) | class CommonTest(GenericTest):
    method test_normcase (line 176) | def test_normcase(self):
    method test_splitdrive (line 182) | def test_splitdrive(self):
    method test_expandvars (line 189) | def test_expandvars(self):
    method test_expandvars_nonascii (line 211) | def test_expandvars_nonascii(self):
    method test_abspath (line 238) | def test_abspath(self):
    method test_realpath (line 245) | def test_realpath(self):
    method test_normpath_issue5827 (line 249) | def test_normpath_issue5827(self):
    method test_abspath_issue3426 (line 255) | def test_abspath_issue3426(self):
    method test_nonascii_abspath (line 276) | def test_nonascii_abspath(self):
  function test_main (line 282) | def test_main():

FILE: third_party/stdlib/test/test_list.py
  class ListTest (line 5) | class ListTest(list_tests.CommonTest):
    method test_basic (line 8) | def test_basic(self):
    method test_truth (line 41) | def test_truth(self):
    method test_identity (line 46) | def test_identity(self):
    method test_len (line 49) | def test_len(self):
    method test_overflow (line 56) | def test_overflow(self):
  function test_main (line 64) | def test_main(verbose=None):

FILE: third_party/stdlib/test/test_md5.py
  function hexstr (line 12) | def hexstr(s):
  class MD5_Test (line 21) | class MD5_Test(unittest.TestCase):
    method md5test (line 23) | def md5test(self, s, expected):
    method test_basics (line 27) | def test_basics(self):
    method test_hexdigest (line 39) | def test_hexdigest(self):
    method test_large_update (line 45) | def test_large_update(self):
  function test_main (line 59) | def test_main():

FILE: third_party/stdlib/test/test_mimetools.py
  class MimeToolsTest (line 17) | class MimeToolsTest(unittest.TestCase):
    method test_decodeencode (line 19) | def test_decodeencode(self):
    method test_boundary (line 32) | def test_boundary(self):
    method test_message (line 39) | def test_message(self):
  function test_main (line 51) | def test_main():

FILE: third_party/stdlib/test/test_mutex.py
  class MutexTest (line 7) | class MutexTest(unittest.TestCase):
    method test_lock_and_unlock (line 9) | def test_lock_and_unlock(self):
  function test_main (line 32) | def test_main():

FILE: third_party/stdlib/test/test_queue.py
  class _TriggerThread (line 13) | class _TriggerThread(threading.Thread):
    method __init__ (line 14) | def __init__(self, fn, args):
    method run (line 20) | def run(self):
  class BlockingTestMixin (line 45) | class BlockingTestMixin(object):
    method tearDown (line 47) | def tearDown(self):
    method do_blocking_test (line 50) | def do_blocking_test(self, block_func, block_args, trigger_func, trigg...
    method do_exceptional_blocking_test (line 65) | def do_exceptional_blocking_test(self,block_func, block_args, trigger_...
  class BaseQueueTest (line 86) | class BaseQueueTest(BlockingTestMixin):
    method setUp (line 87) | def setUp(self):
    method simple_queue_test (line 91) | def simple_queue_test(self, q):
    method worker (line 144) | def worker(self, q):
    method queue_join_test (line 154) | def queue_join_test(self, q):
    method test_queue_task_done (line 167) | def test_queue_task_done(self):
    method test_queue_join (line 177) | def test_queue_join(self):
    method test_simple_queue (line 190) | def test_simple_queue(self):
  class QueueTest (line 198) | class QueueTest(BaseQueueTest, unittest.TestCase):
  class LifoQueueTest (line 201) | class LifoQueueTest(BaseQueueTest, unittest.TestCase):
  class PriorityQueueTest (line 204) | class PriorityQueueTest(BaseQueueTest, unittest.TestCase):
  class FailingQueueException (line 210) | class FailingQueueException(Exception):
  class FailingQueue (line 213) | class FailingQueue(Queue.Queue):
    method __init__ (line 214) | def __init__(self, *args):
    method _put (line 218) | def _put(self, item):
    method _get (line 223) | def _get(self):
  class FailingQueueTest (line 229) | class FailingQueueTest(BlockingTestMixin, unittest.TestCase):
    method failing_queue_test (line 231) | def failing_queue_test(self, q):
    method test_failing_queue (line 312) | def test_failing_queue(self):
  function test_main (line 320) | def test_main():

FILE: third_party/stdlib/test/test_quopri.py
  function withpythonimplementation (line 47) | def withpythonimplementation(testfunc):
  class QuopriTestCase (line 65) | class QuopriTestCase(unittest.TestCase):
    method test_encodestring (line 131) | def test_encodestring(self):
    method test_decodestring (line 136) | def test_decodestring(self):
    method test_idempotent_string (line 141) | def test_idempotent_string(self):
    method test_encode (line 146) | def test_encode(self):
    method test_decode (line 154) | def test_decode(self):
    method test_embedded_ws (line 162) | def test_embedded_ws(self):
    method test_encode_header (line 168) | def test_encode_header(self):
    method test_decode_header (line 173) | def test_decode_header(self):
    method test_scriptencode (line 178) | def test_scriptencode(self):
    method test_scriptdecode (line 190) | def test_scriptdecode(self):
  function test_main (line 198) | def test_main():

FILE: third_party/stdlib/test/test_rfc822.py
  class MessageTestCase (line 13) | class MessageTestCase(unittest.TestCase):
    method create_message (line 14) | def create_message(self, msg):
    method test_get (line 17) | def test_get(self):
    method test_setdefault (line 26) | def test_setdefault(self):
    method check (line 38) | def check(self, msg, results):
    method test_basic (line 68) | def test_basic(self):
    method test_doublecomment (line 137) | def test_doublecomment(self):
    method test_twisted (line 143) | def test_twisted(self):
    method test_commas_in_full_name (line 157) | def test_commas_in_full_name(self):
    method test_quoted_name (line 167) | def test_quoted_name(self):
    method test_bogus_to_header (line 174) | def test_bogus_to_header(self):
    method test_addr_ipquad (line 183) | def test_addr_ipquad(self):
    method test_iter (line 190) | def test_iter(self):
    method test_rfc2822_phrases (line 201) | def test_rfc2822_phrases(self):
    method test_2getaddrlist (line 218) | def test_2getaddrlist(self):
    method test_parseaddr (line 238) | def test_parseaddr(self):
    method test_quote_unquote (line 247) | def test_quote_unquote(self):
    method test_invalid_headers (line 252) | def test_invalid_headers(self):
  function test_main (line 259) | def test_main():

FILE: third_party/stdlib/test/test_sched.py
  class Timer (line 15) | class Timer(object):
    method __init__ (line 16) | def __init__(self):
    method time (line 21) | def time(self):
    method sleep (line 26) | def sleep(self, t):
    method advance (line 36) | def advance(self, t):
  class TestCase (line 43) | class TestCase(unittest.TestCase):
    method test_enter (line 45) | def test_enter(self):
    method test_enterabs (line 54) | def test_enterabs(self):
    method test_enter_concurrent (line 65) | def test_enter_concurrent(self):
    method test_priority (line 95) | def test_priority(self):
    method test_cancel (line 105) | def test_cancel(self):
    method test_cancel_concurrent (line 122) | def test_cancel_concurrent(self):
    method test_empty (line 154) | def test_empty(self):
  function test_main (line 165) | def test_main():

FILE: third_party/stdlib/test/test_select.py
  class SelectTestCase (line 9) | class SelectTestCase(unittest.TestCase):
    class Nope (line 11) | class Nope(object):
    class Almost (line 14) | class Almost(object):
      method fileno (line 15) | def fileno(self):
    method test_error_conditions (line 18) | def test_error_conditions(self):
    method test_returned_list_identity (line 24) | def test_returned_list_identity(self):
    method test_select (line 31) | def test_select(self):
    method test_select_mutated (line 53) | def test_select_mutated(self):
  function test_main (line 62) | def test_main():

FILE: third_party/stdlib/test/test_slice.py
  class SliceTest (line 11) | class SliceTest(unittest.TestCase):
    method test_constructor (line 13) | def test_constructor(self):
    method test_repr (line 17) | def test_repr(self):
    method test_hash (line 20) | def test_hash(self):
    method test_cmp (line 27) | def test_cmp(self):
    method test_members (line 57) | def test_members(self):
    method test_indices (line 81) | def test_indices(self):
    method test_setslice_without_getslice (line 117) | def test_setslice_without_getslice(self):
    method test_cycle (line 137) | def test_cycle(self):
  function test_main (line 146) | def test_main():

FILE: third_party/stdlib/test/test_stat.py
  class TestFilemode (line 6) | class TestFilemode(unittest.TestCase):
    method setUp (line 51) | def setUp(self):
    method get_mode (line 61) | def get_mode(self, fname=TESTFN): #, lstat=True):
    method assertS_IS (line 68) | def assertS_IS(self, name, mode):
    method test_mode (line 86) | def test_mode(self):
    method test_directory (line 119) | def test_directory(self):
    method test_link (line 127) | def test_link(self):
    method test_fifo (line 138) | def test_fifo(self):
    method test_devices (line 145) | def test_devices(self):
    method test_module_attributes (line 157) | def test_module_attributes(self):
  function test_main (line 176) | def test_main():

FILE: third_party/stdlib/test/test_string.py
  class StringTest (line 10) | class StringTest(
    method checkequal (line 17) | def checkequal(self, result, object, methodname, *args):
    method checkraises (line 24) | def checkraises(self, exc, obj, methodname, *args):
    method checkcall (line 29) | def checkcall(self, object, methodname, *args):
    method test_join (line 33) | def test_join(self):
  class ModuleTest (line 68) | class ModuleTest(unittest.TestCase):
    method test_attrs (line 70) | def test_attrs(self):
    method test_atoi (line 81) | def test_atoi(self):
    method test_atol (line 86) | def test_atol(self):
    method test_atof (line 92) | def test_atof(self):
    method test_maketrans (line 97) | def test_maketrans(self):
    method test_capwords (line 104) | def test_capwords(self):
    method test_formatter (line 116) | def test_formatter(self):
    method test_format_keyword_arguments (line 207) | def test_format_keyword_arguments(self):
  class BytesAliasTest (line 219) | class BytesAliasTest(unittest.TestCase):
    method test_builtin (line 222) | def test_builtin(self):
    method test_syntax (line 225) | def test_syntax(self):
  class Bag (line 234) | class Bag(object):
  class Mapping (line 237) | class Mapping(object):
    method __getitem__ (line 238) | def __getitem__(self, name):
  class TestTemplate (line 248) | class TestTemplate(unittest.TestCase):
    method test_regular_templates (line 249) | def test_regular_templates(self):
    method test_regular_templates_with_braces (line 256) | def test_regular_templates_with_braces(self):
    method test_escapes (line 263) | def test_escapes(self):
    method test_percents (line 271) | def test_percents(self):
    method test_stringification (line 278) | def test_stringification(self):
    method test_tupleargs (line 287) | def test_tupleargs(self):
    method test_SafeTemplate (line 294) | def test_SafeTemplate(self):
    method test_invalid_placeholders (line 307) | def test_invalid_placeholders(self):
    method test_idpattern_override (line 316) | def test_idpattern_override(self):
    method test_pattern_override (line 327) | def test_pattern_override(self):
    method test_braced_override (line 355) | def test_braced_override(self):
    method test_braced_override_safe (line 372) | def test_braced_override_safe(self):
    method test_unicode_values (line 389) | def test_unicode_values(self):
    method test_keyword_arguments (line 394) | def test_keyword_arguments(self):
    method test_keyword_arguments_safe (line 411) | def test_keyword_arguments_safe(self):
    method test_delimiter_override (line 432) | def test_delimiter_override(self):
  function test_main (line 453) | def test_main():

FILE: third_party/stdlib/test/test_support.py
  class Error (line 51) | class Error(Exception):
  class TestFailed (line 54) | class TestFailed(Error):
  function _waitfor (line 192) | def _waitfor(func, pathname, waitall=False):
  function _unlink (line 225) | def _unlink(filename):
  function _rmdir (line 228) | def _rmdir(dirname):
  function _rmtree (line 231) | def _rmtree(path):
  function unlink (line 247) | def unlink(filename):
  class WarningsRecorder (line 821) | class WarningsRecorder(object):
    method __init__ (line 825) | def __init__(self, warnings_list):
    method __getattr__ (line 829) | def __getattr__(self, attr):
    method warnings (line 837) | def warnings(self):
    method reset (line 840) | def reset(self):
  function _filterwarnings (line 844) | def _filterwarnings(filters, quiet=False):
  function check_warnings (line 884) | def check_warnings(*filters, **kwargs):
  function check_py3k_warnings (line 908) | def check_py3k_warnings(*filters, **kwargs):
  class CleanImport (line 930) | class CleanImport(object):
    method __init__ (line 942) | def __init__(self, *module_names):
    method __enter__ (line 955) | def __enter__(self):
    method __exit__ (line 958) | def __exit__(self, *ignore_exc):
  class EnvironmentVarGuard (line 962) | class EnvironmentVarGuard(UserDict.DictMixin):
    method __init__ (line 967) | def __init__(self):
    method __getitem__ (line 971) | def __getitem__(self, envvar):
    method __setitem__ (line 974) | def __setitem__(self, envvar, value):
    method __delitem__ (line 980) | def __delitem__(self, envvar):
    method keys (line 987) | def keys(self):
    method set (line 990) | def set(self, envvar, value):
    method unset (line 993) | def unset(self, envvar):
    method __enter__ (line 996) | def __enter__(self):
    method __exit__ (line 999) | def __exit__(self, *ignore_exc):
  class BasicTestRunner (line 1374) | class BasicTestRunner(object):
    method run (line 1375) | def run(self, test):
  function _id (line 1380) | def _id(obj):
  function cpython_only (line 1391) | def cpython_only(test):
  function _run_suite (line 1435) | def _run_suite(suite):
  function run_unittest (line 1455) | def run_unittest(*classes):
  function threading_setup (line 1525) | def threading_setup():
  function threading_cleanup (line 1531) | def threading_cleanup(nb_threads):
  function reap_children (line 1560) | def reap_children():

FILE: third_party/stdlib/test/test_threading.py
  class Counter (line 27) | class Counter(object):
    method __init__ (line 28) | def __init__(self):
    method inc (line 30) | def inc(self):
    method dec (line 32) | def dec(self):
    method get (line 34) | def get(self):
  class TestThread (line 37) | class TestThread(threading.Thread):
    method __init__ (line 38) | def __init__(self, name, testcase, sema, mutex, nrunning):
    method run (line 45) | def run(self):
  class BaseTestCase (line 69) | class BaseTestCase(unittest.TestCase):
    method setUp (line 70) | def setUp(self):
    method tearDown (line 73) | def tearDown(self):
  class ThreadTests (line 78) | class ThreadTests(BaseTestCase):
    method test_various_ops (line 82) | def test_various_ops(self):
    method test_ident_of_no_threading_threads (line 113) | def test_ident_of_no_threading_threads(self):
    method test_various_ops_small_stack (line 128) | def test_various_ops_small_stack(self):
    method test_various_ops_large_stack (line 139) | def test_various_ops_large_stack(self):
    method test_foreign_thread (line 149) | def test_foreign_thread(self):
    method test_PyThreadState_SetAsyncExc (line 169) | def test_PyThreadState_SetAsyncExc(self):
    method test_limbo_cleanup (line 258) | def test_limbo_cleanup(self):
    method test_finalize_runnning_thread (line 274) | def test_finalize_runnning_thread(self):
    method test_finalize_with_trace (line 312) | def test_finalize_with_trace(self):
    method test_join_nondaemon_on_shutdown (line 347) | def test_join_nondaemon_on_shutdown(self):
    method test_enumerate_after_join (line 374) | def test_enumerate_after_join(self):
    method test_no_refcycle_through_target (line 394) | def test_no_refcycle_through_target(self):
    method test_dummy_thread_after_fork (line 427) | def test_dummy_thread_after_fork(self):
    method test_is_alive_after_fork (line 454) | def test_is_alive_after_fork(self):
    method test_BoundedSemaphore_limit (line 476) | def test_BoundedSemaphore_limit(self):
  class ThreadJoinOnShutdown (line 494) | class ThreadJoinOnShutdown(BaseTestCase):
    method _run_and_join (line 503) | def _run_and_join(self, script):
    method test_1_join_on_shutdown (line 522) | def test_1_join_on_shutdown(self):
    method test_2_join_in_forked_process (line 538) | def test_2_join_in_forked_process(self):
    method test_3_join_in_forked_from_thread (line 556) | def test_3_join_in_forked_from_thread(self):
    method assertScriptHasOutput (line 578) | def assertScriptHasOutput(self, script, expected_output):
    method test_4_joining_across_fork_in_worker_thread (line 589) | def test_4_joining_across_fork_in_worker_thread(self):
    method test_5_clear_waiter_locks_to_avoid_crash (line 663) | def test_5_clear_waiter_locks_to_avoid_crash(self):
    method test_reinit_tls_after_fork (line 721) | def test_reinit_tls_after_fork(self):
    method test_frame_tstate_tracing (line 745) | def test_frame_tstate_tracing(self):
  class ThreadingExceptionTests (line 784) | class ThreadingExceptionTests(BaseTestCase):
    method test_start_thread_again (line 787) | def test_start_thread_again(self):
    method test_joining_current_thread (line 792) | def test_joining_current_thread(self):
    method test_joining_inactive_thread (line 796) | def test_joining_inactive_thread(self):
    method test_daemonize_active_thread (line 800) | def test_daemonize_active_thread(self):
    method test_print_exception (line 806) | def test_print_exception(self):
    method test_print_exception_stderr_is_none_1 (line 833) | def test_print_exception_stderr_is_none_1(self):
    method test_print_exception_stderr_is_none_2 (line 862) | def test_print_exception_stderr_is_none_2(self):
  class LockTests (line 888) | class LockTests(lock_tests.LockTests):
  class RLockTests (line 891) | class RLockTests(lock_tests.RLockTests):
  class EventTests (line 894) | class EventTests(lock_tests.EventTests):
  class ConditionAsRLockTests (line 897) | class ConditionAsRLockTests(lock_tests.RLockTests):
  class ConditionTests (line 901) | class ConditionTests(lock_tests.ConditionTests):
  class SemaphoreTests (line 904) | class SemaphoreTests(lock_tests.SemaphoreTests):
  class BoundedSemaphoreTests (line 907) | class BoundedSemaphoreTests(lock_tests.BoundedSemaphoreTests):
    method test_recursion_limit (line 912) | def test_recursion_limit(self):
  function test_main (line 943) | def test_main():

FILE: third_party/stdlib/test/test_tuple.py
  class TupleTest (line 5) | class TupleTest(seq_tests.CommonTest):
    method test_constructors (line 8) | def test_constructors(self):
    method test_truth (line 20) | def test_truth(self):
    method test_len (line 25) | def test_len(self):
    method test_iadd (line 31) | def test_iadd(self):
    method test_imul (line 38) | def test_imul(self):
    method test_tupleresizebug (line 45) | def test_tupleresizebug(self):
    method test_hash (line 52) | def test_hash(self):
    method test_repr (line 76) | def test_repr(self):
  function test_main (line 157) | def test_main():

FILE: third_party/stdlib/test/test_uu.py
  class UUTest (line 20) | class UUTest(unittest.TestCase):
    method test_encode (line 22) | def test_encode(self):
    method test_decode (line 32) | def test_decode(self):
    method test_truncatedinput (line 46) | def test_truncatedinput(self):
    method test_missingbegin (line 55) | def test_missingbegin(self):
    method test_garbage_padding (line 64) | def test_garbage_padding(self):
  class UUStdIOTest (line 84) | class UUStdIOTest(unittest.TestCase):
    method setUp (line 86) | def setUp(self):
    method tearDown (line 90) | def tearDown(self):
    method test_encode (line 94) | def test_encode(self):
    method test_decode (line 103) | def test_decode(self):
  class UUFileTest (line 109) | class UUFileTest(unittest.TestCase):
    method _kill (line 111) | def _kill(self, f):
    method setUp (line 126) | def setUp(self):
    method tearDown (line 130) | def tearDown(self):
    method test_encode (line 134) | def test_encode(self):
    method test_decode (line 164) | def test_decode(self):
    method test_decode_filename (line 184) | def test_decode_filename(self):
    method test_decodetwice (line 201) | def test_decodetwice(self):
  function test_main (line 217) | def test_main():

FILE: third_party/stdlib/textwrap.py
  class _unicode (line 17) | class _unicode(object):
  class TextWrapper (line 40) | class TextWrapper(object):
    method __init__ (line 116) | def __init__(self,
    method _munge_whitespace (line 147) | def _munge_whitespace(self, text):
    method _split (line 166) | def _split(self, text):
    method _fix_sentence_endings (line 196) | def _fix_sentence_endings(self, chunks):
    method _handle_long_word (line 214) | def _handle_long_word(self, reversed_chunks, cur_line, cur_len, width):
    method _wrap_chunks (line 247) | def _wrap_chunks(self, chunks):
    method wrap (line 322) | def wrap(self, text):
    method fill (line 337) | def fill(self, text):
  function wrap (line 349) | def wrap(text, width=70, **kwargs):
  function fill (line 362) | def fill(text, width=70, **kwargs):
  function dedent (line 380) | def dedent(text):

FILE: third_party/stdlib/threading.py
  class _Verbose (line 57) | class _Verbose(object):
    method __init__ (line 59) | def __init__(self, verbose=None):
    method _note (line 64) | def _note(self, format, *args):
    method __init__ (line 80) | def __init__(self, verbose=None):
    method _note (line 82) | def _note(self, *args):
  class _Verbose (line 79) | class _Verbose(object):
    method __init__ (line 59) | def __init__(self, verbose=None):
    method _note (line 64) | def _note(self, format, *args):
    method __init__ (line 80) | def __init__(self, verbose=None):
    method _note (line 82) | def _note(self, *args):
  function setprofile (line 90) | def setprofile(func):
  function settrace (line 100) | def settrace(func):
  function RLock (line 114) | def RLock(*args, **kwargs):
  class _RLock (line 125) | class _RLock(_Verbose):
    method __init__ (line 132) | def __init__(self, verbose=None):
    method __repr__ (line 138) | def __repr__(self):
    method acquire (line 147) | def acquire(self, blocking=1):
    method release (line 187) | def release(self):
    method __exit__ (line 215) | def __exit__(self, t, v, tb):
    method _acquire_restore (line 220) | def _acquire_restore(self, count_owner):
    method _release_save (line 228) | def _release_save(self):
    method _is_owned (line 238) | def _is_owned(self):
  function Condition (line 242) | def Condition(*args, **kwargs):
  class _Condition (line 255) | class _Condition(_Verbose):
    method __init__ (line 260) | def __init__(self, lock=None, verbose=None):
    method __enter__ (line 285) | def __enter__(self):
    method __exit__ (line 288) | def __exit__(self, *args):
    method __repr__ (line 291) | def __repr__(self):
    method _release_save (line 294) | def _release_save(self):
    method _acquire_restore (line 297) | def _acquire_restore(self, x):
    method _is_owned (line 300) | def _is_owned(self):
    method wait (line 309) | def wait(self, timeout=None):
    method notify (line 373) | def notify(self, n=1):
    method notifyAll (line 400) | def notifyAll(self):
  function Semaphore (line 412) | def Semaphore(*args, **kwargs):
  class _Semaphore (line 423) | class _Semaphore(_Verbose):
    method __init__ (line 433) | def __init__(self, value=1, verbose=None):
    method acquire (line 440) | def acquire(self, blocking=1):
    method release (line 479) | def release(self):
    method __exit__ (line 493) | def __exit__(self, t, v, tb):
  function BoundedSemaphore (line 497) | def BoundedSemaphore(*args, **kwargs):
  class _BoundedSemaphore (line 515) | class _BoundedSemaphore(_Semaphore):
    method __init__ (line 521) | def __init__(self, value=1, verbose=None):
    method release (line 525) | def release(self):
  function Event (line 542) | def Event(*args, **kwargs):
  class _Event (line 552) | class _Event(_Verbose):
    method __init__ (line 561) | def __init__(self, verbose=None):
    method _reset_internal_locks (line 566) | def _reset_internal_locks(self):
    method isSet (line 570) | def isSet(self):
    method set (line 576) | def set(self):
    method clear (line 587) | def clear(self):
    method wait (line 597) | def wait(self, timeout=None):
  function _newname (line 620) | def _newname(template="Thread-%d"):
  class Thread (line 631) | class Thread(_Verbose):
    method __init__ (line 639) | def __init__(self, group=None, target=None, name=None,
    method _reset_internal_locks (line 680) | def _reset_internal_locks(self):
    method _block (line 688) | def _block(self):
    method _set_daemon (line 692) | def _set_daemon(self):
    method __repr__ (line 696) | def __repr__(self):
    method start (line 709) | def start(self):
    method run (line 735) | def run(self):
    method __bootstrap (line 752) | def __bootstrap(self):
    method _set_ident (line 772) | def _set_ident(self):
    method __bootstrap_inner (line 775) | def __bootstrap_inner(self):
    method __stop (line 849) | def __stop(self):
    method __delete (line 859) | def __delete(self):
    method join (line 894) | def join(self, timeout=None):
    method _name_getter (line 950) | def _name_getter(self):
    method _name_setter (line 960) | def _name_setter(self, name):
    method ident (line 967) | def ident(self):
    method isAlive (line 978) | def isAlive(self):
    method _daemon_getter (line 991) | def _daemon_getter(self):
    method _daemon_setter (line 1006) | def _daemon_setter(self, daemonic):
    method isDaemon (line 1015) | def isDaemon(self):
    method setDaemon (line 1018) | def setDaemon(self, daemonic):
    method getName (line 1021) | def getName(self):
    method setName (line 1024) | def setName(self, name):
  function Timer (line 1029) | def Timer(*args, **kwargs):
  class _Timer (line 1041) | class _Timer(Thread):
    method __init__ (line 1050) | def __init__(self, interval, function, args=[], kwargs={}):
    method cancel (line 1058) | def cancel(self):
    method run (line 1062) | def run(self):
  class _MainThread (line 1071) | class _MainThread(Thread):
    method __init__ (line 1073) | def __init__(self):
    method _set_daemon (line 1080) | def _set_daemon(self):
    method _exitfunc (line 1083) | def _exitfunc(self):
  function _pickSomeNonDaemonThread (line 1096) | def _pickSomeNonDaemonThread():
  class _DummyThread (line 1111) | class _DummyThread(Thread):
    method __init__ (line 1113) | def __init__(self):
    method _set_daemon (line 1126) | def _set_daemon(self):
    method join (line 1129) | def join(self, timeout=None):
  function currentThread (line 1135) | def currentThread():
  function activeCount (line 1150) | def activeCount():
  function _enumerate (line 1162) | def _enumerate():
  function enumerate (line 1166) | def enumerate():
  class _localbase (line 1191) | class _localbase(object):
    method __new__ (line 1194) | def __new__(cls, *args, **kw):
  function _patch (line 1212) | def _patch(self):
  class local (line 1229) | class local(_localbase):
    method __getattribute__ (line 1231) | def __getattribute__(self, name):
    method __setattr__ (line 1240) | def __setattr__(self, name, value):
    method __delattr__ (line 1253) | def __delattr__(self, name):
    method __del__ (line 1266) | def __del__(self):
  function _after_fork (line 1294) | def _after_fork():
  function _test (line 1331) | def _test():

FILE: third_party/stdlib/traceback.py
  function _print (line 12) | def _print(file, str='', terminator='\n'):
  function print_list (line 16) | def print_list(extracted_list, file=None):
  function format_list (line 27) | def format_list(extracted_list):
  function print_tb (line 46) | def print_tb(tb, limit=None, file=None):
  function format_tb (line 74) | def format_tb(tb, limit = None):
  function extract_tb (line 78) | def extract_tb(tb, limit = None):
  function print_exception (line 110) | def print_exception(etype, value, tb, limit=None, file=None):
  function format_exception (line 132) | def format_exception(etype, value, tb, limit = None):
  function format_exception_only (line 149) | def format_exception_only(etype, value):

FILE: third_party/stdlib/types.py
  function _f (line 42) | def _f(): pass
  function _g (line 47) | def _g():
  class _C (line 51) | class _C(object):
    method _m (line 52) | def _m(self): pass

FILE: third_party/stdlib/unittest_case.py
  class KeyboardInterrupt (line 24) | class KeyboardInterrupt(BaseException):
  class SkipTest (line 34) | class SkipTest(Exception):
  class _ExpectedFailure (line 43) | class _ExpectedFailure(Exception):
    method __init__ (line 50) | def __init__(self, exc_info):
  class _UnexpectedSuccess (line 54) | class _UnexpectedSuccess(Exception):
  function _id (line 60) | def _id(obj):
  function skip (line 63) | def skip(reason):
  function skipIf (line 80) | def skipIf(condition, reason):
  function skipUnless (line 88) | def skipUnless(condition, reason):
  function expectedFailure (line 97) | def expectedFailure(func):
  class _AssertRaisesContext (line 109) | class _AssertRaisesContext(object):
    method __init__ (line 112) | def __init__(self, expected, test_case, expected_regexp=None):
    method __enter__ (line 117) | def __enter__(self):
    method __exit__ (line 120) | def __exit__(self, exc_type, exc_value, tb):
  class TestCase (line 143) | class TestCase(object):
    method __init__ (line 191) | def __init__(self, methodName='runTest'):
    method addTypeEqualityFunc (line 221) | def addTypeEqualityFunc(self, typeobj, function):
    method addCleanup (line 236) | def addCleanup(self, function, *args, **kwargs):
    method setUp (line 244) | def setUp(self):
    method tearDown (line 248) | def tearDown(self):
    method setUpClass (line 253) | def setUpClass(cls):
    method tearDownClass (line 258) | def tearDownClass(cls):
    method countTestCases (line 262) | def countTestCases(self):
    method defaultTestResult (line 265) | def defaultTestResult(self):
    method shortDescription (line 268) | def shortDescription(self):
    method id (line 280) | def id(self):
    method __eq__ (line 283) | def __eq__(self, other):
    method __ne__ (line 289) | def __ne__(self, other):
    method __hash__ (line 292) | def __hash__(self):
    method __str__ (line 295) | def __str__(self):
    method __repr__ (line 298) | def __repr__(self):
    method _addSkip (line 302) | def _addSkip(self, result, reason):
    method run (line 311) | def run(self, result=None):
    method doCleanups (line 392) | def doCleanups(self):
    method __call__ (line 408) | def __call__(self, *args, **kwds):
    method debug (line 411) | def debug(self):
    method skipTest (line 420) | def skipTest(self, reason):
    method fail (line 424) | def fail(self, msg=None):
    method assertFalse (line 428) | def assertFalse(self, expr, msg=None):
    method assertTrue (line 434) | def assertTrue(self, expr, msg=None):
    method _formatMessage (line 440) | def _formatMessage(self, msg, standardMsg):
    method assertRaises (line 462) | def assertRaises(self, excClass, callableObj=None, *args, **kwargs):
    method _getAssertEqualityFunc (line 491) | def _getAssertEqualityFunc(self, first, second):
    method _baseAssertEqual (line 517) | def _baseAssertEqual(self, first, second, msg=None):
    method assertEqual (line 524) | def assertEqual(self, first, second, msg=None):
    method assertNotEqual (line 531) | def assertNotEqual(self, first, second, msg=None):
    method assertAlmostEqual (line 541) | def assertAlmostEqual(self, first, second, places=None, msg=None, delt...
    method assertNotAlmostEqual (line 579) | def assertNotAlmostEqual(self, first, second, places=None, msg=None, d...
    method _deprecate (line 623) | def _deprecate(original_func):
    method assertSequenceEqual (line 640) | def assertSequenceEqual(self, seq1, seq2, msg=None, seq_type=None):
    method _truncateMessage (line 743) | def _truncateMessage(self, message, diff):
    method assertListEqual (line 749) | def assertListEqual(self, list1, list2, msg=None):
    method assertTupleEqual (line 761) | def assertTupleEqual(self, tuple1, tuple2, msg=None):
    method assertSetEqual (line 772) | def assertSetEqual(self, set1, set2, msg=None):
    method assertIn (line 815) | def assertIn(self, member, container, msg=None):
    method assertNotIn (line 822) | def assertNotIn(self, member, container, msg=None):
    method assertIs (line 829) | def assertIs(self, expr1, expr2, msg=None):
    method assertIsNot (line 836) | def assertIsNot(self, expr1, expr2, msg=None):
    method assertDictEqual (line 842) | def assertDictEqual(self, d1, d2, msg=None):
    method assertDictContainsSubset (line 854) | def assertDictContainsSubset(self, expected, actual, msg=None):
    method assertItemsEqual (line 880) | def assertItemsEqual(self, expected_seq, actual_seq, msg=None):
    method assertMultiLineEqual (line 920) | def assertMultiLineEqual(self, first, second, msg=None):
    method assertLess (line 943) | def assertLess(self, a, b, msg=None):
    method assertLessEqual (line 949) | def assertLessEqual(self, a, b, msg=None):
    method assertGreater (line 955) | def assertGreater(self, a, b, msg=None):
    method assertGreaterEqual (line 961) | def assertGreaterEqual(self, a, b, msg=None):
    method assertIsNone (line 967) | def assertIsNone(self, obj, msg=None):
    method assertIsNotNone (line 973) | def assertIsNotNone(self, obj, msg=None):
    method assertIsInstance (line 979) | def assertIsInstance(self, obj, cls, msg=None):
    method assertNotIsInstance (line 986) | def assertNotIsInstance(self, obj, cls, msg=None):
    method assertRaisesRegexp (line 992) | def assertRaisesRegexp(self, expected_exception, expected_regexp,
    method assertRegexpMatches (line 1012) | def assertRegexpMatches(self, text, expected_regexp, msg=None):
    method assertNotRegexpMatches (line 1021) | def assertNotRegexpMatches(self, text, unexpected_regexp, msg=None):
  class FunctionTestCase (line 1035) | class FunctionTestCase(TestCase):
    method __init__ (line 1044) | def __init__(self, testFunc, setUp=None, tearDown=None, description=No...
    method setUp (line 1051) | def setUp(self):
    method tearDown (line 1055) | def tearDown(self):
    method runTest (line 1059) | def runTest(self):
    method id (line 1062) | def id(self):
    method __eq__ (line 1065) | def __eq__(self, other):
    method __ne__ (line 1074) | def __ne__(self, other):
    method __hash__ (line 1077) | def __hash__(self):
    method __str__ (line 1081) | def __str__(self):
    method __repr__ (line 1085) | def __repr__(self):
    method shortDescription (line 1089) | def shortDescription(self):

FILE: third_party/stdlib/unittest_loader.py
  function _make_failed_import_test (line 28) | def _make_failed_import_test(name, suiteClass):
  function _make_failed_load_tests (line 33) | def _make_failed_load_tests(name, exception, suiteClass):
  function _make_failed_test (line 36) | def _make_failed_test(classname, methodname, exception, suiteClass):
  class TestLoader (line 44) | class TestLoader(object):
    method loadTestsFromTestCase (line 54) | def loadTestsFromTestCase(self, testCaseClass):
    method loadTestsFromModule (line 65) | def loadTestsFromModule(self, module, use_load_tests=True):
    method loadTestsFromName (line 83) | def loadTestsFromName(self, name, module=None):
    method loadTestsFromNames (line 132) | def loadTestsFromNames(self, names, module=None):
    method getTestCaseNames (line 139) | def getTestCaseNames(self, testCaseClass):
    method discover (line 152) | def discover(self, start_dir, pattern='test*.py', top_level_dir=None):
    method _get_directory_containing_module (line 216) | def _get_directory_containing_module(self, module_name):
    method _get_name_from_path (line 228) | def _get_name_from_path(self, path):
    method _get_module_from_name (line 238) | def _get_module_from_name(self, name):
    method _match_path (line 242) | def _match_path(self, path, full_path, pattern):
    method _find_tests (line 246) | def _find_tests(self, start_dir, pattern):
  function _makeLoader (line 306) | def _makeLoader(prefix, sortUsing, suiteClass=None):
  function getTestCaseNames (line 314) | def getTestCaseNames(testCaseClass, prefix, sortUsing=cmp):
  function makeSuite (line 317) | def makeSuite(testCaseClass, prefix='test', sortUsing=cmp,
  function findTestCases (line 321) | def findTestCases(module, prefix='test', sortUsing=cmp,

FILE: third_party/stdlib/unittest_result.py
  function failfast (line 19) | def failfast(method):
  class TestResult (line 32) | class TestResult(object):
    method __init__ (line 46) | def __init__(self, stream=None, descriptions=None, verbosity=None):
    method printErrors (line 62) | def printErrors(self):
    method startTest (line 65) | def startTest(self, test):
    method _setupStdout (line 71) | def _setupStdout(self):
    method startTestRun (line 79) | def startTestRun(self):
    method stopTest (line 85) | def stopTest(self, test):
    method _restoreStdout (line 90) | def _restoreStdout(self):
    method stopTestRun (line 111) | def stopTestRun(self):
    method addError (line 118) | def addError(self, test, err):
    method addFailure (line 127) | def addFailure(self, test, err):
    method addSuccess (line 134) | def addSuccess(self, test):
    method addSkip (line 138) | def addSkip(self, test, reason):
    method addExpectedFailure (line 142) | def addExpectedFailure(self, test, err):
    method addUnexpectedSuccess (line 148) | def addUnexpectedSuccess(self, test):
    method wasSuccessful (line 153) | def wasSuccessful(self):
    method stop (line 157) | def stop(self):
    method _exc_info_to_string (line 161) | def _exc_info_to_string(self, err, test):
    method _is_relevant_tb_level (line 189) | def _is_relevant_tb_level(self, tb):
    method _count_relevant_tb_levels (line 192) | def _count_relevant_tb_levels(self, tb):
    method __repr__ (line 199) | def __repr__(self):

FILE: third_party/stdlib/unittest_runner.py
  class _WritelnDecorator (line 15) | class _WritelnDecorator(object):
    method __init__ (line 17) | def __init__(self, stream):
    method __getattr__ (line 20) | def __getattr__(self, attr):
    method writeln (line 25) | def writeln(self, arg=None):
    method write (line 30) | def write(self, arg):
    method flush (line 33) | def flush(self):
  class TextTestResult (line 36) | class TextTestResult(result.TestResult):
    method __init__ (line 44) | def __init__(self, stream, descriptions, verbosity):
    method getDescription (line 51) | def getDescription(self, test):
    method startTest (line 58) | def startTest(self, test):
    method addSuccess (line 65) | def addSuccess(self, test):
    method addError (line 73) | def addError(self, test, err):
    method addFailure (line 81) | def addFailure(self, test, err):
    method addSkip (line 89) | def addSkip(self, test, reason):
    method addExpectedFailure (line 98) | def addExpectedFailure(self, test, err):
    method addUnexpectedSuccess (line 106) | def addUnexpectedSuccess(self, test):
    method printErrors (line 114) | def printErrors(self):
    method printErrorList (line 120) | def printErrorList(self, flavour, errors):
  class TextTestRunner (line 128) | class TextTestRunner(object):
    method __init__ (line 136) | def __init__(self, stream=sys.stderr, descriptions=True, verbosity=1,
    method _makeResult (line 146) | def _makeResult(self):
    method run (line 149) | def run(self, test):

FILE: third_party/stdlib/unittest_signals.py
  class _InterruptHandler (line 12) | class _InterruptHandler(object):
  function registerResult (line 48) | def registerResult(result):
  function removeResult (line 51) | def removeResult(result):
  function installHandler (line 55) | def installHandler():
  function removeHandler (line 64) | def removeHandler(method=None):

FILE: third_party/stdlib/unittest_suite.py
  function _call_if_exists (line 13) | def _call_if_exists(parent, attr):
  class BaseTestSuite (line 18) | class BaseTestSuite(object):
    method __init__ (line 21) | def __init__(self, tests=()):
    method __repr__ (line 25) | def __repr__(self):
    method __eq__ (line 28) | def __eq__(self, other):
    method __ne__ (line 33) | def __ne__(self, other):
    method __iter__ (line 39) | def __iter__(self):
    method countTestCases (line 42) | def countTestCases(self):
    method addTest (line 48) | def addTest(self, test):
    method addTests (line 59) | def addTests(self, tests):
    method run (line 65) | def run(self, result):
    method __call__ (line 72) | def __call__(self, *args, **kwds):
    method debug (line 75) | def debug(self):
  class TestSuite (line 81) | class TestSuite(BaseTestSuite):
    method run (line 91) | def run(self, result, debug=False):
    method debug (line 121) | def debug(self):
    method _handleClassSetUp (line 128) | def _handleClassSetUp(self, test, result):
    method _get_previous_module (line 160) | def _get_previous_module(self, result):
    method _handleModuleFixture (line 168) | def _handleModuleFixture(self, test, result):
    method _addClassOrModuleLevelException (line 195) | def _addClassOrModuleLevelException(self, result, exception, errorName):
    method _handleModuleTearDown (line 203) | def _handleModuleTearDown(self, result):
    method _tearDownPreviousClass (line 228) | def _tearDownPreviousClass(self, test, result):
  class _ErrorHolder (line 255) | class _ErrorHolder(object):
    method __init__ (line 267) | def __init__(self, description):
    method id (line 270) | def id(self):
    method shortDescription (line 273) | def shortDescription(self):
    method __repr__ (line 276) | def __repr__(self):
    method __str__ (line 279) | def __str__(self):
    method run (line 282) | def run(self, result):
    method __call__ (line 287) | def __call__(self, result):
    method countTestCases (line 290) | def countTestCases(self):
  function _isnotsuite (line 293) | def _isnotsuite(test):
  class _DebugResult (line 302) | class _DebugResult(object):

FILE: third_party/stdlib/unittest_util.py
  function safe_repr (line 12) | def safe_repr(obj, short=False):
  function strclass (line 22) | def strclass(cls):
  function sorted_list_difference (line 25) | def sorted_list_difference(expected, actual):
  function unorderable_list_difference (line 66) | def unorderable_list_difference(expected, actual, ignore_duplicate=False):
  class _Mismatch (line 103) | class _Mismatch(tuple):
    method __new__ (line 110) | def __new__(_cls, actual, expected, value):
    method _make (line 115) | def _make(cls, iterable, new=tuple.__new__, len=len):
    method __repr__ (line 123) | def __repr__(self):
    method _asdict (line 127) | def _asdict(self):
    method _replace (line 132) | def _replace(_self, **kwds):
    method __getnewargs__ (line 139) | def __getnewargs__(self):
    method __getstate__ (line 145) | def __getstate__(self):
  function _count_diff_all_purpose (line 155) | def _count_diff_all_purpose(actual, expected):
  function _ordered_count (line 190) | def _ordered_count(iterable):
  function _count_diff_hashable (line 197) | def _count_diff_hashable(actual, expected):

FILE: third_party/stdlib/urlparse.py
  function clear_cache (line 74) | def clear_cache():
  class ResultMixin (line 79) | class ResultMixin(object):
    method username (line 83) | def username(self):
    method password (line 94) | def password(self):
    method hostname (line 104) | def hostname(self):
    method port (line 117) | def port(self):
  class _SplitResult (line 130) | class _SplitResult(tuple):
    method __new__ (line 137) | def __new__(_cls, scheme, netloc, path, query, fragment):
    method _make (line 142) | def _make(cls, iterable, new=tuple.__new__, len=len):
    method __repr__ (line 150) | def __repr__(self):
    method _asdict (line 154) | def _asdict(self):
    method _replace (line 158) | def _replace(_self, **kwds):
    method __getnewargs__ (line 165) | def __getnewargs__(self):
    method __getstate__ (line 171) | def __getstate__(self):
  class SplitResult (line 186) | class SplitResult(_SplitResult, ResultMixin):
    method geturl (line 190) | def geturl(self):
  class _ParseResult (line 193) | class _ParseResult(tuple):
    method __new__ (line 200) | def __new__(_cls, scheme, netloc, path, params, query, fragment):
    method _make (line 205) | def _make(cls, iterable, new=tuple.__new__, len=len):
    method __repr__ (line 213) | def __repr__(self):
    method _asdict (line 217) | def _asdict(self):
    method _replace (line 221) | def _replace(_self, **kwds):
    method __getnewargs__ (line 228) | def __getnewargs__(self):
    method __getstate__ (line 234) | def __getstate__(self):
  class ParseResult (line 251) | class ParseResult(_ParseResult, ResultMixin):
    method geturl (line 255) | def geturl(self):
  function urlparse (line 259) | def urlparse(url, scheme='', allow_fragments=True):
  function _splitparams (line 273) | def _splitparams(url):
  function _splitnetloc (line 282) | def _splitnetloc(url, start=0):
  function urlsplit (line 290) | def urlsplit(url, scheme='', allow_fragments=True):
  function urlunparse (line 345) | def urlunparse(data):
  function urlunsplit (line 355) | def urlunsplit(data):
  function urljoin (line 373) | def urljoin(base, url, allow_fragments=True):
  function urldefrag (line 425) | def urldefrag(url):
  function _is_unicode (line 442) | def _is_unicode(x):
  function _is_unicode (line 445) | def _is_unicode(x):
  function unquote (line 458) | def unquote(s):
  function parse_qs (line 486) | def parse_qs(qs, keep_blank_values=0, strict_parsing=0):
  function parse_qsl (line 512) | def parse_qsl(qs, keep_blank_values=0, strict_parsing=0):

FILE: third_party/stdlib/uu.py
  class Error (line 39) | class Error(Exception):
  function encode (line 42) | def encode(in_file, out_file, name=None, mode=None):
  function decode (line 90) | def decode(in_file, out_file=None, mode=None, quiet=0):
  function test (line 158) | def test():

FILE: third_party/stdlib/warnings.py
  function warnpy3k (line 16) | def warnpy3k(message, category=None, stacklevel=1):
  function _show_warning (line 26) | def _show_warning(message, category, filename, lineno, file=None, line=N...
  function formatwarning (line 41) | def formatwarning(message, category, filename, lineno, line=None):
  function filterwarnings (line 68) | def filterwarnings(action, message="", category=Warning, module="", line...
  function simplefilter (line 95) | def simplefilter(action, category=Warning, lineno=0, append=0):
  function resetwarnings (line 115) | def resetwarnings():
  class _OptionError (line 119) | class _OptionError(Exception):
  function _processoptions (line 124) | def _processoptions(args):
  function _setoption (line 132) | def _setoption(arg):
  function _getaction (line 158) | def _getaction(action):
  function _getcategory (line 168) | def _getcategory(category):
  function warn (line 194) | def warn(message, category=None, stacklevel=1):
  function warn_explicit (line 234) | def warn_explicit(message, category, filename, lineno,
  class WarningMessage (line 300) | class WarningMessage(object):
    method __init__ (line 307) | def __init__(self, message, category, filename, lineno, file=None,
    method __str__ (line 314) | def __str__(self):
  class catch_warnings (line 320) | class catch_warnings(object):
    method __init__ (line 337) | def __init__(self, record=False, module=None):
    method __repr__ (line 349) | def __repr__(self):
    method __enter__ (line 358) | def __enter__(self):
    method __exit__ (line 374) | def __exit__(self, *exc_info):

FILE: third_party/stdlib/weakref.py
  class WeakValueDictionary (line 41) | class WeakValueDictionary(UserDict.UserDict):
    method __init__ (line 53) | def __init__(*args, **kw):
    method _commit_removals (line 74) | def _commit_removals(self):
    method __getitem__ (line 82) | def __getitem__(self, key):
    method __delitem__ (line 89) | def __delitem__(self, key):
    method __contains__ (line 94) | def __contains__(self, key):
    method has_key (line 101) | def has_key(self, key):
    method __repr__ (line 108) | def __repr__(self):
    method __setitem__ (line 111) | def __setitem__(self, key, value):
    method clear (line 116) | def clear(self):
    method copy (line 121) | def copy(self):
    method __deepcopy__ (line 131) | def __deepcopy__(self, memo):
    method get (line 140) | def get(self, key, default=None):
    method items (line 153) | def items(self):
    method iteritems (line 161) | def iteritems(self):
    method iterkeys (line 168) | def iterkeys(self):
    method itervaluerefs (line 175) | def itervaluerefs(self):
    method itervalues (line 189) | def itervalues(self):
    method popitem (line 196) | def popitem(self):
    method pop (line 205) | def pop(self, key, *args):
    method setdefault (line 219) | def setdefault(self, key, default=None):
    method update (line 230) | def update(*args, **kwargs):
    method valuerefs (line 250) | def valuerefs(self):
    method values (line 262) | def values(self):
  class KeyedRef (line 271) | class KeyedRef(ref):
    method __new__ (line 283) | def __new__(type, ob, callback, key):
    method __init__ (line 288) | def __init__(self, ob, callback, key):
  class WeakKeyDictionary (line 292) | class WeakKeyDictionary(UserDict.UserDict):
    method __init__ (line 303) | def __init__(self, dict=None):
    method _commit_removals (line 319) | def _commit_removals(self):
    method __delitem__ (line 332) | def __delitem__(self, key):
    method __getitem__ (line 335) | def __getitem__(self, key):
    method __repr__ (line 338) | def __repr__(self):
    method __setitem__ (line 341) | def __setitem__(self, key, value):
    method copy (line 344) | def copy(self):
    method __deepcopy__ (line 354) | def __deepcopy__(self, memo):
    method get (line 363) | def get(self, key, default=None):
    method has_key (line 366) | def has_key(self, key):
    method __contains__ (line 373) | def __contains__(self, key):
    method items (line 380) | def items(self):
    method iteritems (line 388) | def iteritems(self):
    method iterkeyrefs (line 395) | def iterkeyrefs(self):
    method iterkeys (line 409) | def iterkeys(self):
    method itervalues (line 418) | def itervalues(self):
    method keyrefs (line 423) | def keyrefs(self):
    method keys (line 435) | def keys(self):
    method popitem (line 443) | def popitem(self):
    method pop (line 450) | def pop(self, key, *args):
    method setdefault (line 453) | def setdefault(self, key, default=None):
    method update (line 456) | def update(self, dict=None, **kwargs):

FILE: tools/pkgc.go
  constant packageTemplate (line 29) | packageTemplate = `package %[1]s
  constant typeTemplate (line 45) | typeTemplate = `	if true {
  constant varTemplate (line 55) | varTemplate = `	if o, raised := grumpy.WrapNative(f, reflect.ValueOf(%[1...
  function getConst (line 62) | func getConst(name string, v constant.Value) string {
  function main (line 81) | func main() {