python-minifier 2.9.0__tar.gz → 2.10.0__tar.gz

{python_minifier-2.9.0 → python_minifier-2.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python_minifier
-Version: 2.9.0
+Version: 2.10.0
 Summary: Transform Python source code into it's most compact representation
 Home-page: https://github.com/dflook/python-minifier
 Author: Daniel Flook
@@ -22,13 +22,14 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 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.12
+Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, <3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
 
@@ -38,7 +39,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.11. Previous releases supported Python 2.6.
+python-minifier currently supports Python 2.7 and Python 3.3 to 3.12. Previous releases supported Python 2.6.
 
 * [PyPI](https://pypi.org/project/python-minifier/)
 * [Documentation](https://dflook.github.io/python-minifier/)
@@ -141,7 +142,7 @@ $ pip install python-minifier
 Note that python-minifier depends on the python interpreter for parsing source code, 
 so install using a version of python appropriate for your source.
 
-python-minifier runs with and can minify code written for Python 2.7 and Python 3.3 to 3.11.
+python-minifier runs with and can minify code written for Python 2.7 and Python 3.3 to 3.12.
 
 ## Usage
 

{python_minifier-2.9.0 → python_minifier-2.10.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.11. Previous releases supported Python 2.6.
+python-minifier currently supports Python 2.7 and Python 3.3 to 3.12. Previous releases supported Python 2.6.
 
 * [PyPI](https://pypi.org/project/python-minifier/)
 * [Documentation](https://dflook.github.io/python-minifier/)
@@ -107,7 +107,7 @@ $ pip install python-minifier
 Note that python-minifier depends on the python interpreter for parsing source code, 
 so install using a version of python appropriate for your source.
 
-python-minifier runs with and can minify code written for Python 2.7 and Python 3.3 to 3.11.
+python-minifier runs with and can minify code written for Python 2.7 and Python 3.3 to 3.12.
 
 ## Usage
 

{python_minifier-2.9.0 → python_minifier-2.10.0}/setup.py

@@ -1,5 +1,4 @@
 import os.path
-import sys
 
 from setuptools import setup, find_packages
 
@@ -23,12 +22,12 @@ setup(
     
     package_dir={'': 'src'},
     packages=find_packages('src'),
-    package_data={"python_minifier": ["py.typed", "__init__.pyi"]},
+    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.12',
-    version='2.9.0',
+    python_requires='>=2.7, !=3.0.*, !=3.1.*, !=3.2.*, <3.13',
+    version='2.10.0',
 
     classifiers=[
         'Development Status :: 5 - Production/Stable',
@@ -44,6 +43,7 @@ setup(
         'Programming Language :: Python :: 3.9',
         'Programming Language :: Python :: 3.10',
         'Programming Language :: Python :: 3.11',
+        'Programming Language :: Python :: 3.12',
         'Programming Language :: Python :: 2',
         'Programming Language :: Python :: 2.7',
         'Programming Language :: Python :: Implementation :: CPython',

{python_minifier-2.9.0 → python_minifier-2.10.0}/src/python_minifier/__init__.py

@@ -4,7 +4,7 @@ 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
@@ -20,10 +20,13 @@ from python_minifier.rename import (
 )
 
 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
@@ -52,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,
@@ -67,6 +70,8 @@ def minify(
     remove_asserts=False,
     remove_debug=False,
     remove_explicit_return_none=True,
+    remove_builtin_exception_brackets=True,
+    constant_folding=True
 ):
     """
     Minify a python module
@@ -80,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
@@ -97,6 +103,8 @@ def minify(
     :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
 
@@ -115,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)
@@ -133,13 +153,31 @@ def minify(
     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)
 

{python_minifier-2.9.0 → python_minifier-2.10.0}/src/python_minifier/__init__.pyi

@@ -1,6 +1,7 @@
 import ast
-from typing import List, Text, AnyStr, Optional, Any
+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): ...
@@ -8,7 +9,7 @@ class UnstableMinification(RuntimeError):
 def minify(
     source: AnyStr,
     filename: Optional[str] = ...,
-    remove_annotations: bool = ...,
+    remove_annotations: Union[bool, RemoveAnnotationsOptions] = ...,
     remove_pass: bool = ...,
     remove_literal_statements: bool = ...,
     combine_imports: bool = ...,
@@ -22,7 +23,9 @@ def minify(
     preserve_shebang: bool = ...,
     remove_asserts: bool = ...,
     remove_debug: bool = ...,
-    remove_explicit_return_none: bool = ...
+    remove_explicit_return_none: bool = ...,
+    remove_builtin_exception_brackets: bool = ...,
+    constant_folding: bool = ...
 ) -> Text: ...
 
 def unparse(module: ast.Module) -> Text: ...

{python_minifier-2.9.0 → python_minifier-2.10.0}/src/python_minifier/__main__.py

@@ -1,17 +1,24 @@
 from __future__ import print_function
 
-import sys
-import os
-
 import argparse
-from pkg_resources import get_distribution, DistributionNotFound
+import os
+import sys
 
 from python_minifier import minify
-
-try:
-    version = get_distribution('python_minifier').version
-except DistributionNotFound:
-    version = '0.0.0'
+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():
@@ -68,6 +75,7 @@ examples:
             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__)
 
@@ -113,12 +121,6 @@ def parse_args():
         help='Enable removing statements that are just a literal (including docstrings)',
         dest='remove_literal_statements',
     )
-    minification_options.add_argument(
-        '--no-remove-annotations',
-        action='store_false',
-        help='Disable removing function and variable annotations',
-        dest='remove_annotations',
-    )
     minification_options.add_argument(
         '--no-hoist-literals',
         action='store_false',
@@ -189,6 +191,51 @@ def parse_args():
         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()
@@ -207,8 +254,13 @@ def parse_args():
         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):
@@ -223,6 +275,7 @@ def source_modules(args):
         else:
             yield path_arg
 
+
 def do_minify(source, filename, minification_args):
 
     preserve_globals = []
@@ -237,12 +290,27 @@ def do_minify(source, filename, minification_args):
             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=minification_args.remove_annotations,
+        remove_annotations=remove_annotations,
         remove_literal_statements=minification_args.remove_literal_statements,
         hoist_literals=minification_args.hoist_literals,
         rename_locals=minification_args.rename_locals,
@@ -255,6 +323,8 @@ def do_minify(source, filename, minification_args):
         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-2.9.0 → python_minifier-2.10.0}/src/python_minifier/ast_compare.py

@@ -1,4 +1,4 @@
-import ast
+import python_minifier.ast_compat as ast
 
 from python_minifier.util import is_ast_node
 

python_minifier-2.10.0/src/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)

python_minifier-2.10.0/src/python_minifier/ast_printer.py

@@ -0,0 +1,130 @@
+"""
+Print a representation of an AST
+
+This prints a human readable representation of the nodes in the AST.
+The goal is to make it easy to see what the AST looks like, and to
+make it easy to compare two ASTs.
+
+This is not intended to be a complete representation of the AST, some
+fields or field names may be omitted for clarity. It should still be precise and unambiguous.
+
+"""
+
+import python_minifier.ast_compat as ast
+
+from python_minifier.util import is_ast_node
+
+INDENT = '    '
+
+# The field name that can be omitted for each node
+# Either it's the only field or would otherwise be obvious
+default_fields = {
+    'Constant': 'value',
+    'Num': 'n',
+    'Str': 's',
+    'Bytes': 's',
+    'NameConstant': 'value',
+    'FormattedValue': 'value',
+    'JoinedStr': 'values',
+    'List': 'elts',
+    'Tuple': 'elts',
+    'Set': 'elts',
+    'Name': 'id',
+    'Expr': 'value',
+    'UnaryOp': 'op',
+    'BinOp': 'op',
+    'BoolOp': 'op',
+    'Call': 'func',
+    'Index': 'value',
+    'ExtSlice': 'dims',
+    'Assert': 'test',
+    'Delete': 'targets',
+    'Import': 'names',
+    'If': 'test',
+    'While': 'test',
+    'Try': 'handlers',
+    'TryExcept': 'handlers',
+    'With': 'items',
+    'withitem': 'context_expr',
+    'FunctionDef': 'name',
+    'arg': 'arg',
+    'Return': 'value',
+    'Yield': 'value',
+    'YieldFrom': 'value',
+    'Global': 'names',
+    'Nonlocal': 'names',
+    'ClassDef': 'name',
+    'AsyncFunctionDef': 'name',
+    'Await': 'value',
+    'AsyncWith': 'items',
+    'Raise': 'exc',
+    'Subscript': 'value',
+    'Attribute': 'value',
+    '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':
+        return True
+
+    if is_ast_node(node, ast.Str) and field == 's':
+        return True
+
+    if is_ast_node(node, 'Bytes') and field == 's':
+        return True
+
+    if is_ast_node(node, 'NameConstant') and field == 'value':
+        return True
+
+    return False
+
+def print_ast(node):
+    if not isinstance(node, ast.AST):
+        return repr(node)
+
+    s = ''
+
+    node_name = node.__class__.__name__
+    s += node_name
+    s += '('
+
+    first = True
+    for field, value in ast.iter_fields(node):
+        if not value and not is_literal(node, field):
+            # Don't bother printing fields that are empty, except for literals
+            continue
+
+        if field == 'ctx':
+            # Don't print the ctx, it's always apparent from context
+            continue
+
+        if first:
+            first = False
+        else:
+            s += ', '
+
+        if default_fields.get(node_name) != field:
+            s += field + '='
+
+        if isinstance(value, ast.AST):
+            s += print_ast(value)
+        elif isinstance(value, list):
+            s += '['
+            first_list = True
+            for item in value:
+                if first_list:
+                    first_list = False
+                else:
+                    s += ','
+
+                for line in print_ast(item).splitlines():
+                    s += '\n' + INDENT + line
+            s += '\n]'
+        else:
+            s += repr(value)
+
+    s += ')'
+    return s

{python_minifier-2.9.0 → python_minifier-2.10.0}/src/python_minifier/expression_printer.py

@@ -1,4 +1,4 @@
-import ast
+import python_minifier.ast_compat as ast
 import sys
 
 from python_minifier.util import is_ast_node
@@ -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 isinstance(node, ast.Num):
+        if sys.version_info < (3, 0) and is_ast_node(node, ast.Num):
             if str(node.n)[0] == '-':
                 return self.precedences['USub']
 
@@ -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 isinstance(node.operand, ast.Num):
+        if sys.version_info < (3, 0) and isinstance(node.op, ast.USub) and is_ast_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 isinstance(node.value, ast.Num):
+        if (value_precedence != 0 and (attr_precedence > value_precedence)) or is_ast_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 isinstance(node.slice, ast.Ellipsis):
+        elif is_ast_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)
@@ -735,7 +735,12 @@ class ExpressionPrinter(object):
 
         import python_minifier.f_string
 
-        self.printer.fstring(str(python_minifier.f_string.OuterFString(node)))
+        if sys.version_info < (3, 12):
+            pep701 = False
+        else:
+            pep701 = True
+
+        self.printer.fstring(str(python_minifier.f_string.OuterFString(node, pep701=pep701)))
 
     def visit_NamedExpr(self, node):
         self._expression(node.target)