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

python_minifier/rename/mapper.py

@@ -3,48 +3,47 @@ For each node in an AST set the namespace to use for name binding and resolution
 """
 
 import python_minifier.ast_compat as ast
+from python_minifier.ast_annotation import get_parent
 
 from python_minifier.rename.util import is_namespace
-from python_minifier.util import is_ast_node
 
 
 def add_parent_to_arguments(arguments, func):
-    arguments.parent = func
     arguments.namespace = func
 
     for arg in getattr(arguments, 'posonlyargs', []) + arguments.args:
-        add_parent(arg, arguments, func)
+        add_parent(arg, func)
         if hasattr(arg, 'annotation') and arg.annotation is not None:
-            add_parent(arg.annotation, arguments, func.namespace)
+            add_parent(arg.annotation, func.namespace)
 
     if hasattr(arguments, 'kwonlyargs'):
         for arg in arguments.kwonlyargs:
-            add_parent(arg, arguments, func)
+            add_parent(arg, func)
             if arg.annotation is not None:
-                add_parent(arg.annotation, arguments, func.namespace)
+                add_parent(arg.annotation, func.namespace)
 
         for node in arguments.kw_defaults:
             if node is not None:
-                add_parent(node, arguments, func.namespace)
+                add_parent(node, func.namespace)
 
     for node in arguments.defaults:
-        add_parent(node, arguments, func.namespace)
+        add_parent(node, func.namespace)
 
     if arguments.vararg:
         if hasattr(arguments, 'varargannotation') and arguments.varargannotation is not None:
-            add_parent(arguments.varargannotation, arguments, func.namespace)
+            add_parent(arguments.varargannotation, func.namespace)
         elif isinstance(arguments.vararg, str):
             pass
         else:
-            add_parent(arguments.vararg, arguments, func)
+            add_parent(arguments.vararg, func)
 
     if arguments.kwarg:
         if hasattr(arguments, 'kwargannotation') and arguments.kwargannotation is not None:
-            add_parent(arguments.kwargannotation, arguments, func.namespace)
+            add_parent(arguments.kwargannotation, func.namespace)
         elif isinstance(arguments.kwarg, str):
             pass
         else:
-            add_parent(arguments.kwarg, arguments, func)
+            add_parent(arguments.kwarg, func)
 
 
 def add_parent_to_functiondef(functiondef):
@@ -56,17 +55,17 @@ def add_parent_to_functiondef(functiondef):
         add_parent_to_arguments(functiondef.args, func=functiondef)
 
     for node in functiondef.body:
-        add_parent(node, parent=functiondef, namespace=functiondef)
+        add_parent(node, namespace=functiondef)
 
     for node in functiondef.decorator_list:
-        add_parent(node, parent=functiondef, namespace=functiondef.namespace)
+        add_parent(node, namespace=functiondef.namespace)
 
     if hasattr(functiondef, 'type_params') and functiondef.type_params is not None:
         for node in functiondef.type_params:
-            add_parent(node, parent=functiondef, namespace=functiondef.namespace)
+            add_parent(node, namespace=functiondef.namespace)
 
     if hasattr(functiondef, 'returns') and functiondef.returns is not None:
-        add_parent(functiondef.returns, parent=functiondef, namespace=functiondef.namespace)
+        add_parent(functiondef.returns, namespace=functiondef.namespace)
 
 
 def add_parent_to_classdef(classdef):
@@ -75,64 +74,77 @@ def add_parent_to_classdef(classdef):
     """
 
     for node in classdef.bases:
-        add_parent(node, parent=classdef, namespace=classdef.namespace)
+        add_parent(node, namespace=classdef.namespace)
 
     if hasattr(classdef, 'keywords'):
         for node in classdef.keywords:
-            add_parent(node, parent=classdef, namespace=classdef.namespace)
+            add_parent(node, namespace=classdef.namespace)
 
     if hasattr(classdef, 'starargs') and classdef.starargs is not None:
-        add_parent(classdef.starargs, parent=classdef, namespace=classdef.namespace)
+        add_parent(classdef.starargs, namespace=classdef.namespace)
 
     if hasattr(classdef, 'kwargs') and classdef.kwargs is not None:
-        add_parent(classdef.kwargs, parent=classdef, namespace=classdef.namespace)
+        add_parent(classdef.kwargs, namespace=classdef.namespace)
 
     for node in classdef.body:
-        add_parent(node, parent=classdef, namespace=classdef)
+        add_parent(node, namespace=classdef)
 
     for node in classdef.decorator_list:
-        add_parent(node, parent=classdef, namespace=classdef.namespace)
+        add_parent(node, namespace=classdef.namespace)
 
     if hasattr(classdef, 'type_params') and classdef.type_params is not None:
         for node in classdef.type_params:
-            add_parent(node, parent=classdef, namespace=classdef.namespace)
+            add_parent(node, namespace=classdef.namespace)
+
 
 def add_parent_to_comprehension(node, namespace):
-    assert is_ast_node(node, (ast.GeneratorExp, 'SetComp', 'DictComp', 'ListComp'))
+    assert isinstance(node, (ast.GeneratorExp, ast.SetComp, ast.DictComp, ast.ListComp))
 
     if hasattr(node, 'elt'):
-        add_parent(node.elt, parent=node, namespace=node)
+        add_parent(node.elt, namespace=node)
     elif hasattr(node, 'key'):
