Update pyminify to return the input source unchanged if it can't be made smaller

Author: dflook

.github/actions/run-in-container/action.yml

@@ -20,11 +20,9 @@ runs:
     - name: Run command
       env:
         INPUT_VOLUMES: ${{ inputs.volumes }}
-        INPUT_IMAGE: ${{ inputs.image }}
-        INPUT_RUN: ${{ inputs.run }}
-      run: |
+      run: | # zizmor: ignore[template-injection]
 
-        docker pull --quiet ${INPUT_IMAGE}
+        docker pull --quiet ${{ inputs.image }}
         
         function run() {
           docker run --rm \
@@ -83,9 +81,10 @@ runs:
           -e GITHUB_TRIGGERING_ACTOR \
           -e GITHUB_WORKFLOW_REF \
           -e GITHUB_WORKFLOW_SHA \
+          -e PYTHONUNBUFFERED=1 \
           $VOLUMES_ARGS \
           --entrypoint /bin/bash \
-          ${INPUT_IMAGE} \
+          ${{ inputs.image }} \
           --noprofile --norc -eo pipefail /run.sh
 
         }
@@ -113,7 +112,7 @@ runs:
         fi
 
         cat <<"EOF" >"$RUNNER_TEMP/run.sh"
-        ${INPUT_RUN}
+        ${{ inputs.run }}
         EOF
         
         set -x

src/python_minifier/__main__.py

@@ -7,26 +7,17 @@
 from python_minifier import minify
 from python_minifier.transforms.remove_annotations_options import RemoveAnnotationsOptions
 
-# Python 2.7 compatibility for UTF-8 file writing
-if sys.version_info[0] == 2:
-    import codecs
-    def open_utf8(filename, mode):
-        return codecs.open(filename, mode, encoding='utf-8')
-else:
-    def open_utf8(filename, mode):
-        return open(filename, mode, encoding='utf-8')
 
-def safe_stdout_write(text):
-    """Write text to stdout with proper encoding handling."""
-    try:
-        sys.stdout.write(text)
-    except UnicodeEncodeError:
-        # Fallback: encode to UTF-8 and write to stdout.buffer (Python 3) or sys.stdout (Python 2)
-        if sys.version_info[0] >= 3 and hasattr(sys.stdout, 'buffer'):
-            sys.stdout.buffer.write(text.encode('utf-8'))
-        else:
-            # Python 2.7 or no buffer attribute - write UTF-8 encoded bytes
-            sys.stdout.write(text.encode('utf-8'))
+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."""
+    if sys.version_info >= (3, 0):
+        sys.stdout.buffer.write(data)
+    else:
+        sys.stdout.write(data)
 
 
 if sys.version_info >= (3, 8):
@@ -72,12 +63,23 @@ def main():
     if len(args.path) == 1 and args.path[0] == '-':
         # minify stdin
         source = sys.stdin.buffer.read() if sys.version_info >= (3, 0) else sys.stdin.read()
-        minified = do_minify(source, 'stdin', args)
+        try:
+            minified = do_minify(source, 'stdin', args)
+        except MinificationNotBeneficialError:
+            # Use original source when minification isn't beneficial
+            if args.output:
+                with open(args.output, 'wb') as f:
+                    f.write(source)
+            else:
+                # Write original source to stdout
+                stdout_write_bytes(source)
+            return
+
         if args.output:
-            with open_utf8(args.output, 'w') as f:
+            with open(args.output, 'wb') as f:
                 f.write(minified)
         else:
-            safe_stdout_write(minified)
+            stdout_write_bytes(minified)
 
     else:
         # minify source paths
@@ -88,16 +90,30 @@ def main():
             with open(path, 'rb') as f:
                 source = f.read()
 
-            minified = do_minify(source, path, args)
+            try:
+                minified = do_minify(source, path, args)
+            except MinificationNotBeneficialError:
+                # Use original source when minification isn't beneficial
+                if args.in_place:
+                    # File is already the original, no need to write
+                    pass
+                elif args.output:
+                    # Write original source to output
+                    with open(args.output, 'wb') as f:
+                        f.write(source)
+                else:
+                    # Write original source to stdout
+                    stdout_write_bytes(source)
+                continue
 
             if args.in_place:
-                with open_utf8(path, 'w') as f:
+                with open(path, 'wb') as f:
                     f.write(minified)
             elif args.output:
-                with open_utf8(args.output, 'w') as f:
+                with open(args.output, 'wb') as f:
                     f.write(minified)
             else:
-                safe_stdout_write(minified)
+                stdout_write_bytes(minified)
 
 
 def parse_args():
@@ -301,6 +317,15 @@ def error(os_error):
 
 
 def do_minify(source, filename, minification_args):
+    """Minify Python source code with size-based fallback.
+
+    :param bytes source: Source code as bytes (from file 'rb' or stdin.buffer)
+    :param str filename: Filename for error reporting
+    :param argparse.Namespace minification_args: CLI arguments for minification options
+    :returns: Minified source code as UTF-8 bytes
+    :rtype: bytes
+    :raises MinificationNotBeneficialError: When minified output is larger than original
+    """
 
     preserve_globals = []
     if minification_args.preserve_globals:
@@ -329,7 +354,7 @@ def do_minify(source, filename, minification_args):
             remove_class_attribute_annotations=minification_args.remove_class_attribute_annotations,
         )
 
-    return minify(
+    minified_result = minify(
         source,
         filename=filename,
         combine_imports=minification_args.combine_imports,
@@ -351,6 +376,19 @@ def do_minify(source, filename, minification_args):
         constant_folding=minification_args.constant_folding
     )
 
+    # Encode minified result to bytes for comparison and output
+    minified_bytes = minified_result.encode('utf-8')
+
+    # Check if environment variable forces minified output
+    if os.environ.get('PYMINIFY_FORCE_BEST_EFFORT'):
+        return minified_bytes
+
+    # Compare byte lengths for accurate size comparison
+    if len(minified_bytes) > len(source):
+        raise MinificationNotBeneficialError("Minified output is longer than original")
+
+    return minified_bytes
+
 
 if __name__ == '__main__':
     main()

test/conftest.py

@@ -0,0 +1,6 @@
+"""Pytest configuration and fixtures for python-minifier tests."""
+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')

test/subprocess_compat.py

@@ -0,0 +1,38 @@
+"""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)
+    else:
+        # 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