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

python_minifier/rename/rename_literals.py

@@ -1,14 +1,15 @@
 import python_minifier.ast_compat as ast
+from python_minifier.ast_annotation import get_parent, set_parent
 
 from python_minifier.rename.binding import Binding
 from python_minifier.rename.util import insert
 from python_minifier.transforms.suite_transformer import NodeVisitor
-from python_minifier.util import is_ast_node
+from python_minifier.util import is_constant_node
 
 
 def replace(old_node, new_node):
-    parent = old_node.parent
-    new_node.parent = parent
+    parent = get_parent(old_node)
+    set_parent(new_node, parent)
     new_node.namespace = old_node.namespace
 
     for field, old_value in ast.iter_fields(parent):
@@ -43,7 +44,7 @@ class HoistedBinding(Binding):
 
     @property
     def value(self):
-        if is_ast_node(self._value_node, (ast.Str, 'Bytes')):
+        if is_constant_node(self._value_node, (ast.Str, ast.Bytes)):
             return self._value_node.s
         else:
             return self._value_node.value
@@ -84,6 +85,7 @@ class HoistedBinding(Binding):
 
         return rename_cost <= current_cost
 
+
 class HoistedValue(object):
     """
     HoistedValue comparator object
@@ -132,7 +134,7 @@ class HoistLiterals(NodeVisitor):
 
         """
 
-        if is_ast_node(node.namespace, (ast.FunctionDef, ast.Module, 'AsyncFunctionDef')):
+        if isinstance(node.namespace, (ast.FunctionDef, ast.Module, ast.AsyncFunctionDef)):
             return node.namespace
         return self.nearest_function_namespace(node.namespace)
 
@@ -154,18 +156,18 @@ class HoistLiterals(NodeVisitor):
 
         """
 
-        l = []
+        path = []
 
         while True:
             namespace = self.nearest_function_namespace(node)
-            l.insert(0, namespace)
+            path.insert(0, namespace)
 
             if isinstance(namespace, ast.Module):
                 break
 
             node = namespace
 
-        return l
+        return path
 
     def common_path(self, n1_path, n2_path):
 
@@ -201,7 +203,7 @@ class HoistLiterals(NodeVisitor):
 
     def visit_Str(self, node):
 
-        if isinstance(node.parent, ast.Expr):
+        if isinstance(get_parent(node), ast.Expr):
             # This is literal statement
             # The RemoveLiteralStatements transformer must have left it here, so ignore it.
             return
@@ -213,11 +215,10 @@ class HoistLiterals(NodeVisitor):
 
     def visit_JoinedStr(self, node):
         for v in node.values:
-            if is_ast_node(v, ast.Str):
+            if is_constant_node(v, ast.Str):
                 # Can't hoist this!
                 continue
-            else:
-                self.visit(v)
+            self.visit(v)
 
     def visit_NameConstant(self, node):
         self.get_binding(node.value, node).add_reference(node)
@@ -235,15 +236,16 @@ class HoistLiterals(NodeVisitor):
         if not self._ignore_slots:
             return self.generic_visit(node)
 
-        if not is_ast_node(node.namespace, ast.ClassDef):
+        if not isinstance(node.namespace, ast.ClassDef):
             return self.generic_visit(node)
 
         for target in node.targets:
-            if is_ast_node(target, ast.Name) and target.id == '__slots__':
+            if isinstance(target, ast.Name) and target.id == '__slots__':
                 # This is a __slots__ assignment, don't hoist the literals
-                return
+                return None
 
         return self.generic_visit(node)
 
+
 def rename_literals(module):
     HoistLiterals()(module)

python_minifier/rename/renamer.py

@@ -55,7 +55,7 @@ def reservation_scope(namespace, binding):
 
     """
 
-    namespaces = set([namespace])
+    namespaces = {namespace}
 
     for node in binding.references:
         while node is not namespace:
@@ -112,7 +112,7 @@ class UniqueNameAssigner(object):
     def __call__(self, module):
         assert isinstance(module, ast.Module)
 
-        for namespace, binding in sorted_bindings(module):
+        for _namespace, binding in sorted_bindings(module):
             if binding.allow_rename:
                 binding.new_name = self.available_name()
 
@@ -154,6 +154,8 @@ class NameAssigner(object):
             if self.is_available(prefix + name, reservation_scope):
                 return prefix + name
 
+        return None
+
     def is_available(self, name, reservation_scope):
         """
         Is a name unreserved in a reservation scope
@@ -165,11 +167,7 @@ class NameAssigner(object):
 
         """
 
-        for namespace in reservation_scope:
-            if name in namespace.assigned_names:
-                return False
-
-        return True
+        return all(name not in namespace.assigned_names for namespace in reservation_scope)
 
     def __call__(self, module, prefix_globals, reserved_globals=None):
         assert isinstance(module, ast.Module)
@@ -184,6 +182,26 @@ class NameAssigner(object):
             for name in reserved_globals:
                 module.assigned_names.add(name)
 
+        def should_rename(binding, name, scope):
+            if binding.should_rename(name):
+                return True
+
+            # It's no longer efficient to do this rename
+
+            if isinstance(binding, NameBinding):
+                # Check that the original name is still available
+
+                if binding.reserved == binding.name:
+                    # We already reserved it (this is probably an arg)
+                    return False
+
+                if not self.is_available(binding.name, scope):
+                    # The original name has already been assigned to another binding,
+                    # so we need to rename this anyway.
+                    return True
+
+            return False
+
         for namespace, binding in sorted_bindings(module):
             scope = reservation_scope(namespace, binding)
 
@@ -194,27 +212,7 @@ class NameAssigner(object):
                 else:
                     name = self.available_name(scope)
 
-                def should_rename():
-                    if binding.should_rename(name):
-                        return True
-
-                    # It's no longer efficient to do this rename
-
-                    if isinstance(binding, NameBinding):
-                        # Check that the original name is still available
-
-                        if binding.reserved == binding.name:
-                            # We already reserved it (this is probably an arg)
-                            return False
-
-                        if not self.is_available(binding.name, scope):
-                            # The original name has already been assigned to another binding,
-                            # so we need to rename this anyway.
-                            return True
-
-                    return False
-
-                if should_rename():
+                if should_rename(binding, name, scope):
                     binding.rename(name)
                 else:
                     # Any existing name will become reserved

python_minifier/rename/resolve_names.py

@@ -1,8 +1,7 @@
 import python_minifier.ast_compat as ast
 
 from python_minifier.rename.binding import BuiltinBinding, NameBinding
-from python_minifier.rename.util import get_global_namespace, get_nonlocal_namespace, builtins
-from python_minifier.util import is_ast_node
+from python_minifier.rename.util import builtins, get_global_namespace, get_nonlocal_namespace
 
 
 def get_binding(name, namespace):
@@ -34,6 +33,7 @@ def get_binding(name, namespace):
             namespace.bindings.append(binding)
             return binding
 
+
 def get_binding_disallow_class_namespace_rename(name, namespace):
     binding = get_binding(name, namespace)
 
@@ -43,6 +43,7 @@ def get_binding_disallow_class_namespace_rename(name, namespace):
 
     return binding
 
+
 def resolve_names(node):
     """
     Resolve unbound names to a NameBinding
@@ -65,7 +66,7 @@ def resolve_names(node):
         binding = get_binding_disallow_class_namespace_rename(node.name, node.namespace)
         binding.add_reference(node)
 
-    elif is_ast_node(node, (ast.FunctionDef, 'AsyncFunctionDef')) and node.name in node.namespace.nonlocal_names:
+    elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)) and node.name in node.namespace.nonlocal_names:
         binding = get_binding_disallow_class_namespace_rename(node.name, node.namespace)
         binding.add_reference(node)
 
@@ -91,15 +92,15 @@ def resolve_names(node):
         if isinstance(node.name, str) and node.name in node.namespace.nonlocal_names:
             get_binding_disallow_class_namespace_rename(node.name, node.namespace).add_reference(node)
 
-    elif is_ast_node(node, 'Nonlocal'):
+    elif isinstance(node, ast.Nonlocal):
         for name in node.names:
             get_binding_disallow_class_namespace_rename(name, node.namespace).add_reference(node)
-    elif is_ast_node(node, ('MatchAs', 'MatchStar')) and node.name in node.namespace.nonlocal_names:
+    elif isinstance(node, (ast.MatchAs, ast.MatchStar)) and node.name in node.namespace.nonlocal_names:
         get_binding_disallow_class_namespace_rename(node.name, node.namespace).add_reference(node)
-    elif is_ast_node(node, 'MatchMapping') and node.rest in node.namespace.nonlocal_names:
+    elif isinstance(node, ast.MatchMapping) and node.rest in node.namespace.nonlocal_names:
         get_binding_disallow_class_namespace_rename(node.rest, node.namespace).add_reference(node)
 
-    elif is_ast_node(node, 'Exec'):
+    elif isinstance(node, ast.Exec):
         get_global_namespace(node).tainted = True
 
     for child in ast.iter_child_nodes(node):

python_minifier/rename/util.py

@@ -1,7 +1,8 @@
-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.util import is_constant_node
 
 
 def create_is_namespace():
@@ -32,6 +33,7 @@ def iter_child_namespaces(node):
             for c in iter_child_namespaces(child):
                 yield c
 
+
 def get_global_namespace(node):
     """
     Return the global namespace for a node
@@ -125,7 +127,7 @@ def insert(suite, new_node):
 
         if not inserted:
             if (isinstance(node, ast.ImportFrom) and node.module == '__future__') or (
-                isinstance(node, ast.Expr) and is_ast_node(node.value, ast.Str)
+                isinstance(node, ast.Expr) and is_constant_node(node.value, ast.Str)
             ):
                 pass
             else:
@@ -164,7 +166,7 @@ def find__all__(module):
                 if isinstance(name, ast.Name) and name.id == '__all__':
                     return True
 
-        elif is_ast_node(node, (ast.AugAssign, 'AnnAssign')):
+        elif isinstance(node, (ast.AugAssign, ast.AnnAssign)):
             if isinstance(node.target, ast.Name) and node.target.id == '__all__':
                 return True
 
@@ -178,7 +180,7 @@ def find__all__(module):
             continue
 
         for el in node.value.elts:
-            if is_ast_node(el, ast.Str):
+            if is_constant_node(el, ast.Str):
                 names.append(el.s)
 
     return names

python_minifier/token_printer.py

@@ -3,6 +3,7 @@
 import re
 import sys
 
+
 class TokenTypes(object):
     NoToken = 0
     Identifier = 1
@@ -15,6 +16,7 @@ class TokenTypes(object):
     NewLine = 8
     EndStatement = 9
 
+
 class Delimiter(object):
     def __init__(self, terminal_printer, delimiter=',', add_parens=False):
         """
@@ -74,6 +76,7 @@ class Delimiter(object):
         else:
             self._terminal_printer.delimiter(self._delimiter)
 
+
 class TokenPrinter(object):
     """
     Concatenates terminal symbols of the python grammar

python_minifier/transforms/combine_imports.py

@@ -30,7 +30,6 @@ class CombineImports(SuiteTransformer):
         if alias:
             yield self.add_child(ast.Import(names=alias), parent=parent, namespace=namespace)
 
-
     def _combine_import_from(self, node_list, parent):
 
         prev_import = None

python_minifier/transforms/constant_folding.py

@@ -1,11 +1,14 @@
-import python_minifier.ast_compat as ast
 import math
 import sys
 
+import python_minifier.ast_compat as ast
+from python_minifier.ast_annotation import get_parent
+
 from python_minifier.ast_compare import compare_ast
 from python_minifier.expression_printer import ExpressionPrinter
 from python_minifier.transforms.suite_transformer import SuiteTransformer
-from python_minifier.util import is_ast_node
+from python_minifier.util import is_constant_node
+
 
 class FoldConstants(SuiteTransformer):
     """
@@ -22,9 +25,9 @@ class FoldConstants(SuiteTransformer):
 
         # Check this is a constant expression that could be folded
         # We don't try to fold strings or bytes, since they have probably been arranged this way to make the source shorter and we are unlikely to beat that
-        if not is_ast_node(node.left, (ast.Num, 'NameConstant')):
+        if not is_constant_node(node.left, (ast.Num, ast.NameConstant)):
             return node
-        if not is_ast_node(node.right, (ast.Num, 'NameConstant')):
+        if not is_constant_node(node.right, (ast.Num, ast.NameConstant)):
             return node
 
         if isinstance(node.op, ast.Div):
@@ -68,7 +71,7 @@ class FoldConstants(SuiteTransformer):
         try:
             folded_expression = unparse_expression(new_node)
             folded_value = safe_eval(folded_expression)
-        except Exception as e:
+        except Exception:
             # This can happen if the value is too large to be represented as a literal
             # or if the value is unparsed as nan, inf or -inf - which are not valid python literals
             return node
@@ -91,7 +94,8 @@ class FoldConstants(SuiteTransformer):
             return node
 
         # New representation is shorter and has the same value, so use it
-        return self.add_child(new_node, node.parent, node.namespace)
+        return self.add_child(new_node, get_parent(node), node.namespace)
+
 
 def equal_value_and_type(a, b):
     if type(a) != type(b):
@@ -102,13 +106,15 @@ def equal_value_and_type(a, b):
 
     return a == b
 
+
 def safe_eval(expression):
-    globals = {}
-    locals = {}
+    empty_globals = {}
+    empty_locals = {}
 
     # This will return the value, or could raise an exception
-    return eval(expression, globals, locals)
+    return eval(expression, empty_globals, empty_locals)
+
 
 def unparse_expression(node):
     expression_printer = ExpressionPrinter()
-    return expression_printer(node)
+    return expression_printer(node)

python_minifier/transforms/remove_annotations.py

@@ -1,6 +1,8 @@
-import python_minifier.ast_compat as ast
 import sys
 
+import python_minifier.ast_compat as ast
+from python_minifier.ast_annotation import get_parent
+
 from python_minifier.transforms.remove_annotations_options import RemoveAnnotationsOptions
 from python_minifier.transforms.suite_transformer import SuiteTransformer
 
@@ -71,20 +73,20 @@ class RemoveAnnotations(SuiteTransformer):
             if sys.version_info < (3, 7):
                 return False
 
-            if not isinstance(node.parent, ast.ClassDef):
+            if not isinstance(get_parent(node), ast.ClassDef):
                 return False
 
-            if len(node.parent.decorator_list) == 0:
+            if len(get_parent(node).decorator_list) == 0:
                 return False
 
-            for node in node.parent.decorator_list:
-                if isinstance(node, ast.Name) and node.id == 'dataclass':
+            for decorator_node in get_parent(node).decorator_list:
+                if isinstance(decorator_node, ast.Name) and decorator_node.id == 'dataclass':
                     return True
-                elif isinstance(node, ast.Attribute) and node.attr == 'dataclass':
+                elif isinstance(decorator_node, ast.Attribute) and decorator_node.attr == 'dataclass':
                     return True
-                elif isinstance(node, ast.Call) and isinstance(node.func, ast.Name) and node.func.id == 'dataclass':
+                elif isinstance(decorator_node, ast.Call) and isinstance(decorator_node.func, ast.Name) and decorator_node.func.id == 'dataclass':
                     return True
-                elif isinstance(node, ast.Call) and isinstance(node.func, ast.Attribute) and node.func.attr == 'dataclass':
+                elif isinstance(decorator_node, ast.Call) and isinstance(decorator_node.func, ast.Attribute) and decorator_node.func.attr == 'dataclass':
                     return True
 
             return False
@@ -93,24 +95,24 @@ class RemoveAnnotations(SuiteTransformer):
             if sys.version_info < (3, 5):
                 return False
 
-            if not isinstance(node.parent, ast.ClassDef):
+            if not isinstance(get_parent(node), ast.ClassDef):
                 return False
 
-            if len(node.parent.bases) == 0:
+            if len(get_parent(node).bases) == 0:
                 return False
 
             tricky_types = ['NamedTuple', 'TypedDict']
 
-            for node in node.parent.bases:
-                if isinstance(node, ast.Name) and node.id in tricky_types:
+            for base_node in get_parent(node).bases:
+                if isinstance(base_node, ast.Name) and base_node.id in tricky_types:
                     return True
-                elif isinstance(node, ast. Attribute) and node.attr in tricky_types:
+                elif isinstance(base_node, ast.Attribute) and base_node.attr in tricky_types:
                     return True
 
             return False
 
         # is this a class attribute or a variable?
-        if isinstance(node.parent, ast.ClassDef):
+        if isinstance(get_parent(node), ast.ClassDef):
             if not self._options.remove_class_attribute_annotations:
                 return node
         else:
@@ -120,11 +122,11 @@ class RemoveAnnotations(SuiteTransformer):
         if is_dataclass_field(node) or is_typing_sensitive(node):
             return node
         elif node.value:
-            return self.add_child(ast.Assign([node.target], node.value), parent=node.parent, namespace=node.namespace)
+            return self.add_child(ast.Assign([node.target], node.value), parent=get_parent(node), namespace=node.namespace)
         else:
             # Valueless annotations cause the interpreter to treat the variable as a local.
             # I don't know of another way to do that without assigning to it, so
             # keep it as an AnnAssign, but replace the annotation with '0'
 
-            node.annotation = self.add_child(ast.Num(0), parent=node.parent, namespace=node.namespace)
+            node.annotation = self.add_child(ast.Num(0), parent=get_parent(node), namespace=node.namespace)
             return node

python_minifier/transforms/remove_annotations_options.py

@@ -26,7 +26,9 @@ class RemoveAnnotationsOptions(object):
         self.remove_class_attribute_annotations = remove_class_attribute_annotations
 
     def __repr__(self):
-        return 'RemoveAnnotationsOptions(remove_variable_annotations=%r, remove_return_annotations=%r, remove_argument_annotations=%r, remove_class_attribute_annotations=%r)' % (self.remove_variable_annotations, self.remove_return_annotations, self.remove_argument_annotations, self.remove_class_attribute_annotations)
+        return 'RemoveAnnotationsOptions(remove_variable_annotations=%r, remove_return_annotations=%r, remove_argument_annotations=%r, remove_class_attribute_annotations=%r)' % (
+            self.remove_variable_annotations, self.remove_return_annotations, self.remove_argument_annotations, self.remove_class_attribute_annotations
+        )
 
     def __nonzero__(self):
         return any((self.remove_variable_annotations, self.remove_return_annotations, self.remove_argument_annotations, self.remove_class_attribute_annotations))

python_minifier/transforms/remove_annotations_options.pyi

@@ -1,17 +1,18 @@
 class RemoveAnnotationsOptions:
-
     remove_variable_annotations: bool
     remove_return_annotations: bool
     remove_argument_annotations: bool
     remove_class_attribute_annotations: bool
 
-    def __init__(self,
-                 remove_variable_annotations: bool = ...,
-                 remove_return_annotations: bool = ...,
-                 remove_argument_annotations: bool = ...,
-                 remove_class_attribute_annotations: bool = ...):
+    def __init__(
+        self,
+        remove_variable_annotations: bool = ...,
+        remove_return_annotations: bool = ...,
+        remove_argument_annotations: bool = ...,
+        remove_class_attribute_annotations: bool = ...
+    ):
         ...
 
-    def __repr__(self) -> str: ...
     def __nonzero__(self) -> bool: ...
+
     def __bool__(self) -> bool: ...

python_minifier/transforms/remove_asserts.py

@@ -1,7 +1,6 @@
 import python_minifier.ast_compat as ast
 
 from python_minifier.transforms.suite_transformer import SuiteTransformer
-from python_minifier.util import is_ast_node
 
 
 class RemoveAsserts(SuiteTransformer):
@@ -15,7 +14,7 @@ class RemoveAsserts(SuiteTransformer):
         return self.visit(node)
 
     def suite(self, node_list, parent):
-        without_assert = [self.visit(a) for a in filter(lambda n: not is_ast_node(n, ast.Assert), node_list)]
+        without_assert = [self.visit(a) for a in filter(lambda n: not isinstance(n, ast.Assert), node_list)]
 
         if len(without_assert) == 0:
             if isinstance(parent, ast.Module):

python_minifier/transforms/remove_debug.py

@@ -1,8 +1,9 @@
-import python_minifier.ast_compat as ast
 import sys
 
+import python_minifier.ast_compat as ast
+
 from python_minifier.transforms.suite_transformer import SuiteTransformer
-from python_minifier.util import is_ast_node
+from python_minifier.util import is_constant_node
 
 
 class RemoveDebug(SuiteTransformer):
@@ -18,7 +19,7 @@ class RemoveDebug(SuiteTransformer):
     def constant_value(self, node):
         if sys.version_info < (3, 4):
             return node.id == 'True'
-        elif is_ast_node(node, 'NameConstant'):
+        elif is_constant_node(node, ast.NameConstant):
             return node.value
         return None
 

python_minifier/transforms/remove_exception_brackets.py

@@ -8,11 +8,14 @@ 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 python_minifier.ast_compat as ast
 import sys
 
+import python_minifier.ast_compat as ast
+from python_minifier.ast_annotation import get_parent, set_parent
+
 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',
@@ -73,22 +76,24 @@ builtin_exceptions_3_11 = [
     'BaseExceptionGroup',
 ]
 
+
 def _remove_empty_call(binding):
     assert isinstance(binding, BuiltinBinding)
 
     for name_node in binding.references:
         # For this to be a builtin, all references must be name nodes as it is not defined anywhere
-        assert isinstance(name_node, ast.Name) and isinstance(name_node.ctx, ast.Load)
+        assert isinstance(name_node, ast.Name)
+        assert isinstance(name_node.ctx, ast.Load)
 
-        if not isinstance(name_node.parent, ast.Call):
+        if not isinstance(get_parent(name_node), ast.Call):
             # This is not a call
             continue
-        call_node = name_node.parent
+        call_node = get_parent(name_node)
 
-        if not isinstance(call_node.parent, ast.Raise):
+        if not isinstance(get_parent(call_node), ast.Raise):
             # This is not a raise statement
             continue
-        raise_node = call_node.parent
+        raise_node = get_parent(call_node)
 
         if len(call_node.args) > 0 or len(call_node.keywords) > 0:
             # This is a call with arguments
@@ -101,7 +106,7 @@ def _remove_empty_call(binding):
             raise_node.exc = name_node
         elif raise_node.cause is call_node:
             raise_node.cause = name_node
-        name_node.parent = raise_node
+        set_parent(name_node, raise_node)
 
 
 def remove_no_arg_exception_call(module):

python_minifier/transforms/remove_explicit_return_none.py

@@ -1,8 +1,9 @@
-import python_minifier.ast_compat as ast
 import sys
 
+import python_minifier.ast_compat as ast
+
 from python_minifier.transforms.suite_transformer import SuiteTransformer
-from python_minifier.util import is_ast_node
+from python_minifier.util import is_constant_node
 
 
 class RemoveExplicitReturnNone(SuiteTransformer):
@@ -17,13 +18,13 @@ class RemoveExplicitReturnNone(SuiteTransformer):
         if sys.version_info < (3, 4) and isinstance(node.value, ast.Name) and node.value.id == 'None':
             node.value = None
 
-        elif sys.version_info >= (3, 4) and is_ast_node(node.value, 'NameConstant') and node.value.value is None:
+        elif sys.version_info >= (3, 4) and is_constant_node(node.value, ast.NameConstant) and node.value.value is None:
             node.value = None
 
         return node
 
     def visit_FunctionDef(self, node):
-        assert is_ast_node(node, (ast.FunctionDef, 'AsyncFunctionDef'))
+        assert isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))
 
         node.body = [self.visit(a) for a in node.body]