python-minifier 2.11.2__py2-none-any.whl

python_minifier/__init__.py

@@ -0,0 +1,269 @@
+"""
+This package transforms python source code strings or ast.Module Nodes into
+a 'minified' representation of the same source code.
+
+"""
+
+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
+from python_minifier.rename import (
+    rename_literals,
+    bind_names,
+    resolve_names,
+    rename,
+    allow_rename_globals,
+    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
+from python_minifier.transforms.remove_posargs import remove_posargs
+
+
+class UnstableMinification(RuntimeError):
+    """
+    Raised when a minified module differs from the original module in an unexpected way.
+
+    This is raised when the minifier generates source code that doesn't parse back into the
+    original module (after known transformations).
+    This should never occur and is a bug.
+
+    """
+
+    def __init__(self, exception, source, minified):
+        self.exception = exception
+        self.source = source
+        self.minified = minified
+
+    def __str__(self):
+        return 'Minification was unstable! Please create an issue at https://github.com/dflook/python-minifier/issues'
+
+
+def minify(
+    source,
+    filename=None,
+    remove_annotations=RemoveAnnotationsOptions(),
+    remove_pass=True,
+    remove_literal_statements=False,
+    combine_imports=True,
+    hoist_literals=True,
+    rename_locals=True,
+    preserve_locals=None,
+    rename_globals=False,
+    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
+
+    The module is transformed according the the arguments.
+    If all transformation arguments are False, no transformations are made to the AST, the returned string will
+    parse into exactly the same module.
+
+    Using the default arguments only transformations that are always or almost always safe are enabled.
+
+    :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.
+    :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
+    :param bool hoist_literals: If str and byte literals may be hoisted to the module level where possible.
+    :param bool rename_locals: If local names may be shortened
+    :param preserve_locals: Locals names to leave unchanged when rename_locals is True
+    :type preserve_locals: list[str]
+    :param bool rename_globals: If global names may be shortened
+    :param preserve_globals: Global names to leave unchanged when rename_globals is True
+    :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
+
+    """
+
+    filename = filename or 'python_minifier.minify source'
+
+    # This will raise if the source file can't be parsed
+    module = ast.parse(source, filename)
+
+    add_namespace(module)
+
+    if remove_literal_statements:
+        module = RemoveLiteralStatements()(module)
+
+    if combine_imports:
+        module = CombineImports()(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)
+
+    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)
+
+    if hoist_literals:
+        rename_literals(module)
+
+    rename(module, prefix_globals=not rename_globals, preserved_globals=preserve_globals)
+
+    if convert_posargs_to_args:
+        module = remove_posargs(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):
+    """
+    Turn a module AST into python code
+
+    This returns an exact representation of the given module,
+    such that it can be parsed back into the same AST.
+
+    :param module: The module to turn into python code
+    :type: module: :class:`ast.Module`
+    :rtype: str
+
+    """
+
+    assert isinstance(module, ast.Module)
+
+    printer = ModulePrinter()
+    printer(module)
+
+    try:
+        minified_module = ast.parse(printer.code, 'python_minifier.unparse output')
+    except SyntaxError as syntax_error:
+        raise UnstableMinification(syntax_error, '', printer.code)
+
+    try:
+        compare_ast(module, minified_module)
+    except CompareError as compare_error:
+        raise UnstableMinification(compare_error, '', printer.code)
+
+    return printer.code
+
+
+def awslambda(source, filename=None, entrypoint=None):
+    """
+    Minify a python module for use as an AWS Lambda function
+
+    This returns a string suitable for embedding in a cloudformation template.
+    When minifying, all transformations are enabled.
+
+    :param str source: The python module source code
+    :param str filename: The original source filename if known
+    :param entrypoint: The lambda entrypoint function
+    :type entrypoint: str or NoneType
+    :rtype: str
+
+    """
+
+    rename_globals = True
+    if entrypoint is None:
+        rename_globals = False
+
+    return minify(
+        source, filename, remove_literal_statements=True, rename_globals=rename_globals, preserve_globals=[entrypoint],
+    )

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

@@ -0,0 +1,332 @@
+from __future__ import print_function
+
+import argparse
+import os
+import sys
+
+from python_minifier import minify
+from python_minifier.transforms.remove_annotations_options import RemoveAnnotationsOptions
+
+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
+
+  # Minifying a file in place
+  pyminify example.py --in-place
+
+  # 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',
+    )
+    minification_options.add_argument(
+        '--no-remove-pass',
+        action='store_false',
+        default=True,
+        help='Disable removing Pass statements',
+        dest='remove_pass',
+    )
+    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',
+    )
+    minification_options.add_argument(
+        '--no-hoist-literals',
+        action='store_false',
+        help='Disable replacing string and bytes literals with variables',
+        dest='hoist_literals',
+    )
+    minification_options.add_argument(
+        '--no-rename-locals',
+        action='store_false',
+        help='Disable shortening of local names',
+        dest='rename_locals'
+    )
+    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'
+    )
+    minification_options.add_argument(
+        '--rename-globals',
+        action='store_true',
+        help='Enable shortening of global names',
+        dest='rename_globals'
+    )
+    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'
+    )
+    minification_options.add_argument(
+        '--no-remove-object-base',
+        action='store_false',
+        help='Disable removing object from base class list',
+        dest='remove_object_base',
+    )
+    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',
+    )
+
+    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()
+
+    # 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 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 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)
+
+    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
+    )
+
+
+if __name__ == '__main__':
+    main()