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

python_minifier/module_printer.py

@@ -1,9 +1,9 @@
-import python_minifier.ast_compat as ast
 import sys
 
+import python_minifier.ast_compat as ast
+
 from .expression_printer import ExpressionPrinter
 from .token_printer import Delimiter
-from .util import is_ast_node
 
 
 class ModulePrinter(ExpressionPrinter):
@@ -55,7 +55,7 @@ class ModulePrinter(ExpressionPrinter):
     def visit_Expr(self, node):
         assert isinstance(node, ast.Expr)
 
-        if is_ast_node(node.value, (ast.Yield, 'YieldFrom')):
+        if isinstance(node.value, (ast.Yield, ast.YieldFrom)):
             self._yield_expr(node.value)
         else:
             self._testlist(node.value)
@@ -82,7 +82,7 @@ class ModulePrinter(ExpressionPrinter):
             self.printer.delimiter('=')
 
         # Yield nodes that are the sole node on the right hand side of an assignment do not need parens
-        if is_ast_node(node.value, (ast.Yield, 'YieldFrom')):
+        if isinstance(node.value, (ast.Yield, ast.YieldFrom)):
             self._yield_expr(node.value)
         else:
             self._testlist(node.value)
@@ -97,7 +97,7 @@ class ModulePrinter(ExpressionPrinter):
         self.printer.delimiter('=')
 
         # Yield nodes that are the sole node on the right hand side of an assignment do not need parens
-        if is_ast_node(node.value, (ast.Yield, 'YieldFrom')):
+        if isinstance(node.value, (ast.Yield, ast.YieldFrom)):
             self._yield_expr(node.value)
         else:
             self._testlist(node.value)
@@ -143,7 +143,7 @@ class ModulePrinter(ExpressionPrinter):
 
         self.printer.keyword('return')
         if isinstance(node.value, ast.Tuple):
-            if sys.version_info < (3, 8) and [n for n in node.value.elts if is_ast_node(n, 'Starred')]:
+            if sys.version_info < (3, 8) and [n for n in node.value.elts if isinstance(n, ast.Starred)]:
                 self.printer.delimiter('(')
                 self._testlist(node.value)
                 self.printer.delimiter(')')
@@ -243,7 +243,7 @@ class ModulePrinter(ExpressionPrinter):
         assert isinstance(node, ast.ImportFrom)
 
         self.printer.keyword('from')
-        for i in range(node.level):
+        for _i in range(node.level):
             self.printer.delimiter('.')
         if node.module is not None:
             self.printer.identifier(node.module)
@@ -326,7 +326,7 @@ class ModulePrinter(ExpressionPrinter):
                 self._suite(node.orelse)
 
     def visit_For(self, node, is_async=False):
-        assert isinstance(node, ast.For) or (hasattr(ast, 'AsyncFor') and isinstance(node, ast.AsyncFor))
+        assert isinstance(node, (ast.For, ast.AsyncFor))
 
         self.printer.newline()
 
@@ -362,7 +362,7 @@ class ModulePrinter(ExpressionPrinter):
             self._suite(node.orelse)
 
     def visit_Try(self, node, star=False):
-        assert is_ast_node(node, (ast.Try, 'TryStar'))
+        assert isinstance(node, (ast.Try, ast.TryStar))
 
         self.printer.newline()
         self.printer.keyword('try')
@@ -440,7 +440,7 @@ class ModulePrinter(ExpressionPrinter):
         self._suite(node.body)
 
     def visit_With(self, node, is_async=False):
-        assert is_ast_node(node, (ast.With, 'AsyncWith'))
+        assert isinstance(node, (ast.With, ast.AsyncWith))
 
         self.printer.newline()
 
@@ -469,7 +469,7 @@ class ModulePrinter(ExpressionPrinter):
         self._suite(node.body)
 
     def visit_withitem(self, node):
-        assert is_ast_node(node, ('withitem', ast.With))
+        assert isinstance(node, (ast.withitem, ast.With))
 
         self._expression(node.context_expr)
 
@@ -478,7 +478,7 @@ class ModulePrinter(ExpressionPrinter):
             self._expression(node.optional_vars)
 
     def visit_FunctionDef(self, node, is_async=False):
-        assert is_ast_node(node, (ast.FunctionDef, 'AsyncFunctionDef'))
+        assert isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))
 
         self.printer.newline()
 
@@ -670,7 +670,7 @@ class ModulePrinter(ExpressionPrinter):
         for kwd, pattern in zip(node.kwd_attrs, node.kwd_patterns):
             delimiter.new_item()
 
-            self.printer.identifier(kwd)    
+            self.printer.identifier(kwd)
             self.printer.delimiter('=')
 
             self.pattern(pattern)
@@ -859,4 +859,3 @@ class ModulePrinter(ExpressionPrinter):
 
         for node in node_list:
             statements[node.__class__.__name__](node)
