python-minifier 2.4.2__py3-none-any.whl → 2.10.0__py3-none-any.whl

python_minifier/__init__.py

@@ -4,7 +4,8 @@ a 'minified' representation of the same source code.
 
 """
 
-import ast
+import python_minifier.ast_compat as ast
+import re
 
 from python_minifier.ast_compare import CompareError, compare_ast
 from python_minifier.module_printer import ModulePrinter
@@ -17,8 +18,15 @@ from python_minifier.rename import (
     allow_rename_locals,
     add_namespace,
 )
+
 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_literal_statements import RemoveLiteralStatements
 from python_minifier.transforms.remove_object_base import RemoveObject
 from python_minifier.transforms.remove_pass import RemovePass
@@ -47,7 +55,7 @@ class UnstableMinification(RuntimeError):
 def minify(
     source,
     filename=None,
-    remove_annotations=True,
+    remove_annotations=RemoveAnnotationsOptions(),
     remove_pass=True,
     remove_literal_statements=False,
     combine_imports=True,
@@ -58,6 +66,12 @@ def minify(
     preserve_globals=None,
     remove_object_base=True,
     convert_posargs_to_args=True,
+    preserve_shebang=True,
+    remove_asserts=False,
+    remove_debug=False,
+    remove_explicit_return_none=True,
+    remove_builtin_exception_brackets=True,
+    constant_folding=True
 ):
     """
     Minify a python module
