python-minifier 2.11.2__py2-none-any.whl

python_minifier/ast_compare.py

@@ -0,0 +1,104 @@
+import python_minifier.ast_compat as ast
+
+from python_minifier.util import is_ast_node
+
+
+class CompareError(RuntimeError):
+    """
+    Raised when an AST compares unequal.
+    """
+
+    def __init__(self, lnode, rnode, msg=None):
+        self.lnode = lnode
+        self.rnode = rnode
+        self.msg = msg
+
+    def __repr__(self):
+        return 'NodeError(%r, %r)' % (self.lnode, self.rnode)
+
+    def namespace(self, node):
+        if hasattr(node, 'namespace'):
+            if is_ast_node(node.namespace, (ast.FunctionDef, ast.ClassDef, 'AsyncFunctionDef')):
+                return self.namespace(node.namespace) + '.' + node.namespace.name
+            elif isinstance(node.namespace, ast.Module):
+                return ''
+            else:
+                return repr(node.namespace.__class__)
+
+        return None
+
+    def __str__(self):
+        error = ''
+
+        if self.msg:
+            error += self.msg
+
+        if self.namespace(self.lnode):
+            error += ' in namespace ' + self.namespace(self.lnode)
+
+        if self.lnode and hasattr(self.lnode, 'lineno'):
+            error += ' at source %i:%i' % (self.lnode.lineno, self.lnode.col_offset)
+
+        return error
+
+
+def compare_ast(l_ast, r_ast):
+    """
+    Compare Python Abstract Syntax Trees
+
+    >>> compare_ast(l_ast, r_ast)
+
+    If the AST's are not identical, an exception will be raised.
+
+    """
+
+    def counter():
+        i = 0
+        while True:
+            yield i
+            i += 1
+
+    if type(l_ast) != type(r_ast):
+        raise CompareError(l_ast, r_ast, msg='Nodes do not match! %r != %r' % (l_ast, r_ast))
+
+    for field in set(l_ast._fields + r_ast._fields):
+
+        if field == 'kind' and isinstance(l_ast, ast.Constant):
+            continue
+
+        if isinstance(getattr(l_ast, field, None), list):
+
+            l_list = getattr(l_ast, field, None)
+            r_list = getattr(r_ast, field, None)
+
+            if len(l_list) != len(r_list):
+                raise CompareError(
+                    l_list,
+                    r_list,
+                    'List does not have the same number of elements! len(%s.%s)=%r, len(%s.%s)=%r'
+                    % (type(l_ast), field, len(l_list), type(r_ast), field, len(r_list)),
+                )
+
+            for i, l, r in zip(counter(), l_list, r_list):
+                if isinstance(l, ast.AST) or isinstance(r, ast.AST):
+                    compare_ast(l, r)
+                elif l != r:
+                    raise CompareError(
+                        l_ast,
+                        r_ast,
+                        'Fields do not match! %s.%s[%i]=%r, %s.%s[%i]=%r'
+                        % (type(l_ast), field, i, l, type(r_ast), field, i, r),
+                    )
+
+        else:
+            l = getattr(l_ast, field, None)
+            r = getattr(r_ast, field, None)
+
+            if isinstance(l, ast.AST) or isinstance(r, ast.AST):
+                compare_ast(l, r)
+            elif l != r:
+                raise CompareError(
+                    l_ast,
+                    r_ast,
+                    'Fields do not match! %s.%s=%r, %s.%s=%r' % (type(l_ast), field, l, type(r_ast), field, r),
+                )

python_minifier/ast_compat.py

@@ -0,0 +1,40 @@
+"""
+The is a backwards compatible shim for the ast module.
+
+This is the best way to make the ast module work the same in both python 2 and 3.
+This is essentially what the ast module was doing until 3.12, when it started throwing
+deprecation warnings.
+"""
+
+from ast import *
+
+# Ideally we don't import anything else
+
+if 'TypeAlias' in globals():
+
+    # Add n and s properties to Constant so it can stand in for Num, Str and Bytes
+    Constant.n = property(lambda self: self.value, lambda self, value: setattr(self, 'value', value))  # type: ignore[assignment]
+    Constant.s = property(lambda self: self.value, lambda self, value: setattr(self, 'value', value))  # type: ignore[assignment]
+
+    # These classes are redefined from the ones in ast that complain about deprecation
+    # They will continue to work once they are removed from ast
+
+    class Str(Constant):  # type: ignore[no-redef]
+        def __new__(cls, s, *args, **kwargs):
+            return Constant(value=s, *args, **kwargs)
+
+    class Bytes(Constant):  # type: ignore[no-redef]
+        def __new__(cls, s, *args, **kwargs):
+            return Constant(value=s, *args, **kwargs)
+
+    class Num(Constant):  # type: ignore[no-redef]
+        def __new__(cls, n, *args, **kwargs):
+            return Constant(value=n, *args, **kwargs)
+
+    class NameConstant(Constant):  # type: ignore[no-redef]
+        def __new__(cls, *args, **kwargs):
+            return Constant(*args, **kwargs)
+
+    class Ellipsis(Constant):  # type: ignore[no-redef]
+        def __new__(cls, *args, **kwargs):
+            return Constant(value=literal_eval('...'), *args, **kwargs)

