def checkfilename(brokencode):
     try:
         symtable.symtable(brokencode, "spam", "exec")
     except SyntaxError as e:
         self.assertEqual(e.filename, "spam")
     else:
         self.fail("no SyntaxError for %r" % (brokencode,))

 def test_annotated(self):
     st1 = symtable.symtable('def f():\n    x: int\n', 'test', 'exec')
     st2 = st1.get_children()[0]
     self.assertTrue(st2.lookup('x').is_local())
     self.assertTrue(st2.lookup('x').is_annotated())
     self.assertFalse(st2.lookup('x').is_global())
     st3 = symtable.symtable('def f():\n    x = 1\n', 'test', 'exec')
     st4 = st3.get_children()[0]
     self.assertTrue(st4.lookup('x').is_local())
     self.assertFalse(st4.lookup('x').is_annotated())

def __tests():
    import symtable

    class ClassFinder(ast.NodeVisitor):
        def __init__(self, name):
            ast.NodeVisitor.__init__(self)
            self.name = name
            self.classes = []

        def visit_ClassDef(self, node):
            if node.name == self.name:
                self.classes.append(node)

    with open('tests/game2.py') as source_file:
        code = source_file.read()
        ast_node = ast.parse(code)
        symbol_table = symtable.symtable(code, 'game2.py', 'exec')
        class_finder = ClassFinder('Game')
        class_finder.visit(ast_node)
        subclass = class_finder.classes[0]
        subclass_symbol_table = symbol_table.lookup('Game').get_namespace()
        superclasses, subclass = SuperClassExtractor.extract_into_ideal_cohesion(subclass, subclass_symbol_table)
        for superclass_node in superclasses:
            print to_source(superclass_node)
            # print
            # print ast.dump(superclass_node)
            print
            print '#' * 200
            print
        print to_source(subclass)

 def __init__(self, code, ns=None):
     global __default_namespace__
     if ns is None:
         ns = __default_namespace__
     var = [v for v in symtable.symtable(code, '<string>', 'exec').get_identifiers() if v in ns]
     super(PythonCode, self).__init__(var=var, namespace=ns)
     self.code = compile(code, '<string>', 'exec')

def parse_module(module_name):
    filename = module_name + ".py"
    with open(os.path.join(SOLUTIONS_DIR, filename), 'r') as f:
        source = f.read()

    srclines = source.splitlines()
    module = ast.parse(source, filename)
    table = symtable.symtable(source, filename, "exec")
    stmts = list(get_stmts(module))
    last_fun = stmts[0][0]
    lines = {name:"\n".join(srclines[s:e]).strip() for (name,(s,e)) in stmts}
    imports = dict(get_imports(module))

    def parse_dependencies(name):
        import builtins
        for tab in get_child_tables(table.lookup(name).get_namespace()):
            for g in tab.get_globals():
                if g in dir(builtins):
                    continue

                if table.lookup(g).is_imported():
                    imported = imports[g]
                    if imported[0] != "leetcode":
                        yield imported
                else:
                    yield (module_name, g)

    return last_fun, lines, {name:tuple(parse_dependencies(name)) for name in lines}

 def _inspect(self,string):
   symtab = symtable.symtable(string,'rule',self.mode)
   symbols = symtab.get_symbols()
   defs = [sym.get_name() for sym in symbols if sym.is_assigned()]
   refs = [sym.get_name() for sym in symbols if sym.is_referenced()]
   self.all_symbols = frozenset(symtab.get_identifiers())
   self.sym_assigned = defset = frozenset(defs)
   self.sym_internal = frozenset(defset.intersection(refs))

 def __find_class_symbol_tables(self):
     class_names = self.__get_class_names()
     source_code = self.get_source_code()
     module_symbol_table = symtable.symtable(source_code, self.file_path, 'exec')
     symbol_tables = []
     for name in class_names:
         class_symbol_table = module_symbol_table.lookup(name).get_namespace()
         symbol_tables.append(class_symbol_table)
     return symbol_tables

