python-minifier 2.11.3__tar.gz → 3.0.0__tar.gz

{python_minifier-2.11.3/src/python_minifier.egg-info → python_minifier-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: python_minifier
-Version: 2.11.3
+Version: 3.0.0
 Summary: Transform Python source code into it's most compact representation
 Home-page: https://github.com/dflook/python-minifier
 Author: Daniel Flook
@@ -34,6 +34,18 @@ Classifier: Topic :: Software Development
 Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, <3.14
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-python
+Dynamic: summary
 
 # Python Minifier
 
@@ -130,7 +142,7 @@ def handler(event,context):
 
 ## Why?
 
-AWS Cloudformation templates may have AWS lambda function source code embedded in them, but only if the function is less 
+AWS Cloudformation templates may have AWS lambda function source code embedded in them, but only if the function is less
 than 4KiB. I wrote this package so I could write python normally and still embed the module in a template.
 
 ## Installation

{python_minifier-2.11.3 → python_minifier-3.0.0}/README.md

@@ -93,7 +93,7 @@ def handler(event,context):
 
 ## Why?
 
-AWS Cloudformation templates may have AWS lambda function source code embedded in them, but only if the function is less 
+AWS Cloudformation templates may have AWS lambda function source code embedded in them, but only if the function is less
 than 4KiB. I wrote this package so I could write python normally and still embed the module in a template.
 
 ## Installation

{python_minifier-2.11.3 → python_minifier-3.0.0}/setup.py

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

{python_minifier-2.11.3 → python_minifier-3.0.0}/src/python_minifier/__init__.py

@@ -86,7 +86,8 @@ def minify(
     :param str source: The python module source code
     :param str filename: The original source filename if known
 
-    :param remove_annotations: Configures the removal of type annotations. True removes all annotations, False removes none. RemoveAnnotationsOptions can be used to configure the removal of specific annotations.
+    :param remove_annotations: Configures the removal of type annotations. True removes all annotations, False removes none.
+        RemoveAnnotationsOptions can be used to configure the removal of specific annotations.
     :type remove_annotations: bool or RemoveAnnotationsOptions
     :param bool remove_pass: If Pass statements should be removed where possible
     :param bool remove_literal_statements: If statements consisting of a single literal should be removed, including docstrings

{python_minifier-2.11.3 → python_minifier-3.0.0}/src/python_minifier/__init__.pyi

@@ -1,6 +1,6 @@
 import ast
 
-from typing import Any, AnyStr, List, Optional, Text, Union
+from typing import Any, List, Optional, Text, Union
 
 from .transforms.remove_annotations_options import RemoveAnnotationsOptions as RemoveAnnotationsOptions
 
@@ -10,7 +10,7 @@ class UnstableMinification(RuntimeError):
 
 
 def minify(
-    source: AnyStr,
+    source: Union[str, bytes],
     filename: Optional[str] = ...,
     remove_annotations: Union[bool, RemoveAnnotationsOptions] = ...,
     remove_pass: bool = ...,
@@ -36,7 +36,7 @@ def unparse(module: ast.Module) -> Text: ...
 
 
 def awslambda(
-    source: AnyStr,
+    source: Union[str, bytes],
     filename: Optional[Text] = ...,
     entrypoint: Optional[Text] = ...
 ) -> Text: ...

{python_minifier-2.11.3 → python_minifier-3.0.0}/src/python_minifier/__main__.py

@@ -8,6 +8,18 @@ from python_minifier import minify
 from python_minifier.transforms.remove_annotations_options import RemoveAnnotationsOptions
 
 
+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):
     from importlib import metadata
 
@@ -51,12 +63,23 @@ examples:
     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(args.output, 'w') as f:
+            with open(args.output, 'wb') as f:
                 f.write(minified)
         else:
-            sys.stdout.write(minified)
+            stdout_write_bytes(minified)
 
     else:
         # minify source paths
@@ -67,16 +90,30 @@ examples:
             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(path, 'w') as f:
+                with open(path, 'wb') as f:
                     f.write(minified)
             elif args.output:
-                with open(args.output, 'w') as f:
+                with open(args.output, 'wb') as f:
                     f.write(minified)
             else:
-                sys.stdout.write(minified)
+                stdout_write_bytes(minified)
 
 
 def parse_args():
@@ -280,6 +317,15 @@ def source_modules(args):
 
 
 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:
@@ -308,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,
@@ -330,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()

{python_minifier-2.11.3 → python_minifier-3.0.0}/src/python_minifier/ast_compare.py

@@ -77,26 +77,26 @@ def compare_ast(l_ast, r_ast):
                     % (type(l_ast), field, len(l_list), type(r_ast), field, len(r_list)),
                 )
 
-            for i, l, r in zip(counter(), l_list, r_list):
-                if isinstance(l, ast.AST) or isinstance(r, ast.AST):
-                    compare_ast(l, r)
-                elif l != r:
+            for i, left, right in zip(counter(), l_list, r_list):
+                if isinstance(left, ast.AST) or isinstance(right, ast.AST):
+                    compare_ast(left, right)
+                elif left != right:
                     raise CompareError(
                         l_ast,
                         r_ast,
                         'Fields do not match! %s.%s[%i]=%r, %s.%s[%i]=%r'
-                        % (type(l_ast), field, i, l, type(r_ast), field, i, r),
+                        % (type(l_ast), field, i, left, type(r_ast), field, i, right),
                     )
 
         else:
-            l = getattr(l_ast, field, None)
-            r = getattr(r_ast, field, None)
+            left_field = getattr(l_ast, field, None)
+            right_field = getattr(r_ast, field, None)
 
-            if isinstance(l, ast.AST) or isinstance(r, ast.AST):
-                compare_ast(l, r)
-            elif l != r:
+            if isinstance(left_field, ast.AST) or isinstance(right_field, ast.AST):
+                compare_ast(left_field, right_field)
+            elif left_field != right_field:
                 raise CompareError(
                     l_ast,
                     r_ast,
-                    'Fields do not match! %s.%s=%r, %s.%s=%r' % (type(l_ast), field, l, type(r_ast), field, r),
+                    'Fields do not match! %s.%s=%r, %s.%s=%r' % (type(l_ast), field, left_field, type(r_ast), field, right_field),
                 )

{python_minifier-2.11.3 → python_minifier-3.0.0}/src/python_minifier/f_string.py

@@ -272,31 +272,31 @@ class Str(object):
         raise ValueError("Couldn't find a quote")
 
     def _literals(self):
-        l = ''
+        literal = ''
         for c in self._s:
             if not self._can_quote(c):
-                if l:
-                    l += self.current_quote
-                    yield l
-                    l = ''
+                if literal:
+                    literal += self.current_quote
+                    yield literal
+                    literal = ''
 
                 self.current_quote = self._get_quote(c)
 
-            if l == '':
-                l += self.current_quote
+            if literal == '':
+                literal += self.current_quote
 
             if c == '\n':
-                l += '\\n'
+                literal += '\\n'
             elif c == '\r':
-                l += '\\r'
+                literal += '\\r'
             elif c == '\\':
-                l += '\\\\'
+                literal += '\\\\'
             else:
-                l += c
+                literal += c
 
-        if l:
-            l += self.current_quote
-            yield l
+        if literal:
+            literal += self.current_quote
+            yield literal
 
     def __str__(self):
         if self._s == '':
@@ -315,10 +315,10 @@ class Str(object):
         for start_quote in self.allowed_quotes:
             self.current_quote = start_quote
             s = ''
-            for l in self._literals():
-                if s and s[-1] == l[0]:
+            for literal in self._literals():
+                if s and s[-1] == literal[0]:
                     s += ' '
-                s += l
+                s += literal
 
             if eval(s) == self._s:
                 candidates.append(s)
@@ -399,23 +399,23 @@ class Bytes(object):
         raise ValueError("Couldn't find a quote")
 
     def _literals(self):
-        l = ''
+        literal = ''
         for b in self._b:
             if not self._can_quote(b):
-                if l:
-                    l += self.current_quote
-                    yield l
-                    l = ''
+                if literal:
+                    literal += self.current_quote
+                    yield literal
+                    literal = ''
 
                 self.current_quote = self._get_quote(b)
 
-            if l == '':
-                l = 'b' + self.current_quote
-            l += chr(b)
+            if literal == '':
+                literal = 'b' + self.current_quote
+            literal += chr(b)
 
-        if l:
-            l += self.current_quote
-            yield l
+        if literal:
+            literal += self.current_quote
+            yield literal
 
     def __str__(self):
         if self._b == b'':
@@ -434,10 +434,10 @@ class Bytes(object):
         for start_quote in self.allowed_quotes:
             self.current_quote = start_quote
             s = ''
-            for l in self._literals():
-                if s and s[-1] == l[0]:
+            for literal in self._literals():
+                if s and s[-1] == literal[0]:
                     s += ' '
-                s += l
+                s += literal
 
             assert eval(s) == self._b
             candidates.append(s)

{python_minifier-2.11.3 → python_minifier-3.0.0}/src/python_minifier/module_printer.py

@@ -28,11 +28,15 @@ class ModulePrinter(ExpressionPrinter):
         assert isinstance(module, ast.Module)
 
         self.visit_Module(module)
-        return str(self.printer).rstrip('\n' + self.indent_char + ';')
+        # On Python 2.7, preserve unicode strings to avoid encoding issues
+        code = unicode(self.printer) if sys.version_info[0] < 3 else str(self.printer)
+        return code.rstrip('\n' + self.indent_char + ';')
 
     @property
     def code(self):
-        return str(self.printer).rstrip('\n' + self.indent_char + ';')
+        # On Python 2.7, preserve unicode strings to avoid encoding issues
+        code = unicode(self.printer) if sys.version_info[0] < 3 else str(self.printer)
+        return code.rstrip('\n' + self.indent_char + ';')
 
     # region Simple Statements
 

{python_minifier-2.11.3 → python_minifier-3.0.0}/src/python_minifier/token_printer.py

@@ -91,7 +91,11 @@ class TokenPrinter(object):
         self._prefer_single_line = prefer_single_line
         self._allow_invalid_num_warnings = allow_invalid_num_warnings
 
-        self._code = ''
+        # Initialize as unicode string on Python 2.7 to handle Unicode content
+        if sys.version_info[0] < 3:
+            self._code = u''
+        else:
+            self._code = ''
         self.indent = 0
         self.unicode_literals = False
         self.previous_token = TokenTypes.NoToken
@@ -99,6 +103,10 @@ 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
 
     def identifier(self, name):
         """Add an identifier to the output code."""

{python_minifier-2.11.3 → python_minifier-3.0.0/src/python_minifier.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: python_minifier
-Version: 2.11.3
+Version: 3.0.0
 Summary: Transform Python source code into it's most compact representation
 Home-page: https://github.com/dflook/python-minifier
 Author: Daniel Flook
@@ -34,6 +34,18 @@ Classifier: Topic :: Software Development
 Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, <3.14
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-python
+Dynamic: summary
 
 # Python Minifier
 
@@ -130,7 +142,7 @@ def handler(event,context):
 
 ## Why?
 
-AWS Cloudformation templates may have AWS lambda function source code embedded in them, but only if the function is less 
+AWS Cloudformation templates may have AWS lambda function source code embedded in them, but only if the function is less
 than 4KiB. I wrote this package so I could write python normally and still embed the module in a template.
 
 ## Installation

{python_minifier-2.11.3 → python_minifier-3.0.0}/src/python_minifier.egg-info/SOURCES.txt

@@ -47,6 +47,7 @@ src/python_minifier/transforms/remove_posargs.py
 src/python_minifier/transforms/suite_transformer.py
 test/test_assignment_expressions.py
 test/test_await_fstring.py
+test/test_best_effort_cli.py
 test/test_bind_names.py
 test/test_bind_names_namedexpr.py
 test/test_bind_names_python2.py
@@ -81,4 +82,6 @@ test/test_remove_pass.py
 test/test_rename_builtins.py
 test/test_rename_locals.py
 test/test_slice.py
-test/test_type_param_defaults.py
+test/test_type_param_defaults.py
+test/test_unicode_cli.py
+test/test_utf8_encoding.py

python_minifier-3.0.0/test/test_best_effort_cli.py

@@ -0,0 +1,179 @@
+"""Tests for CLI size-based output selection (best effort) functionality."""
+import os
+import sys
+import tempfile
+
+from subprocess_compat import run_subprocess, safe_decode
+
+
+def test_returns_minified_when_smaller():
+    """Test CLI returns minified output when it's smaller than original."""
+    code = '''
+def hello_world():
+    """A simple function."""
+    print("Hello, world!")
+    return None
+
+if __name__ == "__main__":
+    hello_world()
+'''
+    
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
+        f.write(code)
+        temp_file = f.name
+    
+    try:
+        env = os.environ.copy()
+        env.pop('PYMINIFY_FORCE_BEST_EFFORT', None)
+        
+        result = run_subprocess([
+            sys.executable, '-m', 'python_minifier', temp_file
+        ], timeout=30, env=env)
+        
+        assert result.returncode == 0
+        
+        stdout_text = safe_decode(result.stdout)
+        assert len(stdout_text) < len(code)
+        
+    finally:
+        os.unlink(temp_file)
+
+
+def test_returns_original_when_longer():
+    """Test CLI returns original code when minified output would be longer."""
+    code = 'True if 0in x else False'
+    
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
+        f.write(code)
+        temp_file = f.name
+    
+    try:
+        env = os.environ.copy()
+        env.pop('PYMINIFY_FORCE_BEST_EFFORT', None)
+        
+        result = run_subprocess([
+            sys.executable, '-m', 'python_minifier', temp_file
+        ], timeout=30, env=env)
+        
+        assert result.returncode == 0
+        
+        stdout_text = safe_decode(result.stdout)
+        assert stdout_text == code
+        
+    finally:
+        os.unlink(temp_file)
+
+
+def test_force_minified_with_env_var():
+    """Test environment variable forces minified output regardless of size."""
+    code = 'True if 0in x else False'
+    expected_output = 'True if 0 in x else False'
+    
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
+        f.write(code)
+        temp_file = f.name
+    
+    try:
+        env = os.environ.copy()
+        env['PYMINIFY_FORCE_BEST_EFFORT'] = '1'
+        
+        result = run_subprocess([
+            sys.executable, '-m', 'python_minifier', temp_file
+        ], timeout=30, env=env)
+        
+        assert result.returncode == 0
+        
+        stdout_text = safe_decode(result.stdout)
+        assert stdout_text == expected_output
+        
+    finally:
+        os.unlink(temp_file)
+
+
+def test_stdin_behavior():
+    """Test size-based logic works with stdin input."""
+    code = 'True if 0in x else False'
+    expected_output = 'True if 0 in x else False'
+    
+    # Without env var - should return original
+    env = os.environ.copy()
+    env.pop('PYMINIFY_FORCE_BEST_EFFORT', None)
+    
+    result = run_subprocess([
+        sys.executable, '-m', 'python_minifier', '-'
+    ], input_data=code, timeout=30, env=env)
+    
+    assert result.returncode == 0
+    stdout_text = safe_decode(result.stdout)
+    assert stdout_text == code
+    
+    # With env var - should return minified
+    env['PYMINIFY_FORCE_BEST_EFFORT'] = '1'
+    
+    result = run_subprocess([
+        sys.executable, '-m', 'python_minifier', '-'
+    ], input_data=code, timeout=30, env=env)
+    
+    assert result.returncode == 0
+    stdout_text = safe_decode(result.stdout)
+    assert stdout_text == expected_output
+
+
+def test_output_file_behavior():
+    """Test size-based logic works with --output flag."""
+    code = 'True if 0in x else False'
+    
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as input_file:
+        input_file.write(code)
+        input_filename = input_file.name
+    
+    with tempfile.NamedTemporaryFile(delete=False) as output_file:
+        output_filename = output_file.name
+    
+    try:
+        env = os.environ.copy()
+        env.pop('PYMINIFY_FORCE_BEST_EFFORT', None)
+        
+        result = run_subprocess([
+            sys.executable, '-m', 'python_minifier',
+            input_filename, '--output', output_filename
+        ], timeout=30, env=env)
+        
+        assert result.returncode == 0
+        
+        with open(output_filename, 'r') as f:
+            output_content = f.read()
+        
+        assert output_content == code
+        
+    finally:
+        os.unlink(input_filename)
+        os.unlink(output_filename)
+
+
+def test_in_place_behavior():
+    """Test size-based logic works with --in-place flag."""
+    code = 'True if 0in x else False'
+    
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
+        f.write(code)
+        temp_file = f.name
+    
+    try:
+        env = os.environ.copy()
+        env.pop('PYMINIFY_FORCE_BEST_EFFORT', None)
+        
+        result = run_subprocess([
+            sys.executable, '-m', 'python_minifier',
+            temp_file, '--in-place'
+        ], timeout=30, env=env)
+        
+        assert result.returncode == 0
+        
+        with open(temp_file, 'r') as f:
+            modified_content = f.read()
+        
+        assert modified_content == code
+        
+    finally:
+        os.unlink(temp_file)

{python_minifier-2.11.3 → python_minifier-3.0.0}/test/test_is_constant_node.py

@@ -7,6 +7,11 @@ import ast
 from python_minifier.util import is_constant_node
 
 
+@pytest.mark.filterwarnings("ignore:ast.Str is deprecated:DeprecationWarning")
+@pytest.mark.filterwarnings("ignore:ast.Bytes is deprecated:DeprecationWarning") 
+@pytest.mark.filterwarnings("ignore:ast.Num is deprecated:DeprecationWarning")
+@pytest.mark.filterwarnings("ignore:ast.NameConstant is deprecated:DeprecationWarning")
+@pytest.mark.filterwarnings("ignore:ast.Ellipsis is deprecated:DeprecationWarning")
 def test_type_nodes():
     assert is_constant_node(ast.Str('a'), ast.Str)
 
@@ -28,6 +33,11 @@ def test_type_nodes():
     assert is_constant_node(ast.Ellipsis(), ast.Ellipsis)
 
 
+@pytest.mark.filterwarnings("ignore:ast.Str is deprecated:DeprecationWarning")
+@pytest.mark.filterwarnings("ignore:ast.Bytes is deprecated:DeprecationWarning") 
+@pytest.mark.filterwarnings("ignore:ast.Num is deprecated:DeprecationWarning")
+@pytest.mark.filterwarnings("ignore:ast.NameConstant is deprecated:DeprecationWarning")
+@pytest.mark.filterwarnings("ignore:ast.Ellipsis is deprecated:DeprecationWarning")
 def test_constant_nodes():
     # only test on python 3.8+
     if sys.version_info < (3, 8):

python_minifier-3.0.0/test/test_unicode_cli.py

@@ -0,0 +1,170 @@
+# -*- coding: utf-8 -*-
+import tempfile
+import os
+import sys
+import codecs
+
+from subprocess_compat import run_subprocess, safe_decode
+
+
+def test_cli_output_flag_with_unicode():
+    """
+    Tests that the CLI tool can write Unicode characters to files using --output flag.
+    """
+    # Minimal source with all problematic Unicode characters from reported issues
+    source_code = u'print(u"❌ ✓ 🐍 Привет © ∀")'
+
+    source_file = tempfile.NamedTemporaryFile(mode='wb', suffix='.py', delete=False)
+    source_file.write(source_code.encode('utf-8'))
+    source_file.close()
+
+    output_path = source_file.name + '.min.py'
+
+    try:
+        # Run pyminify CLI with --output flag
+        result = run_subprocess([
+            sys.executable, '-m', 'python_minifier',
+            source_file.name, '--output', output_path
+        ], timeout=30)
+
+        assert result.returncode == 0, "CLI failed with encoding error: {}".format(safe_decode(result.stderr))
+
+        # Verify the output file was created and contains Unicode characters
+        with codecs.open(output_path, 'r', encoding='utf-8') as f:
+            minified_content = f.read()
+
+        # Verify problematic Unicode characters are preserved
+        if hasattr(sys, 'pypy_version_info') and sys.version_info[0] >= 3:
+            # PyPy3: Unicode characters may be escaped as \\u escapes
+            assert "\\u274c" in minified_content
+            assert "✓" in minified_content
+            assert "\\U0001f40d" in minified_content
+            assert "Привет" in minified_content
+            assert "©" in minified_content
+            assert "∀" in minified_content
+        elif hasattr(sys, 'pypy_version_info') and sys.version_info[0] < 3:
+            # PyPy2: Unicode characters appear as UTF-8 byte sequences
+            assert "\\xe2\\x9d\\x8c" in minified_content  # ❌
+            assert "\\xe2\\x9c\\x93" in minified_content  # ✓
+            assert "\\xf0\\x9f\\x90\\x8d" in minified_content  # 🐍
+        elif sys.version_info[0] >= 3:
+            # CPython 3: Unicode characters should appear literally
+            assert "❌" in minified_content
+            assert "✓" in minified_content
+            assert "🐍" in minified_content
+            assert "Привет" in minified_content
+            assert "©" in minified_content
+            assert "∀" in minified_content
+        else:
+            # Python 2.7: Check for escaped sequences or use Unicode literals
+            assert u"\\xe2\\x9d\\x8c" in minified_content
+            assert u"\\xe2\\x9c\\x93" in minified_content
+            assert u"\\xf0\\x9f\\x90\\x8d" in minified_content
+
+    finally:
+        # Cleanup
+        if os.path.exists(source_file.name):
+            os.unlink(source_file.name)
+        if os.path.exists(output_path):
+            os.unlink(output_path)
+
+
+def test_cli_in_place_with_unicode():
+    """
+    Tests that the CLI tool can write Unicode characters to files using --in-place flag.
+    """
+    source_code = u'print(u"❌ ✓ 🐍 Привет © ∀")'
+
+    temp_file = tempfile.NamedTemporaryFile(mode='wb', suffix='.py', delete=False)
+    temp_file.write(source_code.encode('utf-8'))
+    temp_file.close()
+
+    try:
+        # Run pyminify with --in-place flag
+        result = run_subprocess([
+            sys.executable, '-m', 'python_minifier',
+            temp_file.name, '--in-place'
+        ], timeout=30)
+
+        assert result.returncode == 0, "CLI failed with encoding error: {}".format(safe_decode(result.stderr))
+
+        with codecs.open(temp_file.name, 'r', encoding='utf-8') as f:
+            content = f.read()
+
+        if hasattr(sys, 'pypy_version_info') and sys.version_info[0] >= 3:
+            # PyPy3: Unicode characters may be escaped as \\u escapes
+            assert "✓" in content
+            assert "\\u274c" in content  # ❌
+            assert "\\U0001f40d" in content  # 🐍
+            assert "Привет" in content
+            assert "©" in content
+            assert "∀" in content
+        elif hasattr(sys, 'pypy_version_info') and sys.version_info[0] < 3:
+            # PyPy2: Unicode characters appear as UTF-8 byte sequences
+            assert "\\xe2\\x9c\\x93" in content  # ✓
+            assert "\\xe2\\x9d\\x8c" in content  # ❌
+            assert "\\xf0\\x9f\\x90\\x8d" in content  # 🐍
+        elif sys.version_info[0] >= 3:
+            # CPython 3: Unicode characters should appear literally
+            assert "✓" in content
+            assert "❌" in content
+            assert "🐍" in content
+            assert "Привет" in content
+            assert "©" in content
+            assert "∀" in content
+        else:
+            # Python 2.7: Unicode characters appear as escaped sequences
+            assert "\\xe2\\x9d\\x8c" in content  # ❌
+            assert "\\xe2\\x9c\\x93" in content  # ✓
+            assert "\\xf0\\x9f\\x90\\x8d" in content  # 🐍
+
+    finally:
+        if os.path.exists(temp_file.name):
+            os.unlink(temp_file.name)
+
+
+def test_cli_stdout_with_unicode():
+    """
+    Tests that the CLI tool can write Unicode characters to stdout.
+    """
+    source_code = u'print(u"❌ ✓ 🐍 Привет © ∀")'
+
+    temp_file = tempfile.NamedTemporaryFile(mode='wb', suffix='.py', delete=False)
+    temp_file.write(source_code.encode('utf-8'))
+    temp_file.close()
+
+    try:
+        # Run without --output or --in-place (should output to stdout)
+        result = run_subprocess([
+            sys.executable, '-m', 'python_minifier', temp_file.name
+        ], timeout=30)
+
+        assert result.returncode == 0, "Stdout output failed: {}".format(safe_decode(result.stderr))
+
+        stdout_text = safe_decode(result.stdout)
+
+        if hasattr(sys, 'pypy_version_info') and sys.version_info[0] >= 3:
+            # PyPy3: Unicode characters may be escaped as \\u escapes
+            assert "\\u274c" in stdout_text  # ❌
+            assert "✓" in stdout_text   # ✓
+            assert "\\U0001f40d" in stdout_text  # 🐍
+            assert "Привет" in stdout_text  # Привет
+            assert "©" in stdout_text   # ©
+            assert "∀" in stdout_text   # ∀
+        elif sys.version_info[0] >= 3:
+            # CPython 3: Unicode characters should appear literally
+            assert "❌" in stdout_text
+            assert "✓" in stdout_text
+            assert "🐍" in stdout_text
+            assert "Привет" in stdout_text
+            assert "©" in stdout_text
+            assert "∀" in stdout_text
+        else:
+            # Python 2.7: Unicode characters appear as escaped sequences
+            assert "\\xe2\\x9d\\x8c" in stdout_text  # ❌
+            assert "\\xe2\\x9c\\x93" in stdout_text  # ✓
+            assert "\\xf0\\x9f\\x90\\x8d" in stdout_text  # 🐍
+
+    finally:
+        if os.path.exists(temp_file.name):
+            os.unlink(temp_file.name)

python_minifier-3.0.0/test/test_utf8_encoding.py

@@ -0,0 +1,114 @@
+# -*- coding: utf-8 -*-
+import pytest
+import python_minifier
+import tempfile
+import os
+import codecs
+
+
+def test_minify_utf8_file():
+    """Test minifying a Python file with UTF-8 characters not in Windows default encoding."""
+
+    # Create Python source with UTF-8 characters that are not in Windows-1252
+    # Using Greek letters, Cyrillic, and mathematical symbols
+    source_code = u'''"""
+This module contains UTF-8 characters that are not in Windows-1252 encoding:
+- Greek: α β γ δ ε ζ η θ ι κ λ μ ν ξ ο π ρ σ τ υ φ χ ψ ω
+- Cyrillic: а б в г д е ё ж з и й к л м н о п р с т у ф х ц ч ш щ ъ ы ь э ю я
+- Mathematical: ∀ ∃ ∈ ∉ ∅ ∞ ∑ ∏ √ ∫ ∇ ∂ ≠ ≤ ≥ ≈ ≡ ⊂ ⊃ ⊆ ⊇
+- Arrows: ← → ↑ ↓ ↔ ↕ ↖ ↗ ↘ ↙
+"""
+
+def greet_in_greek():
+    return u"Γεια σας κόσμος"  # "Hello world" in Greek
+
+def mathematical_formula():
+    # Using mathematical symbols in comments
+    # ∀x ∈ ℝ: x² ≥ 0
+    return u"∑ from i=1 to ∞ of 1/i² = π²/6"
+
+def arrow_symbols():
+    directions = {
+        u"left": u"←",
+        u"right": u"→", 
+        u"up": u"↑",
+        u"down": u"↓"
+    }
+    return directions
+
+if __name__ == "__main__":
+    print(greet_in_greek())
+    print(greet_in_russian())
+    print(mathematical_formula())
+    print(arrow_symbols())
+'''
+
+    # Write to temporary file with UTF-8 encoding
+    # Python 2.7 doesn't support encoding parameter, so use binary mode
+    with tempfile.NamedTemporaryFile(mode='wb', suffix='.py', delete=False) as f:
+        f.write(source_code.encode('utf-8'))
+        temp_file = f.name
+
+    try:
+        # Read the file and minify it
+        # Python 2.7 doesn't support encoding parameter in open()
+        with codecs.open(temp_file, 'r', encoding='utf-8') as f:
+            original_content = f.read()
+
+        # This should work - minify the UTF-8 content
+        minified = python_minifier.minify(original_content)
+
+        # Verify the minified code still contains the UTF-8 characters
+        # On Python 2.7, Unicode characters in string literals are escaped but preserved
+        # Test by executing the minified code and checking the actual values
+        minified_globals = {}
+        exec(minified, minified_globals)
+        
+        # The minified code should contain the same functions that return Unicode
+        assert 'greet_in_greek' in minified_globals
+        assert u"Γεια σας κόσμος" == minified_globals['greet_in_greek']()
+        
+        # Test that mathematical symbols are also preserved 
+        assert 'mathematical_formula' in minified_globals
+        assert u"∑ from i=1 to ∞" in minified_globals['mathematical_formula']()
+
+    finally:
+        # Clean up
+        os.unlink(temp_file)
+
+
+def test_minify_utf8_file_direct():
+    """Test minifying a file directly with UTF-8 characters."""
+
+    # Create Python source with UTF-8 characters
+    source_code = u'''# UTF-8 test file
+def emoji_function():
+    """Function with emoji and special characters: 🐍 ∆ ∑ ∫ ∞"""
+    return u"Python is 🐍 awesome! Math symbols: ∆x ≈ 0, ∑∞ = ∞"
+
+class UnicodeClass:
+    """Class with unicode: ñ ü ö ä ë ï ÿ"""
+    def __init__(self):
+        self.message = u"Héllö Wörld with àccénts!"
+        
+    def get_symbols(self):
+        return u"Symbols: ™ © ® ° ± × ÷ ≠ ≤ ≥"
+'''
+
+    # Test direct minification
+    minified = python_minifier.minify(source_code)
+
+    # Verify UTF-8 characters are preserved by executing the minified code
+    minified_globals = {}
+    exec(minified, minified_globals)
+    
+    # Test that the functions return the correct Unicode strings
+    assert u"🐍" in minified_globals['emoji_function']()
+    assert u"∆" in minified_globals['emoji_function']()
+    
+    # Test the class
+    unicode_obj = minified_globals['UnicodeClass']()
+    assert u"Héllö" in unicode_obj.message
+    assert u"àccénts" in unicode_obj.message
+    assert u"™" in unicode_obj.get_symbols()
+    assert u"©" in unicode_obj.get_symbols()