python-minifier 2.11.2__py2-none-any.whl

python_minifier/transforms/constant_folding.py

@@ -0,0 +1,114 @@
+import python_minifier.ast_compat as ast
+import math
+import sys
+
+from python_minifier.ast_compare import compare_ast
+from python_minifier.expression_printer import ExpressionPrinter
+from python_minifier.transforms.suite_transformer import SuiteTransformer
+from python_minifier.util import is_ast_node
+
+class FoldConstants(SuiteTransformer):
+    """
+    Fold Constants if it would reduce the size of the source
+    """
+
+    def __init__(self):
+        super(FoldConstants, self).__init__()
+
+    def visit_BinOp(self, node):
+
+        node.left = self.visit(node.left)
+        node.right = self.visit(node.right)
+
+        # Check this is a constant expression that could be folded
+        # We don't try to fold strings or bytes, since they have probably been arranged this way to make the source shorter and we are unlikely to beat that
+        if not is_ast_node(node.left, (ast.Num, 'NameConstant')):
+            return node
+        if not is_ast_node(node.right, (ast.Num, 'NameConstant')):
+            return node
+
+        if isinstance(node.op, ast.Div):
+            # Folding div is subtle, since it can have different results in Python 2 and Python 3
+            # Do this once target version options have been implemented
+            return node
+
+        if isinstance(node.op, ast.Pow):
+            # This can be folded, but it is unlikely to reduce the size of the source
+            # It can also be slow to evaluate
+            return node
+
+        # Evaluate the expression
+        try:
+            original_expression = unparse_expression(node)
+            original_value = safe_eval(original_expression)
+        except Exception:
+            return node
+
+        # Choose the best representation of the value
+        if isinstance(original_value, float) and math.isnan(original_value):
+            # There is no nan literal.
+            # we could use float('nan'), but that complicates folding as it's not a Constant
+            return node
+        elif isinstance(original_value, bool):
+            new_node = ast.NameConstant(value=original_value)
+        elif isinstance(original_value, (int, float, complex)):
+            try:
+                if repr(original_value).startswith('-') and not sys.version_info < (3, 0):
+                    # Represent negative numbers as a USub UnaryOp, so that the ast roundtrip is correct
+                    new_node = ast.UnaryOp(op=ast.USub(), operand=ast.Num(n=-original_value))
+                else:
+                    new_node = ast.Num(n=original_value)
+            except Exception:
+                # repr(value) failed, most likely due to some limit
+                return node
+        else:
+            return node
+
+        # Evaluate the new value representation
+        try:
+            folded_expression = unparse_expression(new_node)
+            folded_value = safe_eval(folded_expression)
+        except Exception as e:
+            # This can happen if the value is too large to be represented as a literal
+            # or if the value is unparsed as nan, inf or -inf - which are not valid python literals
+            return node
+
+        if len(folded_expression) >= len(original_expression):
+            # Result is not shorter than original expression
+            return node
+
+        # Check the folded expression parses back to the same AST
+        try:
+            folded_ast = ast.parse(folded_expression, 'folded expression', mode='eval')
+            compare_ast(new_node, folded_ast.body)
+        except Exception:
+            # This can happen if the printed value doesn't parse back to the same AST
+            # e.g. complex numbers can be parsed as BinOp
+            return node
+
+        # Check the folded value is the same as the original value
+        if not equal_value_and_type(folded_value, original_value):
+            return node
+
+        # New representation is shorter and has the same value, so use it
+        return self.add_child(new_node, node.parent, node.namespace)
+
+def equal_value_and_type(a, b):
+    if type(a) != type(b):
+        return False
+
+    if isinstance(a, float) and math.isnan(a) and not math.isnan(b):
+        return False
+
+    return a == b
+
+def safe_eval(expression):
+    globals = {}
+    locals = {}
+
+    # This will return the value, or could raise an exception
+    return eval(expression, globals, locals)
+
+def unparse_expression(node):
+    expression_printer = ExpressionPrinter()
+    return expression_printer(node)