def get_symtable(path):
	import symtable
	try:
		st = symtables[path]
	except KeyError:
		with open(path, 'r') as f:
			st = symtable.symtable(f.read(), path, 'exec')
		symtables[path] = st
	return st

 def __init__(self, source_no_encoding, pubapi):
     # Our public API (__all__)
     self.pubapi = pubapi
     # Names of imported modules
     self.modnames = []
     self.symtab = symtable.symtable(source_no_encoding, "-", "exec")
     cst = parser.suite(source_no_encoding)
     elements = parser.ast2tuple(cst, line_info=1)
     self.names = {}
     self.walk(elements, [self.symtab])

 def __init__(self, source, path='<string>'):
     self.source = source
     self.path = path
     self.ast = ast.parse(source, path)
     self.symtable = symtable.symtable(source, path, 'exec')
     self.tokens = tokenize_string(source)
     cw = ChainWalker(self.ast, self.symtable)
     self.nodes = cw.nodes
     TokenAssociator(self.nodes, self.tokens)
     self.ast_map = {node.ast_node: node for node in self.nodes}

def format_table(code_string):
    s_table = symtable(code_string, "string", "exec")
    table = []
    for child in s_table.get_children():
        row = {
            "name": child.get_name(),
            "scope": "global",
            "children": [subchild.get_name() for subchild in child.get_children()],
        }
        table.append(row)
    return s_table, table

 def getDefinitions(self, doc, identifier):
     if doc.get_language().get_name() != "Python":
         return
     doc_location = doc.get_location()
     with open(doc_location.get_path()) as f:
         table = symtable.symtable(
             f.read(),
             doc_location.get_basename(),
             "exec",
         )
         for line in self.generateDefLines(table, identifier):
             yield doc_location, line, "", doc_location.get_path()

    def load_file(filename):
        filename = os.path.abspath(filename)
        with open(filename) as fp:
            syminfo = symtable.symtable(fp.read() + '\n', filename, 'exec')

        if(os.path.splitext(filename)[1] == '.py'):
            try:
                py_compile.compile(filename, filename+'c', doraise=True)
            except py_compile.PyCompileError, msg:
                print str(msg)
                print 'Couldn\'t compile %s, stopping.' % filename
                os._exit(0)
            filename += 'c'

    def test_annotated(self):
        st1 = symtable.symtable('def f():\n    x: int\n', 'test', 'exec')
        st2 = st1.get_children()[0]
        self.assertTrue(st2.lookup('x').is_local())
        self.assertTrue(st2.lookup('x').is_annotated())
        self.assertFalse(st2.lookup('x').is_global())
        st3 = symtable.symtable('def f():\n    x = 1\n', 'test', 'exec')
        st4 = st3.get_children()[0]
        self.assertTrue(st4.lookup('x').is_local())
        self.assertFalse(st4.lookup('x').is_annotated())

        # Test that annotations in the global scope are valid after the
        # variable is declared as nonlocal.
        st5 = symtable.symtable('global x\nx: int', 'test', 'exec')
        self.assertTrue(st5.lookup("x").is_global())

        # Test that annotations for nonlocals are valid after the
        # variable is declared as nonlocal.
        st6 = symtable.symtable('def g():\n'
                                '    x = 2\n'
                                '    def f():\n'
                                '        nonlocal x\n'
                                '    x: int',
                                'test', 'exec')

 def test_filename_correct(self):
     ### Bug tickler: SyntaxError file name correct whether error raised
     ### while parsing or building symbol table.
     def checkfilename(brokencode):
         try:
             symtable.symtable(brokencode, "spam", "exec")
         except SyntaxError as e:
             self.assertEqual(e.filename, "spam")
         else:
             self.fail("no SyntaxError for %r" % (brokencode,))
     checkfilename("def f(x): foo)(")  # parse-time
     checkfilename("def f(x): global x")  # symtable-build-time
     symtable.symtable("pass", b"spam", "exec")
     with self.assertRaises(TypeError):
         symtable.symtable("pass", bytearray(b"spam"), "exec")
     symtable.symtable("pass", memoryview(b"spam"), "exec")
     with self.assertRaises(TypeError):
         symtable.symtable("pass", list(b"spam"), "exec")