-

python_minifier/rename/__init__.py

@@ -3,4 +3,4 @@ from python_minifier.rename.mapper import add_namespace
 from python_minifier.rename.rename_literals import rename_literals
 from python_minifier.rename.renamer import rename
 from python_minifier.rename.resolve_names import resolve_names
-from python_minifier.rename.util import allow_rename_locals, allow_rename_globals
+from python_minifier.rename.util import allow_rename_globals, allow_rename_locals

python_minifier/rename/bind_names.py

@@ -1,7 +1,7 @@
 import python_minifier.ast_compat as ast
 
 from python_minifier.rename.binding import NameBinding
-from python_minifier.rename.util import arg_rename_in_place, get_global_namespace, get_nonlocal_namespace, builtins
+from python_minifier.rename.util import arg_rename_in_place, builtins, get_global_namespace
 from python_minifier.transforms.suite_transformer import NodeVisitor
 
 
@@ -180,6 +180,7 @@ class NameBinder(NodeVisitor):
 
         get_global_namespace(node.namespace).preserved.add(node.name)
 
+
 def bind_names(module):
     """
     Bind names to their local namespace

python_minifier/rename/binding.py

@@ -1,7 +1,6 @@
 import python_minifier.ast_compat as ast
 
 from python_minifier.rename.util import arg_rename_in_place, insert
-from python_minifier.util import is_ast_node
 
 
 class Binding(object):
@@ -105,11 +104,11 @@ class Binding(object):
                     # Python 2 Param context
                     if not arg_rename_in_place(node):
                         arg_rename = True
-            elif is_ast_node(node, (ast.ClassDef, ast.FunctionDef, 'AsyncFunctionDef')):
+            elif isinstance(node, (ast.ClassDef, ast.FunctionDef, ast.AsyncFunctionDef)):
                 pass
             elif isinstance(node, ast.ExceptHandler):
                 pass
-            elif is_ast_node(node, (ast.Global, 'Nonlocal')):
+            elif isinstance(node, (ast.Global, ast.Nonlocal)):
                 pass
             elif isinstance(node, ast.alias):
                 if node.asname is None:
@@ -119,22 +118,22 @@ class Binding(object):
                     pass
                 if node.kwarg == self._name:
                     pass
-            elif is_ast_node(node, 'arg'):
+            elif isinstance(node, ast.arg):
                 if not arg_rename_in_place(node):
                     arg_rename = True
 
-            elif is_ast_node(node, 'MatchAs'):
+            elif isinstance(node, ast.MatchAs):
                 if node.name is None:
                     additional_bytes += 4  # ' as '
-            elif is_ast_node(node, 'MatchStar'):
+            elif isinstance(node, ast.MatchStar):
                 pass
-            elif is_ast_node(node, 'MatchMapping'):
+            elif isinstance(node, ast.MatchMapping):
                 pass
-            elif is_ast_node(node, 'TypeVar'):
+            elif isinstance(node, ast.TypeVar):
                 pass
-            elif is_ast_node(node, 'TypeVarTuple'):
+            elif isinstance(node, ast.TypeVarTuple):
                 pass
-            elif is_ast_node(node, 'ParamSpec'):
+            elif isinstance(node, ast.ParamSpec):
                 pass
 
             else:
@@ -160,11 +159,11 @@ class Binding(object):
                         mentions += 1
                         arg_rename = True
 
-            elif is_ast_node(node, (ast.ClassDef, ast.FunctionDef, 'AsyncFunctionDef')):
+            elif isinstance(node, (ast.ClassDef, ast.FunctionDef, ast.AsyncFunctionDef)):
                 pass
             elif isinstance(node, ast.ExceptHandler):
                 pass
-            elif is_ast_node(node, (ast.Global, 'Nonlocal')):
+            elif isinstance(node, (ast.Global, ast.Nonlocal)):
                 pass
             elif isinstance(node, ast.alias):
                 if node.asname is None:
@@ -172,22 +171,22 @@ class Binding(object):
                     mentions += 1
             elif isinstance(node, ast.arguments):
                 pass
-            elif is_ast_node(node, 'arg'):
+            elif isinstance(node, ast.arg):
                 if not arg_rename_in_place(node):
                     mentions += 1
                     arg_rename = True
 
-            elif is_ast_node(node, 'MatchAs'):
+            elif isinstance(node, ast.MatchAs):
                 pass
-            elif is_ast_node(node, 'MatchStar'):
+            elif isinstance(node, ast.MatchStar):
                 pass
-            elif is_ast_node(node, 'MatchMapping'):
+            elif isinstance(node, ast.MatchMapping):
                 pass
-            elif is_ast_node(node, 'TypeVar'):
+            elif isinstance(node, ast.TypeVar):
                 pass
-            elif is_ast_node(node, 'TypeVarTuple'):
+            elif isinstance(node, ast.TypeVarTuple):
                 pass
-            elif is_ast_node(node, 'ParamSpec'):
+            elif isinstance(node, ast.ParamSpec):
                 pass
 
             else:
@@ -210,11 +209,11 @@ class Binding(object):
                 else:
                     # Python 2 Param context
                     arg_rename = True
-            elif is_ast_node(node, (ast.ClassDef, ast.FunctionDef, 'AsyncFunctionDef')):
+            elif isinstance(node, (ast.ClassDef, ast.FunctionDef, ast.AsyncFunctionDef)):
                 mentions += 1
             elif isinstance(node, ast.ExceptHandler):
                 mentions += 1
-            elif is_ast_node(node, (ast.Global, 'Nonlocal')):
+            elif isinstance(node, (ast.Global, ast.Nonlocal)):
                 mentions += len([n for n in node.names if n == self._name])
             elif isinstance(node, ast.alias):
                 mentions += 1
@@ -223,20 +222,20 @@ class Binding(object):
                     mentions += 1
                 if node.kwarg == self._name:
                     mentions += 1
-            elif is_ast_node(node, 'arg'):
+            elif isinstance(node, ast.arg):
                 arg_rename = True
 
-            elif is_ast_node(node, 'MatchAs'):
+            elif isinstance(node, ast.MatchAs):
                 mentions += 1
-            elif is_ast_node(node, 'MatchStar'):
+            elif isinstance(node, ast.MatchStar):
                 mentions += 1
-            elif is_ast_node(node, 'MatchMapping'):
+            elif isinstance(node, ast.MatchMapping):
                 mentions += 1
-            elif is_ast_node(node, 'TypeVar'):
+            elif isinstance(node, ast.TypeVar):
                 mentions += 1
-            elif is_ast_node(node, 'TypeVarTuple'):
+            elif isinstance(node, ast.TypeVarTuple):
                 mentions += 1
-            elif is_ast_node(node, 'ParamSpec'):
+            elif isinstance(node, ast.ParamSpec):
                 mentions += 1
 
             else:
@@ -273,7 +272,7 @@ class Binding(object):
 
         """
 
