FM / python3.5

/opt/alt/python35/lib64/python3.5

Name	Size	Mode	Actions
asyncio/	-	0755	rm
collections/	-	0755	rm
concurrent/	-	0755	rm
config-3.5m/	-	0755	rm
ctypes/	-	0755	rm
curses/	-	0755	rm
dbm/	-	0755	rm
distutils/	-	0755	rm
email/	-	0755	rm
encodings/	-	0755	rm
ensurepip/	-	0755	rm
html/	-	0755	rm
http/	-	0755	rm
idlelib/	-	0755	rm
importlib/	-	0755	rm
json/	-	0755	rm
lib-dynload/	-	0755	rm
lib2to3/	-	0755	rm
logging/	-	0755	rm
multiprocessing/	-	0755	rm
plat-linux/	-	0755	rm
pydoc_data/	-	0755	rm
site-packages/	-	0755	rm
sqlite3/	-	0755	rm
test/	-	0755	rm
unittest/	-	0755	rm
urllib/	-	0755	rm
venv/	-	0755	rm
wsgiref/	-	0755	rm
xml/	-	0755	rm
xmlrpc/	-	0755	rm
__pycache__/	-	0755	rm
abc.py	8628	0644	edit dl rm
aifc.py	31967	0644	edit dl rm
antigravity.py	476	0644	edit dl rm
argparse.py	90138	0644	edit dl rm
ast.py	12001	0644	edit dl rm
asynchat.py	11971	0644	edit dl rm
asyncore.py	20104	0644	edit dl rm
base64.py	20522	0755	edit dl rm
bdb.py	23354	0644	edit dl rm
binhex.py	13954	0644	edit dl rm
bisect.py	2595	0644	edit dl rm
bz2.py	12424	0644	edit dl rm
calendar.py	22998	0644	edit dl rm
cgi.py	36046	0755	edit dl rm
cgitb.py	12023	0644	edit dl rm
chunk.py	5425	0644	edit dl rm
cmd.py	14860	0644	edit dl rm
code.py	10118	0644	edit dl rm
codecs.py	36231	0644	edit dl rm
codeop.py	5994	0644	edit dl rm
colorsys.py	4064	0644	edit dl rm
compileall.py	11711	0644	edit dl rm
configparser.py	53452	0644	edit dl rm
contextlib.py	12451	0644	edit dl rm
copy.py	8946	0644	edit dl rm
copyreg.py	6833	0644	edit dl rm
cProfile.py	5324	0755	edit dl rm
crypt.py	1879	0644	edit dl rm
csv.py	16128	0644	edit dl rm
datetime.py	75899	0644	edit dl rm
decimal.py	320	0644	edit dl rm
difflib.py	84204	0644	edit dl rm
dis.py	17350	0644	edit dl rm
doctest.py	104036	0644	edit dl rm
dummy_threading.py	2815	0644	edit dl rm
enum.py	22226	0644	edit dl rm
filecmp.py	9830	0644	edit dl rm
fileinput.py	14259	0644	edit dl rm
fnmatch.py	3163	0644	edit dl rm
formatter.py	15143	0644	edit dl rm
fractions.py	24612	0644	edit dl rm
ftplib.py	34951	0644	edit dl rm
functools.py	28944	0644	edit dl rm
genericpath.py	4364	0644	edit dl rm
getopt.py	7489	0644	edit dl rm
getpass.py	5994	0644	edit dl rm
gettext.py	21530	0644	edit dl rm
glob.py	5072	0644	edit dl rm
gzip.py	20260	0644	edit dl rm
hashlib.py	7979	0644	edit dl rm
heapq.py	22929	0644	edit dl rm
hmac.py	5063	0644	edit dl rm
imaplib.py	52183	0644	edit dl rm
imghdr.py	3758	0644	edit dl rm
imp.py	10676	0644	edit dl rm
inspect.py	114199	0644	edit dl rm
io.py	3396	0644	edit dl rm
ipaddress.py	75733	0644	edit dl rm
keyword.py	2222	0755	edit dl rm
linecache.py	5312	0644	edit dl rm
locale.py	74713	0644	edit dl rm
lzma.py	12925	0644	edit dl rm
macpath.py	5907	0644	edit dl rm
macurl2path.py	2732	0644	edit dl rm
mailbox.py	78418	0644	edit dl rm
mailcap.py	8104	0644	edit dl rm
mimetypes.py	20847	0644	edit dl rm
modulefinder.py	23085	0644	edit dl rm
netrc.py	5748	0644	edit dl rm
nntplib.py	43078	0644	edit dl rm
ntpath.py	22793	0644	edit dl rm
nturl2path.py	2444	0644	edit dl rm
numbers.py	10243	0644	edit dl rm
opcode.py	5885	0644	edit dl rm
operator.py	10863	0644	edit dl rm
optparse.py	60344	0644	edit dl rm
os.py	37033	0644	edit dl rm
pathlib.py	47001	0644	edit dl rm
pdb.py	61149	0755	edit dl rm
pickle.py	56176	0644	edit dl rm
pickletools.py	91761	0644	edit dl rm
pipes.py	8916	0644	edit dl rm
pkgutil.py	21355	0644	edit dl rm
platform.py	46147	0755	edit dl rm
plistlib.py	31810	0644	edit dl rm
poplib.py	14717	0644	edit dl rm
posixpath.py	14911	0644	edit dl rm
pprint.py	20860	0644	edit dl rm
profile.py	22032	0755	edit dl rm
pstats.py	26564	0644	edit dl rm
pty.py	4763	0644	edit dl rm
pyclbr.py	13564	0644	edit dl rm
pydoc.py	103652	0755	edit dl rm
py_compile.py	7181	0644	edit dl rm
queue.py	8780	0644	edit dl rm
quopri.py	7265	0755	edit dl rm
random.py	26463	0644	edit dl rm
re.py	15501	0644	edit dl rm
reprlib.py	5336	0644	edit dl rm
rlcompleter.py	6307	0644	edit dl rm
runpy.py	11959	0644	edit dl rm
sched.py	6216	0644	edit dl rm
selectors.py	19438	0644	edit dl rm
shelve.py	8528	0644	edit dl rm
shlex.py	11448	0644	edit dl rm
shutil.py	40048	0644	edit dl rm
signal.py	2123	0644	edit dl rm
site.py	21509	0644	edit dl rm
smtpd.py	35373	0755	edit dl rm
smtplib.py	43635	0755	edit dl rm
sndhdr.py	6418	0644	edit dl rm
socket.py	27135	0644	edit dl rm
socketserver.py	24666	0644	edit dl rm
sre_compile.py	18410	0644	edit dl rm
sre_constants.py	6821	0644	edit dl rm
sre_parse.py	35117	0644	edit dl rm
ssl.py	42352	0644	edit dl rm
stat.py	5038	0644	edit dl rm
statistics.py	19533	0644	edit dl rm
string.py	11854	0644	edit dl rm
stringprep.py	12917	0644	edit dl rm
struct.py	257	0644	edit dl rm
subprocess.py	58912	0644	edit dl rm
sunau.py	18095	0644	edit dl rm
symbol.py	2106	0755	edit dl rm
symtable.py	7191	0644	edit dl rm
sysconfig.py	24462	0644	edit dl rm
tabnanny.py	11414	0755	edit dl rm
tarfile.py	93070	0755	edit dl rm
telnetlib.py	23016	0644	edit dl rm
tempfile.py	26636	0644	edit dl rm
textwrap.py	19558	0644	edit dl rm
this.py	1003	0644	edit dl rm
threading.py	49027	0644	edit dl rm
timeit.py	12403	0755	edit dl rm
token.py	3075	0644	edit dl rm
tokenize.py	27790	0644	edit dl rm
trace.py	31553	0755	edit dl rm
traceback.py	22175	0644	edit dl rm
tracemalloc.py	15641	0644	edit dl rm
tty.py	879	0644	edit dl rm
types.py	8799	0644	edit dl rm
typing.py	80135	0644	edit dl rm
uu.py	6766	0755	edit dl rm
uuid.py	23261	0644	edit dl rm
warnings.py	15850	0644	edit dl rm
wave.py	17682	0644	edit dl rm
weakref.py	20466	0644	edit dl rm
webbrowser.py	21828	0755	edit dl rm
xdrlib.py	5913	0644	edit dl rm
zipapp.py	7157	0644	edit dl rm
zipfile.py	73672	0644	edit dl rm
_bootlocale.py	1301	0644	edit dl rm
_collections_abc.py	24794	0644	edit dl rm
_compat_pickle.py	8556	0644	edit dl rm
_compression.py	5340	0644	edit dl rm
_dummy_thread.py	5118	0644	edit dl rm
_markupbase.py	14598	0644	edit dl rm
_osx_support.py	19115	0644	edit dl rm
_pydecimal.py	228628	0644	edit dl rm
_pyio.py	87968	0644	edit dl rm
_sitebuiltins.py	3115	0644	edit dl rm
_strptime.py	22185	0644	edit dl rm
_sysconfigdata.py	24273	0644	edit dl rm
_threading_local.py	7410	0644	edit dl rm
_weakrefset.py	5705	0644	edit dl rm
__future__.py	4841	0644	edit dl rm
__phello__.foo.py	64	0644	edit dl rm