-        add_parent(node.key, parent=node, namespace=node)
-        add_parent(node.value, parent=node, namespace=node)
+        add_parent(node.key, namespace=node)
+        add_parent(node.value, namespace=node)
 
     iter_namespace = namespace
     for generator in node.generators:
-        generator.parent = node
         generator.namespace = node
 
-        add_parent(generator.target, parent=generator, namespace=node)
-        add_parent(generator.iter, parent=generator, namespace=iter_namespace)
-        iter_namespace = node
+        add_parent(generator.target, namespace=node)
+        add_parent(generator.iter, namespace=iter_namespace)
+
         for if_ in generator.ifs:
-            add_parent(if_, parent=generator, namespace=node)
+            add_parent(if_, namespace=node)
 
+        iter_namespace = node
 
-def add_parent(node, parent=None, namespace=None):
+def namedexpr_namespace(node):
+    """
+    Get the namespace for a NamedExpr target
+    """
+
+    if not isinstance(node, (ast.ListComp, ast.DictComp, ast.SetComp, ast.GeneratorExp)):
+        return node
+
+    return namedexpr_namespace(node.namespace)
+
+def add_parent_to_namedexpr(node):
+    assert isinstance(node, ast.NamedExpr)
+
+    add_parent(node.target, namespace=namedexpr_namespace(node.namespace))
+    add_parent(node.value, namespace=node.namespace)
+
+def add_parent(node, namespace=None):
     """
-    Add a parent attribute to child nodes
     Add a namespace attribute to child nodes
 
-    :param node: The tree to add parent and namespace properties to
+    :param node: The tree to add namespace properties to
     :type node: :class:`ast.AST`
-    :param parent: The parent node of this node
-    :type parent: :class:`ast.AST`
     :param namespace: The namespace Node that this node is in
     :type namespace: ast.Lambda or ast.Module or ast.FunctionDef or ast.AsyncFunctionDef or ast.ClassDef or ast.DictComp or ast.SetComp or ast.ListComp or ast.Generator
 
     """
 
-    node.parent = parent if parent is not None else node
     node.namespace = namespace if namespace is not None else node
 
     if is_namespace(node):
@@ -140,35 +152,39 @@ def add_parent(node, parent=None, namespace=None):
         node.global_names = set()
         node.nonlocal_names = set()
 
-        if is_ast_node(node, (ast.FunctionDef, 'AsyncFunctionDef')):
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
             add_parent_to_functiondef(node)
-        elif is_ast_node(node, (ast.GeneratorExp, 'SetComp', 'DictComp', 'ListComp')):
+        elif isinstance(node, (ast.GeneratorExp, ast.SetComp, ast.DictComp, ast.ListComp)):
             add_parent_to_comprehension(node, namespace=namespace)
         elif isinstance(node, ast.Lambda):
             add_parent_to_arguments(node.args, func=node)
-            add_parent(node.body, parent=node, namespace=node)
+            add_parent(node.body, namespace=node)
         elif isinstance(node, ast.ClassDef):
             add_parent_to_classdef(node)
         else:
             for child in ast.iter_child_nodes(node):
-                add_parent(child, parent=node, namespace=node)
+                add_parent(child, namespace=node)
 
         return
 
     if isinstance(node, ast.Global):
         namespace.global_names.update(node.names)
-    if is_ast_node(node, 'Nonlocal'):
+    if isinstance(node, ast.Nonlocal):
         namespace.nonlocal_names.update(node.names)
 
-    if isinstance(node, ast.Name):
-        if isinstance(namespace, ast.ClassDef):
-            if isinstance(node.ctx, ast.Load):
-                namespace.nonlocal_names.add(node.id)
-            elif isinstance(node.ctx, ast.Store) and isinstance(node.parent, ast.AugAssign):
-                namespace.nonlocal_names.add(node.id)
+    if isinstance(node, ast.Name) and isinstance(namespace, ast.ClassDef):
+        if isinstance(node.ctx, ast.Load):
+            namespace.nonlocal_names.add(node.id)
+        elif isinstance(node.ctx, ast.Store) and isinstance(get_parent(node), ast.AugAssign):
+            namespace.nonlocal_names.add(node.id)
+
+    if isinstance(node, ast.NamedExpr):
+        # NamedExpr is 'special'
+        add_parent_to_namedexpr(node)
+        return
 
     for child in ast.iter_child_nodes(node):
-        add_parent(child, parent=node, namespace=namespace)
+        add_parent(child, namespace=namespace)
 
 
 def add_namespace(module):

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
@@ -88,7 +91,11 @@ class TokenPrinter(object):
         self._prefer_single_line = prefer_single_line
         self._allow_invalid_num_warnings = allow_invalid_num_warnings
 
-        self._code = ''
+        # Initialize as unicode string on Python 2.7 to handle Unicode content
+        if sys.version_info[0] < 3:
+            self._code = u''
+        else:
+            self._code = ''
         self.indent = 0
         self.unicode_literals = False
         self.previous_token = TokenTypes.NoToken
@@ -96,6 +103,10 @@ class TokenPrinter(object):
     def __str__(self):
         """Return the output code."""
         return self._code
+    
+    def __unicode__(self):
+        """Return the output code as unicode (for Python 2.7 compatibility)."""
+        return self._code
 
     def identifier(self, name):
         """Add an identifier to the output code."""

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)