Restoring authorship annotation for <orivej@yandex-team.ru>. Commit 1 of 2.

1 files changed, 284 insertions, 284 deletions

diff --git a/contrib/tools/python3/src/Lib/ast.py b/contrib/tools/python3/src/Lib/ast.py
index 396eea1830..854a7332ec 100644
--- a/contrib/tools/python3/src/Lib/ast.py
+++ b/contrib/tools/python3/src/Lib/ast.py
@@ -1,42 +1,42 @@
-"""
-    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.
-"""
+""" 
+    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. 
+""" 
 import sys
-from _ast import *
+from _ast import * 
 from contextlib import contextmanager, nullcontext
 from enum import IntEnum, auto
-
-
+ 
+ 
 def parse(source, filename='<unknown>', mode='exec', *,
           type_comments=False, feature_version=None):
-    """
-    Parse the source into an AST node.
-    Equivalent to compile(source, filename, mode, PyCF_ONLY_AST).
+    """ 
+    Parse the source into an AST node. 
+    Equivalent to compile(source, filename, mode, PyCF_ONLY_AST). 
     Pass type_comments=True to get back type comments where the syntax allows.
-    """
+    """ 
     flags = PyCF_ONLY_AST
     if type_comments:
         flags |= PyCF_TYPE_COMMENTS
@@ -49,74 +49,74 @@ def parse(source, filename='<unknown>', mode='exec', *,
     # Else it should be an int giving the minor version for 3.x.
     return compile(source, filename, mode, flags,
                    _feature_version=feature_version)
-
-
-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 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 _raise_malformed_node(node):
         raise ValueError(f'malformed node or string: {node!r}')
-    def _convert_num(node):
+    def _convert_num(node): 
         if not isinstance(node, Constant) or type(node.value) not in (int, float, complex):
             _raise_malformed_node(node)
         return node.value
-    def _convert_signed_num(node):
-        if isinstance(node, UnaryOp) and isinstance(node.op, (UAdd, USub)):
-            operand = _convert_num(node.operand)
-            if isinstance(node.op, UAdd):
-                return + operand
-            else:
-                return - operand
-        return _convert_num(node)
-    def _convert(node):
-        if isinstance(node, Constant):
-            return node.value
-        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))
+    def _convert_signed_num(node): 
+        if isinstance(node, UnaryOp) and isinstance(node.op, (UAdd, USub)): 
+            operand = _convert_num(node.operand) 
+            if isinstance(node.op, UAdd): 
+                return + operand 
+            else: 
+                return - operand 
+        return _convert_num(node) 
+    def _convert(node): 
+        if isinstance(node, Constant): 
+            return node.value 
+        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, Call) and isinstance(node.func, Name) and
               node.func.id == 'set' and node.args == node.keywords == []):
             return set()
-        elif isinstance(node, Dict):
+        elif isinstance(node, Dict): 
             if len(node.keys) != len(node.values):
                 _raise_malformed_node(node)
-            return dict(zip(map(_convert, node.keys),
-                            map(_convert, node.values)))
-        elif isinstance(node, BinOp) and isinstance(node.op, (Add, Sub)):
-            left = _convert_signed_num(node.left)
-            right = _convert_num(node.right)
-            if isinstance(left, (int, float)) and isinstance(right, complex):
-                if isinstance(node.op, Add):
-                    return left + right
-                else:
-                    return left - right
-        return _convert_signed_num(node)
-    return _convert(node_or_string)
-
-
+            return dict(zip(map(_convert, node.keys), 
+                            map(_convert, node.values))) 
+        elif isinstance(node, BinOp) and isinstance(node.op, (Add, Sub)): 
+            left = _convert_signed_num(node.left) 
+            right = _convert_num(node.right) 
+            if isinstance(left, (int, float)) and isinstance(right, complex): 
+                if isinstance(node.op, Add): 
+                    return left + right 
+                else: 
+                    return left - right 
+        return _convert_signed_num(node) 
+    return _convert(node_or_string) 
+ 
+ 
 def dump(node, annotate_fields=True, include_attributes=False, *, indent=None):
-    """
+    """ 
     Return a formatted dump of the tree in node.  This is mainly useful for
     debugging purposes.  If annotate_fields is true (by default),
     the returned string will show the names and the values for fields.
     If annotate_fields is false, the result string will be more compact by
     omitting unambiguous field names.  Attributes such as line
-    numbers and column offsets are not dumped by default.  If this is wanted,
+    numbers and column offsets are not dumped by default.  If this is wanted, 
     include_attributes can be set to true.  If indent is a non-negative
     integer or string, then the tree will be pretty-printed with that indent
     level. None (the default) selects the single line representation.
-    """
+    """ 
     def _format(node, level=0):
         if indent is not None:
             level += 1
@@ -125,7 +125,7 @@ def dump(node, annotate_fields=True, include_attributes=False, *, indent=None):
         else:
             prefix = ''
             sep = ', '
-        if isinstance(node, AST):
+        if isinstance(node, AST): 
             cls = type(node)
             args = []
             allsimple = True
@@ -145,7 +145,7 @@ def dump(node, annotate_fields=True, include_attributes=False, *, indent=None):
                     args.append('%s=%s' % (name, value))
                 else:
                     args.append(value)
-            if include_attributes and node._attributes:
+            if include_attributes and node._attributes: 
                 for name in node._attributes:
                     try:
                         value = getattr(node, name)
@@ -159,24 +159,24 @@ def dump(node, annotate_fields=True, include_attributes=False, *, indent=None):
             if allsimple and len(args) <= 3:
                 return '%s(%s)' % (node.__class__.__name__, ', '.join(args)), not args
             return '%s(%s%s)' % (node.__class__.__name__, prefix, sep.join(args)), False