-        raise NotImplementedError()
+        raise NotImplementedError
 
     def rename(self, new_name):
         """
@@ -283,7 +282,7 @@ class Binding(object):
 
         """
 
-        raise NotImplementedError()
+        raise NotImplementedError
 
 
 class NameBinding(Binding):
@@ -362,7 +361,7 @@ class NameBinding(Binding):
                         else:
                             assert func_namespace_binding is node.namespace
 
-            elif is_ast_node(node, (ast.FunctionDef, 'AsyncFunctionDef')):
+            elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
                 node.name = new_name
             elif isinstance(node, ast.ClassDef):
                 node.name = new_name
@@ -371,7 +370,7 @@ class NameBinding(Binding):
                     node.asname = None
                 else:
                     node.asname = new_name
-            elif is_ast_node(node, 'arg'):
+            elif isinstance(node, ast.arg):
 
                 if arg_rename_in_place(node):
                     node.arg = new_name
@@ -384,7 +383,7 @@ class NameBinding(Binding):
 
             elif isinstance(node, ast.ExceptHandler):
                 node.name = new_name
-            elif is_ast_node(node, (ast.Global, 'Nonlocal')):
+            elif isinstance(node, (ast.Global, ast.Nonlocal)):
                 node.names = [new_name if n == self._name else n for n in node.names]
             elif isinstance(node, ast.arguments):
 
@@ -398,17 +397,17 @@ class NameBinding(Binding):
                     node.kwarg = new_name
                     node.kwarg_renamed = True
 
-            elif is_ast_node(node, 'MatchAs'):
+            elif isinstance(node, ast.MatchAs):
                 node.name = new_name
-            elif is_ast_node(node, 'MatchStar'):
+            elif isinstance(node, ast.MatchStar):
                 node.name = new_name
-            elif is_ast_node(node, 'MatchMapping'):
+            elif isinstance(node, ast.MatchMapping):
                 node.rest = new_name
-            elif is_ast_node(node, 'TypeVar'):
+            elif isinstance(node, ast.TypeVar):
                 node.name = new_name
-            elif is_ast_node(node, 'TypeVarTuple'):
+            elif isinstance(node, ast.TypeVarTuple):
                 node.name = new_name
-            elif is_ast_node(node, 'ParamSpec'):
+            elif isinstance(node, ast.ParamSpec):
                 node.name = new_name
 
         if func_namespace_binding is not None:
@@ -492,4 +491,4 @@ class BuiltinBinding(NameBinding):
             if not isinstance(node.ctx, ast.Load):
                 return True
 
-        return False
+        return False

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):