@@ -71,7 +85,8 @@ def minify(
     :param str source: The python module source code
     :param str filename: The original source filename if known
 
-    :param bool remove_annotations: If type annotations should be removed where possible
+    :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
     :param bool combine_imports: Combine adjacent import statements where possible
@@ -84,6 +99,12 @@ def minify(
     :type preserve_globals: list[str]
     :param bool remove_object_base: If object as a base class may be removed
     :param bool convert_posargs_to_args: If positional-only arguments will be converted to normal arguments
+    :param bool preserve_shebang: Keep any shebang interpreter directive from the source in the minified output
+    :param bool remove_asserts: If assert statements should be removed
+    :param bool remove_debug: If conditional statements that test '__debug__ is True' should be removed
+    :param bool remove_explicit_return_none: If explicit return None statements should be replaced with a bare return
+    :param bool remove_builtin_exception_brackets: If brackets should be removed when raising exceptions with no arguments
+    :param bool constant_folding: If literal expressions should be evaluated
 
     :rtype: str
 
@@ -102,8 +123,20 @@ def minify(
     if combine_imports:
         module = CombineImports()(module)
 
-    if remove_annotations:
-        module = RemoveAnnotations()(module)
+    if isinstance(remove_annotations, bool):
+        remove_annotations_options = RemoveAnnotationsOptions(
+            remove_variable_annotations=remove_annotations,
+            remove_return_annotations=remove_annotations,
+            remove_argument_annotations=remove_annotations,
+            remove_class_attribute_annotations=remove_annotations,
+        )
+    elif isinstance(remove_annotations, RemoveAnnotationsOptions):
+        remove_annotations_options = remove_annotations
+    else:
+        raise TypeError('remove_annotations must be a bool or RemoveAnnotationsOptions')
+
+    if remove_annotations_options:
+        module = RemoveAnnotations(remove_annotations_options)(module)
 
     if remove_pass:
         module = RemovePass()(module)
@@ -111,13 +144,40 @@ def minify(
     if remove_object_base:
         module = RemoveObject()(module)
 
+    if remove_asserts:
+        module = RemoveAsserts()(module)
+
+    if remove_debug:
+        module = RemoveDebug()(module)
+
+    if remove_explicit_return_none:
+        module = RemoveExplicitReturnNone()(module)
+
+    if constant_folding:
+        module = FoldConstants()(module)
+
     bind_names(module)
     resolve_names(module)
 
+    if remove_builtin_exception_brackets and not module.tainted:
+        remove_no_arg_exception_call(module)
+
     if module.tainted:
         rename_globals = False
         rename_locals = False
 
+    if preserve_locals is None:
+        preserve_locals = []
+    elif isinstance(preserve_locals, str):
+        preserve_locals = [preserve_locals]
+    if preserve_globals is None:
+        preserve_globals = []
+    elif isinstance(preserve_globals, str):
+        preserve_globals = [preserve_globals]
+
+    preserve_locals.extend(module.preserved)
+    preserve_globals.extend(module.preserved)
+
     allow_rename_locals(module, rename_locals, preserve_locals)
     allow_rename_globals(module, rename_globals, preserve_globals)
 
@@ -129,8 +189,30 @@ def minify(
     if convert_posargs_to_args:
         module = remove_posargs(module)
 
-    return unparse(module)
+    minified = unparse(module)
+
+    if preserve_shebang is True:
+        shebang_line = _find_shebang(source)
+        if shebang_line is not None:
+            return shebang_line + '\n' + minified
+
+    return minified
+
+def _find_shebang(source):
+    """
+    Find a shebang line in source
+    """
+
+    if isinstance(source, bytes):
+        shebang = re.match(br'^#!.*', source)
+        if shebang:
+            return shebang.group().decode()
+    else:
+        shebang = re.match(r'^#!.*', source)
+        if shebang:
+            return shebang.group()
 
+    return None
 
 def unparse(module):
     """

python_minifier/__init__.pyi

@@ -0,0 +1,37 @@
+import ast
+from typing import List, Text, AnyStr, Optional, Any, 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,
+    filename: Optional[str] = ...,
+    remove_annotations: Union[bool, RemoveAnnotationsOptions] = ...,
+    remove_pass: bool = ...,
+    remove_literal_statements: bool = ...,
+    combine_imports: bool = ...,
+    hoist_literals: bool = ...,
+    rename_locals: bool = ...,
+    preserve_locals: Optional[List[Text]] = ...,
+    rename_globals: bool = ...,
+    preserve_globals: Optional[List[Text]] = ...,
+    remove_object_base: bool = ...,
+    convert_posargs_to_args: bool = ...,
+    preserve_shebang: bool = ...,
+    remove_asserts: bool = ...,
+    remove_debug: bool = ...,
+    remove_explicit_return_none: bool = ...,
+    remove_builtin_exception_brackets: bool = ...,
+    constant_folding: bool = ...
+) -> Text: ...
+
+def unparse(module: ast.Module) -> Text: ...
+
+def awslambda(
+    source: AnyStr,
+    filename: Optional[Text] = ...,
+    entrypoint: Optional[Text] = ...
+) -> Text: ...

python_minifier/__main__.py

@@ -1,126 +1,330 @@
 from __future__ import print_function
 
-import sys
-
 import argparse
-from pkg_resources import get_distribution, DistributionNotFound
+import os
+import sys
 
 from python_minifier import minify
+from python_minifier.transforms.remove_annotations_options import RemoveAnnotationsOptions
 
-try:
-    version = get_distribution('python_minifier').version
-except DistributionNotFound:
-    version = '0.0.0'
+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
+    try:
+        version = get_distribution('python_minifier').version
+    except DistributionNotFound:
+        version = '0.0.0'
 
 
 def main():
+    """
+examples:
+  # Minifying stdin to stdout
+  pyminify -
+
+  # Minifying a file to stdout
+  pyminify example.py
+
+  # Minifying a file and writing to a different file
+  pyminify example.py --output example.min.py
 
-    parser = argparse.ArgumentParser(prog='pyminify', description='Minify Python source')
+  # Minifying a file in place
+  pyminify example.py --in-place
 
-    parser.add_argument('path', type=str, help='The source file to minify. Use "-" to read from stdin')
+  # Minifying all *.py files in a directory
+  pyminify src/ --in-place
+
+  # Minifying multiple paths in place
+  pyminify file1.py file2.py src/ --in-place
+"""
+
+    args = parse_args()
+
+    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)
+        if args.output:
+            with open(args.output, 'w') as f:
+                f.write(minified)
+        else:
+            sys.stdout.write(minified)
+
+    else:
+        # minify source paths
+        for path in source_modules(args):
+            if args.output or args.in_place:
+                sys.stdout.write(path + '\n')
+
+            with open(path, 'rb') as f:
+                source = f.read()
+
+            minified = do_minify(source, path, args)
+
+            if args.in_place:
+                with open(path, 'w') as f:
+                    f.write(minified)
+            elif args.output:
+                with open(args.output, 'w') as f:
+                    f.write(minified)
+            else:
+                sys.stdout.write(minified)
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(prog='pyminify', description='Minify Python source code', formatter_class=argparse.RawDescriptionHelpFormatter, epilog=main.__doc__)
 
     parser.add_argument(
+        'path',
+        nargs='+',
+        type=str,
+        help='The source file or directory to minify. Use "-" to read from stdin. Directories are recursively searched for ".py" files to minify. May be used multiple times',
+    )
+
+    output_options = parser.add_mutually_exclusive_group()
+    output_options.add_argument(
+        '--output', '-o',
+        action='store',
+        help='Path to write minified output. Can only be used when the source is a single module. Outputs to stdout by default',
+        dest='output'
+    )
+    output_options.add_argument(
+        '--in-place', '-i',
+        action='store_true',
+        help='Overwrite existing files. Required when there is more than one source module',
+        dest='in_place'
+    )
+
+    # Minification arguments
+    minification_options = parser.add_argument_group('minification options', 'Options that affect how the source is minified')
+    minification_options.add_argument(
         '--no-combine-imports',
         action='store_false',
         help='Disable combining adjacent import statements',
         dest='combine_imports',
     )
-    parser.add_argument(
+    minification_options.add_argument(
         '--no-remove-pass',
         action='store_false',
         default=True,
         help='Disable removing Pass statements',
         dest='remove_pass',
     )
-    parser.add_argument(
+    minification_options.add_argument(
         '--remove-literal-statements',
         action='store_true',
         help='Enable removing statements that are just a literal (including docstrings)',
         dest='remove_literal_statements',
     )
-    parser.add_argument(
-        '--no-remove-annotations',
-        action='store_false',
-        help='Disable removing function and variable annotations',
-        dest='remove_annotations',
-    )
-    parser.add_argument(
+    minification_options.add_argument(
         '--no-hoist-literals',
         action='store_false',
         help='Disable replacing string and bytes literals with variables',
         dest='hoist_literals',
     )
-    parser.add_argument(
-        '--no-rename-locals', action='store_false', help='Disable shortening of local names', dest='rename_locals'
+    minification_options.add_argument(
+        '--no-rename-locals',
+        action='store_false',
+        help='Disable shortening of local names',
+        dest='rename_locals'
     )
-    parser.add_argument(
+    minification_options.add_argument(
         '--preserve-locals',
         type=str,
         action='append',
         help='Comma separated list of local names that will not be shortened',
         dest='preserve_locals',
+        metavar='LOCAL_NAMES'
     )
-    parser.add_argument(
-        '--rename-globals', action='store_true', help='Enable shortening of global names', dest='rename_globals'
+    minification_options.add_argument(
+        '--rename-globals',
+        action='store_true',
+        help='Enable shortening of global names',
+        dest='rename_globals'
     )
-    parser.add_argument(
+    minification_options.add_argument(
         '--preserve-globals',
         type=str,
         action='append',
         help='Comma separated list of global names that will not be shortened',
         dest='preserve_globals',
+        metavar='GLOBAL_NAMES'
     )
-    parser.add_argument(
+    minification_options.add_argument(
         '--no-remove-object-base',
         action='store_false',
         help='Disable removing object from base class list',
         dest='remove_object_base',
     )
-    parser.add_argument(
+    minification_options.add_argument(
         '--no-convert-posargs-to-args',
         action='store_false',
         help='Disable converting positional only arguments to normal arguments',
         dest='convert_posargs_to_args',
     )
+    minification_options.add_argument(
+        '--no-preserve-shebang',
+        action='store_false',
+        help='Preserve any shebang line from the source',
+        dest='preserve_shebang',
+    )
+    minification_options.add_argument(
+        '--remove-asserts',
+        action='store_true',
+        help='Remove assert statements',
+        dest='remove_asserts',
+    )
+    minification_options.add_argument(
+        '--remove-debug',
+        action='store_true',
+        help='Remove 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',
+        dest='remove_explicit_return_none',
+    )
+    minification_options.add_argument(
+        '--no-remove-builtin-exception-brackets',
+        action='store_false',
+        help='Disable removing brackets when raising builtin exceptions with no arguments',
+        dest='remove_exception_brackets',
+    )
+    minification_options.add_argument(
+        '--no-constant-folding',
+        action='store_false',
+        help='Disable evaluating literal expressions',
+        dest='constant_folding',
+    )
 
-    parser.add_argument('-v', '--version', action='version', version=version)
+    annotation_options = parser.add_argument_group('remove annotations options', 'Options that affect how annotations are removed')
+    annotation_options.add_argument(
+        '--no-remove-annotations',
+        action='store_false',
+        help='Disable removing all annotations',
+        dest='remove_annotations',
+    )
+    annotation_options.add_argument(
+        '--no-remove-variable-annotations',
+        action='store_false',
+        help='Disable removing variable annotations',
+        dest='remove_variable_annotations',
+    )
+    annotation_options.add_argument(
+        '--no-remove-return-annotations',
+        action='store_false',
+        help='Disable removing function return annotations',
+        dest='remove_return_annotations',
+    )
+    annotation_options.add_argument(
+        '--no-remove-argument-annotations',
+        action='store_false',
+        help='Disable removing function argument annotations',
+        dest='remove_argument_annotations',
+    )
+    annotation_options.add_argument(
+        '--remove-class-attribute-annotations',
+        action='store_true',
+        help='Enable removing class attribute annotations',
+        dest='remove_class_attribute_annotations',
+    )
+
+    parser.add_argument('--version', '-v', action='version', version=version)
 
     args = parser.parse_args()
 
-    if args.path == '-':
-        source = sys.stdin.read()
-    else:
-        with open(args.path, 'rb') as f:
-            source = f.read()
+    # Handle some invalid argument combinations
+    if '-' in args.path and len(args.path) != 1:
+        sys.stderr.write('error: multiple path arguments, reading from stdin not allowed\n')
+        sys.exit(1)
+    if '-' in args.path and args.in_place:
+        sys.stderr.write('error: reading from stdin, --in-place is not valid\n')
+        sys.exit(1)
+    if len(args.path) > 1 and not args.in_place:
+        sys.stderr.write('error: multiple path arguments, --in-place required\n')
+        sys.exit(1)
+    if len(args.path) == 1 and os.path.isdir(args.path[0]) and not args.in_place:
+        sys.stderr.write('error: path ' + args.path[0] + ' is a directory, --in-place required\n')
+        sys.exit(1)
+
+    if args.remove_class_attribute_annotations and not args.remove_annotations:
+        sys.stderr.write('error: --remove-class-attribute-annotations would do nothing when used with --no-remove-annotations\n')
+        sys.exit(1)
+
+    return args
+
+
+def source_modules(args):
+
+    def error(os_error):
+        raise os_error
+
+    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 file in files:
+                    if file.endswith('.py') or file.endswith('.pyw'):
+                        yield os.path.join(root, file)
+        else:
+            yield path_arg
+
+
+def do_minify(source, filename, minification_args):
 
     preserve_globals = []
-    if args.preserve_globals:
-        for arg in args.preserve_globals:
+    if minification_args.preserve_globals:
+        for arg in minification_args.preserve_globals:
             names = [name.strip() for name in arg.split(',') if name]
             preserve_globals.extend(names)
 
     preserve_locals = []
-    if args.preserve_locals:
-        for arg in args.preserve_locals:
+    if minification_args.preserve_locals:
+        for arg in minification_args.preserve_locals:
             names = [name.strip() for name in arg.split(',') if name]
             preserve_locals.extend(names)
 
-    sys.stdout.write(
-        minify(
-            source,
-            filename=args.path,
-            combine_imports=args.combine_imports,
-            remove_pass=args.remove_pass,
-            remove_annotations=args.remove_annotations,
-            remove_literal_statements=args.remove_literal_statements,
-            hoist_literals=args.hoist_literals,
-            rename_locals=args.rename_locals,
-            preserve_locals=preserve_locals,
-            rename_globals=args.rename_globals,
-            preserve_globals=preserve_globals,
-            remove_object_base=args.remove_object_base,
-            convert_posargs_to_args=args.convert_posargs_to_args,
+    if minification_args.remove_annotations is False:
+        remove_annotations = RemoveAnnotationsOptions(
+            remove_variable_annotations=False,
+            remove_return_annotations=False,
+            remove_argument_annotations=False,
+            remove_class_attribute_annotations=False,
+        )
+    else:
+        remove_annotations = RemoveAnnotationsOptions(
+            remove_variable_annotations=minification_args.remove_variable_annotations,
+            remove_return_annotations=minification_args.remove_return_annotations,
+            remove_argument_annotations=minification_args.remove_argument_annotations,
+            remove_class_attribute_annotations=minification_args.remove_class_attribute_annotations,
         )
+
+    return minify(
+        source,
+        filename=filename,
+        combine_imports=minification_args.combine_imports,
+        remove_pass=minification_args.remove_pass,
+        remove_annotations=remove_annotations,
+        remove_literal_statements=minification_args.remove_literal_statements,
+        hoist_literals=minification_args.hoist_literals,
+        rename_locals=minification_args.rename_locals,
+        preserve_locals=preserve_locals,
+        rename_globals=minification_args.rename_globals,
+        preserve_globals=preserve_globals,
+        remove_object_base=minification_args.remove_object_base,
+        convert_posargs_to_args=minification_args.convert_posargs_to_args,
+        preserve_shebang=minification_args.preserve_shebang,
+        remove_asserts=minification_args.remove_asserts,
+        remove_debug=minification_args.remove_debug,
+        remove_explicit_return_none=minification_args.remove_explicit_return_none,
+        remove_builtin_exception_brackets=minification_args.remove_exception_brackets,
+        constant_folding=minification_args.constant_folding
     )
 
 

python_minifier/ast_compare.py

@@ -1,4 +1,6 @@
-import ast
+import python_minifier.ast_compat as ast
+
+from python_minifier.util import is_ast_node
 
 
 class CompareError(RuntimeError):
@@ -16,9 +18,7 @@ class CompareError(RuntimeError):
 
     def namespace(self, node):
         if hasattr(node, 'namespace'):
-            if isinstance(node.namespace, (ast.FunctionDef, ast.ClassDef)) or (
-                hasattr(ast, 'AsyncFunctionDef') and isinstance(node.namespace, ast.AsyncFunctionDef)
-            ):
+            if is_ast_node(node.namespace, (ast.FunctionDef, ast.ClassDef, 'AsyncFunctionDef')):
                 return self.namespace(node.namespace) + '.' + node.namespace.name
             elif isinstance(node.namespace, ast.Module):
                 return ''

python_minifier/ast_compat.py

@@ -0,0 +1,40 @@
+"""
+The is a backwards compatible shim for the ast module.
+
+This is the best way to make the ast module work the same in both python 2 and 3.
+This is essentially what the ast module was doing until 3.12, when it started throwing
+deprecation warnings.
+"""
+
+from ast import *
+
+# Ideally we don't import anything else
+
+if 'TypeAlias' in globals():
+
+    # Add n and s properties to Constant so it can stand in for Num, Str and Bytes
+    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
+
+    class Str(Constant):  # type: ignore[no-redef]
+        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)