python-minifier 2.11.2__py2-none-any.whl → 3.0.0__py2-none-any.whl

python_minifier/__init__.py

@@ -4,29 +4,30 @@ a 'minified' representation of the same source code.
 
 """
 
-import python_minifier.ast_compat as ast
 import re
 
+import python_minifier.ast_compat as ast
+from python_minifier.ast_annotation import add_parent
+
 from python_minifier.ast_compare import CompareError, compare_ast
 from python_minifier.module_printer import ModulePrinter
 from python_minifier.rename import (
-    rename_literals,
-    bind_names,
-    resolve_names,
-    rename,
+    add_namespace,
     allow_rename_globals,
     allow_rename_locals,
-    add_namespace,
+    bind_names,
+    rename,
+    rename_literals,
+    resolve_names
 )
-
 from python_minifier.transforms.combine_imports import CombineImports
 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_debug import RemoveDebug
-from python_minifier.transforms.remove_explicit_return_none import RemoveExplicitReturnNone
 from python_minifier.transforms.remove_exception_brackets import remove_no_arg_exception_call
+from python_minifier.transforms.remove_explicit_return_none import RemoveExplicitReturnNone
 from python_minifier.transforms.remove_literal_statements import RemoveLiteralStatements
 from python_minifier.transforms.remove_object_base import RemoveObject
 from python_minifier.transforms.remove_pass import RemovePass
@@ -85,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
@@ -115,6 +117,7 @@ def minify(
     # This will raise if the source file can't be parsed
     module = ast.parse(source, filename)
 
+    add_parent(module)
     add_namespace(module)
 
     if remove_literal_statements:
@@ -198,6 +201,7 @@ def minify(
 
     return minified
 
+
 def _find_shebang(source):
     """
     Find a shebang line in source
@@ -214,6 +218,7 @@ def _find_shebang(source):
 
     return None
 