Edit: /opt/alt/python35/lib64/python3.5/pyclbr.py (13564B)

"""Parse a Python module and describe its classes and methods.

Parse enough of a Python file to recognize imports and class and
method definitions, and to find out the superclasses of a class.

The interface consists of a single function:
        readmodule_ex(module [, path])
where module is the name of a Python module, and path is an optional
list of directories where the module is to be searched.  If present,
path is prepended to the system search path sys.path.  The return
value is a dictionary.  The keys of the dictionary are the names of
the classes defined in the module (including classes that are defined
via the from XXX import YYY construct).  The values are class
instances of the class Class defined here.  One special key/value pair
is present for packages: the key '__path__' has a list as its value
which contains the package search path.

A class is described by the class Class in this module.  Instances
of this class have the following instance variables:
        module -- the module name
        name -- the name of the class
        super -- a list of super classes (Class instances)
        methods -- a dictionary of methods
        file -- the file in which the class was defined
        lineno -- the line in the file on which the class statement occurred
The dictionary of methods uses the method names as keys and the line
numbers on which the method was defined as values.
If the name of a super class is not recognized, the corresponding
entry in the list of super classes is not a class instance but a
string giving the name of the super class.  Since import statements
are recognized and imported modules are scanned as well, this
shouldn't happen often.

A function is described by the class Function in this module.
Instances of this class have the following instance variables:
        module -- the module name
        name -- the name of the class
        file -- the file in which the class was defined
        lineno -- the line in the file on which the class statement occurred
"""

