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

python_minifier/ast_compare.py

@@ -59,11 +59,14 @@ def compare_ast(l_ast, r_ast):
     if type(l_ast) != type(r_ast):
         raise CompareError(l_ast, r_ast, msg='Nodes do not match! %r != %r' % (l_ast, r_ast))
 
-    for field in set(l_ast._fields + r_ast._fields):
+    for field in sorted(set(l_ast._fields + r_ast._fields)):
 
         if field == 'kind' and isinstance(l_ast, ast.Constant):
             continue
 
+        if field == 'str' and hasattr(ast, 'Interpolation') and isinstance(l_ast, ast.Interpolation):
+            continue
+
         if isinstance(getattr(l_ast, field, None), list):
 
             l_list = getattr(l_ast, field, None)

python_minifier/ast_compat.py

@@ -70,9 +70,11 @@ for _node_type in [
     'TryStar',
     'TypeVar',
     'TypeVarTuple',
+    'TemplateStr',
+    'Interpolation',
     'YieldFrom',
     'arg',
     'withitem',
 ]:
     if _node_type not in globals():
-        globals()[_node_type] = type(_node_type, (AST,), {})
+        globals()[_node_type] = type(_node_type, (AST,), {})

python_minifier/expression_printer.py

@@ -301,8 +301,8 @@ class ExpressionPrinter(object):
 
             if value_precedence != 0 and (
                 (op_precedence > value_precedence)
-                or op_precedence == value_precedence
-                and self._is_left_associative(node.op)
+                or (op_precedence == value_precedence
+                    and self._is_left_associative(node.op))
             ):
                 self.printer.delimiter('(')
                 self._expression(v)
@@ -743,6 +743,13 @@ class ExpressionPrinter(object):
 
         self.printer.fstring(str(python_minifier.f_string.OuterFString(node, pep701=pep701)))
 
+    def visit_TemplateStr(self, node):
+        assert isinstance(node, ast.TemplateStr)
+
+        import python_minifier.t_string
+
+        self.printer.tstring(str(python_minifier.t_string.TString(node)))
+
     def visit_NamedExpr(self, node):
         self._expression(node.target)
         self.printer.operator(':=')

python_minifier/f_string.py

@@ -8,6 +8,7 @@ Mostly because FStrings feel like a hack.
 
 import copy
 import re
+import sys
 
 import python_minifier.ast_compat as ast
 
@@ -58,11 +59,12 @@ class FString(object):
 
         return [x + '}' for x in conversion_candidates]
 
-    def candidates(self):
-        actual_candidates = []
+    def _generate_candidates_with_processor(self, prefix, str_processor):
+        """Generate f-string candidates using the given prefix and string processor function."""
+        candidates = []
 
         for quote in self.allowed_quotes:
-            candidates = ['']
+            quote_candidates = ['']
             debug_specifier_candidates = []
             nested_allowed = copy.copy(self.allowed_quotes)
 
@@ -71,26 +73,24 @@ class FString(object):
 
             for v in self.node.values:
                 if is_constant_node(v, ast.Str):
-
                     # Could this be used as a debug specifier?
-                    if len(candidates) < 10:
+                    if len(quote_candidates) < 10:
                         debug_specifier = re.match(r'.*=\s*$', v.s)
                         if debug_specifier:
-                            # Maybe!
                             try:
-                                debug_specifier_candidates = [x + '{' + v.s for x in candidates]
+                                debug_specifier_candidates = [x + '{' + v.s for x in quote_candidates]
                             except Exception:
                                 continue
 
                     try:
-                        candidates = [x + self.str_for(v.s, quote) for x in candidates]
+                        quote_candidates = [x + str_processor(v.s, quote) for x in quote_candidates]
                     except Exception:
                         continue
                 elif isinstance(v, ast.FormattedValue):
                     try:
                         completed = self.complete_debug_specifier(debug_specifier_candidates, v)
-                        candidates = [
-                            x + y for x in candidates for y in FormattedValue(v, nested_allowed, self.pep701).get_candidates()
+                        quote_candidates = [
+                            x + y for x in quote_candidates for y in FormattedValue(v, nested_allowed, self.pep701).get_candidates()
                         ] + completed
                         debug_specifier_candidates = []
                     except Exception:
@@ -98,13 +98,70 @@ class FString(object):
                 else:
                     raise RuntimeError('Unexpected JoinedStr value')
 
-                actual_candidates += ['f' + quote + x + quote for x in candidates]
+            candidates += [prefix + quote + x + quote for x in quote_candidates]
+
+        return candidates
+
+    def candidates(self):
+        actual_candidates = []
+
+        # Normal f-string candidates
+        actual_candidates += self._generate_candidates_with_processor('f', self.str_for)
+
+        # Raw f-string candidates (if we detect backslashes)
+        if self._contains_literal_backslashes():
+            actual_candidates += self._generate_candidates_with_processor('rf', lambda s, quote: self.raw_str_for(s))
 
         return filter(self.is_correct_ast, actual_candidates)
 
-    def str_for(self, s, quote):
+    def raw_str_for(self, s):
+        """
+        Generate string representation for raw f-strings.
+        Don't escape backslashes like MiniString does.
+        """
         return s.replace('{', '{{').replace('}', '}}')
 
+    def _contains_literal_backslashes(self):
+        """
+        Check if this f-string contains literal backslashes in constant values.
+        This indicates it may need to be a raw f-string.
+        """
+        for node in ast.walk(self.node):
+            if is_constant_node(node, ast.Str):
+                if '\\' in node.s:
+                    return True
+        return False
+
+
+    def str_for(self, s, quote):
+        # Escape null bytes and other characters that can't appear in Python source
+        escaped = ''
+        is_multiline = len(quote) == 3  # Triple-quoted strings
+
+        for c in s:
+            if c == '\0':
+                escaped += '\\x00'
+            elif c == '\n' and not is_multiline:
+                # Only escape newlines in single-quoted strings
+                escaped += '\\n'
+            elif c == '\r':
+                # Always escape carriage returns because Python normalizes them during parsing
+                # This prevents semantic changes (\\r -> \\n) in multiline strings
+                escaped += '\\r'
+            elif c == '\t':
+                # Always escape tabs for consistency (though not strictly necessary in multiline)
+                escaped += '\\t'
+            elif c == '{':
+                escaped += '{{'
+            elif c == '}':
+                escaped += '}}'
+            elif ord(c) < 32 and c not in '\n\r\t':
+                # Escape other control characters
+                escaped += '\\x{:02x}'.format(ord(c))
+            else:
+                escaped += c
+        return escaped
+
 
 class OuterFString(FString):
     """
@@ -285,7 +342,9 @@ class Str(object):
             if literal == '':
                 literal += self.current_quote
 
-            if c == '\n':
+            if c == '\0':
+                literal += '\\x00'
+            elif c == '\n':
                 literal += '\\n'
             elif c == '\r':
                 literal += '\\r'
@@ -302,7 +361,7 @@ class Str(object):
         if self._s == '':
             return str(min(self.allowed_quotes, key=len)) * 2
 
-        if '\0' in self._s or ('\\' in self._s and not self.pep701):
+        if '\\' in self._s and not self.pep701:
             raise ValueError('Impossible to represent a character in f-string expression part')
 
         if not self.pep701 and ('\n' in self._s or '\r' in self._s):
@@ -360,7 +419,35 @@ class FormatSpec(object):
         return candidates
 
     def str_for(self, s):
-        return s.replace('{', '{{').replace('}', '}}')
+        # Special handling for problematic format spec characters that can cause parsing issues
+        # If the format spec contains only braces, it's likely an invalid test case
+
+        # Escape null bytes and other unprintable characters
+        escaped = ''
+        for c in s:
+            if c == '\0':
+                escaped += '\\x00'
+            elif c == '{':
+                escaped += '{{'
+            elif c == '}':
+                escaped += '}}'
+            elif c == '\\':
+                # For Python 3.12+ raw f-string regression (fixed in 3.14rc2), we need to escape backslashes
+                # in format specs so they round-trip correctly
+                if (3, 12) <= sys.version_info < (3, 14):
+                    escaped += '\\\\'
+                else:
+                    escaped += c
+            elif c == '\r':
+                # Always escape carriage returns because Python normalizes them to newlines during parsing
+                # This prevents AST mismatches (\r -> \n normalization)
+                escaped += '\\r'
+            elif ord(c) < 32 and c not in '\t\n':
+                # Escape other control characters except tab, newline
+                escaped += '\\x{:02x}'.format(ord(c))
+            else:
+                escaped += c
+        return escaped
 
 
 class Bytes(object):
@@ -411,7 +498,24 @@ class Bytes(object):
 
             if literal == '':
                 literal = 'b' + self.current_quote
-            literal += chr(b)
+
+            # Handle special characters that need escaping
+            if b == 0:  # null byte
+                literal += '\\x00'
+            elif b == ord('\\'):  # backslash
+                literal += '\\\\'
+            elif b == ord('\n'):  # newline
+                literal += '\\n'
+            elif b == ord('\r'):  # carriage return
+                literal += '\\r'
+            elif b == ord('\t'):  # tab
+                literal += '\\t'
+            elif len(self.current_quote) == 1 and b == ord(self.current_quote):  # single quote character
+                literal += '\\' + self.current_quote
+            elif 32 <= b <= 126:  # printable ASCII
+                literal += chr(b)
+            else:  # other non-printable characters
+                literal += '\\x{:02x}'.format(b)
 
         if literal:
             literal += self.current_quote
@@ -421,8 +525,6 @@ class Bytes(object):
         if self._b == b'':
             return 'b' + str(min(self.allowed_quotes, key=len)) * 2
 
-        if b'\0' in self._b or b'\\' in self._b:
-            raise ValueError('Impossible to represent a %r character in f-string expression part')
 
         if b'\n' in self._b or b'\r' in self._b:
             if '"""' not in self.allowed_quotes and "'''" not in self.allowed_quotes:

python_minifier/module_printer.py

@@ -596,7 +596,7 @@ class ModulePrinter(ExpressionPrinter):
         self.printer.keyword('case')
 
         if isinstance(node.pattern, ast.MatchSequence):
-            self.visit_MatchSequence(node.pattern, open=True)
+            self.visit_MatchSequence(node.pattern, omit_brackets=True)
         else:
             self.pattern(node.pattern)
 
@@ -626,10 +626,10 @@ class ModulePrinter(ExpressionPrinter):
         else:
             self.printer.identifier(node.name)
 
-    def visit_MatchSequence(self, node, open=False):
+    def visit_MatchSequence(self, node, omit_brackets=False):
         assert isinstance(node, ast.MatchSequence)
 
-        if len(node.patterns) < 2 or not open:
+        if len(node.patterns) < 2 or not omit_brackets:
             self.printer.delimiter('[')
 
         delimiter = Delimiter(self.printer)
@@ -637,7 +637,7 @@ class ModulePrinter(ExpressionPrinter):
             delimiter.new_item()
             self.pattern(pattern)
 
-        if len(node.patterns) < 2 or not open:
+        if len(node.patterns) < 2 or not omit_brackets:
             self.printer.delimiter(']')
 
     def visit_MatchMapping(self, node):

python_minifier/rename/rename_literals.py

@@ -220,6 +220,13 @@ class HoistLiterals(NodeVisitor):
                 continue
             self.visit(v)
 
+    def visit_TemplateStr(self, node):
+        for v in node.values:
+            if is_constant_node(v, ast.Str):
+                # Can't hoist string literals that are part of the template
+                continue
+            self.visit(v)
+
     def visit_NameConstant(self, node):
         self.get_binding(node.value, node).add_reference(node)
 

python_minifier/rename/renamer.py

@@ -35,7 +35,7 @@ def sorted_bindings(module):
     """
 
     def comp(tup):
-        namespace, binding = tup
+        _namespace, binding = tup
         return binding.new_mention_count()
 
     return sorted(all_bindings(module), key=comp, reverse=True)

python_minifier/t_string.py

@@ -0,0 +1,330 @@
+"""
+Template String (T-String) unparsing
+
+T-strings in Python 3.14 follow PEP 750 and are based on PEP 701,
+which means they don't have the quote restrictions of older f-strings.
+
+This implementation is much simpler than f_string.py because:
+- No quote tracking needed (PEP 701 benefits)
+- No pep701 parameter needed (always true for t-strings)
+- No Outer vs Inner distinction needed
+- Always use all quote types
+"""
+
+import python_minifier.ast_compat as ast
+
+from python_minifier import UnstableMinification
+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_constant_node
+
+
+class TString(object):
+    """
+    A Template String (t-string)
+
+    Much simpler than f-strings because PEP 701 eliminates quote restrictions
+    """
+
+    def __init__(self, node):
+        assert isinstance(node, ast.TemplateStr)
+        self.node = node
+        # Always use all quotes - no restrictions due to PEP 701
+        self.allowed_quotes = ['"', "'", '"""', "'''"]
+
+    def is_correct_ast(self, code):
+        """Check if the generated code produces the same AST"""
+        try:
+            c = ast.parse(code, 'TString candidate', mode='eval')
+            compare_ast(self.node, c.body)
+            return True
+        except Exception:
+            return False
+
+    def complete_debug_specifier(self, partial_specifier_candidates, value_node):
+        """Complete debug specifier candidates for an Interpolation node"""
+        assert isinstance(value_node, ast.Interpolation)
+
+        conversion = ''
+        if value_node.conversion == 115:  # 's'
+            conversion = '!s'
+        elif value_node.conversion == 114 and value_node.format_spec is not None:
+            # This is the default for debug specifiers, unless there's a format_spec
+            conversion = '!r'
+        elif value_node.conversion == 97:  # 'a'
+            conversion = '!a'
+
+        conversion_candidates = [x + conversion for x in partial_specifier_candidates]
+
+        if value_node.format_spec is not None:
+            # Handle format specifications in debug specifiers
+            if isinstance(value_node.format_spec, ast.JoinedStr):
+                import python_minifier.f_string
+                format_specs = python_minifier.f_string.FormatSpec(value_node.format_spec, self.allowed_quotes, pep701=True).candidates()
+                conversion_candidates = [c + ':' + fs for c in conversion_candidates for fs in format_specs]
+
+        return [x + '}' for x in conversion_candidates]
+
+    def candidates(self):
+        """Generate all possible representations"""
+        actual_candidates = []
+
+        # Normal t-string candidates
+        actual_candidates.extend(self._generate_candidates_with_processor('t', self.str_for))
+
+        # Raw t-string candidates (if we detect backslashes)
+        if self._contains_literal_backslashes():
+            actual_candidates.extend(self._generate_candidates_with_processor('rt', self.raw_str_for))
+
+        return filter(self.is_correct_ast, actual_candidates)
+
+    def _generate_candidates_with_processor(self, prefix, str_processor):
+        """Generate t-string candidates using the given prefix and string processor function."""
+        candidates = []
+
+        for quote in self.allowed_quotes:
+            quote_candidates = ['']
+            debug_specifier_candidates = []
+
+            for v in self.node.values:
+                if is_constant_node(v, ast.Constant) and isinstance(v.value, str):
+                    # String literal part - check for debug specifiers
+
+                    # Could this be used as a debug specifier?
+                    if len(quote_candidates) < 10:
+                        import re
+                        debug_specifier = re.match(r'.*=\s*$', v.value)
+                        if debug_specifier:
+                            # Maybe! Save for potential debug specifier completion
+                            try:
+                                debug_specifier_candidates = [x + '{' + v.value for x in quote_candidates]
+                            except Exception:
+                                continue
+
+                    try:
+                        quote_candidates = [x + str_processor(v.value, quote) for x in quote_candidates]
+                    except Exception:
+                        continue
+
+                elif isinstance(v, ast.Interpolation):
+                    # Interpolated expression part - check for debug completion
+                    try:
+                        # Try debug specifier completion
+                        completed = self.complete_debug_specifier(debug_specifier_candidates, v)
+
+                        # Regular interpolation processing
+                        interpolation_candidates = InterpolationValue(v).get_candidates()
+                        quote_candidates = [x + y for x in quote_candidates for y in interpolation_candidates] + completed
+
+                        debug_specifier_candidates = []
+                    except Exception:
+                        continue
+                else:
+                    raise RuntimeError('Unexpected TemplateStr value: %r' % v)
+
+            candidates.extend([prefix + quote + x + quote for x in quote_candidates])
+
+        return candidates
+
+    def str_for(self, s, quote):
+        """Convert string literal to properly escaped form"""
+        # Use MiniString for optimal string representation
+        # Always allowed due to PEP 701 - no backslash restrictions
+        mini_s = str(MiniString(s, quote)).replace('{', '{{').replace('}', '}}')
+
+        if mini_s == '':
+            return '\\\n'
+        return mini_s
+
+    def raw_str_for(self, s):
+        """
+        Generate string representation for raw t-strings.
+        Don't escape backslashes like MiniString does.
+        """
+        return s.replace('{', '{{').replace('}', '}}')
+
+    def _contains_literal_backslashes(self):
+        """
+        Check if this t-string contains literal backslashes in constant values.
+        This indicates it may need to be a raw t-string.
+        """
+        for node in ast.walk(self.node):
+            if is_constant_node(node, ast.Str):
+                if '\\' in node.s:
+                    return True
+        return False
+
+    def __str__(self):
+        """Generate the shortest valid t-string representation"""
+        if len(self.node.values) == 0:
+            return 't' + min(self.allowed_quotes, key=len) * 2
+
+        candidates = list(self.candidates())
+
+        # Validate all candidates
+        for candidate in candidates:
+            try:
+                minified_t_string = ast.parse(candidate, 'python_minifier.t_string output', mode='eval').body
+            except SyntaxError as syntax_error:
+                raise UnstableMinification(syntax_error, '', candidate)
+
+            try:
+                compare_ast(self.node, minified_t_string)
+            except CompareError as compare_error:
+                raise UnstableMinification(compare_error, '', candidate)
+
+        if not candidates:
+            raise ValueError('Unable to create representation for t-string')
+
+        return min(candidates, key=len)
+
+
+class InterpolationValue(ExpressionPrinter):
+    """
+    A Template String Interpolation Part
+
+    Handles ast.Interpolation nodes (equivalent to FormattedValue for f-strings)
+    """
+
+    def __init__(self, node):
+        super(InterpolationValue, self).__init__()
+
+        assert isinstance(node, ast.Interpolation)
+        self.node = node
+        # Always use all quotes - no restrictions due to PEP 701
+        self.allowed_quotes = ['"', "'", '"""', "'''"]
+        self.candidates = ['']
+
+    def get_candidates(self):
+        """Generate all possible representations of this interpolation"""
+
+        self.printer.delimiter('{')
+
+        if self.is_curly(self.node.value):
+            self.printer.delimiter(' ')
+
+        self._expression(self.node.value)
+
+        # Handle conversion specifiers
+        if self.node.conversion == 115:  # 's'
+            self.printer.append('!s', TokenTypes.Delimiter)
+        elif self.node.conversion == 114:  # 'r'
+            self.printer.append('!r', TokenTypes.Delimiter)
+        elif self.node.conversion == 97:  # 'a'
+            self.printer.append('!a', TokenTypes.Delimiter)
+
+        # Handle format specifications
+        if self.node.format_spec is not None:
+            self.printer.delimiter(':')
+
+            # Format spec is a JoinedStr (f-string) in the AST
+            if isinstance(self.node.format_spec, ast.JoinedStr):
+                import python_minifier.f_string
+                # Use f-string processing for format specs
+                format_candidates = python_minifier.f_string.OuterFString(
+                    self.node.format_spec, pep701=True
+                ).candidates()
+                # Remove the f/rf prefix and quotes to get just the format part
+                format_parts = []
+                for fmt in format_candidates:
+                    # Handle both f"..." and rf"..." patterns
+                    if fmt.startswith('rf'):
+                        # Remove rf prefix and outer quotes
+                        inner = fmt[2:]
+                    elif fmt.startswith('f'):
+                        # Remove f prefix and outer quotes
+                        inner = fmt[1:]
+                    else:
+                        continue
+
+                    if (inner.startswith('"') and inner.endswith('"')) or \
+                       (inner.startswith("'") and inner.endswith("'")):
+                        format_parts.append(inner[1:-1])
+                    elif (inner.startswith('"""') and inner.endswith('"""')) or \
+                         (inner.startswith("'''") and inner.endswith("'''")):
+                        format_parts.append(inner[3:-3])
+                    else:
+                        format_parts.append(inner)
+
+                if format_parts:
+                    self._append(format_parts)
+            else:
+                # Simple constant format spec
+                self.printer.append(str(self.node.format_spec), TokenTypes.Delimiter)
+
+        self.printer.delimiter('}')
+
+        self._finalize()
+        return self.candidates
+
+    def is_curly(self, node):
+        """Check if expression starts with curly braces (needs space)"""
+        if isinstance(node, (ast.SetComp, ast.DictComp, ast.Set, ast.Dict)):
+            return True
+
+        if isinstance(node, (ast.Expr, ast.Attribute, ast.Subscript)):
+            return self.is_curly(node.value)
+
+        if isinstance(node, (ast.Compare, ast.BinOp)):
+            return self.is_curly(node.left)
+
+        if isinstance(node, ast.Call):
+            return self.is_curly(node.func)
+
+        if isinstance(node, ast.BoolOp):
+            return self.is_curly(node.values[0])
+
+        if isinstance(node, ast.IfExp):
+            return self.is_curly(node.body)
+
+        return False
+
+    def visit_Constant(self, node):
+        """Handle constant values in interpolations"""
+        if isinstance(node.value, str):
+            # Use Str class from f_string module for string handling
+            from python_minifier.f_string import Str
+            self.printer.append(str(Str(node.value, self.allowed_quotes, pep701=True)), TokenTypes.NonNumberLiteral)
+        elif isinstance(node.value, bytes):
+            # Use Bytes class from f_string module for bytes handling
+            from python_minifier.f_string import Bytes
+            self.printer.append(str(Bytes(node.value, self.allowed_quotes)), TokenTypes.NonNumberLiteral)
+        else:
+            # Other constants (numbers, None, etc.)
+            super().visit_Constant(node)
+
+    def visit_TemplateStr(self, node):
+        """Handle nested t-strings"""
+        assert isinstance(node, ast.TemplateStr)
+        if self.printer.previous_token in [TokenTypes.Identifier, TokenTypes.Keyword, TokenTypes.SoftKeyword]:
+            self.printer.delimiter(' ')
+        # Nested t-string - no quote restrictions due to PEP 701
+        self._append(TString(node).candidates())
+
+    def visit_JoinedStr(self, node):
+        """Handle nested f-strings in t-strings"""
+        assert isinstance(node, ast.JoinedStr)
+        if self.printer.previous_token in [TokenTypes.Identifier, TokenTypes.Keyword, TokenTypes.SoftKeyword]:
+            self.printer.delimiter(' ')
+
+        import python_minifier.f_string
+        # F-strings nested in t-strings also benefit from PEP 701
+        self._append(python_minifier.f_string.OuterFString(node, pep701=True).candidates())
+
+    def visit_Lambda(self, node):
+        """Handle lambda expressions in interpolations"""
+        self.printer.delimiter('(')
+        super().visit_Lambda(node)
+        self.printer.delimiter(')')
+
+    def _finalize(self):
+        """Finalize the current printer state"""
+        self.candidates = [x + str(self.printer) for x in self.candidates]
+        self.printer._code = ''
+
+    def _append(self, candidates):
+        """Append multiple candidate strings"""
+        self._finalize()
+        self.candidates = [x + y for x in self.candidates for y in candidates]

python_minifier/token_printer.py

@@ -103,7 +103,7 @@ 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
@@ -181,6 +181,16 @@ class TokenPrinter(object):
         self._code += s
         self.previous_token = TokenTypes.NonNumberLiteral
 
+    def tstring(self, s):
+        """Add a template string (t-string) to the output code."""
+        assert isinstance(s, str)
+
+        if self.previous_token in [TokenTypes.Identifier, TokenTypes.Keyword, TokenTypes.SoftKeyword]:
+            self.delimiter(' ')
+
+        self._code += s
+        self.previous_token = TokenTypes.NonNumberLiteral
+
     def delimiter(self, d):
         """Add a delimiter to the output code."""
         assert d in [

python_minifier/transforms/remove_debug.py

@@ -27,18 +27,38 @@ class RemoveDebug(SuiteTransformer):
         if not isinstance(node, ast.If):
             return False
 
-        if isinstance(node.test, ast.Name) and node.test.id == '__debug__':
-            return True
+        def is_simple_debug_check():
+            # Simple case: if __debug__:
+            if isinstance(node.test, ast.Name) and node.test.id == '__debug__':
+                return True
+            return False
 
-        if isinstance(node.test, ast.Compare) and len(node.test.ops) == 1 and isinstance(node.test.ops[0], ast.Is) and self.constant_value(node.test.comparators[0]) is True:
-            return True
+        def is_truthy_debug_comparison():
+            # Comparison case: if __debug__ is True / False / etc.
+            if not isinstance(node.test, ast.Compare):
+                return False
 
-        if isinstance(node.test, ast.Compare) and len(node.test.ops) == 1 and isinstance(node.test.ops[0], ast.IsNot) and self.constant_value(node.test.comparators[0]) is False:
-            return True
+            if not isinstance(node.test.left, ast.Name):
+                return False
 
-        if isinstance(node.test, ast.Compare) and len(node.test.ops) == 1 and isinstance(node.test.ops[0], ast.Eq) and self.constant_value(node.test.comparators[0]) is True:
-            return True
+            if node.test.left.id != '__debug__':
+                return False
 
+            if len(node.test.ops) == 1:
+                op = node.test.ops[0]
+                comparator_value = self.constant_value(node.test.comparators[0])
+
+                if isinstance(op, ast.Is) and comparator_value is True:
+                    return True
+                if isinstance(op, ast.IsNot) and comparator_value is False:
+                    return True
+                if isinstance(op, ast.Eq) and comparator_value is True:
+                    return True
+
+            return False
+
+        if is_simple_debug_check() or is_truthy_debug_comparison():
+            return True
         return False
 
     def suite(self, node_list, parent):

{python_minifier-3.0.0.dist-info → python_minifier-3.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-minifier
-Version: 3.0.0
+Version: 3.1.1
 Summary: Transform Python source code into it's most compact representation
 Home-page: https://github.com/dflook/python-minifier
 Author: Daniel Flook
@@ -26,13 +26,14 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: 2
 Classifier: Programming Language :: Python :: 2.7
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Software Development
-Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, <3.14
+Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, <3.15
 Description-Content-Type: text/markdown
 
 # Python Minifier
@@ -41,7 +42,7 @@ Transforms Python source code into its most compact representation.
 
 [Try it out!](https://python-minifier.com)
 
-python-minifier currently supports Python 2.7 and Python 3.3 to 3.13. Previous releases supported Python 2.6.
+python-minifier currently supports Python 2.7 and Python 3.3 to 3.14. Previous releases supported Python 2.6.
 
 * [PyPI](https://pypi.org/project/python-minifier/)
 * [Documentation](https://dflook.github.io/python-minifier/)
@@ -147,7 +148,7 @@ and outputs source code compatible with the version of the interpreter it is run
 This means that if you minify code written for Python 3.11 using python-minifier running with Python 3.12,
 the minified code may only run with Python 3.12.
 
-python-minifier runs with and can minify code written for Python 2.7 and Python 3.3 to 3.13.
+python-minifier runs with and can minify code written for Python 2.7 and Python 3.3 to 3.14.
 
 ## Usage
 

{python_minifier-3.0.0.dist-info → python_minifier-3.1.1.dist-info}/RECORD

@@ -1,15 +1,16 @@
 python_minifier/__init__.py,sha256=Q95ufDbd7hadjVtJZYclsJqX9S4NsKZSpqCui0Fw7oI,9542
 python_minifier/__init__.pyi,sha256=-xLoKXbQsV7ko_YzyXL9WkI2vmGc6yn4AW5biK_GJXE,1233
 python_minifier/__main__.py,sha256=r7_Vh9n-aoc4jd5CERKO3KqJeqXHeWoycDRlvV7xTFM,14053
-python_minifier/ast_compare.py,sha256=TlkEdQyiEXZZxbu3NrOgmYE7d8nV8dYhHDMysni44-Q,3249
-python_minifier/ast_compat.py,sha256=nubno_yFHtuoxbT7a7CtlcAfdNj9yhniKSfNoOsQ3Fw,2209
+python_minifier/ast_compare.py,sha256=KQyS9TGA1SoCs8uu4iks1IINFb_pEj7x38Q4oiERWnI,3381
+python_minifier/ast_compat.py,sha256=DFJ7WmrEfYXfaby8EWt1aRlcqVPPoXD4Fh9Hnb9dLCU,2250
 python_minifier/ast_printer.py,sha256=TlkyKl9_9ScWeop3W1TwXZ46MJWINfkJ7NvmULpwt4A,3254
-python_minifier/expression_printer.py,sha256=AwkDTs-NJhLyDppE_zlgQdtQQTVQlxdOdgTtSt_DxT8,22465
-python_minifier/f_string.py,sha256=9Zkb2SksoTdx0-dfQKy_Q76KrOR4cxPokR5tnF7jldY,14131
+python_minifier/expression_printer.py,sha256=rBegwnqsjT_buJwSqK_piLwnfCwPyshzUUYgShoZPB4,22676
+python_minifier/f_string.py,sha256=eXYXaxEMSB3iHY_M_RXYpeloJV-7TYnhWIGge0KYCk8,18314
 python_minifier/ministring.py,sha256=R0xaAZqMlLu1Jm0aBVSI0n8KZiZV7PTs4RE4UbCmTy8,4359
-python_minifier/module_printer.py,sha256=CZFZ3WDBgH57_Q2pmC0ySFdRcvQR_7uVQeXKfvT1BN0,25566
+python_minifier/module_printer.py,sha256=zVdsUXm2GkdbIbNUyuavaOWRhn7FP93UqRibhuiokfQ,25602
 python_minifier/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-python_minifier/token_printer.py,sha256=TbN7VDGM_icmruLnBLgtWpHz1iY4pagGKsWCBMWSisA,9640
+python_minifier/t_string.py,sha256=z3KzWaSDqvy701SY3dm8VSkiJuiUfopSWGNIm-nDpAo,13261
+python_minifier/token_printer.py,sha256=MoVyC_ufvTXtI5bAIq6XdWDrkUTF6oYBmto3ILfq_KU,9983
 python_minifier/util.py,sha256=60iT3XkKlPlZhXQ1NuLB27Wv3ihl-gBC_WjOjEiFn-Q,1184
 python_minifier/ast_annotation/__init__.py,sha256=BJ4gyS-_bytIZf0SP8JJG6FECWf8MUaUi3vOAfD60qQ,2259
 python_minifier/rename/__init__.py,sha256=8DLEFgliakf_5T_m-l1Nd35QxKpM4h7RJyFVpjsxjWA,375
@@ -17,8 +18,8 @@ python_minifier/rename/bind_names.py,sha256=CCL2ZT2px___1yE5euO_Wv423DLQFIp5-D7m
 python_minifier/rename/binding.py,sha256=WPospKLbZN7nnzDayJ55HMxuS-E5zvOE78RJkKiyPrE,15335
 python_minifier/rename/mapper.py,sha256=h3dgg3JgUGQhW7oGwBX1syUgmt5AuaF_OP8dW5ImS5o,6482
 python_minifier/rename/name_generator.py,sha256=70Klx2DteYRpBT8dr6jYDB31ARfinS42e08kKlWAzLg,1269
-python_minifier/rename/rename_literals.py,sha256=dBe-6MsPDjzgQ_B5iz184PkEylxdOeBiTuZgeSME4bU,7246
-python_minifier/rename/renamer.py,sha256=B9kNiTkWDw7i7tKQASrCZ4fXsjKf9AspFSUfuxQWZFs,6600
+python_minifier/rename/rename_literals.py,sha256=qKJYCK8X7jEi7IW2PFiOqIjj0pn-1Cz1WaiBEGkUmIw,7488
+python_minifier/rename/renamer.py,sha256=UQWrWrmntT0laNjTxEcH-cK4nZXAzi6LtJCI_STYZbo,6601
 python_minifier/rename/resolve_names.py,sha256=VbePyUUqggvvcF3fAC6XMv6b3Kmb_cmlO9G7vf5Ti-c,4320
 python_minifier/rename/util.py,sha256=ItJykxM_QRjIePMcKYo-LngmP5hLQZK-bOZIefg1cKA,5469
 python_minifier/transforms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -28,7 +29,7 @@ python_minifier/transforms/remove_annotations.py,sha256=qUCdl42yvq1g7B43d88EOz6J
 python_minifier/transforms/remove_annotations_options.py,sha256=kzg-gEPwhrCZxsuzdpEWjqnhsyF89hnIPv1t-IRty64,1889
 python_minifier/transforms/remove_annotations_options.pyi,sha256=jZp8hUQ-BfqU1qA_nsPiluMM-1jznSX3pzbmysvKv-c,518
 python_minifier/transforms/remove_asserts.py,sha256=obccCHRSK6j5z0Slb4vVvK5kPVKobZNQo1HjJeX1N0g,738
-python_minifier/transforms/remove_debug.py,sha256=vuWJPFBMPYZEcSU8oRZ8w41tWl16B0mxpVvxEu4PiwY,1869
+python_minifier/transforms/remove_debug.py,sha256=r5owpGW-T9yh7m5OmdIwCMiYF-1LPBQOQ2FYWRuhNWQ,2334
 python_minifier/transforms/remove_exception_brackets.py,sha256=hOUxrfsl9-u8M1kLbqJ6wR8PFtKWSmmyKdTDkh-XsDA,4214
 python_minifier/transforms/remove_explicit_return_none.py,sha256=drXry0dejtMWLZJCkGh4d7fc89MqiUVCXgaonn6Como,1301
 python_minifier/transforms/remove_literal_statements.py,sha256=mrxgSNtI2J1Nv9DaSiXMlrqvEj1lDAAY5_niWh8PmZg,1631
@@ -36,10 +37,10 @@ python_minifier/transforms/remove_object_base.py,sha256=j4se6OXyZK1lr_ABmGT0Oivu
 python_minifier/transforms/remove_pass.py,sha256=S9e59nBEZ8rBBifvAhbPRDTfUA7s8_a7pSIsZbFZD2A,735
 python_minifier/transforms/remove_posargs.py,sha256=aV0wFnGiDXu4uQBQP7-cB1uLSF3mamIq5-txvDg8BVo,314
 python_minifier/transforms/suite_transformer.py,sha256=WZCVkkBSniWeEtBybVweeMmy-A1wC3lBIYSgxCHelBU,6324
-python_minifier-3.0.0.dist-info/LICENSE,sha256=FzsyDHb8pAZupSGFjIOuHcHMlFf6N-aIxq9gOYGbNyE,1069
-python_minifier-3.0.0.dist-info/METADATA,sha256=qyng9Qp0kOp9hiup4wcfJW2DQJT3_hCjbFemSrIpTpU,6451
-python_minifier-3.0.0.dist-info/WHEEL,sha256=1VPi6hfNQaRRNuEdK_3dv9o8COtLGnHWJghhj4CQ28k,92
-python_minifier-3.0.0.dist-info/entry_points.txt,sha256=aS7ZUWQeeys8lAbrmmEa2__Bg-anH1tUMyi9cKdTbO4,60
-python_minifier-3.0.0.dist-info/top_level.txt,sha256=4SRDfWKi_KMq7LDrjlzUFoDCs6INYPtxc1Pun4z8LsU,16
-python_minifier-3.0.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-python_minifier-3.0.0.dist-info/RECORD,,
+python_minifier-3.1.1.dist-info/LICENSE,sha256=FzsyDHb8pAZupSGFjIOuHcHMlFf6N-aIxq9gOYGbNyE,1069
+python_minifier-3.1.1.dist-info/METADATA,sha256=szq8DMXjTaRYTE-tUW8lKyMiojWV2yyu6l2wGSaxu5k,6502
+python_minifier-3.1.1.dist-info/WHEEL,sha256=1VPi6hfNQaRRNuEdK_3dv9o8COtLGnHWJghhj4CQ28k,92
+python_minifier-3.1.1.dist-info/entry_points.txt,sha256=aS7ZUWQeeys8lAbrmmEa2__Bg-anH1tUMyi9cKdTbO4,60
+python_minifier-3.1.1.dist-info/top_level.txt,sha256=4SRDfWKi_KMq7LDrjlzUFoDCs6INYPtxc1Pun4z8LsU,16
+python_minifier-3.1.1.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+python_minifier-3.1.1.dist-info/RECORD,,