Yu1709$!%yuyu!$%wutu!5=126+

                
____  ___       .__                 
\   \/  /  _____|  |   ______  _  __
 \     /  /  ___/  |  /  _ \ \/ \/ /
 /     \  \___ \|  |_(  <_> )     / 
/___/\  \/____  >____/\____/ \/\_/  
      \_/     \/    @ligmakokz

Editing: symtable.py

"""Interface to the compiler's internal symbol tables"""

import _symtable
from _symtable import (USE, DEF_GLOBAL, DEF_LOCAL, DEF_PARAM,
     DEF_IMPORT, DEF_BOUND, DEF_ANNOT, SCOPE_OFF, SCOPE_MASK, FREE,
     LOCAL, GLOBAL_IMPLICIT, GLOBAL_EXPLICIT, CELL)

import weakref

__all__ = ["symtable", "SymbolTable", "Class", "Function", "Symbol"]

def symtable(code, filename, compile_type):
    top = _symtable.symtable(code, filename, compile_type)
    return _newSymbolTable(top, filename)

class SymbolTableFactory:
    def __init__(self):
        self.__memo = weakref.WeakValueDictionary()

def new(self, table, filename):
        if table.type == _symtable.TYPE_FUNCTION:
            return Function(table, filename)
        if table.type == _symtable.TYPE_CLASS:
            return Class(table, filename)
        return SymbolTable(table, filename)

def __call__(self, table, filename):
        key = table, filename
        obj = self.__memo.get(key, None)
        if obj is None:
            obj = self.__memo[key] = self.new(table, filename)
        return obj

_newSymbolTable = SymbolTableFactory()

class SymbolTable(object):

def __init__(self, raw_table, filename):
        self._table = raw_table
        self._filename = filename
        self._symbols = {}

def __repr__(self):
        if self.__class__ == SymbolTable:
            kind = ""
        else:
            kind = "%s " % self.__class__.__name__

if self._table.name == "global":
            return "<{0}SymbolTable for module {1}>".format(kind, self._filename)
        else:
            return "<{0}SymbolTable for {1} in {2}>".format(kind,
                                                            self._table.name,
                                                            self._filename)

def get_type(self):
        if self._table.type == _symtable.TYPE_MODULE:
            return "module"
        if self._table.type == _symtable.TYPE_FUNCTION:
            return "function"
        if self._table.type == _symtable.TYPE_CLASS:
            return "class"
        assert self._table.type in (1, 2, 3), \
               "unexpected type: {0}".format(self._table.type)

def get_id(self):
        return self._table.id

def get_name(self):
        return self._table.name

def get_lineno(self):
        return self._table.lineno

def is_optimized(self):
        return bool(self._table.type == _symtable.TYPE_FUNCTION)

def is_nested(self):
        return bool(self._table.nested)

def has_children(self):
        return bool(self._table.children)

def has_exec(self):
        """Return true if the scope uses exec.  Deprecated method."""
        return False

def get_identifiers(self):
        return self._table.symbols.keys()

def lookup(self, name):
        sym = self._symbols.get(name)
        if sym is None:
            flags = self._table.symbols[name]
            namespaces = self.__check_children(name)
            sym = self._symbols[name] = Symbol(name, flags, namespaces)
        return sym

def get_symbols(self):
        return [self.lookup(ident) for ident in self.get_identifiers()]

def __check_children(self, name):
        return [_newSymbolTable(st, self._filename)
                for st in self._table.children
                if st.name == name]

def get_children(self):
        return [_newSymbolTable(st, self._filename)
                for st in self._table.children]

class Function(SymbolTable):

# Default values for instance variables
    __params = None
    __locals = None
    __frees = None
    __globals = None

def __idents_matching(self, test_func):
        return tuple([ident for ident in self.get_identifiers()
                      if test_func(self._table.symbols[ident])])

def get_parameters(self):
        if self.__params is None:
            self.__params = self.__idents_matching(lambda x:x & DEF_PARAM)
        return self.__params

def get_locals(self):
        if self.__locals is None:
            locs = (LOCAL, CELL)
            test = lambda x: ((x >> SCOPE_OFF) & SCOPE_MASK) in locs
            self.__locals = self.__idents_matching(test)
        return self.__locals

def get_globals(self):
        if self.__globals is None:
            glob = (GLOBAL_IMPLICIT, GLOBAL_EXPLICIT)
            test = lambda x:((x >> SCOPE_OFF) & SCOPE_MASK) in glob
            self.__globals = self.__idents_matching(test)
        return self.__globals

def get_frees(self):
        if self.__frees is None:
            is_free = lambda x:((x >> SCOPE_OFF) & SCOPE_MASK) == FREE
            self.__frees = self.__idents_matching(is_free)
        return self.__frees

class Class(SymbolTable):

__methods = None

def get_methods(self):
        if self.__methods is None:
            d = {}
            for st in self._table.children:
                d[st.name] = 1
            self.__methods = tuple(d)
        return self.__methods

class Symbol(object):

def __init__(self, name, flags, namespaces=None):
        self.__name = name
        self.__flags = flags
        self.__scope = (flags >> SCOPE_OFF) & SCOPE_MASK # like PyST_GetScope()
        self.__namespaces = namespaces or ()

def __repr__(self):
        return "<symbol {0!r}>".format(self.__name)

def get_name(self):
        return self.__name

def is_referenced(self):
        return bool(self.__flags & _symtable.USE)

def is_parameter(self):
        return bool(self.__flags & DEF_PARAM)

def is_global(self):
        return bool(self.__scope in (GLOBAL_IMPLICIT, GLOBAL_EXPLICIT))

def is_declared_global(self):
        return bool(self.__scope == GLOBAL_EXPLICIT)

