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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python_minifier
-Version: 3.1.0
+Version: 3.2.0
 Summary: Transform Python source code into it's most compact representation
 Home-page: https://github.com/dflook/python-minifier
 Author: Daniel Flook
@@ -160,7 +160,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.13.
+python-minifier runs with and can minify code written for Python 2.7 and Python 3.3 to 3.14.
 
 ## Usage
 

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

@@ -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.13.
+python-minifier runs with and can minify code written for Python 2.7 and Python 3.3 to 3.14.
 
 ## Usage
 

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

{python_minifier-3.1.0 → python_minifier-3.2.0}/src/python_minifier/__init__.py

@@ -72,7 +72,8 @@ 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,
 ):
     """
     Minify a python module
@@ -107,6 +108,7 @@ 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
 
     :rtype: str
 
@@ -192,7 +194,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 +221,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 +230,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.0 → python_minifier-3.2.0}/src/python_minifier/__init__.pyi

@@ -28,11 +28,15 @@ 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 = ...
 ) -> Text: ...
 
 
-def unparse(module: ast.Module) -> Text: ...
+def unparse(
+    module: ast.Module,
+    prefer_single_line: bool = ...
+) -> Text: ...
 
 
 def awslambda(

{python_minifier-3.1.0 → python_minifier-3.2.0}/src/python_minifier/__main__.py

@@ -140,6 +140,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(
@@ -373,7 +380,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.0 → python_minifier-3.2.0}/src/python_minifier/ast_compare.py

@@ -63,7 +63,7 @@ def compare_ast(l_ast, r_ast):
 
         if field == 'kind' and isinstance(l_ast, ast.Constant):
             continue
-        
+
         if field == 'str' and hasattr(ast, 'Interpolation') and isinstance(l_ast, ast.Interpolation):
             continue
 

{python_minifier-3.1.0 → python_minifier-3.2.0}/src/python_minifier/ast_compat.py

@@ -77,4 +77,4 @@ for _node_type in [
     'withitem',
 ]:
     if _node_type not in globals():
-        globals()[_node_type] = type(_node_type, (AST,), {})
+        globals()[_node_type] = type(_node_type, (AST,), {})

{python_minifier-3.1.0 → python_minifier-3.2.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):
         """
@@ -301,8 +301,8 @@ class ExpressionPrinter(object):
 
             if value_precedence != 0 and (
                 (op_precedence > value_precedence)
-                or op_precedence == value_precedence
-                and self._is_left_associative(node.op)
+                or (op_precedence == value_precedence
+                    and self._is_left_associative(node.op))
             ):
                 self.printer.delimiter('(')
                 self._expression(v)

{python_minifier-3.1.0 → python_minifier-3.2.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):
@@ -596,7 +596,7 @@ class ModulePrinter(ExpressionPrinter):
         self.printer.keyword('case')
 
         if isinstance(node.pattern, ast.MatchSequence):
-            self.visit_MatchSequence(node.pattern, open=True)
+            self.visit_MatchSequence(node.pattern, omit_brackets=True)
         else:
             self.pattern(node.pattern)
 
@@ -626,10 +626,10 @@ class ModulePrinter(ExpressionPrinter):
         else:
             self.printer.identifier(node.name)
 
-    def visit_MatchSequence(self, node, open=False):
+    def visit_MatchSequence(self, node, omit_brackets=False):
         assert isinstance(node, ast.MatchSequence)
 
-        if len(node.patterns) < 2 or not open:
+        if len(node.patterns) < 2 or not omit_brackets:
             self.printer.delimiter('[')
 
         delimiter = Delimiter(self.printer)
@@ -637,7 +637,7 @@ class ModulePrinter(ExpressionPrinter):
             delimiter.new_item()
             self.pattern(pattern)
 
-        if len(node.patterns) < 2 or not open:
+        if len(node.patterns) < 2 or not omit_brackets:
             self.printer.delimiter(']')
 
     def visit_MatchMapping(self, node):

{python_minifier-3.1.0 → python_minifier-3.2.0}/src/python_minifier/rename/renamer.py

