mutmut 3.8.0__tar.gz → 3.8.1__tar.gz

{mutmut-3.8.0 → mutmut-3.8.1}/HISTORY.rst

@@ -1,6 +1,21 @@
 Changelog
 ---------
 
+3.8.1
+~~~~~
+
+* Fix stats collection crashing with pytest 9.2 (`#615`, `#616`)
+
+* Fix ``# pragma: no mutate`` being ignored inside multi-line statements (`#614`)
+
+* Don't produce equivalent case mutants inside string escape sequences like `` `` and ``\N{...}`` (`#609`, `#611`)
+
+* Fix enums with a custom ``__init__`` failing to import under mutmut (`#600`, `#603`)
+
+* Fix crash when mutating float literals too large for a float, like ``1e999`` (`#604`, `#605`)
+
+* Fix crash when mypy reports no errors (`#598`, `#599`)
+
 3.8.0
 ~~~~~~~~~~
 

{mutmut-3.8.0 → mutmut-3.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mutmut
-Version: 3.8.0
+Version: 3.8.1
 Summary: mutation testing for Python 3
 Keywords: mutmut,mutant,mutation,test,testing
 Author: Anders Hovmöller
@@ -407,7 +407,7 @@ Skipping via code comments
 You can use following comments to disable mutation:
 
 - `# pragma: no mutate`: disable mutation on this single line
-- `# pragma: no mutate block`: disable mutation in the whole intendation block
+- `# pragma: no mutate block`: disable mutation in the whole indentation block
 - `# pragma: no mutate start/end`: disable mutation between the start and end comments
 
 Skipping single lines

{mutmut-3.8.0 → mutmut-3.8.1}/README.rst

@@ -373,7 +373,7 @@ Skipping via code comments
 You can use following comments to disable mutation:
 
 - `# pragma: no mutate`: disable mutation on this single line
-- `# pragma: no mutate block`: disable mutation in the whole intendation block
+- `# pragma: no mutate block`: disable mutation in the whole indentation block
 - `# pragma: no mutate start/end`: disable mutation between the start and end comments
 
 Skipping single lines

{mutmut-3.8.0 → mutmut-3.8.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mutmut"
-version = "3.8.0"
+version = "3.8.1"
 description = "mutation testing for Python 3"
 keywords = [
     "mutmut",

{mutmut-3.8.0 → mutmut-3.8.1}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "mutmut"
-version = "3.8.0"
+version = "3.8.1"
 description = "mutation testing for Python 3"
 keywords = ["mutmut", "mutant", "mutation", "test", "testing"]
 authors = [

{mutmut-3.8.0 → mutmut-3.8.1}/src/mutmut/mutation/file_mutation.py

@@ -35,6 +35,8 @@ from mutmut.utils.format_utils import get_mutant_name
 from mutmut.utils.format_utils import is_mutated_method_name
 
 NEVER_MUTATE_FUNCTION_NAMES = {"__getattribute__", "__setattr__", "__new__"}
+NEVER_MUTATE_ENUM_FUNCTION_NAMES = {"__init__", "_generate_next_value_"}
+ENUM_BASE_NAMES = {"Enum", "IntEnum", "StrEnum", "Flag", "IntFlag"}
 NEVER_MUTATE_FUNCTION_CALLS = {"len", "isinstance"}
 
 
@@ -217,6 +219,7 @@ class MutationVisitor(cst.CSTVisitor):
         )
         self.ignored_classes: set[str] = set()
         self.ignored_functions: set[str] = set()
+        self._enum_creation_hooks: set[cst.FunctionDef] = set()
 
     def on_visit(self, node: cst.CSTNode) -> bool:
         if self._skip_node_and_children(node):
@@ -300,6 +303,15 @@ class MutationVisitor(cst.CSTVisitor):
             if isinstance(node, cst.BaseExpression):
                 return True
 
+        if isinstance(node, cst.ClassDef) and _is_enum_class(node):
+            self._enum_creation_hooks.update(
+                child
+                for child in node.body.body
+                if isinstance(child, cst.FunctionDef) and child.name.value in NEVER_MUTATE_ENUM_FUNCTION_NAMES
+            )
+        if node in self._enum_creation_hooks:
+            return True
+
         if (
             isinstance(node, cst.Call)
             and isinstance(node.func, cst.Name)
@@ -344,6 +356,11 @@ class MutationVisitor(cst.CSTVisitor):
         return False
 
 
+def _is_enum_class(node: cst.ClassDef) -> bool:
+    bases = (base.value.attr if isinstance(base.value, cst.Attribute) else base.value for base in node.bases)
+    return any(isinstance(base, cst.Name) and base.value in ENUM_BASE_NAMES for base in bases)
+
+
 def _walk(node: cst.CSTNode) -> Iterator[cst.CSTNode]:
     """Yield `node` and every node below it."""
     stack = [node]

{mutmut-3.8.0 → mutmut-3.8.1}/src/mutmut/mutation/mutators.py

@@ -1,5 +1,7 @@
 """This module contains the mutations for indidvidual nodes, e.g. replacing a != b with a == b."""
 
+import cmath
+import math
 import re
 from collections.abc import Callable
 from collections.abc import Iterable
@@ -17,15 +19,33 @@ OPERATORS_TYPE = Sequence[
     ]
 ]
 
-# pattern to match (nearly) all chars in a string that are not part of an escape sequence
-NON_ESCAPE_SEQUENCE = re.compile(r"((?<!\\)[^\\]+)")
+# Pattern matching either: (1) escape sequences with case-sensitive parts (preserved as group None),
+# or (2) runs of non-backslash characters (captured as group 1 for case transformation).
+# For non-raw strings, preserve \xHH, \uHHHH, \UHHHHHHHH, \N{NAME} to avoid equivalent mutants.
+NON_ESCAPE_SEQUENCE = re.compile(
+    r"\\x[0-9a-fA-F]{2}"  # \xHH
+    r"|\\u[0-9a-fA-F]{4}"  # \uHHHH
+    r"|\\U[0-9a-fA-F]{8}"  # \UHHHHHHHH
+    r"|\\N\{[^}]+\}"  # \N{NAME}
+    r"|(\\.)"  # other escapes like \\, \n, \t (group 1, but treat as escape)
+    r"|((?<!\\)[^\\]+)"  # OR non-backslash run (group 2, to be transformed)
+)
 
 
 def operator_number(node: cst.BaseNumber) -> Iterable[cst.BaseNumber]:
+    # A float literal too large for a float, like 1e999 (a common way to spell
+    # infinity), evaluates to inf. inf + 1 is still inf, which has no literal
+    # form, so there is no number mutant to make.
     if isinstance(node, cst.Integer | cst.Float):
-        yield node.with_changes(value=repr(node.evaluated_value + 1))
+        value = node.evaluated_value + 1
+        if isinstance(value, float) and math.isinf(value):
+            return
+        yield node.with_changes(value=repr(value))
     elif isinstance(node, cst.Imaginary):
-        yield node.with_changes(value=repr(node.evaluated_value + 1j))
+        complex_value = node.evaluated_value + 1j
+        if cmath.isinf(complex_value):
+            return
+        yield node.with_changes(value=repr(complex_value))
     else:
         print("Unexpected number type", node)
 
@@ -42,13 +62,31 @@ def operator_string(node: cst.BaseString) -> Iterable[cst.BaseString]:
             # that mutation is meaningless for
             return
 
+        # For raw strings (r"..." or R"..."), escape sequences are literal, so case changes are NOT equivalent
+        is_raw = "r" in prefix.lower()
+
         supported_str_mutations: list[Callable[[str], str]] = [
             lambda x: "XX" + x + "XX",
-            # do not modify escape sequences, as this could break python syntax
-            lambda x: NON_ESCAPE_SEQUENCE.sub(lambda match: match.group(1).lower(), x),
-            lambda x: NON_ESCAPE_SEQUENCE.sub(lambda match: match.group(1).upper(), x),
         ]
 
+        if is_raw:
+            # Raw strings: use original regex (all non-backslash chars)
+            old_pattern = re.compile(r"((?<!\\)[^\\]+)")
+            supported_str_mutations.extend(
+                [
+                    lambda x: old_pattern.sub(lambda m: m.group(1).lower(), x),
+                    lambda x: old_pattern.sub(lambda m: m.group(1).upper(), x),
+                ]
+            )
+        else:
+            # Regular strings: preserve escape sequences with case-sensitive hex/names
+            supported_str_mutations.extend(
+                [
+                    lambda x: NON_ESCAPE_SEQUENCE.sub(lambda m: m.group(2).lower() if m.group(2) else m.group(0), x),
+                    lambda x: NON_ESCAPE_SEQUENCE.sub(lambda m: m.group(2).upper() if m.group(2) else m.group(0), x),
+                ]
+            )
+
         for mut_func in supported_str_mutations:
             new_value = f"{prefix}{value[0]}{mut_func(value[1:-1])}{value[-1]}"
             if new_value == value:

{mutmut-3.8.0 → mutmut-3.8.1}/src/mutmut/mutation/pragma_handling.py

@@ -217,6 +217,15 @@ class PragmaVisitor(cst.CSTVisitor):
             self.no_mutate_lines.add(line)
         return True
 
+    def visit_ParenthesizedWhitespace(self, node: cst.ParenthesizedWhitespace) -> bool | None:
+        # A comment ending a line inside brackets (a call, a literal, a parenthesized
+        # condition) belongs to this whitespace node, not to the statement's trailing
+        # whitespace, so visit_SimpleStatementLine never sees it.
+        if _parse_pragma_token(node.first_line.comment) == "bare":
+            line = self.get_metadata(PositionProvider, node).start.line
+            self.no_mutate_lines.add(line)
+        return True
+
     def _visit_compound_header(self, node: cst.CSTNode) -> None:
         body = getattr(node, "body", None)
         if isinstance(body, cst.IndentedBlock):

{mutmut-3.8.0 → mutmut-3.8.1}/src/mutmut/runners/harness.py

@@ -154,7 +154,7 @@ class PytestRunner(TestRunner):
             def pytest_runtest_teardown(self, item: Any, nextitem: Any) -> None:
                 unused(nextitem)
                 for function in state()._stats:
-                    state().tests_by_mangled_function_name[function].add(strip_prefix(item._nodeid, prefix="mutants/"))
+                    state().tests_by_mangled_function_name[function].add(strip_prefix(item.nodeid, prefix="mutants/"))
                 state()._stats.clear()
 
             # noinspection PyMethodMayBeStatic

{mutmut-3.8.0 → mutmut-3.8.1}/src/mutmut/type_checking.py

@@ -21,7 +21,8 @@ def run_type_checker(type_check_command: list[str]) -> list[TypeCheckingError]:
 
     try:
         if "mypy" in type_check_command:
-            report = [json.loads(line) for line in completed_process.stdout.splitlines()]
+            # mypy prints a lone newline (not an empty string) when it found no errors
+            report = [json.loads(line) for line in completed_process.stdout.splitlines() if line.strip()]
         else:
             report = json.loads(completed_process.stdout)
     except json.JSONDecodeError: