Merge pull request #89 from dflook/no-arg-exceptions

Replace exception calls with names

Author: dflook

docs/source/transforms/remove_builtin_exception_brackets.py

@@ -0,0 +1,3 @@
+class MyBaseClass:
+    def override_me(self):
+        raise NotImplementedError()

docs/source/transforms/remove_builtin_exception_brackets.rst

@@ -0,0 +1,26 @@
+Remove Builtin Exception Brackets
+=================================
+
+This transform removes parentheses when raising builtin exceptions with no arguments.
+
+The raise statement automatically instantiates exceptions with no arguments, so the parentheses are unnecessary.
+This transform does nothing on Python 2.
+
+If the exception is not a builtin exception, or has arguments, the parentheses are not removed.
+
+This transform is enabled by default. Disable by passing the ``remove_builtin_exception_brackets=False`` argument to the :func:`python_minifier.minify` function,
+or passing ``--no-remove-builtin-exception-brackets`` to the pyminify command.
+
+Example
+-------
+
+Input
+~~~~~
+
+.. literalinclude:: remove_exception_brackets.py
+
+Output
+~~~~~~
+
+.. literalinclude:: remove_exception_brackets.min.py
+    :language: python

src/python_minifier/__init__.py

@@ -25,6 +25,7 @@
 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
@@ -68,6 +69,7 @@ def minify(
     remove_asserts=False,
     remove_debug=False,
     remove_explicit_return_none=True,
+    remove_builtin_exception_brackets=True
 ):
     """
     Minify a python module
@@ -99,6 +101,7 @@ 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
 
     :rtype: str
 
@@ -150,6 +153,9 @@ def minify(
     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

src/python_minifier/__init__.pyi

@@ -23,7 +23,8 @@ 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 = ...
 ) -> Text: ...
 
 def unparse(module: ast.Module) -> Text: ...

src/python_minifier/__main__.py

@@ -184,6 +184,12 @@ 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',
+    )
 
     annotation_options = parser.add_argument_group('remove annotations options', 'Options that affect how annotations are removed')
     annotation_options.add_argument(
@@ -302,6 +308,7 @@ 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
     )
 
 

src/python_minifier/transforms/remove_exception_brackets.py

@@ -0,0 +1,117 @@
+"""
+Remove Call nodes that are only used to raise exceptions with no arguments
+
+If a Raise statement is used on a Name and the name refers to an exception, it is automatically instantiated with no arguments
+We can remove any Call nodes that are only used to raise exceptions with no arguments and let the Raise statement do the instantiation.
+When printed, this essentially removes the brackets from the exception name.
+
+We can't generally know if a name refers to an exception, so we only do this for builtin exceptions
+"""
+
+import ast
+import sys
+
+from python_minifier.rename.binding import BuiltinBinding
+
+# These are always exceptions, in every version of python
+builtin_exceptions = [
+    'SyntaxError', 'Exception', 'ValueError', 'BaseException', 'MemoryError', 'RuntimeError', 'DeprecationWarning', 'UnicodeEncodeError', 'KeyError', 'LookupError', 'TypeError', 'BufferError',
+    'ImportError', 'OSError', 'StopIteration', 'ArithmeticError', 'UserWarning', 'PendingDeprecationWarning', 'RuntimeWarning', 'IndentationError', 'UnicodeTranslateError', 'UnboundLocalError',
+    'AttributeError', 'EOFError', 'UnicodeWarning', 'BytesWarning', 'NameError', 'IndexError', 'TabError', 'SystemError', 'OverflowError', 'FutureWarning', 'SystemExit', 'Warning',
+    'FloatingPointError', 'ReferenceError', 'UnicodeError', 'AssertionError', 'SyntaxWarning', 'UnicodeDecodeError', 'GeneratorExit', 'ImportWarning', 'KeyboardInterrupt', 'ZeroDivisionError',
+    'NotImplementedError'
+]
+
+# These are exceptions only in python 2.7
+builtin_exceptions_2_7 = [
+    'IOError',
+    'StandardError',
+    'EnvironmentError',
+    'VMSError',
+    'WindowsError'
+]
+
+# These are exceptions in 3.3+
+builtin_exceptions_3_3 = [
+    'ChildProcessError',
+    'ConnectionError',
+    'BrokenPipeError',
+    'ConnectionAbortedError',
+    'ConnectionRefusedError',
+    'ConnectionResetError',
+    'FileExistsError',
+    'FileNotFoundError',
+    'InterruptedError',
+    'IsADirectoryError',
+    'NotADirectoryError',
+    'PermissionError',
+    'ProcessLookupError',
+    'TimeoutError',
+    'ResourceWarning',
+]
+
+# These are exceptions in 3.5+
+builtin_exceptions_3_5 = [
+    'StopAsyncIteration',
+    'RecursionError',
+]
+
+# These are exceptions in 3.6+
+builtin_exceptions_3_6 = [
+    'ModuleNotFoundError'
+]
+
+# These are exceptions in 3.10+
+builtin_exceptions_3_10 = [
+    'EncodingWarning'
+]
+
+# These are exceptions in 3.11+
+builtin_exceptions_3_11 = [
+    'BaseExceptionGroup',
+    'ExceptionGroup',
+    'BaseExceptionGroup',
+]
+
+def _remove_empty_call(binding):
+    assert isinstance(binding, BuiltinBinding)
+
+    for name_node in binding.references:
+        assert isinstance(name_node, ast.Name)  # For this to be a builtin, all references must be name nodes as it is not defined anywhere
+
+        if not isinstance(name_node.parent, ast.Call):
+            # This is not a call
+            continue
+        call_node = name_node.parent
+
+        if not isinstance(call_node.parent, ast.Raise):
+            # This is not a raise statement
+            continue
+        raise_node = call_node.parent
+
+        if len(call_node.args) > 0 or len(call_node.keywords) > 0:
+            # This is a call with arguments
+            continue
+
+        # This is an instance of the exception being called with no arguments
+        # let's replace it with just the name, cutting out the Call node
+
+        if raise_node.exc is call_node:
+            raise_node.exc = name_node
+        elif raise_node.cause is call_node:
+            raise_node.cause = name_node
+        name_node.parent = raise_node
+
+
+def remove_no_arg_exception_call(module):
+    assert isinstance(module, ast.Module)
+
+    if sys.version_info < (3, 0):
+        return module
+
+    for binding in module.bindings:
+        if isinstance(binding, BuiltinBinding) and binding.name in builtin_exceptions:
+            # We can remove any calls to builtin exceptions
+            _remove_empty_call(binding)
+
+    return module

test/test_remove_exception_brackets.py

@@ -0,0 +1,125 @@
+import ast
+import sys
+
+import pytest
+
+from python_minifier.rename import add_namespace, bind_names, resolve_names
+from python_minifier.ast_compare import compare_ast
+from python_minifier.transforms.remove_exception_brackets import remove_no_arg_exception_call
+
+
+def remove_brackets(source):
+    module = ast.parse(source, 'remove_brackets')
+
+    add_namespace(module)
+    bind_names(module)
+    resolve_names(module)
+    return remove_no_arg_exception_call(module)
+
+
+def test_exception_brackets():
+    """This is a buitin so remove the brackets"""
+    if sys.version_info < (3, 0):
+        pytest.skip('transform does not work in this version of python')
+
+    source = 'def a(): raise Exception()'
+    expected = 'def a(): raise Exception'
+
+    expected_ast = ast.parse(expected)
+    actual_ast = remove_brackets(source)
+    compare_ast(expected_ast, actual_ast)
+
+def test_zero_division_error_brackets():
+    """This is a buitin so remove the brackets"""
+    if sys.version_info < (3, 0):
+        pytest.skip('transform does not work in this version of python')
+
+    source = 'def a(): raise ZeroDivisionError()'
+    expected = 'def a(): raise ZeroDivisionError'
+
+    expected_ast = ast.parse(expected)
+    actual_ast = remove_brackets(source)
+    compare_ast(expected_ast, actual_ast)
+
+def test_builtin_with_arg():
+    """This has an arg so dont' remove the brackets"""
+    if sys.version_info < (3, 0):
+        pytest.skip('transform does not work in this version of python')
+
+    source = 'def a(): raise Exception(1)'
+    expected = 'def a(): raise Exception(1)'
+
+    expected_ast = ast.parse(expected)
+    actual_ast = remove_brackets(source)
+    compare_ast(expected_ast, actual_ast)
+
+def test_one_division_error_brackets():
+    """This is not a builtin so don't remove the brackets even though it's not defined in the module"""
+    if sys.version_info < (3, 0):
+        pytest.skip('transform does not work in this version of python')
+
+    source = 'def a(): raise OneDivisionError()'
+    expected = source
+
+    expected_ast = ast.parse(expected)
+    actual_ast = remove_brackets(source)
+    compare_ast(expected_ast, actual_ast)
+
+def test_redefined():
+    """This is usually a builtin, but don't remove brackets if it's been redefined"""
+    if sys.version_info < (3, 0):
+        pytest.skip('transform does not work in this version of python')
+
+    source = '''
+def a():
+    raise ZeroDivisionError()
+def b():
+    ZeroDivisionError = blag
+    raise ZeroDivisionError()
+'''
+    expected = '''
+def a():
+    raise ZeroDivisionError
+def b():
+    ZeroDivisionError = blag
+    raise ZeroDivisionError()
+'''
+    expected_ast = ast.parse(expected)
+    actual_ast = remove_brackets(source)
+    compare_ast(expected_ast, actual_ast)
+
+def test_raise_from():
+    """This is a builtin so remove the brackets"""
+    if sys.version_info < (3, 0):
+        pytest.skip('raise from not supported in this version of python')
+
+    source = 'def a(): raise Exception() from Exception()'
+    expected = 'def a(): raise Exception from Exception'
+
+    expected_ast = ast.parse(expected)
+    actual_ast = remove_brackets(source)
+    compare_ast(expected_ast, actual_ast)
+
+def test_raise_from_only():
+    """This is a builtin so remove the brackets"""
+    if sys.version_info < (3, 0):
+        pytest.skip('raise from not supported in this version of python')
+
+    source = 'def a(): raise Hello() from Exception()'
+    expected = 'def a(): raise Hello() from Exception'
+
+    expected_ast = ast.parse(expected)
+    actual_ast = remove_brackets(source)
+    compare_ast(expected_ast, actual_ast)
+
+def test_raise_from_arg():
+    """This is a builtin so remove the brackets"""
+    if sys.version_info < (3, 0):
+        pytest.skip('raise from not supported in this version of python')
+
+    source = 'def a(): raise Hello() from Exception(1)'
+    expected = 'def a(): raise Hello() from Exception(1)'
+
+    expected_ast = ast.parse(expected)
+    actual_ast = remove_brackets(source)
+    compare_ast(expected_ast, actual_ast)