import io
import os
import sys
import importlib.util
import tokenize
from token import NAME, DEDENT, OP
from operator import itemgetter

__all__ = ["readmodule", "readmodule_ex", "Class", "Function"]

_modules = {}                           # cache of modules we've seen

# each Python class is represented by an instance of this class
class Class:
    '''Class to represent a Python class.'''
    def __init__(self, module, name, super, file, lineno):
        self.module = module
        self.name = name
        if super is None:
            super = []
        self.super = super
        self.methods = {}
        self.file = file
        self.lineno = lineno

def _addmethod(self, name, lineno):
        self.methods[name] = lineno

class Function:
    '''Class to represent a top-level Python function'''
    def __init__(self, module, name, file, lineno):
        self.module = module
        self.name = name
        self.file = file
        self.lineno = lineno

def readmodule(module, path=None):
    '''Backwards compatible interface.

Call readmodule_ex() and then only keep Class objects from the
    resulting dictionary.'''

res = {}
    for key, value in _readmodule(module, path or []).items():
        if isinstance(value, Class):
            res[key] = value
    return res

def readmodule_ex(module, path=None):
    '''Read a module file and return a dictionary of classes.

Search for MODULE in PATH and sys.path, read and parse the
    module and return a dictionary with one entry for each class
    found in the module.
    '''
    return _readmodule(module, path or [])

