File Manager

X7ROOT File Manager

Current Path: /opt/alt/python39/lib64/python3.9

opt / alt / python39 / lib64 / python3.9 /

ðŸ“ ..
ðŸ“„ LICENSE.txt(13.61 KB)
ðŸ“„ __future__.py(5.03 KB)
ðŸ“„ __phello__.foo.py(64 B)
ðŸ“ __pycache__
ðŸ“„ _aix_support.py(3.31 KB)
ðŸ“„ _bootlocale.py(1.76 KB)
ðŸ“„ _bootsubprocess.py(2.61 KB)
ðŸ“„ _collections_abc.py(28.69 KB)
ðŸ“„ _compat_pickle.py(8.54 KB)
ðŸ“„ _compression.py(5.21 KB)
ðŸ“„ _markupbase.py(14.28 KB)
ðŸ“„ _osx_support.py(21.26 KB)
ðŸ“„ _py_abc.py(6.04 KB)
ðŸ“„ _pydecimal.py(223.31 KB)
ðŸ“„ _pyio.py(91.13 KB)
ðŸ“„ _sitebuiltins.py(3.04 KB)
ðŸ“„ _strptime.py(24.68 KB)
ðŸ“„ _sysconfigdata__linux_x86_64-linux-gnu.py(39.59 KB)
ðŸ“„ _sysconfigdata_d_linux_x86_64-linux-gnu.py(39.33 KB)
ðŸ“„ _threading_local.py(7.05 KB)
ðŸ“„ _weakrefset.py(5.78 KB)
ðŸ“„ abc.py(4.8 KB)
ðŸ“„ aifc.py(31.84 KB)
ðŸ“„ antigravity.py(500 B)
ðŸ“„ argparse.py(95.82 KB)
ðŸ“„ ast.py(54.94 KB)
ðŸ“„ asynchat.py(11.06 KB)
ðŸ“ asyncio
ðŸ“„ asyncore.py(19.63 KB)
ðŸ“„ base64.py(19.41 KB)
ðŸ“„ bdb.py(30.65 KB)
ðŸ“„ binhex.py(14.44 KB)
ðŸ“„ bisect.py(2.29 KB)
ðŸ“„ bz2.py(12.16 KB)
ðŸ“„ cProfile.py(6.21 KB)
ðŸ“„ calendar.py(24.25 KB)
ðŸ“„ cgi.py(33.15 KB)
ðŸ“„ cgitb.py(11.81 KB)
ðŸ“„ chunk.py(5.31 KB)
ðŸ“„ cmd.py(14.51 KB)
ðŸ“„ code.py(10.37 KB)
ðŸ“„ codecs.py(35.81 KB)
ðŸ“„ codeop.py(6.18 KB)
ðŸ“ collections
ðŸ“„ colorsys.py(3.97 KB)
ðŸ“„ compileall.py(19.63 KB)
ðŸ“ concurrent
ðŸ“ config-3.9-x86_64-linux-gnu
ðŸ“„ configparser.py(53.3 KB)
ðŸ“„ contextlib.py(24.05 KB)
ðŸ“„ contextvars.py(129 B)
ðŸ“„ copy.py(8.45 KB)
ðŸ“„ copyreg.py(7.1 KB)
ðŸ“„ crypt.py(3.73 KB)
ðŸ“„ csv.py(15.77 KB)
ðŸ“ ctypes
ðŸ“ curses
ðŸ“„ dataclasses.py(48.42 KB)
ðŸ“„ datetime.py(87.09 KB)
ðŸ“ dbm
ðŸ“„ decimal.py(320 B)
ðŸ“„ difflib.py(81.35 KB)
ðŸ“„ dis.py(20.09 KB)
ðŸ“ distutils
ðŸ“„ doctest.py(102.12 KB)
ðŸ“ email
ðŸ“ encodings
ðŸ“ ensurepip
ðŸ“„ enum.py(38.52 KB)
ðŸ“„ filecmp.py(9.79 KB)
ðŸ“„ fileinput.py(14.44 KB)
ðŸ“„ fnmatch.py(5.86 KB)
ðŸ“„ formatter.py(14.79 KB)
ðŸ“„ fractions.py(23.75 KB)
ðŸ“„ ftplib.py(34.66 KB)
ðŸ“„ functools.py(37.97 KB)
ðŸ“„ genericpath.py(4.86 KB)
ðŸ“„ getopt.py(7.31 KB)
ðŸ“„ getpass.py(5.85 KB)
ðŸ“„ gettext.py(26.63 KB)
ðŸ“„ glob.py(5.69 KB)
ðŸ“„ graphlib.py(9.35 KB)
ðŸ“„ gzip.py(21.26 KB)
ðŸ“„ hashlib.py(9.78 KB)
ðŸ“„ heapq.py(22.34 KB)
ðŸ“„ hmac.py(6.84 KB)
ðŸ“ html
ðŸ“ http
ðŸ“„ imaplib.py(53.96 KB)
ðŸ“„ imghdr.py(3.72 KB)
ðŸ“„ imp.py(10.29 KB)
ðŸ“ importlib
ðŸ“„ inspect.py(115.46 KB)
ðŸ“„ io.py(3.46 KB)
ðŸ“„ ipaddress.py(76.79 KB)
ðŸ“ json
ðŸ“„ keyword.py(1.02 KB)
ðŸ“ lib-dynload
ðŸ“ lib2to3
ðŸ“„ linecache.py(5.33 KB)
ðŸ“„ locale.py(76.44 KB)
ðŸ“ logging
ðŸ“„ lzma.py(12.92 KB)
ðŸ“„ mailbox.py(76.95 KB)
ðŸ“„ mailcap.py(8.9 KB)
ðŸ“„ mimetypes.py(21.06 KB)
ðŸ“„ modulefinder.py(23.83 KB)
ðŸ“ multiprocessing
ðŸ“„ netrc.py(5.44 KB)
ðŸ“„ nntplib.py(40.06 KB)
ðŸ“„ ntpath.py(27.08 KB)
ðŸ“„ nturl2path.py(2.82 KB)
ðŸ“„ numbers.py(10.1 KB)
ðŸ“„ opcode.py(5.53 KB)
ðŸ“„ operator.py(10.5 KB)
ðŸ“„ optparse.py(58.95 KB)
ðŸ“„ os.py(38.15 KB)
ðŸ“„ pathlib.py(52.81 KB)
ðŸ“„ pdb.py(61.77 KB)
ðŸ“„ pickle.py(63.4 KB)
ðŸ“„ pickletools.py(91.29 KB)
ðŸ“„ pipes.py(8.71 KB)
ðŸ“„ pkgutil.py(23.71 KB)
ðŸ“„ platform.py(39.66 KB)
ðŸ“„ plistlib.py(27.59 KB)
ðŸ“„ poplib.py(14.84 KB)
ðŸ“„ posixpath.py(15.35 KB)
ðŸ“„ pprint.py(22 KB)
ðŸ“„ profile.py(22.36 KB)
ðŸ“„ pstats.py(28.64 KB)
ðŸ“„ pty.py(4.69 KB)
ðŸ“„ py_compile.py(8.01 KB)
ðŸ“„ pyclbr.py(14.9 KB)
ðŸ“„ pydoc.py(107.04 KB)
ðŸ“ pydoc_data
ðŸ“„ queue.py(11.23 KB)
ðŸ“„ quopri.py(7.11 KB)
ðŸ“„ random.py(30.75 KB)
ðŸ“„ re.py(15.49 KB)
ðŸ“„ reprlib.py(5.14 KB)
ðŸ“„ rlcompleter.py(7.47 KB)
ðŸ“„ runpy.py(12.78 KB)
ðŸ“„ sched.py(6.29 KB)
ðŸ“„ secrets.py(1.99 KB)
ðŸ“„ selectors.py(19.08 KB)
ðŸ“„ shelve.py(8.33 KB)
ðŸ“„ shlex.py(13.18 KB)
ðŸ“„ shutil.py(51.79 KB)
ðŸ“„ signal.py(2.38 KB)
ðŸ“ site-packages
ðŸ“„ site.py(21.33 KB)
ðŸ“„ smtpd.py(34.02 KB)
ðŸ“„ smtplib.py(44.35 KB)
ðŸ“„ sndhdr.py(6.93 KB)
ðŸ“„ socket.py(36.05 KB)
ðŸ“„ socketserver.py(26.66 KB)
ðŸ“ sqlite3
ðŸ“„ sre_compile.py(27.32 KB)
ðŸ“„ sre_constants.py(7.01 KB)
ðŸ“„ sre_parse.py(39.82 KB)
ðŸ“„ ssl.py(51.3 KB)
ðŸ“„ stat.py(5.36 KB)
ðŸ“„ statistics.py(37.17 KB)
ðŸ“„ string.py(10.32 KB)
ðŸ“„ stringprep.py(12.61 KB)
ðŸ“„ struct.py(257 B)
ðŸ“„ subprocess.py(81.61 KB)
ðŸ“„ sunau.py(17.73 KB)
ðŸ“„ symbol.py(2.23 KB)
ðŸ“„ symtable.py(7.72 KB)
ðŸ“„ sysconfig.py(24.33 KB)
ðŸ“„ tabnanny.py(11.15 KB)
ðŸ“„ tarfile.py(104.39 KB)
ðŸ“„ telnetlib.py(22.71 KB)
ðŸ“„ tempfile.py(27.31 KB)
ðŸ“„ textwrap.py(18.95 KB)
ðŸ“„ this.py(1003 B)
ðŸ“„ threading.py(52.91 KB)
ðŸ“„ timeit.py(13.18 KB)
ðŸ“„ token.py(2.31 KB)
ðŸ“„ tokenize.py(25.28 KB)
ðŸ“„ trace.py(28.54 KB)
ðŸ“„ traceback.py(24.08 KB)
ðŸ“„ tracemalloc.py(17.62 KB)
ðŸ“„ tty.py(879 B)
ðŸ“„ types.py(9.56 KB)
ðŸ“„ typing.py(75.24 KB)
ðŸ“ unittest
ðŸ“ urllib
ðŸ“„ uu.py(7.11 KB)
ðŸ“„ uuid.py(26.68 KB)
ðŸ“ venv
ðŸ“„ warnings.py(19.23 KB)
ðŸ“„ wave.py(17.58 KB)
ðŸ“„ weakref.py(21.05 KB)
ðŸ“„ webbrowser.py(23.53 KB)
ðŸ“ wsgiref
ðŸ“„ xdrlib.py(5.77 KB)
ðŸ“ xml
ðŸ“ xmlrpc
ðŸ“„ zipapp.py(7.36 KB)
ðŸ“„ zipfile.py(86.17 KB)
ðŸ“„ zipimport.py(30.04 KB)
ðŸ“ zoneinfo

Editing: symtable.py

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

import _symtable
from _symtable import (USE, DEF_GLOBAL, DEF_NONLOCAL, 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:

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 == "top":
            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 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)
            module_scope = (self._table.name == "top")
            sym = self._symbols[name] = Symbol(name, flags, namespaces,
                                               module_scope=module_scope)
        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
    __nonlocals = 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_nonlocals(self):
        if self.__nonlocals is None:
            self.__nonlocals = self.__idents_matching(lambda x:x & DEF_NONLOCAL)
        return self.__nonlocals

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:

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

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 *True* if the sysmbol is global.
        """
        return bool(self.__scope in (GLOBAL_IMPLICIT, GLOBAL_EXPLICIT)
                    or (self.__module_scope and self.__flags & DEF_BOUND))

def is_nonlocal(self):
        return bool(self.__flags & DEF_NONLOCAL)

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

def is_local(self):
        """Return *True* if the symbol is local.
        """
        return bool(self.__scope in (LOCAL, CELL)
                    or (self.__module_scope and 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())

X7ROOT File Manager

Editing: symtable.py

Upload File

Create Folder