python-minifier 3.1.1__tar.gz → 3.3.0__tar.gz

{python_minifier-3.1.1/src/python_minifier.egg-info → python_minifier-3.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python_minifier
-Version: 3.1.1
+Version: 3.3.0
 Summary: Transform Python source code into it's most compact representation
 Home-page: https://github.com/dflook/python-minifier
 Author: Daniel Flook

{python_minifier-3.1.1 → python_minifier-3.3.0}/setup.py

@@ -27,7 +27,7 @@ setup(
     long_description_content_type='text/markdown',
 
     python_requires='>=2.7, !=3.0.*, !=3.1.*, !=3.2.*, <3.15',
-    version='3.1.1',
+    version='3.3.0',
 
     classifiers=[
         'Development Status :: 5 - Production/Stable',

{python_minifier-3.1.1 → python_minifier-3.3.0}/src/python_minifier/__init__.py

@@ -25,6 +25,7 @@ from python_minifier.transforms.constant_folding import FoldConstants
 from python_minifier.transforms.remove_annotations import RemoveAnnotations
 from python_minifier.transforms.remove_annotations_options import RemoveAnnotationsOptions
 from python_minifier.transforms.remove_asserts import RemoveAsserts
+from python_minifier.transforms.remove_dead_branches import RemoveDeadBranches
 from python_minifier.transforms.remove_debug import RemoveDebug
 from python_minifier.transforms.remove_exception_brackets import remove_no_arg_exception_call
 from python_minifier.transforms.remove_explicit_return_none import RemoveExplicitReturnNone
@@ -72,7 +73,9 @@ def minify(
     remove_debug=False,
     remove_explicit_return_none=True,
     remove_builtin_exception_brackets=True,
-    constant_folding=True
+    constant_folding=True,
+    prefer_single_line=False,
+    remove_dead_branches=True
 ):
     """
     Minify a python module
@@ -107,6 +110,8 @@ def minify(
     :param bool remove_explicit_return_none: If explicit return None statements should be replaced with a bare return
     :param bool remove_builtin_exception_brackets: If brackets should be removed when raising exceptions with no arguments
     :param bool constant_folding: If literal expressions should be evaluated
+    :param bool prefer_single_line: If semi-colons should be preferred over newlines where there is no difference in output size
+    :param bool remove_dead_branches: If if-statements with a constant False test should be removed
 
     :rtype: str
 
@@ -153,12 +158,15 @@ def minify(
     if remove_debug:
         module = RemoveDebug()(module)
 
-    if remove_explicit_return_none:
-        module = RemoveExplicitReturnNone()(module)
-
     if constant_folding:
         module = FoldConstants()(module)
 
+    if remove_dead_branches:
+        module = RemoveDeadBranches()(module)
+
+    if remove_explicit_return_none:
+        module = RemoveExplicitReturnNone()(module)
+
     bind_names(module)
     resolve_names(module)
 
@@ -192,7 +200,7 @@ def minify(
     if convert_posargs_to_args:
         module = remove_posargs(module)
 
-    minified = unparse(module)
+    minified = unparse(module, prefer_single_line=prefer_single_line)
 
     if preserve_shebang is True:
         shebang_line = _find_shebang(source)
@@ -219,7 +227,7 @@ def _find_shebang(source):
     return None
 
 
-def unparse(module):
+def unparse(module, prefer_single_line=False):
     """
     Turn a module AST into python code
 
@@ -228,13 +236,14 @@ def unparse(module):
 
     :param module: The module to turn into python code
     :type: module: :class:`ast.Module`
+    :param bool prefer_single_line: If semi-colons should be preferred over newlines where there is no difference in output size
     :rtype: str
 
     """
 
     assert isinstance(module, ast.Module)
 
-    printer = ModulePrinter()
+    printer = ModulePrinter(prefer_single_line=prefer_single_line)
     printer(module)
 
     try:

{python_minifier-3.1.1 → python_minifier-3.3.0}/src/python_minifier/__init__.pyi

@@ -28,11 +28,16 @@ def minify(
     remove_debug: bool = ...,
     remove_explicit_return_none: bool = ...,
     remove_builtin_exception_brackets: bool = ...,
-    constant_folding: bool = ...
+    constant_folding: bool = ...,
+    prefer_single_line: bool = ...,
+    remove_dead_branches: bool = ...
 ) -> Text: ...
 
 
-def unparse(module: ast.Module) -> Text: ...
+def unparse(
+    module: ast.Module,
+    prefer_single_line: bool = ...
+) -> Text: ...
 
 
 def awslambda(

{python_minifier-3.1.1 → python_minifier-3.3.0}/src/python_minifier/__main__.py

@@ -10,7 +10,6 @@ from python_minifier.transforms.remove_annotations_options import RemoveAnnotati
 
 class MinificationNotBeneficialError(Exception):
     """Raised when minification results in larger output than the original."""
-    pass
 
 def stdout_write_bytes(data):
     """Write bytes to stdout with proper Python 2.7/3.x compatibility."""
@@ -140,6 +139,13 @@ def parse_args():
         dest='in_place'
     )
 
+    parser.add_argument(
+        '--prefer-single-line',
+        action='store_true',
+        help='Prefer multiple statements on a single line separated by semicolons, instead of newlines, where there is no difference in output size',
+        dest='prefer_single_line',
+    )
+
     # Minification arguments
     minification_options = parser.add_argument_group('minification options', 'Options that affect how the source is minified')
     minification_options.add_argument(
@@ -243,6 +249,12 @@ def parse_args():
         help='Disable evaluating literal expressions',
         dest='constant_folding',
     )
+    minification_options.add_argument(
+        '--no-remove-dead-branches',
+        action='store_false',
+        help='Disable removing branches that are never executed',
+        dest='remove_dead_branches',
+    )
 
     annotation_options = parser.add_argument_group('remove annotations options', 'Options that affect how annotations are removed')
     annotation_options.add_argument(
@@ -298,6 +310,10 @@ def parse_args():
         sys.stderr.write('error: --remove-class-attribute-annotations would do nothing when used with --no-remove-annotations\n')
         sys.exit(1)
 
+    if args.remove_debug and not args.remove_dead_branches:
+        sys.stderr.write('error: --remove-debug would do nothing when used with --no-remove-dead-branches\n')
+        sys.exit(1)
+
     return args
 
 
@@ -373,7 +389,8 @@ def do_minify(source, filename, minification_args):
         remove_debug=minification_args.remove_debug,
         remove_explicit_return_none=minification_args.remove_explicit_return_none,
         remove_builtin_exception_brackets=minification_args.remove_exception_brackets,
-        constant_folding=minification_args.constant_folding
+        constant_folding=minification_args.constant_folding,
+        prefer_single_line=minification_args.prefer_single_line,
     )
 
     # Encode minified result to bytes for comparison and output

{python_minifier-3.1.1 → python_minifier-3.3.0}/src/python_minifier/expression_printer.py

@@ -11,7 +11,7 @@ class ExpressionPrinter(object):
     Builds the smallest possible exact representation of an ast
     """
 
-    def __init__(self):
+    def __init__(self, prefer_single_line=False):
 
         self.precedences = {
             'Lambda': 2,  # Lambda
@@ -34,7 +34,7 @@ class ExpressionPrinter(object):
             'Tuple': 18, 'Set': 18, 'List': 18, 'Dict': 18, 'ListComp': 18, 'SetComp': 18, 'DictComp': 18, 'GeneratorExp': 18,  # Container
         }
 
-        self.printer = TokenPrinter()
+        self.printer = TokenPrinter(prefer_single_line=prefer_single_line)
 
     def __call__(self, module):
         """
@@ -221,9 +221,7 @@ class ExpressionPrinter(object):
         right_precedence = self.precedence(node.operand)
         op_precedence = self.precedence(node)
 
-        if right_precedence != 0 and (
-            (op_precedence > right_precedence)
-        ):
+        if right_precedence != 0 and op_precedence > right_precedence:
             self.printer.delimiter('(')
             self._expression(node.operand)
             self.printer.delimiter(')')

{python_minifier-3.1.1 → python_minifier-3.3.0}/src/python_minifier/module_printer.py

@@ -11,8 +11,8 @@ class ModulePrinter(ExpressionPrinter):
     Builds the smallest possible exact representation of an ast
     """
 
-    def __init__(self, indent_char='\t'):
-        super(ModulePrinter, self).__init__()
+    def __init__(self, indent_char='\t', prefer_single_line=False):
+        super(ModulePrinter, self).__init__(prefer_single_line=prefer_single_line)
         self.indent_char = indent_char
 
     def __call__(self, module):
@@ -602,7 +602,7 @@ class ModulePrinter(ExpressionPrinter):
 
         if node.guard is not None:
             self.printer.keyword('if')
-            self.visit(node.guard)
+            self._expression(node.guard)
 
         self.printer.delimiter(':')
         self._suite(node.body)

{python_minifier-3.1.1 → python_minifier-3.3.0}/src/python_minifier/rename/rename_literals.py

@@ -1,3 +1,5 @@
+from collections import OrderedDict
+
 import python_minifier.ast_compat as ast
 from python_minifier.ast_annotation import get_parent, set_parent
 
@@ -118,7 +120,7 @@ class HoistLiterals(NodeVisitor):
     def __call__(self, module, ignore_slots=True):
         self.module = module
         self._ignore_slots = ignore_slots
-        self._hoisted = {}
+        self._hoisted = OrderedDict()
         self.visit(module)
         self.place_bindings()
 

{python_minifier-3.1.1 → python_minifier-3.3.0}/src/python_minifier/token_printer.py

@@ -306,7 +306,7 @@ class TokenPrinter(object):
     def end_statement(self):
         """ End a statement with a newline, or a semi-colon if it saves characters. """
 
-        if self.indent == 0:
+        if self.indent == 0 and not self._prefer_single_line:
             self.newline()
         else:
             if self._code[-1] != ';':

{python_minifier-3.1.1 → python_minifier-3.3.0}/src/python_minifier/transforms/constant_folding.py

@@ -10,40 +10,46 @@ from python_minifier.transforms.suite_transformer import SuiteTransformer
 from python_minifier.util import is_constant_node
 
 
-class FoldConstants(SuiteTransformer):
+def is_foldable_constant(node):
     """
-    Fold Constants if it would reduce the size of the source
+    Check if a node is a constant expression that can participate in folding.
+
+    We can assume that children have already been folded, so foldable constants are either:
+    - Simple literals (Num, NameConstant)
+    - UnaryOp(USub/Invert) on a Num - these don't fold to shorter forms,
+      so they remain after child visiting. UAdd and Not would have been
+      folded away since they always produce shorter results.
     """
+    if is_constant_node(node, (ast.Num, ast.NameConstant)):
+        return True
 
-    def __init__(self):
-        super(FoldConstants, self).__init__()
+    if isinstance(node, ast.UnaryOp):
+        if isinstance(node.op, (ast.USub, ast.Invert)):
+            return is_constant_node(node.operand, ast.Num)
 
-    def visit_BinOp(self, node):
+    return False
 
-        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_constant_node(node.left, (ast.Num, ast.NameConstant)):
-            return node
-        if not is_constant_node(node.right, (ast.Num, ast.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
+class FoldConstants(SuiteTransformer):
+    """
+    Fold Constants if it would reduce the size of the source
+    """
 
-        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
+    def __init__(self):
+        super(FoldConstants, self).__init__()
 
+    def fold(self, node):
         # Evaluate the expression
         try:
             original_expression = unparse_expression(node)
-            original_value = safe_eval(original_expression)
+
+            if isinstance(node, ast.UnaryOp) and isinstance(node.op, ast.Invert) and is_constant_node(node.operand, ast.NameConstant) and isinstance(node.operand.value, bool):
+                # ~ on a bool is deprecated from python 3.12, to be removed in 3.16.
+                if sys.version_info >= (3, 16):
+                    return node
+                original_value = ~int(node.operand.value)
+            else:
+                original_value = safe_eval(original_expression)
         except Exception:
             return node
 
@@ -96,6 +102,68 @@ class FoldConstants(SuiteTransformer):
         # New representation is shorter and has the same value, so use it
         return self.add_child(new_node, get_parent(node), node.namespace)
 
+    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_foldable_constant(node.left):
+            return node
+        if not is_foldable_constant(node.right):
+            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
+
+        return self.fold(node)
+
+    def visit_BoolOp(self, node):
+        node.values = [self.visit(v) for v in node.values]
+
+        # Check this is a constant expression that could be folded
+        if not all(is_foldable_constant(v) for v in node.values):
+            return node
+
+        return self.fold(node)
+
+    def visit_Compare(self, node):
+        node.left = self.visit(node.left)
+        node.comparators = [self.visit(c) for c in node.comparators]
+
+        operands = [node.left] + node.comparators
+        if not all(is_foldable_constant(n) for n in operands):
+            return node
+
+        if any(isinstance(op, (ast.Is, ast.IsNot)) for op in node.ops):
+            # Identity is only language-guaranteed for the singletons
+            if not all(is_constant_node(n, ast.NameConstant) for n in operands):
+                return node
+
+        return self.fold(node)
+
+    def visit_UnaryOp(self, node):
+
+        node.operand = self.visit(node.operand)
+
+        # Only fold if the operand is a foldable constant
+        if not is_foldable_constant(node.operand):
+            return node
+
+        # Only fold these unary operators
+        if not isinstance(node.op, (ast.USub, ast.UAdd, ast.Invert, ast.Not)):
+            return node
+
+        return self.fold(node)
+
 
 def equal_value_and_type(a, b):
     if type(a) != type(b):

python_minifier-3.3.0/src/python_minifier/transforms/remove_dead_branches.py

@@ -0,0 +1,273 @@
+import python_minifier.ast_compat as ast
+
+from python_minifier.transforms.suite_transformer import SuiteTransformer
+from python_minifier.util import is_constant_node
+
+class NamespaceProperties(object):
+    """
+    The analysed properties of a namespace, including the names defined in it and whether it is a generator
+    """
+
+    def __init__(self):
+        self.local_names = set()
+        self.nonlocal_names = set()
+        self.global_names = set()
+        self.is_generator = False
+
+    def __eq__(self, other):
+        assert isinstance(other, NamespaceProperties)
+        return (
+            self.local_names == other.local_names and
+            self.nonlocal_names == other.nonlocal_names and
+            self.global_names == other.global_names and
+            self.is_generator is other.is_generator
+        )
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __repr__(self):
+        return 'NamespaceProperties(local_names=%r, nonlocal_names=%r, global_names=%r, is_generator=%r)' % (
+            self.local_names, self.nonlocal_names, self.global_names, self.is_generator
+        )
+
+
+def in_function_scope(namespace):
+    """
+    Is this namespace nested in a function scope?
+
+    A name bound anywhere in a class body - even in unreachable code - makes
+    loads of that name in the class body fall through to the global scope,
+    instead of an enclosing function scope cell. Removing such a binding is
+    only safe when there is no enclosing function scope to fall through to.
+    """
+    while not isinstance(namespace, ast.Module):
+        if isinstance(namespace, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            return True
+        namespace = namespace.namespace
+    return False
+
+
+class RemoveDeadBranches(SuiteTransformer):
+    """
+    Remove if statements where the condition tests False
+    """
+
+    def __call__(self, node):
+        # Suites that have been condemned during this run, but may not have been
+        # detached from the tree yet. Shared across all suites so that decisions
+        # in nested or sibling suites don't count already-removed bindings.
+        self._removed_suites = []
+        return self.visit(node)
+
+    def get_namespace_properties(self, namespace, removed_suites=None):
+        """
+        Gather the binding properties of a namespace
+
+        Walks the namespace and collects the names it binds (as local, nonlocal
+        and global name sets) and whether it is a generator.
+
+        :param namespace: The namespace node to analyse
+        :param removed_suites: Suites to skip while walking, for
+            branches that are being removed.
+        :type removed_suites: list or None
+        :rtype: NamespaceProperties
+        """
+        if removed_suites is None:
+            removed_suites = []
+
+        properties = NamespaceProperties()
+
+        def explore_namespace(node):
+            binds_here = getattr(node, 'namespace', namespace) is namespace
+
+            if binds_here:
+                if isinstance(node, ast.Name):
+                    if isinstance(node.ctx, (ast.Store, ast.Del, ast.Param)):
+                        properties.local_names.add(node.id)
+                elif isinstance(node, (ast.ClassDef, ast.FunctionDef, ast.AsyncFunctionDef)):
+                    properties.local_names.add(node.name)
+                elif isinstance(node, ast.alias):
+                    # What about import *
+
+                    if node.asname is not None:
+                        properties.local_names.add(node.asname)
+                    else:
+                        properties.local_names.add(node.name.split('.')[0])
+                elif isinstance(node, ast.arguments):
+                    if isinstance(node.vararg, str):
+                        properties.local_names.add(node.vararg)
+                    if isinstance(node.kwarg, str):
+                        properties.local_names.add(node.kwarg)
+                elif isinstance(node, ast.arg):
+                    properties.local_names.add(node.arg)
+                elif isinstance(node, ast.ExceptHandler):
+                    if isinstance(node.name, str):
+                        properties.local_names.add(node.name)
+
+                elif isinstance(node, ast.Global):
+                    properties.global_names.update(node.names)
+                elif isinstance(node, ast.Nonlocal):
+                    properties.nonlocal_names.update(node.names)
+
+                elif isinstance(node, ast.MatchAs):
+                    if isinstance(node.name, str):
+                        properties.local_names.add(node.name)
+                elif isinstance(node, ast.MatchStar):
+                    if isinstance(node.name, str):
+                        properties.local_names.add(node.name)
+                elif isinstance(node, ast.MatchMapping):
+                    if isinstance(node.rest, str):
+                        properties.local_names.add(node.rest)
+
+                elif isinstance(node, ast.TypeVar):
+                    properties.local_names.add(node.name)
+                elif isinstance(node, ast.TypeVarTuple):
+                    properties.local_names.add(node.name)
+                elif isinstance(node, ast.ParamSpec):
+                    properties.local_names.add(node.name)
+
+                elif isinstance(node, (ast.Yield, ast.YieldFrom)):
+                    properties.is_generator = True
+
+            # Skip recursing into the body field of child namespaces, as they can only affect the child namespace
+            # Other fields (decorators, annotations, arguments...) can affect this namespace,
+            # so we do want to recurse into them
+            skip_body = node is not namespace and isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.Lambda, ast.ClassDef))
+
+            for name, field in ast.iter_fields(node):
+                if field in removed_suites:
+                    continue
+
+                if skip_body and name == 'body':
+                    continue
+
+                if isinstance(field, ast.AST):
+                    explore_namespace(field)
+                elif isinstance(field, list):
+                    for item in field:
+                        if isinstance(item, ast.AST):
+                            explore_namespace(item)
+
+        explore_namespace(namespace)
+
+        return properties
+
+    def changes_semantics(self, namespace, candidate_suite):
+        """
+        Does removing this branch change the semantics of the program?
+
+        :param namespace: The namespace of the If statement
+        :param candidate_suite: The branch that is being removed
+        :return: True if removing the branch changes the semantics of the program, False otherwise
+        """
+
+        # Gather properties in the namespace, excluding suites already condemned
+        properties = self.get_namespace_properties(namespace, removed_suites=self._removed_suites)
+
+        # Gather properties in the namespace, additionally excluding the candidate branch
+        candidate_properties = self.get_namespace_properties(namespace, removed_suites=[candidate_suite] + self._removed_suites)
+
+        declarations_changed = (
+            properties.is_generator != candidate_properties.is_generator
+            or properties.nonlocal_names != candidate_properties.nonlocal_names
+            or properties.global_names != candidate_properties.global_names
+        )
+
+        if isinstance(namespace, ast.Module):
+            # The module namespace is dynamic, removing unreachable bindings doesn't
+            # change their resolution behaviour, so we can safely remove them.
+            return declarations_changed
+        elif isinstance(namespace, ast.ClassDef) and not in_function_scope(namespace):
+            # Class namespaces are also dynamic, but a binding in the class body stops
+            # loads deferring to an enclosing function scope cell, so unreachable local
+            # bindings can only be ignored when no function scope encloses the class.
+            return declarations_changed
+        else:
+            return properties != candidate_properties
+
+    def constant_test(self, node):
+        """
+        The constant truth value of an if statement's test, or None
+
+        RemoveDebug marks if statements whose __debug__ test it has resolved
+        with a resolved_test attribute. Otherwise only the True and False
+        constants are recognised - before python 3.4 they are reassignable
+        names, so nothing is recognised.
+
+        :param node: The statement to examine
+        :type node: ast.AST
+        :rtype: bool or None
+        """
+        if not isinstance(node, ast.If):
+            return None
+
+        if hasattr(node, 'resolved_test'):
+            if node.resolved_test is True or node.resolved_test is False:
+                return node.resolved_test
+            return None
+
+        if is_constant_node(node.test, ast.NameConstant) and isinstance(node.test.value, bool):
+            return node.test.value
+
+        return None
+
+    def remove_false_branches(self, node_list):
+        suite = []
+
+        for node in node_list:
+            condition = self.constant_test(node)
+
+            # A branch of a constant test can be removed, if that doesn't change
+            # the semantics of the program
+
+            if condition is True and not self.changes_semantics(node.namespace, node.orelse):
+                # The else branch is dead, keep only the body
+                self._removed_suites.append(node.orelse)
+                suite.extend(self.remove_false_branches(node.body))
+                continue
+
+            if condition is False and not self.changes_semantics(node.namespace, node.body):
+                # The body is dead, keep only the else branch
+                self._removed_suites.append(node.body)
+                suite.extend(self.remove_false_branches(node.orelse))
+                continue
+
+            node = self.visit(node)
+
+            # An else suite that dead branch removal (or another transform) emptied
+            # or reduced to the 0 padding can be omitted.
+            orelse = getattr(node, 'orelse', None)
+            if orelse and self._is_empty_suite(orelse):
+                node.orelse = []
+
+            suite.append(node)
+
+        return suite
+
+    def suite(self, node_list, parent):
+
+        without_dead_branches = self.remove_false_branches(node_list)
+
+        if len(without_dead_branches) == 0:
+            if isinstance(parent, ast.Module):
+                return []
+            else:
+                return [self.add_child(ast.Expr(value=ast.Num(0)), parent=parent)]
+
+        return without_dead_branches
+
+    def _is_empty_suite(self, suite):
+        """
+        Is the suite empty?
+
+        An empty suite is either a zero length list, or a list containing a single expression statement that is the constant 0.
+        The constant 0 is used by various transforms as a placeholder for an empty suite, because not all suites can be empty (e.g. the body of a function or class).
+
+        :param suite:
+        :type suite: list
+        :rtype: bool
+        """
+        if len(suite) == 0:
+            return True
+        return len(suite) == 1 and isinstance(suite[0], ast.Expr) and is_constant_node(suite[0].value, ast.Num) and suite[0].value.n == 0