def _readmodule(module, path, inpackage=None):
    '''Do the hard work for readmodule[_ex].

If INPACKAGE is given, it must be the dotted name of the package in
    which we are searching for a submodule, and then PATH must be the
    package search path; otherwise, we are searching for a top-level
    module, and PATH is combined with sys.path.
    '''
    # Compute the full module name (prepending inpackage if set)
    if inpackage is not None:
        fullmodule = "%s.%s" % (inpackage, module)
    else:
        fullmodule = module

# Check in the cache
    if fullmodule in _modules:
        return _modules[fullmodule]

# Initialize the dict for this module's contents
    dict = {}

# Check if it is a built-in module; we don't do much for these
    if module in sys.builtin_module_names and inpackage is None:
        _modules[module] = dict
        return dict

# Check for a dotted module name
    i = module.rfind('.')
    if i >= 0:
        package = module[:i]
        submodule = module[i+1:]
        parent = _readmodule(package, path, inpackage)
        if inpackage is not None:
            package = "%s.%s" % (inpackage, package)
        if not '__path__' in parent:
            raise ImportError('No package named {}'.format(package))
        return _readmodule(submodule, parent['__path__'], package)

# Search the path for the module
    f = None
    if inpackage is not None:
        search_path = path
    else:
        search_path = path + sys.path
    # XXX This will change once issue19944 lands.
    spec = importlib.util._find_spec_from_path(fullmodule, search_path)
    _modules[fullmodule] = dict
    # is module a package?
    if spec.submodule_search_locations is not None:
        dict['__path__'] = spec.submodule_search_locations
    try:
        source = spec.loader.get_source(fullmodule)
        if source is None:
            return dict
    except (AttributeError, ImportError):
        # not Python source, can't do anything with this module
        return dict

fname = spec.loader.get_filename(fullmodule)

f = io.StringIO(source)

stack = [] # stack of (class, indent) pairs