+
 def unparse(module):
     """
     Turn a module AST into python code

python_minifier/__init__.pyi

@@ -1,13 +1,16 @@
 import ast
-from typing import List, Text, AnyStr, Optional, Any, Union
+
+from typing import Any, List, Optional, Text, Union
 
 from .transforms.remove_annotations_options import RemoveAnnotationsOptions as RemoveAnnotationsOptions
 
+
 class UnstableMinification(RuntimeError):
     def __init__(self, exception: Any, source: Any, minified: Any): ...
 
+
 def minify(
-    source: AnyStr,
+    source: Union[str, bytes],
     filename: Optional[str] = ...,
     remove_annotations: Union[bool, RemoveAnnotationsOptions] = ...,
     remove_pass: bool = ...,
@@ -28,10 +31,12 @@ def minify(
     constant_folding: bool = ...
 ) -> Text: ...
 
+
 def unparse(module: ast.Module) -> Text: ...
 
+
 def awslambda(
-    source: AnyStr,
+    source: Union[str, bytes],
     filename: Optional[Text] = ...,
     entrypoint: Optional[Text] = ...
 ) -> Text: ...

python_minifier/__main__.py

@@ -7,14 +7,29 @@ import sys
 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
+
     try:
         version = metadata.version('python-minifier')
     except metadata.PackageNotFoundError:
         version = '0.0.0'
 else:
-    from pkg_resources import get_distribution, DistributionNotFound
+    from pkg_resources import DistributionNotFound, get_distribution
+
     try:
         version = get_distribution('python_minifier').version
     except DistributionNotFound:
@@ -48,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
@@ -64,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():
@@ -170,25 +210,25 @@ def parse_args():
     minification_options.add_argument(
         '--no-preserve-shebang',
         action='store_false',
-        help='Preserve any shebang line from the source',
+        help='Disable preserving any shebang line from the source',
         dest='preserve_shebang',
     )
     minification_options.add_argument(
         '--remove-asserts',
         action='store_true',
-        help='Remove assert statements',
+        help='Enable removing assert statements',
         dest='remove_asserts',
     )
     minification_options.add_argument(
         '--remove-debug',
         action='store_true',
-        help='Remove conditional statements that test __debug__ is True',
+        help='Enable removing conditional statements that test __debug__ is True',
         dest='remove_debug',
     )
     minification_options.add_argument(
         '--no-remove-explicit-return-none',
         action='store_false',
-        help='Replace explicit return None with a bare return',
+        help='Disable replacing explicit return None with a bare return',
         dest='remove_explicit_return_none',
     )
     minification_options.add_argument(
@@ -268,15 +308,24 @@ def source_modules(args):
 
     for path_arg in args.path:
         if os.path.isdir(path_arg):
-            for root, dirs, files in os.walk(path_arg, onerror=error, followlinks=True):
+            for root, _dirs, files in os.walk(path_arg, onerror=error, followlinks=True):
                 for file in files:
-                    if file.endswith('.py') or file.endswith('.pyw'):
+                    if file.endswith(('.py', '.pyw')):
                         yield os.path.join(root, file)
         else:
             yield path_arg
 
 
 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:
@@ -305,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,
@@ -327,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/ast_annotation/__init__.py

@@ -0,0 +1,82 @@
+"""
+This module provides utilities for annotating Abstract Syntax Tree (AST) nodes with parent references.
+"""
+
+import ast
+
+class _NoParent(ast.AST):
+    """A placeholder class used to indicate that a node has no parent."""
+
+    def __repr__(self):
+        # type: () -> str
+        return 'NoParent()'
+
+def add_parent(node, parent=_NoParent()):
+    # type: (ast.AST, ast.AST) -> None
+    """
+    Recursively adds a parent reference to each node in the AST.
+
+    >>> tree = ast.parse('a = 1')
+    >>> add_parent(tree)
+    >>> get_parent(tree.body[0]) == tree
+    True
+
+    :param node: The current AST node.
+    :param parent: The parent :class:`ast.AST` node.
+    """
+
+    node._parent = parent  # type: ignore[attr-defined]
+    for child in ast.iter_child_nodes(node):
+        add_parent(child, node)
+
+def get_parent(node):
+    # type: (ast.AST) -> ast.AST
+    """
+    Retrieves the parent of the given AST node.
+
+    >>> tree = ast.parse('a = 1')
+    >>> add_parent(tree)
+    >>> get_parent(tree.body[0]) == tree
+    True
+
+    :param node: The AST node whose parent is to be retrieved.
+    :return: The parent AST node.
+    :raises ValueError: If the node has no parent.
+    """
+
+    if not hasattr(node, '_parent') or isinstance(node._parent, _NoParent):  # type: ignore[attr-defined]
+        raise ValueError('Node has no parent')
+
+    return node._parent  # type: ignore[attr-defined]
+
+def set_parent(node, parent):
+    # type: (ast.AST, ast.AST) -> None
+    """
+    Replace the parent of the given AST node.
+
+    Create a simple AST:
+    >>> tree = ast.parse('a = func()')
+    >>> add_parent(tree)
+    >>> isinstance(tree.body[0], ast.Assign) and isinstance(tree.body[0].value, ast.Call)
+    True
+    >>> assign = tree.body[0]
+    >>> call = tree.body[0].value
+    >>> get_parent(call) == assign
+    True
+
+    Replace the parent of the call node:
+    >>> tree.body[0] = call
+    >>> set_parent(call, tree)
+    >>> get_parent(call) == tree
+    True
+    >>> from python_minifier.ast_printer import print_ast
+    >>> print(print_ast(tree))
+    Module(body=[
+        Call(Name('func'))
+    ])
+
+    :param node: The AST node whose parent is to be set.
+    :param parent: The parent AST node.
+    """
+
+    node._parent = parent  # type: ignore[attr-defined]

python_minifier/ast_compare.py

@@ -1,7 +1,5 @@
 import python_minifier.ast_compat as ast
 
-from python_minifier.util import is_ast_node
-
 
 class CompareError(RuntimeError):
     """
@@ -18,7 +16,7 @@ class CompareError(RuntimeError):
 
     def namespace(self, node):
         if hasattr(node, 'namespace'):
-            if is_ast_node(node.namespace, (ast.FunctionDef, ast.ClassDef, 'AsyncFunctionDef')):
+            if isinstance(node.namespace, (ast.FunctionDef, ast.ClassDef, ast.AsyncFunctionDef)):
                 return self.namespace(node.namespace) + '.' + node.namespace.name
             elif isinstance(node.namespace, ast.Module):
                 return ''