python_minifier/transforms/remove_annotations.py

@@ -0,0 +1,130 @@
+import python_minifier.ast_compat as ast
+import sys
+
+from python_minifier.transforms.remove_annotations_options import RemoveAnnotationsOptions
+from python_minifier.transforms.suite_transformer import SuiteTransformer
+
+
+class RemoveAnnotations(SuiteTransformer):
+    """
+    Remove type annotations from source
+    """
+
+    def __init__(self, options):
+        assert isinstance(options, RemoveAnnotationsOptions)
+        self._options = options
+        super(RemoveAnnotations, self).__init__()
+
+    def __call__(self, node):
+        if sys.version_info < (3, 0):
+            return node
+        return self.visit(node)
+
+    def visit_FunctionDef(self, node):
+        node.args = self.visit_arguments(node.args)
+        node.body = self.suite(node.body, parent=node)
+        node.decorator_list = [self.visit(d) for d in node.decorator_list]
+
+        if hasattr(node, 'type_params') and node.type_params is not None:
+            node.type_params = [self.visit(t) for t in node.type_params]
+
+        if hasattr(node, 'returns') and self._options.remove_return_annotations:
+            node.returns = None
+
+        return node
+
+    def visit_arguments(self, node):
+        assert isinstance(node, ast.arguments)
+
+        if hasattr(node, 'posonlyargs') and node.posonlyargs:
+            node.posonlyargs = [self.visit_arg(a) for a in node.posonlyargs]
+
+        if node.args:
+            node.args = [self.visit_arg(a) for a in node.args]
+
+        if hasattr(node, 'kwonlyargs') and node.kwonlyargs:
+            node.kwonlyargs = [self.visit_arg(a) for a in node.kwonlyargs]
+
+        if hasattr(node, 'varargannotation'):
+            if self._options.remove_argument_annotations:
+                node.varargannotation = None
+        else:
+            if node.vararg:
+                node.vararg = self.visit_arg(node.vararg)
+
+        if hasattr(node, 'kwargannotation'):
+            if self._options.remove_argument_annotations:
+                node.kwargannotation = None
+        else:
+            if node.kwarg:
+                node.kwarg = self.visit_arg(node.kwarg)
+
+        return node
+
+    def visit_arg(self, node):
+        if self._options.remove_argument_annotations:
+            node.annotation = None
+        return node
+
+    def visit_AnnAssign(self, node):
+        def is_dataclass_field(node):
+            if sys.version_info < (3, 7):
+                return False
+
+            if not isinstance(node.parent, ast.ClassDef):
+                return False
+
+            if len(node.parent.decorator_list) == 0:
+                return False
+
+            for node in node.parent.decorator_list:
+                if isinstance(node, ast.Name) and node.id == 'dataclass':
+                    return True
+                elif isinstance(node, ast.Attribute) and node.attr == 'dataclass':
+                    return True
+                elif isinstance(node, ast.Call) and isinstance(node.func, ast.Name) and node.func.id == 'dataclass':
+                    return True
+                elif isinstance(node, ast.Call) and isinstance(node.func, ast.Attribute) and node.func.attr == 'dataclass':
+                    return True
+
+            return False
+
+        def is_typing_sensitive(node):
+            if sys.version_info < (3, 5):
+                return False
+
+            if not isinstance(node.parent, ast.ClassDef):
+                return False
+
+            if len(node.parent.bases) == 0:
+                return False
+
+            tricky_types = ['NamedTuple', 'TypedDict']
+
+            for node in node.parent.bases:
+                if isinstance(node, ast.Name) and node.id in tricky_types:
+                    return True
+                elif isinstance(node, ast. Attribute) and node.attr in tricky_types:
+                    return True
+
+            return False
+
+        # is this a class attribute or a variable?
+        if isinstance(node.parent, ast.ClassDef):
+            if not self._options.remove_class_attribute_annotations:
+                return node
+        else:
+            if not self._options.remove_variable_annotations:
+                return node
+
+        if is_dataclass_field(node) or is_typing_sensitive(node):
+            return node
+        elif node.value:
+            return self.add_child(ast.Assign([node.target], node.value), parent=node.parent, namespace=node.namespace)
+        else:
+            # Valueless annotations cause the interpreter to treat the variable as a local.
+            # I don't know of another way to do that without assigning to it, so
+            # keep it as an AnnAssign, but replace the annotation with '0'
+
+            node.annotation = self.add_child(ast.Num(0), parent=node.parent, namespace=node.namespace)
+            return node