def is_local(self):
        return bool(self.__flags & DEF_BOUND)

def is_annotated(self):
        return bool(self.__flags & DEF_ANNOT)

def is_free(self):
        return bool(self.__scope == FREE)

def is_imported(self):
        return bool(self.__flags & DEF_IMPORT)

def is_assigned(self):
        return bool(self.__flags & DEF_LOCAL)

def is_namespace(self):
        """Returns true if name binding introduces new namespace.

If the name is used as the target of a function or class
        statement, this will be true.

Note that a single name can be bound to multiple objects.  If
        is_namespace() is true, the name may also be bound to other
        objects, like an int or list, that does not introduce a new
        namespace.
        """
        return bool(self.__namespaces)

def get_namespaces(self):
        """Return a list of namespaces bound to this name"""
        return self.__namespaces

def get_namespace(self):
        """Returns the single namespace bound to this name.

Raises ValueError if the name is bound to multiple namespaces.
        """
        if len(self.__namespaces) != 1:
            raise ValueError("name is bound to multiple namespaces")
        return self.__namespaces[0]

if __name__ == "__main__":
    import os, sys
    with open(sys.argv[0]) as f:
        src = f.read()
    mod = symtable(src, os.path.split(sys.argv[0])[1], "exec")
    for ident in mod.get_identifiers():
        info = mod.lookup(ident)
        print(info, info.is_local(), info.is_namespace())

Name	Type	Actions
__pycache__	Directory
asyncio	Directory
collections	Directory
concurrent	Directory
config-3.6m-x86_64-linux-gnu	Directory
ctypes	Directory
curses	Directory
dbm	Directory
distutils	Directory
email	Directory
encodings	Directory
ensurepip	Directory
html	Directory
http	Directory
importlib	Directory
json	Directory
lib-dynload	Directory
lib2to3	Directory
logging	Directory
multiprocessing	Directory
pydoc_data	Directory
site-packages	Directory
sqlite3	Directory
test	Directory
unittest	Directory
urllib	Directory
venv	Directory
wsgiref	Directory
xml	Directory
xmlrpc	Directory
__future__.py	File
__phello__.foo.py	File
_bootlocale.py	File
_collections_abc.py	File
_compat_pickle.py	File
_compression.py	File
_dummy_thread.py	File
_markupbase.py	File
_osx_support.py	File
_pydecimal.py	File
_pyio.py	File
_sitebuiltins.py	File
_strptime.py	File
_sysconfigdata_dm_linux_x86_64-linux-gnu.py	File
_sysconfigdata_m_linux_x86_64-linux-gnu.py	File
_threading_local.py	File
_weakrefset.py	File
abc.py	File
aifc.py	File
antigravity.py	File
argparse.py	File
ast.py	File
asynchat.py	File
asyncore.py	File
base64.py	File
bdb.py	File
binhex.py	File
bisect.py	File
bz2.py	File
cProfile.py	File
calendar.py	File
cgi.py	File
cgitb.py	File
chunk.py	File
cmd.py	File
code.py	File
codecs.py	File
codeop.py	File
colorsys.py	File
compileall.py	File
configparser.py	File
contextlib.py	File
copy.py	File
copyreg.py	File
crypt.py	File
csv.py	File
datetime.py	File
decimal.py	File
difflib.py	File
dis.py	File
doctest.py	File
dummy_threading.py	File
enum.py	File
filecmp.py	File
fileinput.py	File
fnmatch.py	File
formatter.py	File
fractions.py	File
ftplib.py	File
functools.py	File
genericpath.py	File
getopt.py	File
getpass.py	File
gettext.py	File
glob.py	File
gzip.py	File
hashlib.py	File
heapq.py	File
hmac.py	File
imaplib.py	File
imghdr.py	File
imp.py	File
inspect.py	File
io.py	File
ipaddress.py	File
keyword.py	File
linecache.py	File
locale.py	File
lzma.py	File
macpath.py	File
macurl2path.py	File
mailbox.py	File
mailcap.py	File
mimetypes.py	File
modulefinder.py	File
netrc.py	File
nntplib.py	File
ntpath.py	File
nturl2path.py	File
numbers.py	File
opcode.py	File
operator.py	File
optparse.py	File
os.py	File
pathlib.py	File
pdb.py	File
pickle.py	File
pickletools.py	File
pipes.py	File
pkgutil.py	File
platform.py	File
plistlib.py	File
poplib.py	File
posixpath.py	File
pprint.py	File
profile.py	File
pstats.py	File
pty.py	File
py_compile.py	File
pyclbr.py	File
pydoc.py	File
queue.py	File
quopri.py	File
random.py	File
re.py	File
reprlib.py	File
rlcompleter.py	File
runpy.py	File
sched.py	File
secrets.py	File
selectors.py	File
shelve.py	File
shlex.py	File
shutil.py	File
signal.py	File
site.py	File
smtpd.py	File
smtplib.py	File
sndhdr.py	File
socket.py	File
socketserver.py	File
sre_compile.py	File
sre_constants.py	File
sre_parse.py	File
ssl.py	File
stat.py	File
statistics.py	File
string.py	File
stringprep.py	File
struct.py	File
subprocess.py	File
sunau.py	File
symbol.py	File
symtable.py	File
sysconfig.py	File
tabnanny.py	File
tarfile.py	File
telnetlib.py	File
tempfile.py	File
textwrap.py	File
this.py	File
threading.py	File
timeit.py	File
token.py	File
tokenize.py	File
trace.py	File
traceback.py	File
tracemalloc.py	File
tty.py	File
types.py	File
typing.py	File
uu.py	File
uuid.py	File
warnings.py	File
wave.py	File
weakref.py	File
webbrowser.py	File
xdrlib.py	File
zipapp.py	File
zipfile.py	File