def symtabdump(fn):
    if not os.path.exists(fn):
        print "%s doesn't exist" % fn
        raise SystemExit()
    text = open(fn).read()
    mod = symtable.symtable(text, os.path.split(fn)[1], "exec")
    def getidents(obj, indent=""):
        ret = ""
        ret += """%sSym_type: %s
%sSym_name: %s
%sSym_lineno: %s
%sSym_nested: %s
%sSym_haschildren: %s
""" % (
        indent, obj.get_type(),
        indent, obj.get_name(),
        indent, obj.get_lineno(),
        indent, obj.is_nested(),
        indent, obj.has_children())
        if obj.get_type() == "function":
            ret += "%sFunc_params: %s\n%sFunc_locals: %s\n%sFunc_globals: %s\n%sFunc_frees: %s\n" % (
                    indent, sorted(obj.get_parameters()),
                    indent, sorted(obj.get_locals()),
                    indent, sorted(obj.get_globals()),
                    indent, sorted(obj.get_frees()))
        elif obj.get_type() == "class":
            ret += "%sClass_methods: %s\n" % (
                    indent, sorted(obj.get_methods()))
        ret += "%s-- Identifiers --\n" % indent
        for ident in sorted(obj.get_identifiers()):
            info = obj.lookup(ident)
            ret += "%sname: %s\n  %sis_referenced: %s\n  %sis_imported: %s\n  %sis_parameter: %s\n  %sis_global: %s\n  %sis_declared_global: %s\n  %sis_local: %s\n  %sis_free: %s\n  %sis_assigned: %s\n  %sis_namespace: %s\n  %snamespaces: [\n%s  %s]\n" % (
                    indent, info.get_name(),
                    indent, info.is_referenced(),
                    indent, info.is_imported(),
                    indent, info.is_parameter(),
                    indent, info.is_global(),
                    indent, info.is_declared_global(),
                    indent, info.is_local(),
                    indent, info.is_free(),
                    indent, info.is_assigned(),
                    indent, info.is_namespace(),
                    indent, '\n'.join([getidents(x, indent + "    ") for x in info.get_namespaces()]),
                    indent
                    )
        return ret
    return getidents(mod)

def to_one_line(original):
    # original :: string
    # :: string
    t = ast.parse(original)
    table = symtable.symtable(original, '<string>', 'exec')

    original = original.strip()

    # If there's only one line anyways, be lazy
    if len(original.splitlines()) == 1 and \
       len(t.body) == 1 and \
       type(t.body[0]) in (ast.Delete, ast.Assign, ast.AugAssign, ast.Print,
                           ast.Raise, ast.Assert, ast.Import, ast.ImportFrom,
                           ast.Exec, ast.Global, ast.Expr, ast.Pass):
        return original

    return get_init_code(t, table)

 def __init__(self, name="", path=None, file_name="<unknown>", code=None):
     CKClass.__init__(self, name, None, None, None)
     self.path = path
     self.descriptor = pyclbr.readmodule_ex(self.name, path)
     self.file_name = file_name
     self.code = code
     if self.code:
         self.symbol_table = symtable.symtable(self.code, self.file_name, 'exec')
         self.ast_node = ast.parse(self.code, self.file_name)
     self.classes = {}
     class_node_finder = ClassNodeFinder(self.ast_node)
     for class_name in self.descriptor.keys():
         class_descriptor = self.descriptor[class_name]
         if isinstance(class_descriptor, pyclbr.Class):
             if class_descriptor.module == self.name:
                 class_table = self.symbol_table.lookup(class_name).get_namespace()
                 class_node = class_node_finder.find(class_name)
                 ck_class = CKClass(class_name, class_descriptor, class_table, class_node)
                 ck_class.extract_references()
                 self.classes[self.name + "." + class_name] = ck_class

def parse_code(source_code, filename='app.py'):
    # type: (str, str) -> ParsedCode
    parsed = ast.parse(source_code, filename)
    table = symtable.symtable(source_code, filename, 'exec')
    return ParsedCode(parsed, ChainedSymbolTable(table, table))

if __name__ == "__main__":
    import sys
    from compiler import parseFile, walk
    import symtable

    def get_names(syms):
        return [s for s in [s.get_name() for s in syms.get_symbols()]
                if not (s.startswith('_[') or s.startswith('.'))]

    for file in sys.argv[1:]:
        print file
        f = open(file)
        buf = f.read()
        f.close()
        syms = symtable.symtable(buf, file, "exec")
        mod_names = get_names(syms)
        tree = parseFile(file)
        s = SymbolVisitor()
        walk(tree, s)

        # compare module-level symbols
        names2 = s.scopes[tree].get_names()

        if not list_eq(mod_names, names2):
            print
            print "oops", file
            print sorted(mod_names)
            print sorted(names2)
            sys.exit(-1)