python_minifier/transforms/remove_annotations_options.py

@@ -0,0 +1,35 @@
+class RemoveAnnotationsOptions(object):
+    """
+    Options for the RemoveAnnotations transform
+
+    This can be passed to the minify function as the remove_annotations argument
+
+    :param remove_variable_annotations: Remove variable annotations
+    :type remove_variable_annotations: bool
+    :param remove_return_annotations: Remove return annotations
+    :type remove_return_annotations: bool
+    :param remove_argument_annotations: Remove argument annotations
+    :type remove_argument_annotations: bool
+    :param remove_class_attribute_annotations: Remove class attribute annotations
+    :type remove_class_attribute_annotations: bool
+    """
+
+    remove_variable_annotations = True
+    remove_return_annotations = True
+    remove_argument_annotations = True
+    remove_class_attribute_annotations = False
+
+    def __init__(self, remove_variable_annotations=True, remove_return_annotations=True, remove_argument_annotations=True, remove_class_attribute_annotations=False):
+        self.remove_variable_annotations = remove_variable_annotations
+        self.remove_return_annotations = remove_return_annotations
+        self.remove_argument_annotations = remove_argument_annotations
+        self.remove_class_attribute_annotations = remove_class_attribute_annotations
+
+    def __repr__(self):
+        return 'RemoveAnnotationsOptions(remove_variable_annotations=%r, remove_return_annotations=%r, remove_argument_annotations=%r, remove_class_attribute_annotations=%r)' % (self.remove_variable_annotations, self.remove_return_annotations, self.remove_argument_annotations, self.remove_class_attribute_annotations)
+
+    def __nonzero__(self):
+        return any((self.remove_variable_annotations, self.remove_return_annotations, self.remove_argument_annotations, self.remove_class_attribute_annotations))
+
+    def __bool__(self):
+        return self.__nonzero__()

python_minifier/transforms/remove_annotations_options.pyi

@@ -0,0 +1,17 @@
+class RemoveAnnotationsOptions:
+
+    remove_variable_annotations: bool
+    remove_return_annotations: bool
+    remove_argument_annotations: bool
+    remove_class_attribute_annotations: bool
+
+    def __init__(self,
+                 remove_variable_annotations: bool = ...,
+                 remove_return_annotations: bool = ...,
+                 remove_argument_annotations: bool = ...,
+                 remove_class_attribute_annotations: bool = ...):
+        ...
+
+    def __repr__(self) -> str: ...
+    def __nonzero__(self) -> bool: ...
+    def __bool__(self) -> bool: ...

python_minifier/transforms/remove_asserts.py

@@ -0,0 +1,26 @@
+import python_minifier.ast_compat as ast
+
+from python_minifier.transforms.suite_transformer import SuiteTransformer
+from python_minifier.util import is_ast_node
+
+
+class RemoveAsserts(SuiteTransformer):
+    """
+    Remove assert statements
+
+    If a statement is syntactically necessary, use an empty expression instead
+    """
+
+    def __call__(self, node):
+        return self.visit(node)
+
+    def suite(self, node_list, parent):
+        without_assert = [self.visit(a) for a in filter(lambda n: not is_ast_node(n, ast.Assert), node_list)]
+
+        if len(without_assert) == 0:
+            if isinstance(parent, ast.Module):
+                return []
+            else:
+                return [self.add_child(ast.Expr(value=ast.Num(0)), parent=parent)]
+
+        return without_assert

