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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python_minifier
-Version: 3.2.0
+Version: 3.4.0
 Summary: Transform Python source code into it's most compact representation
 Home-page: https://github.com/dflook/python-minifier
 Author: Daniel Flook
@@ -26,13 +26,14 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Programming Language :: Python :: 2
 Classifier: Programming Language :: Python :: 2.7
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Software Development
-Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, <3.15
+Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, <3.16
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Dynamic: author
@@ -54,7 +55,7 @@ Transforms Python source code into its most compact representation.
 
 [Try it out!](https://python-minifier.com)
 
-python-minifier currently supports Python 2.7 and Python 3.3 to 3.14. Previous releases supported Python 2.6.
+python-minifier currently supports Python 2.7 and Python 3.3 to 3.15. Previous releases supported Python 2.6.
 
 * [PyPI](https://pypi.org/project/python-minifier/)
 * [Documentation](https://dflook.github.io/python-minifier/)
@@ -160,7 +161,7 @@ and outputs source code compatible with the version of the interpreter it is run
 This means that if you minify code written for Python 3.11 using python-minifier running with Python 3.12,
 the minified code may only run with Python 3.12.
 
-python-minifier runs with and can minify code written for Python 2.7 and Python 3.3 to 3.14.
+python-minifier runs with and can minify code written for Python 2.7 and Python 3.3 to 3.15.
 
 ## Usage
 

{python_minifier-3.2.0 → python_minifier-3.4.0}/README.md

@@ -4,7 +4,7 @@ Transforms Python source code into its most compact representation.
 
 [Try it out!](https://python-minifier.com)
 
-python-minifier currently supports Python 2.7 and Python 3.3 to 3.14. Previous releases supported Python 2.6.
+python-minifier currently supports Python 2.7 and Python 3.3 to 3.15. Previous releases supported Python 2.6.
 
 * [PyPI](https://pypi.org/project/python-minifier/)
 * [Documentation](https://dflook.github.io/python-minifier/)
@@ -110,7 +110,7 @@ and outputs source code compatible with the version of the interpreter it is run
 This means that if you minify code written for Python 3.11 using python-minifier running with Python 3.12,
 the minified code may only run with Python 3.12.
 
-python-minifier runs with and can minify code written for Python 2.7 and Python 3.3 to 3.14.
+python-minifier runs with and can minify code written for Python 2.7 and Python 3.3 to 3.15.
 
 ## Usage
 

{python_minifier-3.2.0 → python_minifier-3.4.0}/setup.py

@@ -26,8 +26,8 @@ setup(
     long_description=long_desc,
     long_description_content_type='text/markdown',
 
-    python_requires='>=2.7, !=3.0.*, !=3.1.*, !=3.2.*, <3.15',
-    version='3.2.0',
+    python_requires='>=2.7, !=3.0.*, !=3.1.*, !=3.2.*, <3.16',
+    version='3.4.0',
 
     classifiers=[
         'Development Status :: 5 - Production/Stable',
@@ -46,6 +46,7 @@ setup(
         'Programming Language :: Python :: 3.12',
         'Programming Language :: Python :: 3.13',
         'Programming Language :: Python :: 3.14',
+        'Programming Language :: Python :: 3.15',
         'Programming Language :: Python :: 2',
         'Programming Language :: Python :: 2.7',
         'Programming Language :: Python :: Implementation :: CPython',

{python_minifier-3.2.0 → python_minifier-3.4.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.4.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.4.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.4.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(')')
@@ -526,9 +524,15 @@ class ExpressionPrinter(object):
 
     def visit_DictComp(self, node):
         self.printer.delimiter('{')
-        self._expression(node.key)
-        self.printer.delimiter(':')
-        self._expression(node.value)
+
+        if node.value is None:
+            self.printer.operator('**')
+            self._expression(node.key)
+        else:
+            self._expression(node.key)
+            self.printer.delimiter(':')
+            self._expression(node.value)
+
         [self.visit_comprehension(x) for x in node.generators]
         self.printer.delimiter('}')
 

{python_minifier-3.2.0 → python_minifier-3.4.0}/src/python_minifier/module_printer.py

@@ -234,6 +234,8 @@ class ModulePrinter(ExpressionPrinter):
     def visit_Import(self, node):
         assert isinstance(node, ast.Import)
 
+        if getattr(node, 'is_lazy', 0) == 1:
+            self.printer.keyword('lazy')
         self.printer.keyword('import')
 
         delimiter = Delimiter(self.printer)
@@ -246,6 +248,9 @@ class ModulePrinter(ExpressionPrinter):
     def visit_ImportFrom(self, node):
         assert isinstance(node, ast.ImportFrom)
 
+        if getattr(node, 'is_lazy', 0) == 1:
+            self.printer.keyword('lazy')
+
         self.printer.keyword('from')
         for _i in range(node.level):
             self.printer.delimiter('.')
@@ -602,7 +607,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.4.0}/src/python_minifier/rename/mapper.py

@@ -104,7 +104,9 @@ def add_parent_to_comprehension(node, namespace):
         add_parent(node.elt, namespace=node)
     elif hasattr(node, 'key'):
         add_parent(node.key, namespace=node)
-        add_parent(node.value, namespace=node)
+
+        if node.value is not None:
+            add_parent(node.value, namespace=node)
 
     iter_namespace = namespace
     for generator in node.generators:

{python_minifier-3.2.0 → python_minifier-3.4.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.4.0}/src/python_minifier/token_printer.py

@@ -130,7 +130,7 @@ class TokenPrinter(object):
             'or', 'pass', 'raise', 'return',
             'try', 'while', 'with', 'yield', '_',
             'case', 'match', 'print', 'exec',
-            'type'
+            'type', 'lazy'
         ]
 
         if self.previous_token in [TokenTypes.Identifier, TokenTypes.Keyword, TokenTypes.SoftKeyword, TokenTypes.NumberLiteral]:
@@ -138,7 +138,7 @@ class TokenPrinter(object):
 
         self._code += kw
 
-        if kw in ['_', 'case', 'match', 'type']:
+        if kw in ['_', 'case', 'match', 'type', 'lazy']:
             self.previous_token = TokenTypes.SoftKeyword
         else:
             self.previous_token = TokenTypes.Keyword

python_minifier-3.4.0/src/python_minifier/transforms/combine_imports.py

@@ -0,0 +1,119 @@
+import python_minifier.ast_compat as ast
+
+from python_minifier.transforms.suite_transformer import SuiteTransformer
+
+
+def import_kwargs(import_node):
+    lazy = getattr(import_node, 'is_lazy', None)
+    if lazy is None:
+        return {}
+    return {'is_lazy': lazy}
+
+
+class CombineImports(SuiteTransformer):
+    """
+    Combine multiple import statements where possible
+
+    This doesn't change the order of imports
+
+    """
+
+    def _combine_import(self, node_list, parent):
+
+        prev_import = None
+        alias = []
+
+        def can_merge_with_previous_group(statement):
+            if not isinstance(statement, ast.Import):
+                return False
+
+            if prev_import is None:
+                return True
+
+            if getattr(statement, 'is_lazy', None) != getattr(prev_import, 'is_lazy', None):
+                return False
+
+            return True
+
+        def can_create_group(statement):
+            return isinstance(statement, ast.Import)
+
+        for statement in node_list:
+            if can_merge_with_previous_group(statement):
+                prev_import = statement
+                alias += statement.names
+            else:
+                if alias:
+                    yield self.add_child(ast.Import(names=alias, **import_kwargs(prev_import)), parent=parent, namespace=prev_import.namespace)
+                    prev_import = None
+                    alias = []
+
+                if can_create_group(statement):
+                    prev_import = statement
+                    alias += statement.names
+                else:
+                    yield statement
+
+        if alias:
+            yield self.add_child(ast.Import(names=alias, **import_kwargs(prev_import)), parent=parent, namespace=prev_import.namespace)
+
+    def _combine_import_from(self, node_list, parent):
+
+        prev_import = None
+        alias = []
+
+        def can_merge_with_previous_group(statement):
+            if not isinstance(statement, ast.ImportFrom):
+                return False
+
+            if len(statement.names) == 1 and statement.names[0].name == '*':
+                return False
+
+            if prev_import is None:
+                return True
+
+            if getattr(statement, 'is_lazy', None) != getattr(prev_import, 'is_lazy', None):
+                return False
+
+            if statement.module == prev_import.module and statement.level == prev_import.level:
+                return True
+
+            return False
+
+        def can_create_group(statement):
+            if not isinstance(statement, ast.ImportFrom):
+                return False
+
+            if len(statement.names) == 1 and statement.names[0].name == '*':
+                return False
+
+            return True
+
+        for statement in node_list:
+            if can_merge_with_previous_group(statement):
+                prev_import = statement
+                alias += statement.names
+            else:
+                if alias:
+                    yield self.add_child(
+                        ast.ImportFrom(module=prev_import.module, names=alias, level=prev_import.level, **import_kwargs(prev_import)), parent=parent, namespace=prev_import.namespace
+                    )
+                    prev_import = None
+                    alias = []
+
+                if can_create_group(statement):
+                    prev_import = statement
+                    alias += statement.names
+                else:
+                    yield statement
+
+        if alias:
+            yield self.add_child(
+                ast.ImportFrom(module=prev_import.module, names=alias, level=prev_import.level, **import_kwargs(prev_import)), parent=parent, namespace=prev_import.namespace
+            )
+
+    def suite(self, node_list, parent):
+        a = list(self._combine_import(node_list, parent))
+        b = list(self._combine_import_from(a, parent))
+
+        return [self.visit(n) for n in b]

{python_minifier-3.2.0 → python_minifier-3.4.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)