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/ast.py (12001B)

"""
    ast
    ~~~

The `ast` module helps Python applications to process trees of the Python
    abstract syntax grammar.  The abstract syntax itself might change with
    each Python release; this module helps to find out programmatically what
    the current grammar looks like and allows modifications of it.

An abstract syntax tree can be generated by passing `ast.PyCF_ONLY_AST` as
    a flag to the `compile()` builtin function or by using the `parse()`
    function from this module.  The result will be a tree of objects whose
    classes all inherit from `ast.AST`.

A modified abstract syntax tree can be compiled into a Python code object
    using the built-in `compile()` function.

Additionally various helper functions are provided that make working with
    the trees simpler.  The main intention of the helper functions and this
    module in general is to provide an easy to use interface for libraries
    that work tightly with the python syntax (template engines for example).

:copyright: Copyright 2008 by Armin Ronacher.
    :license: Python License.
"""
from _ast import *

def parse(source, filename='<unknown>', mode='exec'):
    """
    Parse the source into an AST node.
    Equivalent to compile(source, filename, mode, PyCF_ONLY_AST).
    """
    return compile(source, filename, mode, PyCF_ONLY_AST)

def literal_eval(node_or_string):
    """
    Safely evaluate an expression node or a string containing a Python
    expression.  The string or node provided may only consist of the following
    Python literal structures: strings, bytes, numbers, tuples, lists, dicts,
    sets, booleans, and None.
    """
    if isinstance(node_or_string, str):
        node_or_string = parse(node_or_string, mode='eval')
    if isinstance(node_or_string, Expression):
        node_or_string = node_or_string.body
    def _convert(node):
        if isinstance(node, (Str, Bytes)):
            return node.s
        elif isinstance(node, Num):
            return node.n
        elif isinstance(node, Tuple):
            return tuple(map(_convert, node.elts))
        elif isinstance(node, List):
            return list(map(_convert, node.elts))
        elif isinstance(node, Set):
            return set(map(_convert, node.elts))
        elif isinstance(node, Dict):
            return dict((_convert(k), _convert(v)) for k, v
                        in zip(node.keys, node.values))
        elif isinstance(node, NameConstant):
            return node.value
        elif isinstance(node, UnaryOp) and \
             isinstance(node.op, (UAdd, USub)) and \
             isinstance(node.operand, (Num, UnaryOp, BinOp)):
            operand = _convert(node.operand)
            if isinstance(node.op, UAdd):
                return + operand
            else:
                return - operand
        elif isinstance(node, BinOp) and \
             isinstance(node.op, (Add, Sub)) and \
             isinstance(node.right, (Num, UnaryOp, BinOp)) and \
             isinstance(node.left, (Num, UnaryOp, BinOp)):
            left = _convert(node.left)
            right = _convert(node.right)
            if isinstance(node.op, Add):
                return left + right
            else:
                return left - right
        raise ValueError('malformed node or string: ' + repr(node))
    return _convert(node_or_string)

def dump(node, annotate_fields=True, include_attributes=False):
    """
    Return a formatted dump of the tree in *node*.  This is mainly useful for
    debugging purposes.  The returned string will show the names and the values
    for fields.  This makes the code impossible to evaluate, so if evaluation is
    wanted *annotate_fields* must be set to False.  Attributes such as line
    numbers and column offsets are not dumped by default.  If this is wanted,
    *include_attributes* can be set to True.
    """
    def _format(node):
        if isinstance(node, AST):
            fields = [(a, _format(b)) for a, b in iter_fields(node)]
            rv = '%s(%s' % (node.__class__.__name__, ', '.join(
                ('%s=%s' % field for field in fields)
                if annotate_fields else
                (b for a, b in fields)
            ))
            if include_attributes and node._attributes:
                rv += fields and ', ' or ' '
                rv += ', '.join('%s=%s' % (a, _format(getattr(node, a)))
                                for a in node._attributes)
            return rv + ')'
        elif isinstance(node, list):
            return '[%s]' % ', '.join(_format(x) for x in node)
        return repr(node)
    if not isinstance(node, AST):
        raise TypeError('expected AST, got %r' % node.__class__.__name__)
    return _format(node)

def copy_location(new_node, old_node):
    """
    Copy source location (`lineno` and `col_offset` attributes) from
    *old_node* to *new_node* if possible, and return *new_node*.
    """
    for attr in 'lineno', 'col_offset':
        if attr in old_node._attributes and attr in new_node._attributes \
           and hasattr(old_node, attr):
            setattr(new_node, attr, getattr(old_node, attr))
    return new_node

def fix_missing_locations(node):
    """
    When you compile a node tree with compile(), the compiler expects lineno and
    col_offset attributes for every node that supports them.  This is rather
    tedious to fill in for generated nodes, so this helper adds these attributes
    recursively where not already set, by setting them to the values of the
    parent node.  It works recursively starting at *node*.
    """
    def _fix(node, lineno, col_offset):
        if 'lineno' in node._attributes:
            if not hasattr(node, 'lineno'):
                node.lineno = lineno
            else:
                lineno = node.lineno
        if 'col_offset' in node._attributes:
            if not hasattr(node, 'col_offset'):
                node.col_offset = col_offset
            else:
                col_offset = node.col_offset
        for child in iter_child_nodes(node):
            _fix(child, lineno, col_offset)
    _fix(node, 1, 0)
    return node