python_minifier/transforms/remove_debug.py

@@ -0,0 +1,53 @@
+import python_minifier.ast_compat as ast
+import sys
+
+from python_minifier.transforms.suite_transformer import SuiteTransformer
+from python_minifier.util import is_ast_node
+
+
+class RemoveDebug(SuiteTransformer):
+    """
+    Remove if statements where the condition tests __debug__ is True
+
+    If a statement is syntactically necessary, use an empty expression instead
+    """
+
+    def __call__(self, node):
+        return self.visit(node)
+
+    def constant_value(self, node):
+        if sys.version_info < (3, 4):
+            return node.id == 'True'
+        elif is_ast_node(node, 'NameConstant'):
+            return node.value
+        return None
+
+    def can_remove(self, node):
+        if not isinstance(node, ast.If):
+            return False
+
+        if isinstance(node.test, ast.Name) and node.test.id == '__debug__':
+            return True
+
+        if isinstance(node.test, ast.Compare) and len(node.test.ops) == 1 and isinstance(node.test.ops[0], ast.Is) and self.constant_value(node.test.comparators[0]) is True:
+            return True
+
+        if isinstance(node.test, ast.Compare) and len(node.test.ops) == 1 and isinstance(node.test.ops[0], ast.IsNot) and self.constant_value(node.test.comparators[0]) is False:
+            return True
+
+        if isinstance(node.test, ast.Compare) and len(node.test.ops) == 1 and isinstance(node.test.ops[0], ast.Eq) and self.constant_value(node.test.comparators[0]) is True:
+            return True
+
+        return False
+
+    def suite(self, node_list, parent):
+
+        without_debug = [self.visit(a) for a in filter(lambda n: not self.can_remove(n), node_list)]
+
+        if len(without_debug) == 0:
+            if isinstance(parent, ast.Module):
+                return []
+            else:
+                return [self.add_child(ast.Expr(value=ast.Num(0)), parent=parent)]
+
+        return without_debug

python_minifier/transforms/remove_exception_brackets.py