@@ -35,7 +35,7 @@ def sorted_bindings(module):
     """
 
     def comp(tup):
-        namespace, binding = tup
+        _namespace, binding = tup
         return binding.new_mention_count()
 
     return sorted(all_bindings(module), key=comp, reverse=True)

{python_minifier-3.1.0 → python_minifier-3.2.0}/src/python_minifier/token_printer.py

@@ -103,7 +103,7 @@ class TokenPrinter(object):
     def __str__(self):
         """Return the output code."""
         return self._code
-    
+
     def __unicode__(self):
         """Return the output code as unicode (for Python 2.7 compatibility)."""
         return self._code
@@ -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.0 → python_minifier-3.2.0}/src/python_minifier/transforms/constant_folding.py

@@ -10,36 +10,35 @@ from python_minifier.transforms.suite_transformer import SuiteTransformer
 from python_minifier.util import is_constant_node
 
 
-class FoldConstants(SuiteTransformer):
-    """
-    Fold Constants if it would reduce the size of the source
+def is_foldable_constant(node):
     """
+    Check if a node is a constant expression that can participate in folding.
 
-    def __init__(self):
-        super(FoldConstants, self).__init__()
+    We can asume 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 visit_BinOp(self, node):
+    if isinstance(node, ast.UnaryOp):
+        if isinstance(node.op, (ast.USub, ast.Invert)):
+            return is_constant_node(node.operand, ast.Num)
 
-        node.left = self.visit(node.left)
-        node.right = self.visit(node.right)
+    return False
 
-        # 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)
@@ -96,6 +95,44 @@ 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_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.1.0 → python_minifier-3.2.0}/src/python_minifier/transforms/remove_debug.py

@@ -27,18 +27,38 @@ class RemoveDebug(SuiteTransformer):
         if not isinstance(node, ast.If):
             return False
 
-        if isinstance(node.test, ast.Name) and node.test.id == '__debug__':
-            return True
+        def is_simple_debug_check():
+            # Simple case: if __debug__:
+            if isinstance(node.test, ast.Name) and node.test.id == '__debug__':
+                return True
+            return False
 
-        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
+        def is_truthy_debug_comparison():
+            # Comparison case: if __debug__ is True / False / etc.
+            if not isinstance(node.test, ast.Compare):
+                return False
 
-        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 not isinstance(node.test.left, ast.Name):
+                return False
 
-        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
+            if node.test.left.id != '__debug__':
+                return False
 
+            if len(node.test.ops) == 1:
+                op = node.test.ops[0]
+                comparator_value = self.constant_value(node.test.comparators[0])
+
+                if isinstance(op, ast.Is) and comparator_value is True:
+                    return True
+                if isinstance(op, ast.IsNot) and comparator_value is False:
+                    return True
+                if isinstance(op, ast.Eq) and comparator_value is True:
+                    return True
+
+            return False
+
+        if is_simple_debug_check() or is_truthy_debug_comparison():
+            return True
         return False
 
     def suite(self, node_list, parent):

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python_minifier
-Version: 3.1.0
+Version: 3.2.0
 Summary: Transform Python source code into it's most compact representation
 Home-page: https://github.com/dflook/python-minifier
 Author: Daniel Flook
@@ -160,7 +160,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.13.
+python-minifier runs with and can minify code written for Python 2.7 and Python 3.3 to 3.14.
 
 ## Usage
 

{python_minifier-3.1.0 → python_minifier-3.2.0}/src/python_minifier.egg-info/SOURCES.txt

@@ -77,6 +77,7 @@ test/test_match_rename.py
 test/test_name_generator.py
 test/test_nonlocal.py
 test/test_posargs.py
+test/test_prefer_single_line.py
 test/test_preserve_shebang.py
 test/test_raw_fstring_backslash.py
 test/test_raw_tstring_backslash.py

{python_minifier-3.1.0 → python_minifier-3.2.0}/test/ast_annotation/test_add_parent.py

@@ -30,13 +30,13 @@ class A:
 def test_no_parent_for_root_node():
     tree = ast.parse('a = 1')
     add_parent(tree)
-    with pytest.raises(ValueError):
+    with pytest.raises(ValueError, match="Node has no parent"):
         get_parent(tree)
 
 
 def test_no_parent_for_unannotated_node():
     tree = ast.parse('a = 1')
-    with pytest.raises(ValueError):
+    with pytest.raises(ValueError, match="Node has no parent"):
         get_parent(tree.body[0])
 
 

{python_minifier-3.1.0 → python_minifier-3.2.0}/test/conftest.py

@@ -3,4 +3,4 @@ import os
 
 # Set default environment variable to preserve existing test behavior
 # Tests can explicitly unset this if they need to test size-based behavior
-os.environ.setdefault('PYMINIFY_FORCE_BEST_EFFORT', '1')
+os.environ.setdefault('PYMINIFY_FORCE_BEST_EFFORT', '1')

python_minifier-3.2.0/test/subprocess_compat.py

@@ -0,0 +1,37 @@
+"""Subprocess compatibility utilities for Python 2.7/3.x."""
+import subprocess
+import sys
+
+
+def run_subprocess(cmd, timeout=None, input_data=None, env=None):
+    """Cross-platform subprocess runner for Python 2.7+ compatibility."""
+    if hasattr(subprocess, 'run'):
+        # 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)
+    # 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)
+    # For Python 3.3/3.4, communicate() doesn't support timeout
+    # Also, Python 3.x needs bytes for stdin, Python 2.x needs str
+    if input_data and sys.version_info[0] >= 3 and isinstance(input_data, str):
+        input_data = input_data.encode('utf-8')
+    stdout, stderr = popen.communicate(input_data)
+    # Create a simple result object similar to subprocess.CompletedProcess
+    class Result:
+        def __init__(self, returncode, stdout, stderr):
+            self.returncode = returncode
+            self.stdout = stdout
+            self.stderr = stderr
+    return Result(popen.returncode, stdout, stderr)
+
+
+def safe_decode(data, encoding='utf-8', errors='replace'):
+    """Safe decode for Python 2.7/3.x compatibility."""
+    if isinstance(data, bytes):
+        try:
+            return data.decode(encoding, errors)
+        except UnicodeDecodeError:
+            return data.decode(encoding, 'replace')
+    return data