g = tokenize.generate_tokens(f.readline)
    try:
        for tokentype, token, start, _end, _line in g:
            if tokentype == DEDENT:
                lineno, thisindent = start
                # close nested classes and defs
                while stack and stack[-1][1] >= thisindent:
                    del stack[-1]
            elif token == 'def':
                lineno, thisindent = start
                # close previous nested classes and defs
                while stack and stack[-1][1] >= thisindent:
                    del stack[-1]
                tokentype, meth_name, start = next(g)[0:3]
                if tokentype != NAME:
                    continue # Syntax error
                if stack:
                    cur_class = stack[-1][0]
                    if isinstance(cur_class, Class):
                        # it's a method
                        cur_class._addmethod(meth_name, lineno)
                    # else it's a nested def
                else:
                    # it's a function
                    dict[meth_name] = Function(fullmodule, meth_name,
                                               fname, lineno)
                stack.append((None, thisindent)) # Marker for nested fns
            elif token == 'class':
                lineno, thisindent = start
                # close previous nested classes and defs
                while stack and stack[-1][1] >= thisindent:
                    del stack[-1]
                tokentype, class_name, start = next(g)[0:3]
                if tokentype != NAME:
                    continue # Syntax error
                # parse what follows the class name
                tokentype, token, start = next(g)[0:3]
                inherit = None
                if token == '(':
                    names = [] # List of superclasses
                    # there's a list of superclasses
                    level = 1
                    super = [] # Tokens making up current superclass
                    while True:
                        tokentype, token, start = next(g)[0:3]
                        if token in (')', ',') and level == 1:
                            n = "".join(super)
                            if n in dict:
                                # we know this super class
                                n = dict[n]
                            else:
                                c = n.split('.')
                                if len(c) > 1:
                                    # super class is of the form
                                    # module.class: look in module for
                                    # class
                                    m = c[-2]
                                    c = c[-1]
                                    if m in _modules:
                                        d = _modules[m]
                                        if c in d:
                                            n = d[c]
                            names.append(n)
                            super = []
                        if token == '(':
                            level += 1
                        elif token == ')':
                            level -= 1
                            if level == 0:
                                break
                        elif token == ',' and level == 1:
                            pass
                        # only use NAME and OP (== dot) tokens for type name
                        elif tokentype in (NAME, OP) and level == 1:
                            super.append(token)
                        # expressions in the base list are not supported
                    inherit = names
                cur_class = Class(fullmodule, class_name, inherit,
                                  fname, lineno)
                if not stack:
                    dict[class_name] = cur_class
                stack.append((cur_class, thisindent))
            elif token == 'import' and start[1] == 0:
                modules = _getnamelist(g)
                for mod, _mod2 in modules:
                    try:
                        # Recursively read the imported module
                        if inpackage is None:
                            _readmodule(mod, path)
                        else:
                            try:
                                _readmodule(mod, path, inpackage)
                            except ImportError:
                                _readmodule(mod, [])
                    except:
                        # If we can't find or parse the imported module,
                        # too bad -- don't die here.
                        pass
            elif token == 'from' and start[1] == 0:
                mod, token = _getname(g)
                if not mod or token != "import":
                    continue
                names = _getnamelist(g)
                try:
                    # Recursively read the imported module
                    d = _readmodule(mod, path, inpackage)
                except:
                    # If we can't find or parse the imported module,
                    # too bad -- don't die here.
                    continue
                # add any classes that were defined in the imported module
                # to our name space if they were mentioned in the list
                for n, n2 in names:
                    if n in d:
                        dict[n2 or n] = d[n]
                    elif n == '*':
                        # don't add names that start with _
                        for n in d:
                            if n[0] != '_':
                                dict[n] = d[n]
    except StopIteration:
        pass

f.close()
    return dict

def _getnamelist(g):
    # Helper to get a comma-separated list of dotted names plus 'as'
    # clauses.  Return a list of pairs (name, name2) where name2 is
    # the 'as' name, or None if there is no 'as' clause.
    names = []
    while True:
        name, token = _getname(g)
        if not name:
            break
        if token == 'as':
            name2, token = _getname(g)
        else:
            name2 = None
        names.append((name, name2))
        while token != "," and "\n" not in token:
            token = next(g)[1]
        if token != ",":
            break
    return names

def _getname(g):
    # Helper to get a dotted name, return a pair (name, token) where
    # name is the dotted name, or None if there was no dotted name,
    # and token is the next input token.
    parts = []
    tokentype, token = next(g)[0:2]
    if tokentype != NAME and token != '*':
        return (None, token)
    parts.append(token)
    while True:
        tokentype, token = next(g)[0:2]
        if token != '.':
            break
        tokentype, token = next(g)[0:2]
        if tokentype != NAME:
            break
        parts.append(token)
    return (".".join(parts), token)

def _main():
    # Main program for testing.
    import os
    mod = sys.argv[1]
    if os.path.exists(mod):
        path = [os.path.dirname(mod)]
        mod = os.path.basename(mod)
        if mod.lower().endswith(".py"):
            mod = mod[:-3]
    else:
        path = []
    dict = readmodule_ex(mod, path)
    objs = list(dict.values())
    objs.sort(key=lambda a: getattr(a, 'lineno', 0))
    for obj in objs:
        if isinstance(obj, Class):
            print("class", obj.name, obj.super, obj.lineno)
            methods = sorted(obj.methods.items(), key=itemgetter(1))
            for name, lineno in methods:
                if name != "__path__":
                    print("  def", name, lineno)
        elif isinstance(obj, Function):
            print("def", obj.name, obj.lineno)

if __name__ == "__main__":
    _main()

cmd: