python-minifier 2.11.2__tar.gz → 2.11.3__tar.gz

{python_minifier-2.11.2/src/python_minifier.egg-info → python_minifier-2.11.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python_minifier
-Version: 2.11.2
+Version: 2.11.3
 Summary: Transform Python source code into it's most compact representation
 Home-page: https://github.com/dflook/python-minifier
 Author: Daniel Flook

{python_minifier-2.11.2 → python_minifier-2.11.3}/setup.py

@@ -28,7 +28,7 @@ setup(
     long_description_content_type='text/markdown',
 
     python_requires='>=2.7, !=3.0.*, !=3.1.*, !=3.2.*, <3.14',
-    version='2.11.2',
+    version='2.11.3',
 
     classifiers=[
         'Development Status :: 5 - Production/Stable',

{python_minifier-2.11.2 → python_minifier-2.11.3}/src/python_minifier/__init__.py

@@ -4,29 +4,30 @@ a 'minified' representation of the same source code.
 
 """
 
-import python_minifier.ast_compat as ast
 import re
 
+import python_minifier.ast_compat as ast
+from python_minifier.ast_annotation import add_parent
+
 from python_minifier.ast_compare import CompareError, compare_ast
 from python_minifier.module_printer import ModulePrinter
 from python_minifier.rename import (
-    rename_literals,
-    bind_names,
-    resolve_names,
-    rename,
+    add_namespace,
     allow_rename_globals,
     allow_rename_locals,
-    add_namespace,
+    bind_names,
+    rename,
+    rename_literals,
+    resolve_names
 )
-
 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_explicit_return_none import RemoveExplicitReturnNone
 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
@@ -115,6 +116,7 @@ def minify(
     # This will raise if the source file can't be parsed
     module = ast.parse(source, filename)
 
+    add_parent(module)
     add_namespace(module)
 
     if remove_literal_statements:
@@ -198,6 +200,7 @@ def minify(
 
     return minified
 
+
 def _find_shebang(source):
     """
     Find a shebang line in source
@@ -214,6 +217,7 @@ def _find_shebang(source):
 
     return None
 
+
 def unparse(module):
     """
     Turn a module AST into python code

{python_minifier-2.11.2 → python_minifier-2.11.3}/src/python_minifier/__init__.pyi

@@ -1,11 +1,14 @@
 import ast
-from typing import List, Text, AnyStr, Optional, Any, Union
+
+from typing import Any, AnyStr, List, Optional, Text, Union
 
 from .transforms.remove_annotations_options import RemoveAnnotationsOptions as RemoveAnnotationsOptions
 
+
 class UnstableMinification(RuntimeError):
     def __init__(self, exception: Any, source: Any, minified: Any): ...
 
+
 def minify(
     source: AnyStr,
     filename: Optional[str] = ...,
@@ -28,8 +31,10 @@ def minify(
     constant_folding: bool = ...
 ) -> Text: ...
 
+
 def unparse(module: ast.Module) -> Text: ...
 
+
 def awslambda(
     source: AnyStr,
     filename: Optional[Text] = ...,

{python_minifier-2.11.2 → python_minifier-2.11.3}/src/python_minifier/__main__.py

@@ -7,14 +7,17 @@ import sys
 from python_minifier import minify
 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
+    from pkg_resources import DistributionNotFound, get_distribution
+
     try:
         version = get_distribution('python_minifier').version
     except DistributionNotFound:
@@ -170,25 +173,25 @@ def parse_args():
     minification_options.add_argument(
         '--no-preserve-shebang',
         action='store_false',
-        help='Preserve any shebang line from the source',
+        help='Disable preserving any shebang line from the source',
         dest='preserve_shebang',
     )
     minification_options.add_argument(
         '--remove-asserts',
         action='store_true',
-        help='Remove assert statements',
+        help='Enable removing assert statements',
         dest='remove_asserts',
     )
     minification_options.add_argument(
         '--remove-debug',
         action='store_true',
-        help='Remove conditional statements that test __debug__ is True',
+        help='Enable removing conditional statements that test __debug__ is True',
         dest='remove_debug',
     )
     minification_options.add_argument(
         '--no-remove-explicit-return-none',
         action='store_false',
-        help='Replace explicit return None with a bare return',
+        help='Disable replacing explicit return None with a bare return',
         dest='remove_explicit_return_none',
     )
     minification_options.add_argument(
@@ -268,9 +271,9 @@ def source_modules(args):
 
     for path_arg in args.path:
         if os.path.isdir(path_arg):
-            for root, dirs, files in os.walk(path_arg, onerror=error, followlinks=True):
+            for root, _dirs, files in os.walk(path_arg, onerror=error, followlinks=True):
                 for file in files:
-                    if file.endswith('.py') or file.endswith('.pyw'):
+                    if file.endswith(('.py', '.pyw')):
                         yield os.path.join(root, file)
         else:
             yield path_arg

python_minifier-2.11.3/src/python_minifier/ast_annotation/__init__.py

@@ -0,0 +1,82 @@
+"""
+This module provides utilities for annotating Abstract Syntax Tree (AST) nodes with parent references.
+"""
+
+import ast
+
+class _NoParent(ast.AST):
+    """A placeholder class used to indicate that a node has no parent."""
+
+    def __repr__(self):
+        # type: () -> str
+        return 'NoParent()'
+
+def add_parent(node, parent=_NoParent()):
+    # type: (ast.AST, ast.AST) -> None
+    """
+    Recursively adds a parent reference to each node in the AST.
+
+    >>> tree = ast.parse('a = 1')
+    >>> add_parent(tree)
+    >>> get_parent(tree.body[0]) == tree
+    True
+
+    :param node: The current AST node.
+    :param parent: The parent :class:`ast.AST` node.
+    """
+
+    node._parent = parent  # type: ignore[attr-defined]
+    for child in ast.iter_child_nodes(node):
+        add_parent(child, node)
+
+def get_parent(node):
+    # type: (ast.AST) -> ast.AST
+    """
+    Retrieves the parent of the given AST node.
+
+    >>> tree = ast.parse('a = 1')
+    >>> add_parent(tree)
+    >>> get_parent(tree.body[0]) == tree
+    True
+
+    :param node: The AST node whose parent is to be retrieved.
+    :return: The parent AST node.
+    :raises ValueError: If the node has no parent.
+    """
+
+    if not hasattr(node, '_parent') or isinstance(node._parent, _NoParent):  # type: ignore[attr-defined]
+        raise ValueError('Node has no parent')
+
+    return node._parent  # type: ignore[attr-defined]
+
+def set_parent(node, parent):
+    # type: (ast.AST, ast.AST) -> None
+    """
+    Replace the parent of the given AST node.
+
+    Create a simple AST:
+    >>> tree = ast.parse('a = func()')
+    >>> add_parent(tree)
+    >>> isinstance(tree.body[0], ast.Assign) and isinstance(tree.body[0].value, ast.Call)
+    True
+    >>> assign = tree.body[0]
+    >>> call = tree.body[0].value
+    >>> get_parent(call) == assign
+    True
+
+    Replace the parent of the call node:
+    >>> tree.body[0] = call
+    >>> set_parent(call, tree)
+    >>> get_parent(call) == tree
+    True
+    >>> from python_minifier.ast_printer import print_ast
+    >>> print(print_ast(tree))
+    Module(body=[
+        Call(Name('func'))
+    ])
+
+    :param node: The AST node whose parent is to be set.
+    :param parent: The parent AST node.
+    """
+
+    node._parent = parent  # type: ignore[attr-defined]

{python_minifier-2.11.2 → python_minifier-2.11.3}/src/python_minifier/ast_compare.py

@@ -1,7 +1,5 @@
 import python_minifier.ast_compat as ast
 
-from python_minifier.util import is_ast_node
-
 
 class CompareError(RuntimeError):
     """
@@ -18,7 +16,7 @@ class CompareError(RuntimeError):
 
     def namespace(self, node):
         if hasattr(node, 'namespace'):
-            if is_ast_node(node.namespace, (ast.FunctionDef, ast.ClassDef, 'AsyncFunctionDef')):
+            if isinstance(node.namespace, (ast.FunctionDef, ast.ClassDef, ast.AsyncFunctionDef)):
                 return self.namespace(node.namespace) + '.' + node.namespace.name
             elif isinstance(node.namespace, ast.Module):
                 return ''

{python_minifier-2.11.2 → python_minifier-2.11.3}/src/python_minifier/ast_compat.py

@@ -8,6 +8,7 @@ deprecation warnings.
 
 from ast import *
 
+
 # Ideally we don't import anything else
 
 if 'TypeAlias' in globals():
@@ -16,6 +17,7 @@ if 'TypeAlias' in globals():
     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
 
@@ -23,18 +25,54 @@ if 'TypeAlias' in globals():
         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)
+
+
+# Create a dummy class for missing AST nodes
+for _node_type in [
+    'AnnAssign',
+    'AsyncFor',
+    'AsyncFunctionDef',
+    'AsyncFunctionDef',
+    'AsyncWith',
+    'Bytes',
+    'Constant',
+    'DictComp',
+    'Exec',
+    'ListComp',
+    'MatchAs',
+    'MatchMapping',
+    'MatchStar',
+    'NameConstant',
+    'NamedExpr',
+    'Nonlocal',
+    'ParamSpec',
+    'SetComp',
+    'Starred',
+    'TryStar',
+    'TypeVar',
+    'TypeVarTuple',
+    'YieldFrom',
+    'arg',
+    'withitem',
+]:
+    if _node_type not in globals():
+        globals()[_node_type] = type(_node_type, (AST,), {})

{python_minifier-2.11.2 → python_minifier-2.11.3}/src/python_minifier/ast_printer.py

@@ -12,7 +12,8 @@ fields or field names may be omitted for clarity. It should still be precise and
 
 import python_minifier.ast_compat as ast
 
-from python_minifier.util import is_ast_node
+from python_minifier.util import is_constant_node
+
 
 INDENT = '    '
 
@@ -63,24 +64,26 @@ default_fields = {
     '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':
+    if is_constant_node(node, ast.Num) and field == 'n':
         return True
 
-    if is_ast_node(node, ast.Str) and field == 's':
+    if is_constant_node(node, ast.Str) and field == 's':
         return True
 
-    if is_ast_node(node, 'Bytes') and field == 's':
+    if is_constant_node(node, ast.Bytes) and field == 's':
         return True
 
-    if is_ast_node(node, 'NameConstant') and field == 'value':
+    if is_constant_node(node, ast.NameConstant) and field == 'value':
         return True
 
     return False
 
+
 def print_ast(node):
     if not isinstance(node, ast.AST):
         return repr(node)

{python_minifier-2.11.2 → python_minifier-2.11.3}/src/python_minifier/expression_printer.py

@@ -1,9 +1,9 @@
-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.token_printer import TokenPrinter, Delimiter
+from python_minifier.token_printer import Delimiter, TokenPrinter
+from python_minifier.util import is_constant_node
 
 
 class ExpressionPrinter(object):
@@ -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 is_ast_node(node, ast.Num):
+        if sys.version_info < (3, 0) and is_constant_node(node, ast.Num):
             if str(node.n)[0] == '-':
                 return self.precedences['USub']
 
@@ -156,7 +156,7 @@ class ExpressionPrinter(object):
             if key is None:
                 self.printer.operator('**')
 
-                if 0 < self.precedence(datum) <=7:
+                if 0 < self.precedence(datum) <= 7:
                     self.printer.delimiter('(')
                     self._expression(datum)
                     self.printer.delimiter(')')
@@ -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 is_ast_node(node.operand, ast.Num):
+        if sys.version_info < (3, 0) and isinstance(node.op, ast.USub) and is_constant_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 is_ast_node(node.value, ast.Num):
+        if (value_precedence != 0 and (attr_precedence > value_precedence)) or is_constant_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 is_ast_node(node.slice, ast.Ellipsis):
+        elif is_constant_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)
@@ -629,7 +629,8 @@ class ExpressionPrinter(object):
     def visit_arg(self, node):
         if isinstance(node, ast.Name):
             # Python 2 uses Name nodes
-            return self.visit_Name(node)
+            self.visit_Name(node)
+            return
 
         self.printer.identifier(node.arg)
 
@@ -648,7 +649,7 @@ class ExpressionPrinter(object):
         self._expression(node.body)
 
     def _expression(self, expression):
-        if is_ast_node(expression, (ast.Yield, 'YieldFrom')):
+        if isinstance(expression, (ast.Yield, ast.YieldFrom)):
             self.printer.delimiter('(')
             self._yield_expr(expression)
             self.printer.delimiter(')')
@@ -656,7 +657,7 @@ class ExpressionPrinter(object):
             self.printer.delimiter('(')
             self.visit_Tuple(expression)
             self.printer.delimiter(')')
-        elif is_ast_node(expression, 'NamedExpr'):
+        elif isinstance(expression, ast.NamedExpr):
             self.printer.delimiter('(')
             self.visit_NamedExpr(expression)
             self.printer.delimiter(')')
@@ -664,11 +665,11 @@ class ExpressionPrinter(object):
             self.visit(expression)
 
     def _testlist(self, test):
-        if is_ast_node(test, (ast.Yield, 'YieldFrom')):
+        if isinstance(test, (ast.Yield, ast.YieldFrom)):
             self.printer.delimiter('(')
             self._yield_expr(test)
             self.printer.delimiter(')')
-        elif is_ast_node(test, 'NamedExpr'):
+        elif isinstance(test, ast.NamedExpr):
             self.printer.delimiter('(')
             self.visit_NamedExpr(test)
             self.printer.delimiter(')')

{python_minifier-2.11.2 → python_minifier-2.11.3}/src/python_minifier/f_string.py

@@ -6,17 +6,17 @@ Mostly because FStrings feel like a hack.
 
 """
 
-import python_minifier.ast_compat as ast
 import copy
 import re
 
+import python_minifier.ast_compat as ast
+
 from python_minifier import UnstableMinification
-from python_minifier.ast_compare import CompareError
-from python_minifier.ast_compare import compare_ast
+from python_minifier.ast_compare import CompareError, compare_ast
 from python_minifier.expression_printer import ExpressionPrinter
 from python_minifier.ministring import MiniString
 from python_minifier.token_printer import TokenTypes
-from python_minifier.util import is_ast_node
+from python_minifier.util import is_constant_node
 
 
 class FString(object):
@@ -36,7 +36,7 @@ class FString(object):
             c = ast.parse(code, 'FString candidate', mode='eval')
             compare_ast(self.node, c.body)
             return True
-        except Exception as e:
+        except Exception:
             return False
 
     def complete_debug_specifier(self, partial_specifier_candidates, value_node):
@@ -70,7 +70,7 @@ class FString(object):
                 nested_allowed.remove(quote)
 
             for v in self.node.values:
-                if is_ast_node(v, ast.Str):
+                if is_constant_node(v, ast.Str):
 
                     # Could this be used as a debug specifier?
                     if len(candidates) < 10:
@@ -79,12 +79,12 @@ class FString(object):
                             # Maybe!
                             try:
                                 debug_specifier_candidates = [x + '{' + v.s for x in candidates]
-                            except Exception as e:
+                            except Exception:
                                 continue
 
                     try:
                         candidates = [x + self.str_for(v.s, quote) for x in candidates]
-                    except Exception as e:
+                    except Exception:
                         continue
                 elif isinstance(v, ast.FormattedValue):
                     try:
@@ -93,15 +93,14 @@ class FString(object):
                             x + y for x in candidates for y in FormattedValue(v, nested_allowed, self.pep701).get_candidates()
                         ] + completed
                         debug_specifier_candidates = []
-                    except Exception as e:
+                    except Exception:
                         continue
                 else:
                     raise RuntimeError('Unexpected JoinedStr value')
 
                 actual_candidates += ['f' + quote + x + quote for x in candidates]
 
-        actual_candidates = filter(self.is_correct_ast, actual_candidates)
-        return actual_candidates
+        return filter(self.is_correct_ast, actual_candidates)
 
     def str_for(self, s, quote):
         return s.replace('{', '{{').replace('}', '}}')
@@ -270,7 +269,7 @@ class Str(object):
             elif c != quote:
                 return quote
 
-        raise ValueError('Couldn\'t find a quote')
+        raise ValueError("Couldn't find a quote")
 
     def _literals(self):
         l = ''
@@ -349,7 +348,7 @@ class FormatSpec(object):
 
         candidates = ['']
         for v in self.node.values:
-            if is_ast_node(v, ast.Str):
+            if is_constant_node(v, ast.Str):
                 candidates = [x + self.str_for(v.s) for x in candidates]
             elif isinstance(v, ast.FormattedValue):
                 candidates = [
@@ -397,7 +396,7 @@ class Bytes(object):
             elif chr(c) != quote:
                 return quote
 
-        raise ValueError('Couldn\'t find a quote')
+        raise ValueError("Couldn't find a quote")
 
     def _literals(self):
         l = ''

{python_minifier-2.11.2 → python_minifier-2.11.3}/src/python_minifier/ministring.py

@@ -32,7 +32,7 @@ class MiniString(object):
 
         try:
             eval(self.quote + s + self.quote)
-        except (UnicodeDecodeError, UnicodeEncodeError) as e:
+        except (UnicodeDecodeError, UnicodeEncodeError):
             if self.safe_mode:
                 raise
 
@@ -63,7 +63,7 @@ class MiniString(object):
         }
 
         for c in self._s:
-            if c in escaped.keys():
+            if c in escaped:
                 s += escaped[c]
             else:
                 if self.safe_mode:
@@ -95,7 +95,7 @@ class MiniString(object):
         }
 
         for c in self._s:
-            if c in escaped.keys():
+            if c in escaped:
                 s += escaped[c]
             else:
                 if self.safe_mode: