wehub-resource-sync
719 lines
28 KiB
Python
719 lines
28 KiB
Python
# Copyright (c) 2016, Serge Guelton
|
|
# All rights reserved.
|
|
|
|
# Redistribution and use in source and binary forms, with or without
|
|
# modification, are permitted provided that the following conditions are met:
|
|
|
|
# Redistributions of source code must retain the above copyright notice, this
|
|
# list of conditions and the following disclaimer.
|
|
|
|
# Redistributions in binary form must reproduce the above copyright notice,
|
|
# this list of conditions and the following disclaimer in the documentation
|
|
# and/or other materials provided with the distribution.
|
|
|
|
# Neither the name of HPCProject, Serge Guelton nor the names of its
|
|
# contributors may be used to endorse or promote products derived from this
|
|
# software without specific prior written permission.
|
|
|
|
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
|
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
|
|
# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
|
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
|
# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
# NOTE(paddle-dev): We introduce third-party library Gast as unified AST
|
|
# representation. See https://github.com/serge-sans-paille/gast for details.
|
|
|
|
import sys as _sys
|
|
import ast as _ast
|
|
from ast import boolop, cmpop, excepthandler, expr, expr_context, operator
|
|
from ast import slice, stmt, unaryop, mod, AST
|
|
from ast import iter_child_nodes, walk
|
|
|
|
try:
|
|
from ast import TypeIgnore
|
|
except ImportError:
|
|
class TypeIgnore(AST):
|
|
pass
|
|
|
|
try:
|
|
from ast import pattern
|
|
except ImportError:
|
|
class pattern(AST):
|
|
pass
|
|
|
|
|
|
try:
|
|
from ast import type_param
|
|
except ImportError:
|
|
class type_param(AST):
|
|
pass
|
|
|
|
|
|
def _make_node(Name, Fields, Attributes, Bases):
|
|
|
|
# This constructor is used a lot during conversion from ast to gast,
|
|
# then as the primary way to build ast nodes. So we tried to optimized it
|
|
# for speed and not for readability.
|
|
def create_node(self, *args, **kwargs):
|
|
if len(args) > len(Fields):
|
|
raise TypeError(
|
|
"{} constructor takes at most {} positional arguments".
|
|
format(Name, len(Fields)))
|
|
|
|
# it's faster to iterate rather than zipping or enumerate
|
|
for i in range(len(args)):
|
|
setattr(self, Fields[i], args[i])
|
|
if kwargs: # cold branch
|
|
self.__dict__.update(kwargs)
|
|
|
|
setattr(_sys.modules[__name__],
|
|
Name,
|
|
type(Name,
|
|
Bases,
|
|
{'__init__': create_node,
|
|
'_fields': Fields,
|
|
'_field_types': {},
|
|
'_attributes': Attributes}))
|
|
|
|
def _fill_field_types(Name, FieldTypes):
|
|
node = getattr(_sys.modules[__name__], Name)
|
|
assert len(node._fields) == len(FieldTypes), Name
|
|
node._field_types.update(zip(node._fields, FieldTypes))
|
|
|
|
_nodes = (
|
|
# mod
|
|
('Module', (('body', 'type_ignores'), (), (mod,))),
|
|
('Interactive', (('body',), (), (mod,))),
|
|
('Expression', (('body',), (), (mod,))),
|
|
('FunctionType', (('argtypes', 'returns'), (), (mod,))),
|
|
('Suite', (('body',), (), (mod,))),
|
|
|
|
# stmt
|
|
('FunctionDef', (('name', 'args', 'body', 'decorator_list', 'returns',
|
|
'type_comment', 'type_params'),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(stmt,))),
|
|
('AsyncFunctionDef', (('name', 'args', 'body', 'decorator_list', 'returns',
|
|
'type_comment', 'type_params',),
|
|
('lineno', 'col_offset',
|
|
'end_lineno', 'end_col_offset',),
|
|
(stmt,))),
|
|
('ClassDef', (('name', 'bases', 'keywords', 'body', 'decorator_list',
|
|
'type_params',),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(stmt,))),
|
|
('Return', (('value',),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(stmt,))),
|
|
('Delete', (('targets',),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(stmt,))),
|
|
('Assign', (('targets', 'value', 'type_comment'),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(stmt,))),
|
|
('TypeAlias', (('name', 'type_params', 'value'),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(stmt,))),
|
|
('AugAssign', (('target', 'op', 'value',),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(stmt,))),
|
|
('AnnAssign', (('target', 'annotation', 'value', 'simple',),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(stmt,))),
|
|
('Print', (('dest', 'values', 'nl',),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(stmt,))),
|
|
('For', (('target', 'iter', 'body', 'orelse', 'type_comment'),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(stmt,))),
|
|
('AsyncFor', (('target', 'iter', 'body', 'orelse', 'type_comment'),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(stmt,))),
|
|
('While', (('test', 'body', 'orelse',),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(stmt,))),
|
|
('If', (('test', 'body', 'orelse',),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(stmt,))),
|
|
('With', (('items', 'body', 'type_comment'),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(stmt,))),
|
|
('AsyncWith', (('items', 'body', 'type_comment'),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(stmt,))),
|
|
('Match', (('subject', 'cases'),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(stmt,))),
|
|
('Raise', (('exc', 'cause',),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(stmt,))),
|
|
('Try', (('body', 'handlers', 'orelse', 'finalbody',),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(stmt,))),
|
|
('TryStar', (('body', 'handlers', 'orelse', 'finalbody',),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(stmt,))),
|
|
('Assert', (('test', 'msg',),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(stmt,))),
|
|
('Import', (('names',),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(stmt,))),
|
|
('ImportFrom', (('module', 'names', 'level',),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(stmt,))),
|
|
('Exec', (('body', 'globals', 'locals',),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(stmt,))),
|
|
('Global', (('names',),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(stmt,))),
|
|
('Nonlocal', (('names',),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(stmt,))),
|
|
('Expr', (('value',),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(stmt,))),
|
|
('Pass', ((), ('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(stmt,))),
|
|
('Break', ((), ('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(stmt,))),
|
|
('Continue', ((),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(stmt,))),
|
|
|
|
# expr
|
|
|
|
('BoolOp', (('op', 'values',),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(expr,))),
|
|
('NamedExpr', (('target', 'value',),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(expr,))),
|
|
('BinOp', (('left', 'op', 'right',),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(expr,))),
|
|
('UnaryOp', (('op', 'operand',),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(expr,))),
|
|
('Lambda', (('args', 'body',),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(expr,))),
|
|
('IfExp', (('test', 'body', 'orelse',),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(expr,))),
|
|
('Dict', (('keys', 'values',),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(expr,))),
|
|
('Set', (('elts',),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(expr,))),
|
|
('ListComp', (('elt', 'generators',),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(expr,))),
|
|
('SetComp', (('elt', 'generators',),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(expr,))),
|
|
('DictComp', (('key', 'value', 'generators',),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(expr,))),
|
|
('GeneratorExp', (('elt', 'generators',),
|
|
('lineno', 'col_offset',
|
|
'end_lineno', 'end_col_offset',),
|
|
(expr,))),
|
|
('Await', (('value',),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(expr,))),
|
|
('Yield', (('value',),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(expr,))),
|
|
('YieldFrom', (('value',),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(expr,))),
|
|
('Compare', (('left', 'ops', 'comparators',),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(expr,))),
|
|
('Call', (('func', 'args', 'keywords',),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(expr,))),
|
|
('Repr', (('value',),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(expr,))),
|
|
('FormattedValue', (('value', 'conversion', 'format_spec',),
|
|
('lineno', 'col_offset',
|
|
'end_lineno', 'end_col_offset',),
|
|
(expr,))),
|
|
('Interpolation', (('value', 'str', 'conversion', 'format_spec',),
|
|
('lineno', 'col_offset',
|
|
'end_lineno', 'end_col_offset',),
|
|
(expr,))),
|
|
('JoinedStr', (('values',),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(expr,))),
|
|
('TemplateStr', (('values',),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(expr,))),
|
|
('Constant', (('value', 'kind'),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(expr,))),
|
|
('Attribute', (('value', 'attr', 'ctx',),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(expr,))),
|
|
('Subscript', (('value', 'slice', 'ctx',),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(expr,))),
|
|
('Starred', (('value', 'ctx',),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(expr,))),
|
|
('Name', (('id', 'ctx', 'annotation', 'type_comment'),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(expr,))),
|
|
('List', (('elts', 'ctx',),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(expr,))),
|
|
('Tuple', (('elts', 'ctx',),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(expr,))),
|
|
|
|
# expr_context
|
|
('Load', ((), (), (expr_context,))),
|
|
('Store', ((), (), (expr_context,))),
|
|
('Del', ((), (), (expr_context,))),
|
|
('AugLoad', ((), (), (expr_context,))),
|
|
('AugStore', ((), (), (expr_context,))),
|
|
('Param', ((), (), (expr_context,))),
|
|
|
|
# slice
|
|
('Slice', (('lower', 'upper', 'step'),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset',),
|
|
(slice,))),
|
|
|
|
# boolop
|
|
('And', ((), (), (boolop,))),
|
|
('Or', ((), (), (boolop,))),
|
|
|
|
# operator
|
|
('Add', ((), (), (operator,))),
|
|
('Sub', ((), (), (operator,))),
|
|
('Mult', ((), (), (operator,))),
|
|
('MatMult', ((), (), (operator,))),
|
|
('Div', ((), (), (operator,))),
|
|
('Mod', ((), (), (operator,))),
|
|
('Pow', ((), (), (operator,))),
|
|
('LShift', ((), (), (operator,))),
|
|
('RShift', ((), (), (operator,))),
|
|
('BitOr', ((), (), (operator,))),
|
|
('BitXor', ((), (), (operator,))),
|
|
('BitAnd', ((), (), (operator,))),
|
|
('FloorDiv', ((), (), (operator,))),
|
|
|
|
# unaryop
|
|
('Invert', ((), (), (unaryop, AST,))),
|
|
('Not', ((), (), (unaryop, AST,))),
|
|
('UAdd', ((), (), (unaryop, AST,))),
|
|
('USub', ((), (), (unaryop, AST,))),
|
|
|
|
# cmpop
|
|
('Eq', ((), (), (cmpop,))),
|
|
('NotEq', ((), (), (cmpop,))),
|
|
('Lt', ((), (), (cmpop,))),
|
|
('LtE', ((), (), (cmpop,))),
|
|
('Gt', ((), (), (cmpop,))),
|
|
('GtE', ((), (), (cmpop,))),
|
|
('Is', ((), (), (cmpop,))),
|
|
('IsNot', ((), (), (cmpop,))),
|
|
('In', ((), (), (cmpop,))),
|
|
('NotIn', ((), (), (cmpop,))),
|
|
|
|
# comprehension
|
|
('comprehension', (('target', 'iter', 'ifs', 'is_async'), (), (AST,))),
|
|
|
|
# excepthandler
|
|
('ExceptHandler', (('type', 'name', 'body'),
|
|
('lineno', 'col_offset',
|
|
'end_lineno', 'end_col_offset'),
|
|
(excepthandler,))),
|
|
|
|
# arguments
|
|
('arguments', (('args', 'posonlyargs', 'vararg', 'kwonlyargs',
|
|
'kw_defaults', 'kwarg', 'defaults'), (), (AST,))),
|
|
|
|
# keyword
|
|
('keyword', (('arg', 'value'),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset'),
|
|
(AST,))),
|
|
|
|
# alias
|
|
('alias', (('name', 'asname'),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset'),
|
|
(AST,))),
|
|
|
|
# withitem
|
|
('withitem', (('context_expr', 'optional_vars'), (), (AST,))),
|
|
|
|
# match_case
|
|
('match_case', (('pattern', 'guard', 'body'), (), (AST,))),
|
|
|
|
# pattern
|
|
('MatchValue', (('value',),
|
|
('lineno', 'col_offset', 'end_lineno', 'end_col_offset'),
|
|
(pattern,))),
|
|
('MatchSingleton', (('value',),
|
|
('lineno', 'col_offset',
|
|
'end_lineno', 'end_col_offset'),
|
|
(pattern,))),
|
|
('MatchSequence', (('patterns',),
|
|
('lineno', 'col_offset',
|
|
'end_lineno', 'end_col_offset'),
|
|
(pattern,))),
|
|
('MatchMapping', (('keys', 'patterns', 'rest'),
|
|
('lineno', 'col_offset',
|
|
'end_lineno', 'end_col_offset'),
|
|
(pattern,))),
|
|
('MatchClass', (('cls', 'patterns', 'kwd_attrs', 'kwd_patterns'),
|
|
('lineno', 'col_offset',
|
|
'end_lineno', 'end_col_offset'),
|
|
(pattern,))),
|
|
('MatchStar', (('name',),
|
|
('lineno', 'col_offset',
|
|
'end_lineno', 'end_col_offset'),
|
|
(pattern,))),
|
|
('MatchAs', (('pattern', 'name'),
|
|
('lineno', 'col_offset',
|
|
'end_lineno', 'end_col_offset'),
|
|
(pattern,))),
|
|
('MatchOr', (('patterns',),
|
|
('lineno', 'col_offset',
|
|
'end_lineno', 'end_col_offset'),
|
|
(pattern,))),
|
|
|
|
# type_ignore
|
|
('type_ignore', ((), ('lineno', 'tag'), (TypeIgnore,))),
|
|
|
|
# type_param
|
|
('TypeVar', (('name', 'bound', 'default_value'),
|
|
('lineno', 'col_offset',
|
|
'end_lineno', 'end_col_offset'),
|
|
(type_param,))),
|
|
('ParamSpec', (('name', 'default_value'),
|
|
('lineno', 'col_offset',
|
|
'end_lineno', 'end_col_offset'),
|
|
(type_param,))),
|
|
('TypeVarTuple', (('name', 'default_value'),
|
|
('lineno', 'col_offset',
|
|
'end_lineno', 'end_col_offset'),
|
|
(type_param,))),
|
|
)
|
|
|
|
for _name, _descr in _nodes:
|
|
_make_node(_name, *_descr)
|
|
|
|
# As an exception to gast rule that states that all nodes are identical for all
|
|
# python version, we don't fill the field type for python with a version lower
|
|
# than 3.10. Those version lack type support to be compatible with the more
|
|
# modern representation anyway. The _field_types still exists though, but it's
|
|
# always empty.
|
|
if _sys.version_info >= (3, 10):
|
|
|
|
_node_types = (
|
|
# mod
|
|
('Module', (list[stmt], list[type_ignore])),
|
|
('Interactive', (list[stmt],)),
|
|
('Expression', (expr,)),
|
|
('FunctionType', ('argtypes', 'returns'),),
|
|
('Suite', (list[stmt],),),
|
|
|
|
# stmt
|
|
('FunctionDef', (str, arguments, list[stmt], list[expr], expr | None, str | None, list[type_param]),),
|
|
('AsyncFunctionDef', (str, arguments, list[stmt], list[expr], expr | None, str | None, list[type_param]),),
|
|
('ClassDef', (str, list[expr], list[keyword], list[stmt], list[expr], list[type_param])),
|
|
('Return', (expr | None,)),
|
|
('Delete', (list[expr],)),
|
|
('Assign', (list[expr], expr, str | None),),
|
|
('TypeAlias', (expr, list[type_param], expr),),
|
|
('AugAssign', (expr, operator, expr), ),
|
|
('AnnAssign', (expr, expr, expr | None, int), ),
|
|
('Print', (expr | None, list[expr], bool), ),
|
|
('For', (expr, expr, list[stmt], list[stmt], str | None), ),
|
|
('AsyncFor', (expr, expr, list[stmt], list[stmt], str | None), ),
|
|
('While', (expr, list[stmt], list[stmt]), ),
|
|
('If', (expr, list[stmt], list[stmt]), ),
|
|
('With', (list[withitem], list[stmt], str | None), ),
|
|
('AsyncWith', (list[withitem], list[stmt], str | None), ),
|
|
('Match', (expr, match_case), ),
|
|
('Raise', (expr | None, expr | None), ),
|
|
('Try', (list[stmt], list[excepthandler], list[stmt], list[stmt]), ),
|
|
('TryStar', (list[stmt], list[excepthandler], list[stmt], list[stmt]), ),
|
|
('Assert', (expr, expr | None), ),
|
|
('Import', (list[alias],), ),
|
|
('ImportFrom', (str|None, list[alias], int | None), ),
|
|
('Exec', (expr, expr | None, expr | None), ),
|
|
('Global', (list[str],), ),
|
|
('Nonlocal', (list[str],), ),
|
|
('Expr', (expr,), ),
|
|
|
|
# expr
|
|
|
|
('BoolOp', (boolop, list[expr]), ),
|
|
('NamedExpr', (expr, expr), ),
|
|
('BinOp', (expr, operator, expr), ),
|
|
('UnaryOp', (unaryop, expr), ),
|
|
('Lambda', (arguments, expr), ),
|
|
('IfExp', (expr, expr, expr), ),
|
|
('Dict', (list[expr], list[expr]), ),
|
|
('Set', (list[expr],), ),
|
|
('ListComp', (expr, list[comprehension]), ),
|
|
('SetComp', (expr, list[comprehension]), ),
|
|
('DictComp', (expr, expr, list[comprehension]), ),
|
|
('GeneratorExp', (expr, list[comprehension]), ),
|
|
('Await', (expr,), ),
|
|
('Yield', (expr | None,), ),
|
|
('YieldFrom', (expr,), ),
|
|
('Compare', (expr, list[cmpop], list[expr]), ),
|
|
('Call', (expr, list[expr], list[keyword]), ),
|
|
('Repr', (expr,), ),
|
|
('FormattedValue', (expr, int, expr | None), ),
|
|
('Interpolation', (expr, str, int, expr | None), ),
|
|
('JoinedStr', (list[expr],), ),
|
|
('TemplateStr', (list[expr],), ),
|
|
('Constant', (object, str | None), ),
|
|
('Attribute', (expr, str, expr_context), ),
|
|
('Subscript', (expr, expr, expr_context), ),
|
|
('Starred', (expr, expr_context), ),
|
|
('Name', (str, expr_context, expr, str | None), ),
|
|
('List', (list[expr], expr_context), ),
|
|
('Tuple', (list[expr], expr_context), ),
|
|
('Slice', (expr | None, expr | None, expr | None), ),
|
|
|
|
# comprehension
|
|
('comprehension', (expr, expr, list[expr], int), ),
|
|
|
|
# excepthandler
|
|
('ExceptHandler', (expr | None, str | None, list[stmt]), ),
|
|
|
|
# arguments
|
|
('arguments', (list[expr], list[expr], expr | None, list[expr], list[expr], expr | None, list[expr]), ),
|
|
|
|
# keyword
|
|
('keyword', (str | None, expr), ),
|
|
|
|
# alias
|
|
('alias', (str, str | None), ),
|
|
|
|
# withitem
|
|
('withitem', (expr, expr | None), ),
|
|
|
|
# match_case
|
|
('match_case', (pattern, expr, list[stmt]), ),
|
|
|
|
# pattern
|
|
('MatchValue', (expr,), ),
|
|
('MatchSingleton', (object,), ),
|
|
('MatchSequence', (list[pattern],), ),
|
|
('MatchMapping', (list[expr], list[pattern], str | None), ),
|
|
('MatchClass', (expr, list[pattern], list[str], list[pattern]), ),
|
|
('MatchStar', (str | None,), ),
|
|
('MatchAs', (pattern | None, str | None), ),
|
|
('MatchOr', (list[pattern],), ),
|
|
|
|
# type_param
|
|
('TypeVar', (str, expr | None, expr | None), ),
|
|
('ParamSpec', (str, expr | None), ),
|
|
('TypeVarTuple', (str, expr | None), ),
|
|
)
|
|
|
|
for _name, _types in _node_types:
|
|
_fill_field_types(_name, _types)
|
|
|
|
from .ast3 import ast_to_gast, gast_to_ast
|
|
|
|
|
|
def parse(*args, **kwargs):
|
|
return ast_to_gast(_ast.parse(*args, **kwargs))
|
|
|
|
|
|
def literal_eval(node_or_string):
|
|
if isinstance(node_or_string, AST):
|
|
node_or_string = gast_to_ast(node_or_string)
|
|
return _ast.literal_eval(node_or_string)
|
|
|
|
|
|
def get_docstring(node, clean=True):
|
|
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, Constant) and isinstance(node.value, str):
|
|
text = node.value
|
|
else:
|
|
return None
|
|
if clean:
|
|
import inspect
|
|
text = inspect.cleandoc(text)
|
|
return text
|
|
|
|
|
|
# the following are directly imported from python3.8's Lib/ast.py #
|
|
|
|
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 \
|
|
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, end_lineno, end_col_offset):
|
|
if 'lineno' in node._attributes:
|
|
if not hasattr(node, 'lineno'):
|
|
node.lineno = lineno
|
|
else:
|
|
lineno = node.lineno
|
|
if 'end_lineno' in node._attributes:
|
|
if not hasattr(node, 'end_lineno'):
|
|
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 'end_col_offset' in node._attributes:
|
|
if not hasattr(node, 'end_col_offset'):
|
|
node.end_col_offset = end_col_offset
|
|
else:
|
|
end_col_offset = node.end_col_offset
|
|
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
|
|
|
|
|
|
if _sys.version_info.major == 3 and _sys.version_info.minor >= 8:
|
|
get_source_segment = _ast.get_source_segment
|
|
else:
|
|
# No end_lineno no end_col_offset info set for those version, so always
|
|
# return None
|
|
def get_source_segment(source, node, padded=False):
|
|
return None
|
|
|
|
|
|
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) or 0) + n
|
|
if 'end_lineno' in child._attributes:
|
|
child.end_lineno = (getattr(child, 'end_lineno', 0) or 0) + n
|
|
return node
|
|
|
|
# Code import from Lib/ast.py
|
|
#
|
|
# minor changes: getattr(x, y, ...) is None => getattr(x, y, 42) is None
|
|
#
|
|
def dump(
|
|
node, annotate_fields=True, include_attributes=False,
|
|
# *, # removed for compatibility with python2 :-/
|
|
indent=None, show_empty=False,
|
|
):
|
|
"""
|
|
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,
|
|
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.
|
|
If show_empty is False, then empty lists and fields that are None
|
|
will be omitted from the output for better readability.
|
|
"""
|
|
def _format(node, level=0):
|
|
if indent is not None:
|
|
level += 1
|
|
prefix = '\n' + indent * level
|
|
sep = ',\n' + indent * level
|
|
else:
|
|
prefix = ''
|
|
sep = ', '
|
|
if isinstance(node, AST):
|
|
cls = type(node)
|
|
args = []
|
|
args_buffer = []
|
|
allsimple = True
|
|
keywords = annotate_fields
|
|
for name in node._fields:
|
|
try:
|
|
value = getattr(node, name)
|
|
except AttributeError:
|
|
keywords = True
|
|
continue
|
|
if value is None and getattr(cls, name, 42) is None:
|
|
keywords = True
|
|
continue
|
|
if not show_empty:
|
|
if value == []:
|
|
if not keywords:
|
|
args_buffer.append(repr(value))
|
|
continue
|
|
if not keywords:
|
|
args.extend(args_buffer)
|
|
args_buffer = []
|
|
value, simple = _format(value, level)
|
|
allsimple = allsimple and simple
|
|
if keywords:
|
|
args.append('%s=%s' % (name, value))
|
|
else:
|
|
args.append(value)
|
|
if include_attributes and node._attributes:
|
|
for name in node._attributes:
|
|
try:
|
|
value = getattr(node, name)
|
|
except AttributeError:
|
|
continue
|
|
if value is None and getattr(cls, name, 42) is None:
|
|
continue
|
|
value, simple = _format(value, level)
|
|
allsimple = allsimple and simple
|
|
args.append('%s=%s' % (name, value))
|
|
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):
|
|
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 indent is not None and not isinstance(indent, str):
|
|
indent = ' ' * indent
|
|
return _format(node)[0]
|