@pyscript/core 0.5.8 → 0.5.10

package/env/lib/python3.12/site-packages/python_minifier/expression_printer.py

@@ -1,748 +0,0 @@
-import ast
-import sys
-
-from python_minifier.util import is_ast_node
-
-from python_minifier.token_printer import TokenPrinter, Delimiter
-
-
-class ExpressionPrinter(object):
-    """
-    Builds the smallest possible exact representation of an ast
-    """
-
-    def __init__(self):
-
-        self.precedences = {
-            'Lambda': 2,  # Lambda
-            'IfExp': 3,  # IfExp
-            'comprehension': 3.5,
-            'Or': 4,  # BoolOp
-            'And': 5,
-            'Not': 6,
-            'In': 7, 'NotIn': 7, 'Is': 7, 'IsNot': 7, 'Lt': 7, 'LtE': 7, 'Gt': 7, 'GtE': 7, 'NotEq': 7, 'Eq': 7,  # Compare
-            'BitOr': 8,
-            'BitXor': 9,
-            'BitAnd': 10,
-            'LShift': 11, 'RShift': 11,
-            'Add': 12, 'Sub': 12,
-            'Mult': 13, 'Div': 13, 'FloorDiv': 13, 'Mod': 13, 'MatMult': 13,
-            'UAdd': 14, 'USub': 14, 'Invert': 14,
-            'Pow': 15,
-            'Await': 16,
-            'Subscript': 17, 'Call': 17, 'Attribute': 17,
-            'Tuple': 18, 'Set': 18, 'List': 18, 'Dict': 18, 'ListComp': 18, 'SetComp': 18, 'DictComp': 18, 'GeneratorExp': 18,  # Container
-        }
-
-        self.printer = TokenPrinter()
-
-    def __call__(self, module):
-        """
-        Generate the source code for an AST
-
-        :param module: The Module to generate code for
-        :type module: ast.Module
-        :rtype: str
-
-        """
-
-        self.visit(module)
-        return str(self.printer)
-
-    def precedence(self, node):
-        """
-        The precedence of an expression
-
-        Node will usually be an operator or literal.
-        Nodes with no precedence value return 0.
-
-        :param node: The AST node to decide precedence for
-        :type node: ast.Node
-        :rtype: int
-
-        """
-
-        if isinstance(node, (ast.BinOp, ast.UnaryOp, ast.BoolOp)):
-            return self.precedences[node.op.__class__.__name__]
-        elif isinstance(node, ast.Compare):
-            return min(self.precedences[n.__class__.__name__] for n in node.ops)
-
-        # Python2 parses negative ints as an ast.Num with a negative value.
-        # Make sure the Num get the precedence of the USub operator in this case.
-        if sys.version_info < (3, 0) and isinstance(node, ast.Num):
-            if str(node.n)[0] == '-':
-                return self.precedences['USub']
-
-        return self.precedences.get(node.__class__.__name__, 0)
-
-    def visit(self, node):
-        """
-        Visit a node
-
-        Call the correct visit_ method based on the node type.
-        Prefer to call the correct method directly if you already know
-        the node type.
-
-        :param node: The node to visit
-        :type node: ast.Node
-
-        """
-
-        method = 'visit_' + node.__class__.__name__
-        visitor = getattr(self, method, self.visit_Unknown)
-        return visitor(node)
-
-    def visit_Unknown(self, node):
-        raise RuntimeError('Unknown node %r' % node)
-
-    # region Literals
-
-    def visit_Constant(self, node):
-        if node.value is None or node.value is True or node.value is False:
-            return self.visit_NameConstant(node)
-        elif isinstance(node.value, (int, float, complex)):
-            return self.visit_Num(node)
-        elif isinstance(node.value, str):
-            return self.visit_Str(node)
-        elif isinstance(node.value, bytes):
-            return self.visit_Bytes(node)
-        elif node.value == Ellipsis:
-            return self.visit_Ellipsis(node)
-
-        raise RuntimeError('Unknown Constant value %r' % type(node.value))
-
-    def visit_Num(self, node):
-        if isinstance(node.n, float):
-            self.printer.floatnumber(node.n)
-        elif isinstance(node.n, complex):
-            self.printer.imagnumber(node.n)
-        else:
-            # int or possibly long in python2
-            self.printer.integer(node.n)
-
-    def visit_Str(self, node):
-        self.printer.stringliteral(node.s)
-
-    def visit_Bytes(self, node):
-        self.printer.bytesliteral(node.s)
-
-    def visit_List(self, node):
-        self.printer.delimiter('[')
-        self._exprlist(node.elts)
-        self.printer.delimiter(']')
-
-    def visit_Tuple(self, node):
-
-        if len(node.elts) == 0:
-            self.printer.delimiter('(')
-            self.printer.delimiter(')')
-            return
-
-        self._exprlist(node.elts)
-
-        if len(node.elts) == 1:
-            self.printer.delimiter(',')
-
-    def visit_Set(self, node):
-        self.printer.delimiter('{')
-        self._exprlist(node.elts)
-        self.printer.delimiter('}')
-
-    def visit_Dict(self, node):
-        assert isinstance(node, ast.Dict)
-
-        def key_datum(key, datum):
-
-            if key is None:
-                self.printer.operator('**')
-
-                if 0 < self.precedence(datum) <=7:
-                    self.printer.delimiter('(')
-                    self._expression(datum)
-                    self.printer.delimiter(')')
-                else:
-                    self._expression(datum)
-            else:
-                self._expression(key)
-                self.printer.delimiter(':')
-
-                self._expression(datum)
-
-        self.printer.delimiter('{')
-
-        delimiter = Delimiter(self.printer)
-        for key, datum in zip(node.keys, node.values):
-            delimiter.new_item()
-            key_datum(key, datum)
-
-        self.printer.delimiter('}')
-
-    def visit_Ellipsis(self, node):
-        self.printer.delimiter('.')
-        self.printer.delimiter('.')
-        self.printer.delimiter('.')
-
-    def visit_NameConstant(self, node):
-        self.printer.keyword(repr(node.value))
-
-    # endregion
-
-    # region Variables
-
-    def visit_Name(self, node):
-        self.printer.identifier(node.id)
-
-    def visit_Starred(self, node):
-        self.printer.operator('*')
-        if 0 < self.precedence(node.value) <= 7:
-            self.printer.delimiter('(')
-            self._expression(node.value)
-            self.printer.delimiter(')')
-        else:
-            self._expression(node.value)
-
-    # endregion
-
-    # region Expressions
-
-    def visit_UnaryOp(self, node):
-        self.visit(node.op)
-
-        if sys.version_info < (3, 0) and isinstance(node.op, ast.USub) and isinstance(node.operand, ast.Num):
-            # For: -(1), which is parsed as a UnaryOp(USub, Num(1)).
-            # Without this special case it would be printed as -1
-            # This is fine, but python 2 will then parse it at Num(-1) so the AST wouldn't round-trip.
-
-            self.printer.delimiter('(')
-            self.visit_Num(node.operand)
-            self.printer.delimiter(')')
-            return
-
-        right_precedence = self.precedence(node.operand)
-        op_precedence = self.precedence(node)
-
-        if right_precedence != 0 and (
-            (op_precedence > right_precedence)
-        ):
-            self.printer.delimiter('(')
-            self._expression(node.operand)
-            self.printer.delimiter(')')
-        else:
-            self._expression(node.operand)
-
-    def visit_UAdd(self, node):
-        self.printer.operator('+')
-
-    def visit_USub(self, node):
-        self.printer.operator('-')
-
-    def visit_Not(self, node):
-        self.printer.keyword('not')
-
-    def visit_Invert(self, node):
-        self.printer.operator('~')
-
-    def visit_BinOp(self, node):
-        self._lhs(node.left, node.op)
-        self.visit(node.op)
-        self._rhs(node.right, node.op)
-
-    def visit_Add(self, node):
-        self.printer.operator('+')
-
-    def visit_Sub(self, node):
-        self.printer.operator('-')
-
-    def visit_Mult(self, node):
-        self.printer.operator('*')
-
-    def visit_Div(self, node):
-        self.printer.operator('/')
-
-    def visit_FloorDiv(self, node):
-        self.printer.operator('//')
-
-    def visit_Mod(self, node):
-        self.printer.operator('%')
-
-    def visit_Pow(self, node):
-        self.printer.operator('**')
-
-    def visit_LShift(self, node):
-        self.printer.operator('<<')
-
-    def visit_RShift(self, node):
-        self.printer.operator('>>')
-
-    def visit_BitOr(self, node):
-        self.printer.operator('|')
-
-    def visit_BitXor(self, node):
-        self.printer.operator('^')
-
-    def visit_BitAnd(self, node):
-        self.printer.operator('&')
-
-    def visit_MatMult(self, node):
-        self.printer.operator('@')
-
-    def visit_BoolOp(self, node):
-        first = True
-
-        op_precedence = self.precedence(node.op)
-
-        for v in node.values:
-            if first:
-                first = False
-            else:
-                self._expression(node.op)
-
-            value_precedence = self.precedence(v)
-
-            if value_precedence != 0 and (
-                (op_precedence > value_precedence)
-                or op_precedence == value_precedence
-                and self._is_left_associative(node.op)
-            ):
-                self.printer.delimiter('(')
-                self._expression(v)
-                self.printer.delimiter(')')
-            else:
-                self._expression(v)
-
-    def visit_And(self, node):
-        self.printer.keyword('and')
-
-    def visit_Or(self, node):
-        self.printer.keyword('or')
-
-    def visit_Compare(self, node):
-
-        left_precedence = self.precedence(node.left)
-        op_precedence = self.precedence(node.ops[0])
-
-        if left_precedence != 0 and ((op_precedence > left_precedence) or (op_precedence == left_precedence)):
-            self.printer.delimiter('(')
-            self._expression(node.left)
-            self.printer.delimiter(')')
-        else:
-            self._expression(node.left)
-
-        for op, comparator in zip(node.ops, node.comparators):
-            self._expression(op)
-            self._rhs(comparator, op)
-
-    def visit_Eq(self, node):
-        self.printer.operator('==')
-
-    def visit_NotEq(self, node):
-        self.printer.operator('!=')
-
-    def visit_Lt(self, node):
-        self.printer.operator('<')
-
-    def visit_LtE(self, node):
-        self.printer.operator('<=')
-
-    def visit_Gt(self, node):
-        self.printer.operator('>')
-
-    def visit_GtE(self, node):
-        self.printer.operator('>=')
-
-    def visit_Is(self, node):
-        self.printer.keyword('is')
-
-    def visit_IsNot(self, node):
-        self.printer.keyword('is')
-        self.printer.keyword('not')
-
-    def visit_In(self, node):
-        self.printer.keyword('in')
-
-    def visit_NotIn(self, node):
-        self.printer.keyword('not')
-        self.printer.keyword('in')
-
-    def visit_Call(self, node):
-
-        self._lhs(node.func, node)
-
-        self.printer.delimiter('(')
-
-        single_call = len(node.args) == 1 and not node.keywords and not hasattr(node, 'starargs') and not hasattr(node, 'kwargs')
-
-        delimiter = Delimiter(self.printer)
-
-        for arg in node.args:
-            delimiter.new_item()
-
-            if single_call and isinstance(arg, ast.GeneratorExp):
-                self.visit_GeneratorExp(arg, omit_parens=True)
-            else:
-                self._expression(arg)
-
-        if node.keywords:
-            for kwarg in node.keywords:
-                delimiter.new_item()
-
-                assert isinstance(kwarg, ast.keyword)
-                self.visit_keyword(kwarg)
-
-        if hasattr(node, 'starargs') and node.starargs is not None:
-            delimiter.new_item()
-
-            self.printer.operator('*')
-            self._expression(node.starargs)
-
-        if hasattr(node, 'kwargs') and node.kwargs is not None:
-            delimiter.new_item()
-
-            self.printer.operator('**')
-            self.visit(node.kwargs)
-
-        self.printer.delimiter(')')
-
-    def visit_keyword(self, node):
-        if node.arg is None:
-            self.printer.operator('**')
-            self._expression(node.value)
-        else:
-            self.printer.identifier(node.arg)
-            self.printer.delimiter('=')
-            self._expression(node.value)
-
-    def visit_IfExp(self, node):
-
-        self._rhs(node.body, node)
-
-        self.printer.keyword('if')
-
-        self._rhs(node.test, node)
-
-        self.printer.keyword('else')
-
-        self._expression(node.orelse)
-
-    def visit_Attribute(self, node):
-        value_precedence = self.precedence(node.value)
-        attr_precedence = self.precedence(node)
-
-        if (value_precedence != 0 and (attr_precedence > value_precedence)) or isinstance(node.value, ast.Num):
-            self.printer.delimiter('(')
-            self._expression(node.value)
-            self.printer.delimiter(')')
-        else:
-            self._expression(node.value)
-
-        self.printer.delimiter('.')
-        self.printer.identifier(node.attr)
-
-    # endregion
-
-    # region Subscripting
-
-    def visit_Subscript(self, node):
-
-        value_precedence = self.precedence(node.value)
-        slice_precedence = 17  # self.precedence(node)
-
-        if value_precedence != 0 and (slice_precedence > value_precedence):
-            self.printer.delimiter('(')
-            self._expression(node.value)
-            self.printer.delimiter(')')
-        else:
-            self._expression(node.value)
-
-        self.printer.delimiter('[')
-
-        if isinstance(node.slice, ast.Index):
-            self.visit_Index(node.slice)
-        elif isinstance(node.slice, ast.Slice):
-            self.visit_Slice(node.slice)
-        elif isinstance(node.slice, ast.ExtSlice):
-            self.visit_ExtSlice(node.slice)
-        elif isinstance(node.slice, ast.Ellipsis):
-            self.visit_Ellipsis(node)
-        elif sys.version_info >= (3, 9) and isinstance(node.slice, ast.Tuple):
-            self.visit_Tuple(node.slice)
-        elif sys.version_info >= (3, 9):
-            self._expression(node.slice)
-        else:
-            raise AssertionError('Unknown slice type %r' % node.slice)
-
-        self.printer.delimiter(']')
-
-    def visit_Index(self, node):
-        self._expression(node.value)
-
-    def visit_Slice(self, node):
-        if node.lower:
-            self._expression(node.lower)
-        self.printer.delimiter(':')
-
-        if node.upper:
-            self._expression(node.upper)
-        if node.step:
-            self.printer.delimiter(':')
-            self._expression(node.step)
-
-    def visit_ExtSlice(self, node):
-
-        delimiter = Delimiter(self.printer)
-        for s in node.dims:
-            delimiter.new_item()
-            self._expression(s)
-
-        if len(node.dims) == 1:
-            self.printer.delimiter(',')
-
-    # endregion
-
-    # region Comprehensions
-
-    def visit_ListComp(self, node):
-        self.printer.delimiter('[')
-        self._expression(node.elt)
-        [self.visit_comprehension(x) for x in node.generators]
-        self.printer.delimiter(']')
-
-    def visit_SetComp(self, node):
-        self.printer.delimiter('{')
-        self._expression(node.elt)
-        [self.visit_comprehension(x) for x in node.generators]
-        self.printer.delimiter('}')
-
-    def visit_GeneratorExp(self, node, omit_parens=False):
-
-        if not omit_parens:
-            self.printer.delimiter('(')
-
-        self._expression(node.elt)
-        [self.visit_comprehension(x) for x in node.generators]
-
-        if not omit_parens:
-            self.printer.delimiter(')')
-
-    def visit_DictComp(self, node):
-        self.printer.delimiter('{')
-        self._expression(node.key)
-        self.printer.delimiter(':')
-        self._expression(node.value)
-        [self.visit_comprehension(x) for x in node.generators]
-        self.printer.delimiter('}')
-
-    def visit_comprehension(self, node):
-        assert isinstance(node, ast.comprehension)
-
-        if hasattr(node, 'is_async') and node.is_async:
-            self.printer.keyword('async')
-
-        self.printer.keyword('for')
-        self._exprlist([node.target])
-        self.printer.keyword('in')
-
-        self._rhs(node.iter, node)
-
-        if node.ifs:
-            for i in node.ifs:
-                self.printer.keyword('if')
-                self._rhs(i, node)
-
-    # endregion
-
-    # region Function and Class definitions
-
-    def visit_Lambda(self, node):
-
-        self.printer.keyword('lambda')
-
-        self.visit_arguments(node.args)
-
-        self.printer.delimiter(':')
-
-        self._expression(node.body)
-
-    def visit_arguments(self, node):
-        args = getattr(node, 'posonlyargs', []) + node.args
-
-        delimiter = Delimiter(self.printer)
-
-        count_no_defaults = len(args) - len(node.defaults)
-        for i, arg in enumerate(args):
-            delimiter.new_item()
-
-            self._expression(arg)
-
-            if i >= count_no_defaults:
-                self.printer.delimiter('=')
-                self._expression(node.defaults[i - count_no_defaults])
-
-            if hasattr(node, 'posonlyargs') and node.posonlyargs and i + 1 == len(node.posonlyargs):
-                self.printer.delimiter(',')
-                self.printer.operator('/')
-
-        if node.vararg:
-            delimiter.new_item()
-
-            self.printer.operator('*')
-
-            if hasattr(node, 'varargannotation'):
-                self.printer.identifier(node.vararg)
-                if node.varargannotation is not None:
-                    self.printer.delimiter(':')
-                    self._expression(node.varargannotation)
-            elif isinstance(node.vararg, str):
-                self.printer.identifier(node.vararg)
-            else:
-                self.visit(node.vararg)
-
-        if hasattr(node, 'kwonlyargs') and node.kwonlyargs:
-
-            if not node.vararg:
-                delimiter.new_item()
-                self.printer.operator('*')
-
-            for i, arg in enumerate(node.kwonlyargs):
-                self.printer.delimiter(',')
-                self.visit_arg(arg)
-
-                if node.kw_defaults[i] is not None:
-                    self.printer.delimiter('=')
-                    self._expression(node.kw_defaults[i])
-
-        if node.kwarg:
-            delimiter.new_item()
-
-            self.printer.operator('**')
-
-            if hasattr(node, 'kwargannotation'):
-                self.printer.identifier(node.kwarg)
-                if node.kwargannotation is not None:
-                    self.printer.delimiter(':')
-                    self._expression(node.kwargannotation)
-            elif isinstance(node.kwarg, str):
-                self.printer.identifier(node.kwarg)
-            else:
-                self.visit(node.kwarg)
-
-    def visit_arg(self, node):
-        if isinstance(node, ast.Name):
-            # Python 2 uses Name nodes
-            return self.visit_Name(node)
-
-        self.printer.identifier(node.arg)
-
-        if node.annotation:
-            self.printer.delimiter(':')
-            self._expression(node.annotation)
-
-    def visit_Repr(self, node):
-        self.printer.delimiter('`')
-        self._expression(node.value)
-        self.printer.delimiter('`')
-
-    # endregion
-
-    def visit_Expression(self, node):
-        self._expression(node.body)
-
-    def _expression(self, expression):
-        if is_ast_node(expression, (ast.Yield, 'YieldFrom')):
-            self.printer.delimiter('(')
-            self._yield_expr(expression)
-            self.printer.delimiter(')')
-        elif isinstance(expression, ast.Tuple) and len(expression.elts) > 0:
-            self.printer.delimiter('(')
-            self.visit_Tuple(expression)
-            self.printer.delimiter(')')
-        elif is_ast_node(expression, 'NamedExpr'):
-            self.printer.delimiter('(')
-            self.visit_NamedExpr(expression)
-            self.printer.delimiter(')')
-        else:
-            self.visit(expression)
-
-    def _testlist(self, test):
-        if is_ast_node(test, (ast.Yield, 'YieldFrom')):
-            self.printer.delimiter('(')
-            self._yield_expr(test)
-            self.printer.delimiter(')')
-        elif is_ast_node(test, 'NamedExpr'):
-            self.printer.delimiter('(')
-            self.visit_NamedExpr(test)
-            self.printer.delimiter(')')
-        else:
-            self.visit(test)
-
-    def _exprlist(self, exprlist):
-        delimiter = Delimiter(self.printer)
-        for expr in exprlist:
-            delimiter.new_item()
-            self._expression(expr)
-
-    def _yield_expr(self, yield_node):
-        if isinstance(yield_node, ast.Yield):
-            self.printer.keyword('yield')
-        elif isinstance(yield_node, ast.YieldFrom):
-            self.printer.keyword('yield')
-            self.printer.keyword('from')
-
-        if yield_node.value is not None:
-            self._expression(yield_node.value)
-
-    @staticmethod
-    def _is_right_associative(operator):
-        return isinstance(operator, ast.Pow)
-
-    @staticmethod
-    def _is_left_associative(operator):
-        return not isinstance(operator, ast.Pow)
-
-    def _lhs(self, left_node, op_node):
-        left_precedence = self.precedence(left_node)
-        op_precedence = self.precedence(op_node)
-
-        if left_precedence != 0 and (
-            (op_precedence > left_precedence)
-            or (op_precedence == left_precedence and self._is_right_associative(op_node))
-        ):
-            self.printer.delimiter('(')
-            self._expression(left_node)
-            self.printer.delimiter(')')
-        else:
-            self._expression(left_node)
-
-    def _rhs(self, right_node, op_node):
-        right_precedence = self.precedence(right_node)
-        op_precedence = self.precedence(op_node)
-
-        if isinstance(op_node, ast.Pow) and right_precedence == 14:
-            op_precedence = right_precedence
-
-        if right_precedence != 0 and (
-            (op_precedence > right_precedence)
-            or (op_precedence == right_precedence and self._is_left_associative(op_node))
-        ):
-            self.printer.delimiter('(')
-            self._expression(right_node)
-            self.printer.delimiter(')')
-        else:
-            self._expression(right_node)
-
-    def visit_JoinedStr(self, node):
-        assert isinstance(node, ast.JoinedStr)
-
-        import python_minifier.f_string
-
-        self.printer.fstring(str(python_minifier.f_string.OuterFString(node)))
-
-    def visit_NamedExpr(self, node):
-        self._expression(node.target)
-        self.printer.operator(':=')
-        self._expression(node.value)
-
-    def visit_Await(self, node):
-        assert isinstance(node, ast.Await)
-        self.printer.keyword('await')
-        self._rhs(node.value, node)