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

python_minifier-3.1.0/MANIFEST.in

@@ -0,0 +1,21 @@
+include README.md
+include LICENSE
+include setup.py
+graft src/python_minifier
+graft test
+exclude .gitignore
+exclude tox.ini
+exclude tox-windows.ini
+exclude requirements-dev.txt
+exclude CHANGELOG.md
+prune .github
+prune .config
+prune docker
+prune docs
+prune corpus_test
+prune hypo_test
+prune typing_test
+prune xtest
+prune tox
+global-exclude *.pyc
+global-exclude __pycache__

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: python_minifier
-Version: 2.11.3
+Version: 3.1.0
 Summary: Transform Python source code into it's most compact representation
 Home-page: https://github.com/dflook/python-minifier
 Author: Daniel Flook
@@ -25,15 +25,28 @@ Classifier: Programming Language :: Python :: 3.10
 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 :: 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.14
+Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, <3.15
 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
 
@@ -41,7 +54,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.13. Previous releases supported Python 2.6.
+python-minifier currently supports Python 2.7 and Python 3.3 to 3.14. Previous releases supported Python 2.6.
 
 * [PyPI](https://pypi.org/project/python-minifier/)
 * [Documentation](https://dflook.github.io/python-minifier/)
@@ -130,7 +143,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.1.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.13. Previous releases supported Python 2.6.
+python-minifier currently supports Python 2.7 and Python 3.3 to 3.14. Previous releases supported Python 2.6.
 
 * [PyPI](https://pypi.org/project/python-minifier/)
 * [Documentation](https://dflook.github.io/python-minifier/)
@@ -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.1.0}/setup.py

@@ -20,15 +20,14 @@ setup(
     },
     keywords='minify minifier',
 
-    
     package_dir={'': 'src'},
     packages=find_packages('src'),
     package_data={"python_minifier": ["py.typed", "*.pyi", "rename/*.pyi", "transforms/*.pyi"]},
     long_description=long_desc,
     long_description_content_type='text/markdown',
 
-    python_requires='>=2.7, !=3.0.*, !=3.1.*, !=3.2.*, <3.14',
-    version='2.11.3',
+    python_requires='>=2.7, !=3.0.*, !=3.1.*, !=3.2.*, <3.15',
+    version='3.1.0',
 
     classifiers=[
         'Development Status :: 5 - Production/Stable',
@@ -46,6 +45,7 @@ setup(
         'Programming Language :: Python :: 3.11',
         'Programming Language :: Python :: 3.12',
         'Programming Language :: Python :: 3.13',
+        'Programming Language :: Python :: 3.14',
         'Programming Language :: Python :: 2',
         'Programming Language :: Python :: 2.7',
         'Programming Language :: Python :: Implementation :: CPython',

{python_minifier-2.11.3 → python_minifier-3.1.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.1.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.1.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.1.0}/src/python_minifier/ast_compare.py

@@ -59,10 +59,13 @@ def compare_ast(l_ast, r_ast):
     if type(l_ast) != type(r_ast):
         raise CompareError(l_ast, r_ast, msg='Nodes do not match! %r != %r' % (l_ast, r_ast))
 
-    for field in set(l_ast._fields + r_ast._fields):
+    for field in sorted(set(l_ast._fields + r_ast._fields)):
 
         if field == 'kind' and isinstance(l_ast, ast.Constant):
             continue
+        
+        if field == 'str' and hasattr(ast, 'Interpolation') and isinstance(l_ast, ast.Interpolation):
+            continue
 
         if isinstance(getattr(l_ast, field, None), list):
 
@@ -77,26 +80,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.1.0}/src/python_minifier/ast_compat.py

@@ -70,6 +70,8 @@ for _node_type in [
     'TryStar',
     'TypeVar',
     'TypeVarTuple',
+    'TemplateStr',
+    'Interpolation',
     'YieldFrom',
     'arg',
     'withitem',

{python_minifier-2.11.3 → python_minifier-3.1.0}/src/python_minifier/expression_printer.py

@@ -743,6 +743,13 @@ class ExpressionPrinter(object):
 
         self.printer.fstring(str(python_minifier.f_string.OuterFString(node, pep701=pep701)))
 
+    def visit_TemplateStr(self, node):
+        assert isinstance(node, ast.TemplateStr)
+
+        import python_minifier.t_string
+
+        self.printer.tstring(str(python_minifier.t_string.TString(node)))
+
     def visit_NamedExpr(self, node):
         self._expression(node.target)
         self.printer.operator(':=')

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

@@ -8,6 +8,7 @@ Mostly because FStrings feel like a hack.
 
 import copy
 import re
+import sys
 
 import python_minifier.ast_compat as ast
 
@@ -58,11 +59,12 @@ class FString(object):
 
         return [x + '}' for x in conversion_candidates]
 
-    def candidates(self):
-        actual_candidates = []
+    def _generate_candidates_with_processor(self, prefix, str_processor):
+        """Generate f-string candidates using the given prefix and string processor function."""
+        candidates = []
 
         for quote in self.allowed_quotes:
-            candidates = ['']
+            quote_candidates = ['']
             debug_specifier_candidates = []
             nested_allowed = copy.copy(self.allowed_quotes)
 
@@ -71,26 +73,24 @@ class FString(object):
 
             for v in self.node.values:
                 if is_constant_node(v, ast.Str):
-
                     # Could this be used as a debug specifier?
-                    if len(candidates) < 10:
+                    if len(quote_candidates) < 10:
                         debug_specifier = re.match(r'.*=\s*$', v.s)
                         if debug_specifier:
-                            # Maybe!
                             try:
-                                debug_specifier_candidates = [x + '{' + v.s for x in candidates]
+                                debug_specifier_candidates = [x + '{' + v.s for x in quote_candidates]
                             except Exception:
                                 continue
 
                     try:
-                        candidates = [x + self.str_for(v.s, quote) for x in candidates]
+                        quote_candidates = [x + str_processor(v.s, quote) for x in quote_candidates]
                     except Exception:
                         continue
                 elif isinstance(v, ast.FormattedValue):
                     try:
                         completed = self.complete_debug_specifier(debug_specifier_candidates, v)
-                        candidates = [
-                            x + y for x in candidates for y in FormattedValue(v, nested_allowed, self.pep701).get_candidates()
+                        quote_candidates = [
+                            x + y for x in quote_candidates for y in FormattedValue(v, nested_allowed, self.pep701).get_candidates()
                         ] + completed
                         debug_specifier_candidates = []
                     except Exception:
@@ -98,13 +98,70 @@ class FString(object):
                 else:
                     raise RuntimeError('Unexpected JoinedStr value')
 
-                actual_candidates += ['f' + quote + x + quote for x in candidates]
+            candidates += [prefix + quote + x + quote for x in quote_candidates]
+
+        return candidates
+
+    def candidates(self):
+        actual_candidates = []
+
+        # Normal f-string candidates
+        actual_candidates += self._generate_candidates_with_processor('f', self.str_for)
+
+        # Raw f-string candidates (if we detect backslashes)
+        if self._contains_literal_backslashes():
+            actual_candidates += self._generate_candidates_with_processor('rf', lambda s, quote: self.raw_str_for(s))
 
         return filter(self.is_correct_ast, actual_candidates)
 
-    def str_for(self, s, quote):
+    def raw_str_for(self, s):
+        """
+        Generate string representation for raw f-strings.
+        Don't escape backslashes like MiniString does.
+        """
         return s.replace('{', '{{').replace('}', '}}')
 
+    def _contains_literal_backslashes(self):
+        """
+        Check if this f-string contains literal backslashes in constant values.
+        This indicates it may need to be a raw f-string.
+        """
+        for node in ast.walk(self.node):
+            if is_constant_node(node, ast.Str):
+                if '\\' in node.s:
+                    return True
+        return False
+
+
+    def str_for(self, s, quote):
+        # Escape null bytes and other characters that can't appear in Python source
+        escaped = ''
+        is_multiline = len(quote) == 3  # Triple-quoted strings
+
+        for c in s:
+            if c == '\0':
+                escaped += '\\x00'
+            elif c == '\n' and not is_multiline:
+                # Only escape newlines in single-quoted strings
+                escaped += '\\n'
+            elif c == '\r':
+                # Always escape carriage returns because Python normalizes them during parsing
+                # This prevents semantic changes (\\r -> \\n) in multiline strings
+                escaped += '\\r'
+            elif c == '\t':
+                # Always escape tabs for consistency (though not strictly necessary in multiline)
+                escaped += '\\t'
+            elif c == '{':
+                escaped += '{{'
+            elif c == '}':
+                escaped += '}}'
+            elif ord(c) < 32 and c not in '\n\r\t':
+                # Escape other control characters
+                escaped += '\\x{:02x}'.format(ord(c))
+            else:
+                escaped += c
+        return escaped
+
 
 class OuterFString(FString):
     """
@@ -272,37 +329,39 @@ 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'
+            if c == '\0':
+                literal += '\\x00'
+            elif c == '\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 == '':
             return str(min(self.allowed_quotes, key=len)) * 2
 
-        if '\0' in self._s or ('\\' in self._s and not self.pep701):
+        if '\\' in self._s and not self.pep701:
             raise ValueError('Impossible to represent a character in f-string expression part')
 
         if not self.pep701 and ('\n' in self._s or '\r' in self._s):
@@ -315,10 +374,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)
@@ -360,7 +419,35 @@ class FormatSpec(object):
         return candidates
 
     def str_for(self, s):
-        return s.replace('{', '{{').replace('}', '}}')
+        # Special handling for problematic format spec characters that can cause parsing issues
+        # If the format spec contains only braces, it's likely an invalid test case
+
+        # Escape null bytes and other unprintable characters
+        escaped = ''
+        for c in s:
+            if c == '\0':
+                escaped += '\\x00'
+            elif c == '{':
+                escaped += '{{'
+            elif c == '}':
+                escaped += '}}'
+            elif c == '\\':
+                # For Python 3.12+ raw f-string regression (fixed in 3.14rc2), we need to escape backslashes
+                # in format specs so they round-trip correctly
+                if (3, 12) <= sys.version_info < (3, 14):
+                    escaped += '\\\\'
+                else:
+                    escaped += c
+            elif c == '\r':
+                # Always escape carriage returns because Python normalizes them to newlines during parsing
+                # This prevents AST mismatches (\r -> \n normalization)
+                escaped += '\\r'
+            elif ord(c) < 32 and c not in '\t\n':
+                # Escape other control characters except tab, newline
+                escaped += '\\x{:02x}'.format(ord(c))
+            else:
+                escaped += c
+        return escaped
 
 
 class Bytes(object):
@@ -399,30 +486,45 @@ 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 l:
-            l += self.current_quote
-            yield l
+            if literal == '':
+                literal = 'b' + self.current_quote
+
+            # Handle special characters that need escaping
+            if b == 0:  # null byte
+                literal += '\\x00'
+            elif b == ord('\\'):  # backslash
+                literal += '\\\\'
+            elif b == ord('\n'):  # newline
+                literal += '\\n'
+            elif b == ord('\r'):  # carriage return
+                literal += '\\r'
+            elif b == ord('\t'):  # tab
+                literal += '\\t'
+            elif len(self.current_quote) == 1 and b == ord(self.current_quote):  # single quote character
+                literal += '\\' + self.current_quote
+            elif 32 <= b <= 126:  # printable ASCII
+                literal += chr(b)
+            else:  # other non-printable characters
+                literal += '\\x{:02x}'.format(b)
+
+        if literal:
+            literal += self.current_quote
+            yield literal
 
     def __str__(self):
         if self._b == b'':
             return 'b' + str(min(self.allowed_quotes, key=len)) * 2
 
-        if b'\0' in self._b or b'\\' in self._b:
-            raise ValueError('Impossible to represent a %r character in f-string expression part')
 
         if b'\n' in self._b or b'\r' in self._b:
             if '"""' not in self.allowed_quotes and "'''" not in self.allowed_quotes:
@@ -434,10 +536,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)