@@ -0,0 +1,124 @@
+"""
+Remove Call nodes that are only used to raise exceptions with no arguments
+
+If a Raise statement is used on a Name and the name refers to an exception, it is automatically instantiated with no arguments
+We can remove any Call nodes that are only used to raise exceptions with no arguments and let the Raise statement do the instantiation.
+When printed, this essentially removes the brackets from the exception name.
+
+We can't generally know if a name refers to an exception, so we only do this for builtin exceptions
+"""
+
+import python_minifier.ast_compat as ast
+import sys
+
+from python_minifier.rename.binding import BuiltinBinding
+
+# These are always exceptions, in every version of python
+builtin_exceptions = [
+    'SyntaxError', 'Exception', 'ValueError', 'BaseException', 'MemoryError', 'RuntimeError', 'DeprecationWarning', 'UnicodeEncodeError', 'KeyError', 'LookupError', 'TypeError', 'BufferError',
+    'ImportError', 'OSError', 'StopIteration', 'ArithmeticError', 'UserWarning', 'PendingDeprecationWarning', 'RuntimeWarning', 'IndentationError', 'UnicodeTranslateError', 'UnboundLocalError',
+    'AttributeError', 'EOFError', 'UnicodeWarning', 'BytesWarning', 'NameError', 'IndexError', 'TabError', 'SystemError', 'OverflowError', 'FutureWarning', 'SystemExit', 'Warning',
+    'FloatingPointError', 'ReferenceError', 'UnicodeError', 'AssertionError', 'SyntaxWarning', 'UnicodeDecodeError', 'GeneratorExit', 'ImportWarning', 'KeyboardInterrupt', 'ZeroDivisionError',
+    'NotImplementedError'
+]
+
+# These are exceptions only in python 2.7
+builtin_exceptions_2_7 = [
+    'IOError',
+    'StandardError',
+    'EnvironmentError',
+    'VMSError',
+    'WindowsError'
+]
+
+# These are exceptions in 3.3+
+builtin_exceptions_3_3 = [
+    'ChildProcessError',
+    'ConnectionError',
+    'BrokenPipeError',
+    'ConnectionAbortedError',
+    'ConnectionRefusedError',
+    'ConnectionResetError',
+    'FileExistsError',
+    'FileNotFoundError',
+    'InterruptedError',
+    'IsADirectoryError',
+    'NotADirectoryError',
+    'PermissionError',
+    'ProcessLookupError',
+    'TimeoutError',
+    'ResourceWarning',
+]
+
+# These are exceptions in 3.5+
+builtin_exceptions_3_5 = [
+    'StopAsyncIteration',
+    'RecursionError',
+]
+
+# These are exceptions in 3.6+
+builtin_exceptions_3_6 = [
+    'ModuleNotFoundError'
+]
+
+# These are exceptions in 3.10+
+builtin_exceptions_3_10 = [
+    'EncodingWarning'
+]
+
+# These are exceptions in 3.11+
+builtin_exceptions_3_11 = [
+    'BaseExceptionGroup',
+    'ExceptionGroup',
+    'BaseExceptionGroup',
+]
+
+def _remove_empty_call(binding):
+    assert isinstance(binding, BuiltinBinding)
+
+    for name_node in binding.references:
+        # For this to be a builtin, all references must be name nodes as it is not defined anywhere
+        assert isinstance(name_node, ast.Name) and isinstance(name_node.ctx, ast.Load)
+
+        if not isinstance(name_node.parent, ast.Call):
+            # This is not a call
+            continue
+        call_node = name_node.parent
+
+        if not isinstance(call_node.parent, ast.Raise):
+            # This is not a raise statement
+            continue
+        raise_node = call_node.parent
+
+        if len(call_node.args) > 0 or len(call_node.keywords) > 0:
+            # This is a call with arguments
+            continue
+
+        # This is an instance of the exception being called with no arguments
+        # let's replace it with just the name, cutting out the Call node
+
+        if raise_node.exc is call_node:
+            raise_node.exc = name_node
+        elif raise_node.cause is call_node:
+            raise_node.cause = name_node
+        name_node.parent = raise_node
+
+
+def remove_no_arg_exception_call(module):
+    assert isinstance(module, ast.Module)
+
+    if sys.version_info < (3, 0):
+        return module
+
+    for binding in module.bindings:
+        if not isinstance(binding, BuiltinBinding):
+            continue
+
+        if binding.is_redefined():
+            continue
+
+        if binding.name in builtin_exceptions:
+            # We can remove any calls to builtin exceptions
+            _remove_empty_call(binding)
+
+    return module

python_minifier/transforms/remove_explicit_return_none.py

@@ -0,0 +1,38 @@
+import python_minifier.ast_compat as ast
+import sys
+
+from python_minifier.transforms.suite_transformer import SuiteTransformer
+from python_minifier.util import is_ast_node
+
+
+class RemoveExplicitReturnNone(SuiteTransformer):
+    def __call__(self, node):
+        return self.visit(node)
+
+    def visit_Return(self, node):
+        assert isinstance(node, ast.Return)
+
+        # Transform `return None` -> `return`
+
+        if sys.version_info < (3, 4) and isinstance(node.value, ast.Name) and node.value.id == 'None':
+            node.value = None
+
+        elif sys.version_info >= (3, 4) and is_ast_node(node.value, 'NameConstant') and node.value.value is None:
+            node.value = None
+
+        return node
+
+    def visit_FunctionDef(self, node):
+        assert is_ast_node(node, (ast.FunctionDef, 'AsyncFunctionDef'))
+
+        node.body = [self.visit(a) for a in node.body]
+
+        # Remove an explicit valueless `return` from the end of a function
+        if len(node.body) > 0 and isinstance(node.body[-1], ast.Return) and node.body[-1].value is None:
+            node.body.pop()
+
+        # Replace empty suites with `0` expression statements
+        if len(node.body) == 0:
+            node.body = [self.add_child(ast.Expr(value=ast.Num(0)), parent=node)]
+
+        return node