def increment_lineno(node, n=1):
    """
    Increment the line number of each node in the tree starting at *node* by *n*.
    This is useful to "move code" to a different location in a file.
    """
    for child in walk(node):
        if 'lineno' in child._attributes:
            child.lineno = getattr(child, 'lineno', 0) + n
    return node

def iter_fields(node):
    """
    Yield a tuple of ``(fieldname, value)`` for each field in ``node._fields``
    that is present on *node*.
    """
    for field in node._fields:
        try:
            yield field, getattr(node, field)
        except AttributeError:
            pass

def iter_child_nodes(node):
    """
    Yield all direct child nodes of *node*, that is, all fields that are nodes
    and all items of fields that are lists of nodes.
    """
    for name, field in iter_fields(node):
        if isinstance(field, AST):
            yield field
        elif isinstance(field, list):
            for item in field:
                if isinstance(item, AST):
                    yield item

def get_docstring(node, clean=True):
    """
    Return the docstring for the given node or None if no docstring can
    be found.  If the node provided does not have docstrings a TypeError
    will be raised.
    """
    if not isinstance(node, (AsyncFunctionDef, FunctionDef, ClassDef, Module)):
        raise TypeError("%r can't have docstrings" % node.__class__.__name__)
    if node.body and isinstance(node.body[0], Expr) and \
       isinstance(node.body[0].value, Str):
        if clean:
            import inspect
            return inspect.cleandoc(node.body[0].value.s)
        return node.body[0].value.s

def walk(node):
    """
    Recursively yield all descendant nodes in the tree starting at *node*
    (including *node* itself), in no specified order.  This is useful if you
    only want to modify nodes in place and don't care about the context.
    """
    from collections import deque
    todo = deque([node])
    while todo:
        node = todo.popleft()
        todo.extend(iter_child_nodes(node))
        yield node

class NodeVisitor(object):
    """
    A node visitor base class that walks the abstract syntax tree and calls a
    visitor function for every node found.  This function may return a value
    which is forwarded by the `visit` method.

This class is meant to be subclassed, with the subclass adding visitor
    methods.

Per default the visitor functions for the nodes are ``'visit_'`` +
    class name of the node.  So a `TryFinally` node visit function would
    be `visit_TryFinally`.  This behavior can be changed by overriding
    the `visit` method.  If no visitor function exists for a node
    (return value `None`) the `generic_visit` visitor is used instead.

Don't use the `NodeVisitor` if you want to apply changes to nodes during
    traversing.  For this a special visitor exists (`NodeTransformer`) that
    allows modifications.
    """

def visit(self, node):
        """Visit a node."""
        method = 'visit_' + node.__class__.__name__
        visitor = getattr(self, method, self.generic_visit)
        return visitor(node)

def generic_visit(self, node):
        """Called if no explicit visitor function exists for a node."""
        for field, value in iter_fields(node):
            if isinstance(value, list):
                for item in value:
                    if isinstance(item, AST):
                        self.visit(item)
            elif isinstance(value, AST):
                self.visit(value)

class NodeTransformer(NodeVisitor):
    """
    A :class:`NodeVisitor` subclass that walks the abstract syntax tree and
    allows modification of nodes.

The `NodeTransformer` will walk the AST and use the return value of the
    visitor methods to replace or remove the old node.  If the return value of
    the visitor method is ``None``, the node will be removed from its location,
    otherwise it is replaced with the return value.  The return value may be the
    original node in which case no replacement takes place.

Here is an example transformer that rewrites all occurrences of name lookups
    (``foo``) to ``data['foo']``::

class RewriteName(NodeTransformer):

def visit_Name(self, node):
               return copy_location(Subscript(
                   value=Name(id='data', ctx=Load()),
                   slice=Index(value=Str(s=node.id)),
                   ctx=node.ctx
               ), node)

Keep in mind that if the node you're operating on has child nodes you must
    either transform the child nodes yourself or call the :meth:`generic_visit`
    method for the node first.

For nodes that were part of a collection of statements (that applies to all
    statement nodes), the visitor may also return a list of nodes rather than
    just a single node.

Usually you use the transformer like this::

node = YourTransformer().visit(node)
    """

def generic_visit(self, node):
        for field, old_value in iter_fields(node):
            if isinstance(old_value, list):
                new_values = []
                for value in old_value:
                    if isinstance(value, AST):
                        value = self.visit(value)
                        if value is None:
                            continue
                        elif not isinstance(value, AST):
                            new_values.extend(value)
                            continue
                    new_values.append(value)
                old_value[:] = new_values
            elif isinstance(old_value, AST):
                new_node = self.visit(old_value)
                if new_node is None:
                    delattr(node, field)
                else:
                    setattr(node, field, new_node)
        return node

cmd: