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

{python_minifier-3.2.0/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.2.0
+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.2.0 → 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.2.0',
+    version='3.3.0',
 
     classifiers=[
         'Development Status :: 5 - Production/Stable',

{python_minifier-3.2.0 → 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
@@ -74,6 +75,7 @@ def minify(
     remove_builtin_exception_brackets=True,
     constant_folding=True,
     prefer_single_line=False,
+    remove_dead_branches=True
 ):
     """
     Minify a python module
@@ -109,6 +111,7 @@ def minify(
     :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
 
@@ -155,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)
 

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

@@ -29,7 +29,8 @@ def minify(
     remove_explicit_return_none: bool = ...,
     remove_builtin_exception_brackets: bool = ...,
     constant_folding: bool = ...,
-    prefer_single_line: bool = ...
+    prefer_single_line: bool = ...,
+    remove_dead_branches: bool = ...
 ) -> Text: ...
 
 

{python_minifier-3.2.0 → 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."""
@@ -250,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(
@@ -305,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
 
 

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

@@ -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.2.0 → python_minifier-3.3.0}/src/python_minifier/module_printer.py

@@ -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.2.0 → 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.2.0 → python_minifier-3.3.0}/src/python_minifier/transforms/constant_folding.py

@@ -14,7 +14,7 @@ def is_foldable_constant(node):
     """
     Check if a node is a constant expression that can participate in folding.
 
-    We can asume that children have already been folded, so foldable constants are either:
+    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
@@ -42,7 +42,14 @@ class FoldConstants(SuiteTransformer):
         # 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
 
@@ -119,6 +126,30 @@ class FoldConstants(SuiteTransformer):
 
         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)

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

{python_minifier-3.2.0 → python_minifier-3.3.0}/src/python_minifier/transforms/remove_debug.py

@@ -8,9 +8,11 @@ from python_minifier.util import is_constant_node
 
 class RemoveDebug(SuiteTransformer):
     """
-    Remove if statements where the condition tests __debug__ is True
+    Mark if statements whose condition tests __debug__ is True as dead
 
-    If a statement is syntactically necessary, use an empty expression instead
+    The marked statements are removed by the RemoveDeadBranches transform, which
+    keeps any else branch and any branch that can't be removed without changing
+    the meaning of the program.
     """
 
     def __call__(self, node):
@@ -18,7 +20,11 @@ class RemoveDebug(SuiteTransformer):
 
     def constant_value(self, node):
         if sys.version_info < (3, 4):
-            return node.id == 'True'
+            # True and False are Name nodes before python 3.4.
+            # The comparator may be any expression, so check it is a Name.
+            if isinstance(node, ast.Name) and node.id in ('True', 'False'):
+                return node.id == 'True'
+            return None
         elif is_constant_node(node, ast.NameConstant):
             return node.value
         return None
@@ -61,14 +67,10 @@ class RemoveDebug(SuiteTransformer):
             return True
         return False
 
-    def suite(self, node_list, parent):
+    def visit_If(self, node):
+        assert isinstance(node, ast.If)
 
-        without_debug = [self.visit(a) for a in filter(lambda n: not self.can_remove(n), node_list)]
+        if self.can_remove(node):
+            node.resolved_test = False
 
-        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
+        return self.generic_visit(node)

{python_minifier-3.2.0 → python_minifier-3.3.0}/src/python_minifier/transforms/suite_transformer.py

@@ -117,6 +117,51 @@ class SuiteTransformer(NodeVisitor):
 
         return node
 
+    def visit_TryStar(self, node):
+        return self.visit_Try(node)
+
+    def visit_TryFinally(self, node):
+        # Python 2
+        node.body = self.suite(node.body, parent=node)
+        node.finalbody = self.suite(node.finalbody, parent=node)
+        return node
+
+    def visit_TryExcept(self, node):
+        # Python 2
+        node.body = self.suite(node.body, parent=node)
+
+        node.handlers = [self.visit(h) for h in node.handlers]
+
+        if node.orelse:
+            node.orelse = self.suite(node.orelse, parent=node)
+
+        return node
+
+    def visit_ExceptHandler(self, node):
+        if node.type is not None:
+            node.type = self.visit(node.type)
+
+        if node.name is not None and isinstance(node.name, ast.AST):
+            # Python 2 uses a Name node
+            node.name = self.visit(node.name)
+
+        node.body = self.suite(node.body, parent=node)
+        return node
+
+    def visit_Match(self, node):
+        node.subject = self.visit(node.subject)
+        node.cases = [self.visit(c) for c in node.cases]
+        return node
+
+    def visit_match_case(self, node):
+        node.pattern = self.visit(node.pattern)
+
+        if node.guard is not None:
+            node.guard = self.visit(node.guard)
+
+        node.body = self.suite(node.body, parent=node)
+        return node
+
     def visit_While(self, node):
         node.test = self.visit(node.test)
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python_minifier
-Version: 3.2.0
+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.2.0 → python_minifier-3.3.0}/src/python_minifier.egg-info/SOURCES.txt

@@ -40,6 +40,7 @@ src/python_minifier/transforms/remove_annotations.py
 src/python_minifier/transforms/remove_annotations_options.py
 src/python_minifier/transforms/remove_annotations_options.pyi
 src/python_minifier/transforms/remove_asserts.py
+src/python_minifier/transforms/remove_dead_branches.py
 src/python_minifier/transforms/remove_debug.py
 src/python_minifier/transforms/remove_exception_brackets.py
 src/python_minifier/transforms/remove_explicit_return_none.py
@@ -83,6 +84,7 @@ test/test_raw_fstring_backslash.py
 test/test_raw_tstring_backslash.py
 test/test_remove_annotations.py
 test/test_remove_assert.py
+test/test_remove_dead_branches.py
 test/test_remove_debug.py
 test/test_remove_exception_brackets.py
 test/test_remove_explicit_return_none.py

{python_minifier-3.2.0 → python_minifier-3.3.0}/test/subprocess_compat.py

@@ -9,7 +9,7 @@ def run_subprocess(cmd, timeout=None, input_data=None, env=None):
         # Python 3.5+ - encode string input to bytes for subprocess
         input_bytes = input_data.encode('utf-8') if isinstance(input_data, str) else input_data
         return subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
-                            input=input_bytes, timeout=timeout, env=env)
+                            input=input_bytes, timeout=timeout, env=env, check=False)
     # Python 2.7, 3.3, 3.4 - no subprocess.run, no timeout support
     popen = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
                            stdin=subprocess.PIPE if input_data else None, env=env)

{python_minifier-3.2.0 → python_minifier-3.3.0}/test/test_combine_imports.py

@@ -86,6 +86,25 @@ def test_import_in_function():
     compare_ast(expected_ast, actual_ast)
 
 
+def test_import_in_except_handler():
+    # SuiteTransformer now visits except handler bodies
+    source = '''try:
+    pass
+except Exception:
+    import collection as c
+    import builtins
+'''
+    expected = '''try:
+    pass
+except Exception:
+    import collection as c, builtins
+'''
+
+    expected_ast = ast.parse(expected)
+    actual_ast = combine_imports(ast.parse(source))
+    compare_ast(expected_ast, actual_ast)
+
+
 def test_import_star():
     source = '''
 from breakfast import hashbrown