python_minifier/transforms/remove_literal_statements.py

@@ -0,0 +1,61 @@
+import python_minifier.ast_compat as ast
+
+from python_minifier.transforms.suite_transformer import SuiteTransformer
+from python_minifier.util import is_ast_node
+
+
+def find_doc(node):
+
+    if isinstance(node, ast.Attribute):
+        if node.attr == '__doc__':
+            raise ValueError('__doc__ found!')
+
+    for child in ast.iter_child_nodes(node):
+        find_doc(child)
+
+
+def _doc_in_module(module):
+    try:
+        find_doc(module)
+        return False
+    except:
+        return True
+
+
+class RemoveLiteralStatements(SuiteTransformer):
+    """
+    Remove literal expressions from the code
+
+    This includes docstrings
+    """
+
+    def __call__(self, node):
+        if _doc_in_module(node):
+            return node
+        return self.visit(node)
+
+    def visit_Module(self, node):
+        for binding in node.bindings:
+            if binding.name == '__doc__':
+                node.body = [self.visit(a) for a in node.body]
+                return node
+
+        node.body = self.suite(node.body, parent=node)
+        return node
+
+    def is_literal_statement(self, node):
+        if not isinstance(node, ast.Expr):
+            return False
+
+        return is_ast_node(node.value, (ast.Num, ast.Str, 'NameConstant', 'Bytes'))
+
+    def suite(self, node_list, parent):
+        without_literals = [self.visit(n) for n in node_list if not self.is_literal_statement(n)]
+
+        if len(without_literals) == 0:
+            if isinstance(parent, ast.Module):
+                return []
+            else:
+                return [self.add_child(ast.Expr(value=ast.Num(0)), parent=parent)]
+
+        return without_literals

python_minifier/transforms/remove_object_base.py

@@ -0,0 +1,24 @@
+import python_minifier.ast_compat as ast
+import sys
+
+from python_minifier.transforms.suite_transformer import SuiteTransformer
+
+
+class RemoveObject(SuiteTransformer):
+    def __call__(self, node):
+        if sys.version_info < (3, 0):
+            return node
+
+        return self.visit(node)
+
+    def visit_ClassDef(self, node):
+        node.bases = [
+            b for b in node.bases if not isinstance(b, ast.Name) or (isinstance(b, ast.Name) and b.id != 'object')
+        ]
+
+        if hasattr(node, 'type_params') and node.type_params is not None:
+            node.type_params = [self.visit(t) for t in node.type_params]
+
+        node.body = [self.visit(n) for n in node.body]
+
+        return node

python_minifier/transforms/remove_pass.py

@@ -0,0 +1,26 @@
+import python_minifier.ast_compat as ast
+
+from python_minifier.transforms.suite_transformer import SuiteTransformer
+from python_minifier.util import is_ast_node
+
+
+class RemovePass(SuiteTransformer):
+    """
+    Remove Pass keywords from source
+
+    If a statement is syntactically necessary, use an empty expression instead
+    """
+
+    def __call__(self, node):
+        return self.visit(node)
+
+    def suite(self, node_list, parent):
+        without_pass = [self.visit(a) for a in filter(lambda n: not is_ast_node(n, ast.Pass), node_list)]
+
+        if len(without_pass) == 0:
+            if isinstance(parent, ast.Module):
+                return []
+            else:
+                return [self.add_child(ast.Expr(value=ast.Num(0)), parent=parent)]
+
+        return without_pass

python_minifier/transforms/remove_posargs.py

@@ -0,0 +1,13 @@
+import python_minifier.ast_compat as ast
+
+
+def remove_posargs(node):
+    if isinstance(node, ast.arguments):
+        if hasattr(node, 'posonlyargs'):
+            node.args = node.posonlyargs + node.args
+            node.posonlyargs = []
+
+    for child in ast.iter_child_nodes(node):
+        remove_posargs(child)
+
+    return node