python_minifier/ast_printer.py

@@ -0,0 +1,130 @@
+"""
+Print a representation of an AST
+
+This prints a human readable representation of the nodes in the AST.
+The goal is to make it easy to see what the AST looks like, and to
+make it easy to compare two ASTs.
+
+This is not intended to be a complete representation of the AST, some
+fields or field names may be omitted for clarity. It should still be precise and unambiguous.
+
+"""
+
+import python_minifier.ast_compat as ast
+
+from python_minifier.util import is_ast_node
+
+INDENT = '    '
+
+# The field name that can be omitted for each node
+# Either it's the only field or would otherwise be obvious
+default_fields = {
+    'Constant': 'value',
+    'Num': 'n',
+    'Str': 's',
+    'Bytes': 's',
+    'NameConstant': 'value',
+    'FormattedValue': 'value',
+    'JoinedStr': 'values',
+    'List': 'elts',
+    'Tuple': 'elts',
+    'Set': 'elts',
+    'Name': 'id',
+    'Expr': 'value',
+    'UnaryOp': 'op',
+    'BinOp': 'op',
+    'BoolOp': 'op',
+    'Call': 'func',
+    'Index': 'value',
+    'ExtSlice': 'dims',
+    'Assert': 'test',
+    'Delete': 'targets',
+    'Import': 'names',
+    'If': 'test',
+    'While': 'test',
+    'Try': 'handlers',
+    'TryExcept': 'handlers',
+    'With': 'items',
+    'withitem': 'context_expr',
+    'FunctionDef': 'name',
+    'arg': 'arg',
+    'Return': 'value',
+    'Yield': 'value',
+    'YieldFrom': 'value',
+    'Global': 'names',
+    'Nonlocal': 'names',
+    'ClassDef': 'name',
+    'AsyncFunctionDef': 'name',
+    'Await': 'value',
+    'AsyncWith': 'items',
+    'Raise': 'exc',
+    'Subscript': 'value',
+    'Attribute': 'value',
+    'AugAssign': 'op',
+}
+
+def is_literal(node, field):
+    if hasattr(ast, 'Constant') and isinstance(node, ast.Constant) and field == 'value':
+        return True
+
+    if is_ast_node(node, ast.Num) and field == 'n':
+        return True
+
+    if is_ast_node(node, ast.Str) and field == 's':
+        return True
+
+    if is_ast_node(node, 'Bytes') and field == 's':
+        return True
+
+    if is_ast_node(node, 'NameConstant') and field == 'value':
+        return True
+
+    return False
+
+def print_ast(node):
+    if not isinstance(node, ast.AST):
+        return repr(node)
+
+    s = ''
+
+    node_name = node.__class__.__name__
+    s += node_name
+    s += '('
+
+    first = True
+    for field, value in ast.iter_fields(node):
+        if not value and not is_literal(node, field):
+            # Don't bother printing fields that are empty, except for literals
+            continue
+
+        if field == 'ctx':
+            # Don't print the ctx, it's always apparent from context
+            continue
+
+        if first:
+            first = False
+        else:
+            s += ', '
+
+        if default_fields.get(node_name) != field:
+            s += field + '='
+
+        if isinstance(value, ast.AST):
+            s += print_ast(value)
+        elif isinstance(value, list):
+            s += '['
+            first_list = True
+            for item in value:
+                if first_list:
+                    first_list = False
+                else:
+                    s += ','
+
+                for line in print_ast(item).splitlines():
+                    s += '\n' + INDENT + line
+            s += '\n]'
+        else:
+            s += repr(value)
+
+    s += ')'
+    return s