@@ -79,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/ast_compat.py

@@ -8,6 +8,7 @@ deprecation warnings.
 
 from ast import *
 
+
 # Ideally we don't import anything else
 
 if 'TypeAlias' in globals():
@@ -16,6 +17,7 @@ if 'TypeAlias' in globals():
     Constant.n = property(lambda self: self.value, lambda self, value: setattr(self, 'value', value))  # type: ignore[assignment]
     Constant.s = property(lambda self: self.value, lambda self, value: setattr(self, 'value', value))  # type: ignore[assignment]
 
+
     # These classes are redefined from the ones in ast that complain about deprecation
     # They will continue to work once they are removed from ast
 
@@ -23,18 +25,54 @@ if 'TypeAlias' in globals():
         def __new__(cls, s, *args, **kwargs):
             return Constant(value=s, *args, **kwargs)
 
+
     class Bytes(Constant):  # type: ignore[no-redef]
         def __new__(cls, s, *args, **kwargs):
             return Constant(value=s, *args, **kwargs)
 
+
     class Num(Constant):  # type: ignore[no-redef]
         def __new__(cls, n, *args, **kwargs):
             return Constant(value=n, *args, **kwargs)
 
+
     class NameConstant(Constant):  # type: ignore[no-redef]
         def __new__(cls, *args, **kwargs):
             return Constant(*args, **kwargs)
 
+
     class Ellipsis(Constant):  # type: ignore[no-redef]
         def __new__(cls, *args, **kwargs):
             return Constant(value=literal_eval('...'), *args, **kwargs)
+
+
+# Create a dummy class for missing AST nodes
+for _node_type in [
+    'AnnAssign',
+    'AsyncFor',
+    'AsyncFunctionDef',
+    'AsyncFunctionDef',
+    'AsyncWith',
+    'Bytes',
+    'Constant',
+    'DictComp',
+    'Exec',
+    'ListComp',
+    'MatchAs',
+    'MatchMapping',
+    'MatchStar',
+    'NameConstant',
+    'NamedExpr',
+    'Nonlocal',
+    'ParamSpec',
+    'SetComp',
+    'Starred',
+    'TryStar',
+    'TypeVar',
+    'TypeVarTuple',
+    'YieldFrom',
+    'arg',
+    'withitem',
+]:
+    if _node_type not in globals():
+        globals()[_node_type] = type(_node_type, (AST,), {})

python_minifier/ast_printer.py

@@ -12,7 +12,8 @@ fields or field names may be omitted for clarity. It should still be precise and
 
 import python_minifier.ast_compat as ast
 
-from python_minifier.util import is_ast_node
+from python_minifier.util import is_constant_node
+
 
 INDENT = '    '
 
@@ -63,24 +64,26 @@ default_fields = {
     'AugAssign': 'op',
 }
 
+
 def is_literal(node, field):
     if hasattr(ast, 'Constant') and isinstance(node, ast.Constant) and field == 'value':
         return True
 
-    if is_ast_node(node, ast.Num) and field == 'n':
+    if is_constant_node(node, ast.Num) and field == 'n':
         return True
 
-    if is_ast_node(node, ast.Str) and field == 's':
+    if is_constant_node(node, ast.Str) and field == 's':
         return True
 
-    if is_ast_node(node, 'Bytes') and field == 's':
+    if is_constant_node(node, ast.Bytes) and field == 's':
         return True
 
-    if is_ast_node(node, 'NameConstant') and field == 'value':
+    if is_constant_node(node, ast.NameConstant) and field == 'value':
         return True
 
     return False
 
+
 def print_ast(node):
     if not isinstance(node, ast.AST):
         return repr(node)

python_minifier/expression_printer.py

@@ -1,9 +1,9 @@
-import python_minifier.ast_compat as ast
 import sys
 
-from python_minifier.util import is_ast_node
+import python_minifier.ast_compat as ast
 
-from python_minifier.token_printer import TokenPrinter, Delimiter
+from python_minifier.token_printer import Delimiter, TokenPrinter
+from python_minifier.util import is_constant_node
 
 
 class ExpressionPrinter(object):