-        elif isinstance(node, list):
+        elif isinstance(node, list): 
             if not node:
                 return '[]', True
             return '[%s%s]' % (prefix, sep.join(_format(x, level)[0] for x in node)), False
         return repr(node), True
 
-    if not isinstance(node, AST):
-        raise TypeError('expected AST, got %r' % node.__class__.__name__)
+    if not isinstance(node, AST): 
+        raise TypeError('expected AST, got %r' % node.__class__.__name__) 
     if indent is not None and not isinstance(indent, str):
         indent = ' ' * indent
     return _format(node)[0]
-
-
-def copy_location(new_node, old_node):
-    """
+ 
+ 
+def copy_location(new_node, old_node): 
+    """ 
     Copy source location (`lineno`, `col_offset`, `end_lineno`, and `end_col_offset`
     attributes) from *old_node* to *new_node* if possible, and return *new_node*.
-    """
+    """ 
     for attr in 'lineno', 'col_offset', 'end_lineno', 'end_col_offset':
         if attr in old_node._attributes and attr in new_node._attributes:
             value = getattr(old_node, attr, None)
@@ -186,113 +186,113 @@ def copy_location(new_node, old_node):
                 hasattr(old_node, attr) and attr.startswith("end_")
             ):
                 setattr(new_node, attr, value)
-    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*.
-    """
+    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, end_lineno, end_col_offset):
-        if 'lineno' in node._attributes:
-            if not hasattr(node, 'lineno'):
-                node.lineno = lineno
-            else:
-                lineno = node.lineno
+        if 'lineno' in node._attributes: 
+            if not hasattr(node, 'lineno'): 
+                node.lineno = lineno 
+            else: 
+                lineno = node.lineno 
         if 'end_lineno' in node._attributes:
             if getattr(node, 'end_lineno', None) is None:
                 node.end_lineno = end_lineno
             else:
                 end_lineno = node.end_lineno
-        if 'col_offset' in node._attributes:
-            if not hasattr(node, 'col_offset'):
-                node.col_offset = col_offset
-            else:
-                col_offset = node.col_offset
+        if 'col_offset' in node._attributes: 
+            if not hasattr(node, 'col_offset'): 
+                node.col_offset = col_offset 
+            else: 
+                col_offset = node.col_offset 
         if 'end_col_offset' in node._attributes:
             if getattr(node, 'end_col_offset', None) is None:
                 node.end_col_offset = end_col_offset
             else:
                 end_col_offset = node.end_col_offset
-        for child in iter_child_nodes(node):
+        for child in iter_child_nodes(node): 
             _fix(child, lineno, col_offset, end_lineno, end_col_offset)
     _fix(node, 1, 0, 1, 0)
-    return node
-
-
-def increment_lineno(node, n=1):
-    """
+    return node 
+ 
+ 
+def increment_lineno(node, n=1): 
+    """ 
     Increment the line number and end 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
+    """ 
+    for child in walk(node): 
+        if 'lineno' in child._attributes: 
+            child.lineno = getattr(child, 'lineno', 0) + n 
         if (
             "end_lineno" in child._attributes
             and (end_lineno := getattr(child, "end_lineno", 0)) is not None
         ):
             child.end_lineno = end_lineno + 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 *clean* is `True`, all tabs are expanded to spaces and any whitespace
-    that can be uniformly removed from the second line onwards is removed.
-    """
-    if not isinstance(node, (AsyncFunctionDef, FunctionDef, ClassDef, Module)):
-        raise TypeError("%r can't have docstrings" % node.__class__.__name__)
-    if not(node.body and isinstance(node.body[0], Expr)):
-        return None
-    node = node.body[0].value
-    if isinstance(node, Str):
-        text = node.s
-    elif isinstance(node, Constant) and isinstance(node.value, str):
-        text = node.value
-    else:
-        return None
-    if clean:
-        import inspect
-        text = inspect.cleandoc(text)
-    return text
-
-
+    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 *clean* is `True`, all tabs are expanded to spaces and any whitespace 
+    that can be uniformly removed from the second line onwards is removed. 
+    """ 
+    if not isinstance(node, (AsyncFunctionDef, FunctionDef, ClassDef, Module)): 
+        raise TypeError("%r can't have docstrings" % node.__class__.__name__) 
+    if not(node.body and isinstance(node.body[0], Expr)): 
+        return None 
+    node = node.body[0].value 
+    if isinstance(node, Str): 
+        text = node.s 
+    elif isinstance(node, Constant) and isinstance(node.value, str): 
+        text = node.value 
+    else: 
+        return None 
+    if clean: 
+        import inspect 
+        text = inspect.cleandoc(text) 
+    return text 
+ 
+ 
 def _splitlines_no_ff(source):
     """Split a string into lines ignoring form feed and other chars.
 
@@ -366,56 +366,56 @@ def get_source_segment(source, node, *, padded=False):
     return ''.join(lines)
 
 
-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)
-
+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) 
+ 
     def visit_Constant(self, node):
         value = node.value
         type_name = _const_node_type_names.get(type(value))
@@ -436,65 +436,65 @@ class NodeVisitor(object):
                               DeprecationWarning, 2)
                 return visitor(node)
         return self.generic_visit(node)
-
-
-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):
+ 
+
+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 Subscript(
-                   value=Name(id='data', ctx=Load()),
+                   value=Name(id='data', ctx=Load()), 
                    slice=Constant(value=node.id),
-                   ctx=node.ctx
+                   ctx=node.ctx 
                )
-
-    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
+ 
+    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 
 
 
 # If the ast module is loaded more than once, only add deprecated methods once