@@ -69,7 +69,7 @@ class ExpressionPrinter(object):
 
         # Python2 parses negative ints as an ast.Num with a negative value.
         # Make sure the Num get the precedence of the USub operator in this case.
-        if sys.version_info < (3, 0) and is_ast_node(node, ast.Num):
+        if sys.version_info < (3, 0) and is_constant_node(node, ast.Num):
             if str(node.n)[0] == '-':
                 return self.precedences['USub']
 
@@ -156,7 +156,7 @@ class ExpressionPrinter(object):
             if key is None:
                 self.printer.operator('**')
 
-                if 0 < self.precedence(datum) <=7:
+                if 0 < self.precedence(datum) <= 7:
                     self.printer.delimiter('(')
                     self._expression(datum)
                     self.printer.delimiter(')')
@@ -208,7 +208,7 @@ class ExpressionPrinter(object):
     def visit_UnaryOp(self, node):
         self.visit(node.op)
 
-        if sys.version_info < (3, 0) and isinstance(node.op, ast.USub) and is_ast_node(node.operand, ast.Num):
+        if sys.version_info < (3, 0) and isinstance(node.op, ast.USub) and is_constant_node(node.operand, ast.Num):
             # For: -(1), which is parsed as a UnaryOp(USub, Num(1)).
             # Without this special case it would be printed as -1
             # This is fine, but python 2 will then parse it at Num(-1) so the AST wouldn't round-trip.
@@ -428,7 +428,7 @@ class ExpressionPrinter(object):
         value_precedence = self.precedence(node.value)
         attr_precedence = self.precedence(node)
 
-        if (value_precedence != 0 and (attr_precedence > value_precedence)) or is_ast_node(node.value, ast.Num):
+        if (value_precedence != 0 and (attr_precedence > value_precedence)) or is_constant_node(node.value, ast.Num):
             self.printer.delimiter('(')
             self._expression(node.value)
             self.printer.delimiter(')')
@@ -462,7 +462,7 @@ class ExpressionPrinter(object):
             self.visit_Slice(node.slice)
         elif isinstance(node.slice, ast.ExtSlice):
             self.visit_ExtSlice(node.slice)
-        elif is_ast_node(node.slice, ast.Ellipsis):
+        elif is_constant_node(node.slice, ast.Ellipsis):
             self.visit_Ellipsis(node)
         elif sys.version_info >= (3, 9) and isinstance(node.slice, ast.Tuple):
             self.visit_Tuple(node.slice)
@@ -629,7 +629,8 @@ class ExpressionPrinter(object):
     def visit_arg(self, node):
         if isinstance(node, ast.Name):
             # Python 2 uses Name nodes
-            return self.visit_Name(node)
+            self.visit_Name(node)
+            return
 
         self.printer.identifier(node.arg)
 
@@ -648,7 +649,7 @@ class ExpressionPrinter(object):
         self._expression(node.body)
 
     def _expression(self, expression):
-        if is_ast_node(expression, (ast.Yield, 'YieldFrom')):
+        if isinstance(expression, (ast.Yield, ast.YieldFrom)):
             self.printer.delimiter('(')
             self._yield_expr(expression)
             self.printer.delimiter(')')
@@ -656,7 +657,7 @@ class ExpressionPrinter(object):
             self.printer.delimiter('(')
             self.visit_Tuple(expression)
             self.printer.delimiter(')')
-        elif is_ast_node(expression, 'NamedExpr'):
+        elif isinstance(expression, ast.NamedExpr):
             self.printer.delimiter('(')
             self.visit_NamedExpr(expression)
             self.printer.delimiter(')')
@@ -664,11 +665,11 @@ class ExpressionPrinter(object):
             self.visit(expression)
 
     def _testlist(self, test):
-        if is_ast_node(test, (ast.Yield, 'YieldFrom')):
+        if isinstance(test, (ast.Yield, ast.YieldFrom)):
             self.printer.delimiter('(')
             self._yield_expr(test)
             self.printer.delimiter(')')
-        elif is_ast_node(test, 'NamedExpr'):
+        elif isinstance(test, ast.NamedExpr):
             self.printer.delimiter('(')
             self.visit_NamedExpr(test)
             self.printer.delimiter(')')