mutmut 3.7.0__tar.gz → 3.8.0__tar.gz

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

@@ -1,6 +1,37 @@
 Changelog
 ---------
 
+3.8.0
+~~~~~~~~~~
+
+* Fix obsolete test names never being removed from ``mutants/mutmut-stats.json`` (`#564`)
+
+* Fix ``# pragma: no mutate block`` being silently ignored when placed on an ``else``, ``except``, ``except*`` or ``finally`` header, and on the ``try`` line of a ``try``/``except*`` (`#559`)
+
+* Fix ``# pragma: no mutate`` being silently ignored on ``match`` and ``case`` headers (`#554`)
+
+* Fix mutants being reported as survived when a test uses ``patch.dict(os.environ, ..., clear=True)`` (`#511`, `#552`)
+
+* Fix `mutate_only_covered_lines` mutating code that coverage.py excludes from measurement (`# pragma: no cover`, `exclude_lines`, `exclude_also`) (`#547`)
+
+* Fix mutations that delete ignored code. Dropping a `case` from a `match`, or an argument from a call, is a mutation of the enclosing node, so it used to be made even when the removed lines were themselves ignored (`#547`)
+
+* Fix methods of decorated classes (for example `@dataclass`) not being mutated (`#480`, `#539`)
+
+* Fix time measurement including test setup/teardown instead of only the main test run (`#544`)
+
+* Fix mutants stopped by the CPU-time limit being reported as killed instead of timed out (`#565`)
+
+* Fix ``mutate_only_covered_lines`` breaking when the test suite imports a dependency that cannot be initialized twice in one process, which raised for numpy and libyaml, produced misleading type errors for cryptography, and segfaulted for asyncpg. Coverage is now gathered in a separate process, so the modules the coverage run imports are no longer unloaded and re-imported in the main process (`#528`, `#566`)
+
+* Mutate the condition of ternary expressions (`#196`, `#546`)
+
+* Add a ``process_isolation`` config for choosing which process mutant workers are forked from. The new ``forkserver`` strategy keeps mutmut's main process free of pytest and your ``conftest.py``, routing every fork through a dedicated fork server process, for test setups that are not fork-safe (``gevent``, ``grpc``, ``torch``). Tune what it preloads with ``forkserver_warmup`` (`#578`, `#566`)
+
+* Add a `badge` command that writes a shields.io endpoint file, for publishing the mutation score (`#549`)
+
+* Support python3.15 (`#551`)
+
 3.7.0
 ~~~~~
 
@@ -586,7 +617,7 @@ Thanks goes out Marcelo Da Cruz Pinto, Savo Kovačević,
 
 * Dict literals looking like `dict(a=foo)` now have mutated keys. You can also declare synonyms in setup.cfg.
 
-* Fix "from x import *"
+* Fix ``from x import *``
 
 
 0.0.6 (2017-06-13)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mutmut
-Version: 3.7.0
+Version: 3.8.0
 Summary: mutation testing for Python 3
 Keywords: mutmut,mutant,mutation,test,testing
 Author: Anders Hovmöller
@@ -16,19 +16,20 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
-Requires-Dist: click>=8.0.0
+Classifier: Programming Language :: Python :: 3.15
+Requires-Dist: click>=8.4.2
 Requires-Dist: coverage>=7.3.0
-Requires-Dist: libcst>=1.8.5
+Requires-Dist: libcst>=1.9.0
 Requires-Dist: pytest>=6.2.5
-Requires-Dist: setproctitle>=1.1.0
+Requires-Dist: setproctitle>=1.3.7
 Requires-Dist: textual>=1.0.0
 Requires-Dist: toml>=0.10.2 ; python_full_version < '3.11'
 Requires-Python: >=3.10
-Project-URL: Changelog, https://github.com/boxed/mutmut/blob/main/HISTORY.rst
-Project-URL: Documentation, https://mutmut.readthedocs.io/en/latest/
 Project-URL: Homepage, https://github.com/boxed/mutmut
-Project-URL: Issues, https://github.com/boxed/mutmut/issues
+Project-URL: Documentation, https://mutmut.readthedocs.io/en/latest/
 Project-URL: Repository, https://github.com/boxed/mutmut
+Project-URL: Issues, https://github.com/boxed/mutmut/issues
+Project-URL: Changelog, https://github.com/boxed/mutmut/blob/main/HISTORY.rst
 Description-Content-Type: text/x-rst
 
 mutmut - python mutation tester
@@ -202,6 +203,11 @@ If you only want to mutate lines that are called (according to coverage.py), you
 
     mutate_only_covered_lines=true
 
+This also honours the lines coverage.py is told to leave out of its measurement, so code
+marked with `# pragma: no cover`, or matched by your `exclude_lines`/`exclude_also`
+settings, is not mutated either. Such code is not held to your test suite, so mutants
+there could only ever show up as survivors.
+
 
 Filter generated mutants with type checker
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -264,6 +270,108 @@ macOS at your own risk, or to disable it on other platforms), set ``use_setproct
     use_setproctitle = false
 
 
+Process isolation (``fork`` vs ``forkserver``)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. code-block:: toml
+
+    # pyproject.toml
+    [tool.mutmut]
+    process_isolation = "fork"  # or "forkserver"
+
+Both strategies require ``os.fork``, so they are POSIX-only.
+
+``fork`` (default)
+    Mutmut's main process imports pytest and runs your test suite to collect
+    stats, then forks one child per mutant. This is fast and needs no
+    configuration, but every mutant worker inherits whatever your test setup
+    left behind in that process: monkey-patched sockets, running event loops,
+    background threads, open database connections, CUDA contexts. If any of
+    that is not fork-safe, the workers can hang, segfault, or report nonsense.
+
+``forkserver``
+    Mutmut's main process never imports pytest or your ``conftest.py``. It forks
+    a dedicated *fork server* child, and that child does the importing once and
+    forks a worker per mutant::
+
+        main process (clean) -> fork server (imports pytest) -> N mutant workers
+
+    Because the fork server only imports and forks, and never runs a test
+    itself, every worker starts from the same predictable state. This is the
+    same design as the ``forkserver`` start method in Python's
+    ``multiprocessing``, and it is still only one pytest import for the whole
+    run, so it is not slower than ``fork`` in the normal case.
+
+**Which one should you use?** Start with ``fork``. Switch to ``forkserver`` if
+your run hangs, crashes, or gives results you cannot reproduce by running the
+tests by hand, and your test setup touches something known to be fork-unsafe,
+such as ``gevent.monkey.patch_all()``, ``grpc``, or ``torch``. It is also the
+better choice if you simply do not want your session-scoped setup living in the
+process that forks mutants.
+
+
+Tuning what the fork server preloads
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+``forkserver_warmup`` controls how much the fork server imports before it starts
+forking workers. It only applies when ``process_isolation = "forkserver"``.
+Anything imported in the fork server is inherited by every  worker, and anything
+left out is imported in each worker.
+
+.. code-block:: toml
+
+    # pyproject.toml
+    [tool.mutmut]
+    process_isolation = "forkserver"
+    forkserver_warmup = "collect"  # "collect" (default), "import" or "none"
+
+``collect`` (default)
+    Run ``pytest --collect-only``, which imports your ``conftest.py``, your
+    plugins and your test modules. This is the right default for most projects
+    and usually the fastest.
+
+``import``
+    Import only the modules listed in ``preload_modules_file`` (one dotted
+    module name per line; blank lines and ``#`` comments are ignored, and
+    modules that fail to import are skipped). Use this when test *collection*
+    itself has side effects you do not want every worker to share, but you still
+    want your slow imports warmed up.
+
+``none``
+    Import nothing beyond what running a single test requires. This is the
+    slowest option, and the most isolated. It is mostly useful for working out
+    whether a warmup side effect is what is breaking your run.
+
+.. code-block:: toml
+
+    # pyproject.toml
+    [tool.mutmut]
+    process_isolation = "forkserver"
+    forkserver_warmup = "import"
+    preload_modules_file = "mutmut_preload.txt"
+
+If the fork server itself crashes, mutmut starts a new one and re-submits the
+mutants that were in flight, up to ``max_forkserver_restarts`` times (default
+``3``) before giving up with a ``ForkServerCrashError``:
+
+.. code-block:: toml
+
+    # pyproject.toml
+    [tool.mutmut]
+    max_forkserver_restarts = 3
+
+The fork server and its workers cannot write to the console without mangling
+mutmut's progress output, so they log to a file instead. Logging is off unless
+you ask for it with ``log_to_file`` (or ``debug``):
+
+.. code-block:: toml
+
+    # pyproject.toml
+    [tool.mutmut]
+    log_to_file = true
+    log_file_path = "mutants/mutmut-debug.log"
+
+
 Disabling mutation on specific code
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -547,6 +655,21 @@ Mutmut keeps the data of what it has done and the mutants in the `mutants/`
 directory. If you want to make sure you run a full mutmut run you can delete
 this directory to start from scratch.
 
+
+Mutation score badges
+---------------------
+
+`mutmut badge` turns `mutmut export-cicd-stats` output into `Shields endpoint JSON <https://shields.io/badges/endpoint-badge>`_:
+
+.. code-block:: console
+
+    mutmut export-cicd-stats
+    mutmut badge --output mutation-score.json
+
+.. code-block:: md
+
+    ![mutation](https://img.shields.io/endpoint?url=https://example.com/mutation-score.json)
+
 Contributing to Mutmut
 ----------------------
 

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

@@ -169,6 +169,11 @@ If you only want to mutate lines that are called (according to coverage.py), you
 
     mutate_only_covered_lines=true
 
+This also honours the lines coverage.py is told to leave out of its measurement, so code
+marked with `# pragma: no cover`, or matched by your `exclude_lines`/`exclude_also`
+settings, is not mutated either. Such code is not held to your test suite, so mutants
+there could only ever show up as survivors.
+
 
 Filter generated mutants with type checker
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -231,6 +236,108 @@ macOS at your own risk, or to disable it on other platforms), set ``use_setproct
     use_setproctitle = false
 
 
+Process isolation (``fork`` vs ``forkserver``)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. code-block:: toml
+
+    # pyproject.toml
+    [tool.mutmut]
+    process_isolation = "fork"  # or "forkserver"
+
+Both strategies require ``os.fork``, so they are POSIX-only.
+
+``fork`` (default)
+    Mutmut's main process imports pytest and runs your test suite to collect
+    stats, then forks one child per mutant. This is fast and needs no
+    configuration, but every mutant worker inherits whatever your test setup
+    left behind in that process: monkey-patched sockets, running event loops,
+    background threads, open database connections, CUDA contexts. If any of
+    that is not fork-safe, the workers can hang, segfault, or report nonsense.
+
+``forkserver``
+    Mutmut's main process never imports pytest or your ``conftest.py``. It forks
+    a dedicated *fork server* child, and that child does the importing once and
+    forks a worker per mutant::
+
+        main process (clean) -> fork server (imports pytest) -> N mutant workers
+
+    Because the fork server only imports and forks, and never runs a test
+    itself, every worker starts from the same predictable state. This is the
+    same design as the ``forkserver`` start method in Python's
+    ``multiprocessing``, and it is still only one pytest import for the whole
+    run, so it is not slower than ``fork`` in the normal case.
+
+**Which one should you use?** Start with ``fork``. Switch to ``forkserver`` if
+your run hangs, crashes, or gives results you cannot reproduce by running the
+tests by hand, and your test setup touches something known to be fork-unsafe,
+such as ``gevent.monkey.patch_all()``, ``grpc``, or ``torch``. It is also the
+better choice if you simply do not want your session-scoped setup living in the
+process that forks mutants.
+
+
+Tuning what the fork server preloads
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+``forkserver_warmup`` controls how much the fork server imports before it starts
+forking workers. It only applies when ``process_isolation = "forkserver"``.
+Anything imported in the fork server is inherited by every  worker, and anything
+left out is imported in each worker.
+
+.. code-block:: toml
+
+    # pyproject.toml
+    [tool.mutmut]
+    process_isolation = "forkserver"
+    forkserver_warmup = "collect"  # "collect" (default), "import" or "none"
+
+``collect`` (default)
+    Run ``pytest --collect-only``, which imports your ``conftest.py``, your
+    plugins and your test modules. This is the right default for most projects
+    and usually the fastest.
+
+``import``
+    Import only the modules listed in ``preload_modules_file`` (one dotted
+    module name per line; blank lines and ``#`` comments are ignored, and
+    modules that fail to import are skipped). Use this when test *collection*
+    itself has side effects you do not want every worker to share, but you still
+    want your slow imports warmed up.
+
+``none``
+    Import nothing beyond what running a single test requires. This is the
+    slowest option, and the most isolated. It is mostly useful for working out
+    whether a warmup side effect is what is breaking your run.
+
+.. code-block:: toml
+
+    # pyproject.toml
+    [tool.mutmut]
+    process_isolation = "forkserver"
+    forkserver_warmup = "import"
+    preload_modules_file = "mutmut_preload.txt"
+
+If the fork server itself crashes, mutmut starts a new one and re-submits the
+mutants that were in flight, up to ``max_forkserver_restarts`` times (default
+``3``) before giving up with a ``ForkServerCrashError``:
+
+.. code-block:: toml
+
+    # pyproject.toml
+    [tool.mutmut]
+    max_forkserver_restarts = 3
+
+The fork server and its workers cannot write to the console without mangling
+mutmut's progress output, so they log to a file instead. Logging is off unless
+you ask for it with ``log_to_file`` (or ``debug``):
+
+.. code-block:: toml
+
+    # pyproject.toml
+    [tool.mutmut]
+    log_to_file = true
+    log_file_path = "mutants/mutmut-debug.log"
+
+
 Disabling mutation on specific code
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -514,6 +621,21 @@ Mutmut keeps the data of what it has done and the mutants in the `mutants/`
 directory. If you want to make sure you run a full mutmut run you can delete
 this directory to start from scratch.
 
+
+Mutation score badges
+---------------------
+
+`mutmut badge` turns `mutmut export-cicd-stats` output into `Shields endpoint JSON <https://shields.io/badges/endpoint-badge>`_:
+
+.. code-block:: console
+
+    mutmut export-cicd-stats
+    mutmut badge --output mutation-score.json
+
+.. code-block:: md
+
+    ![mutation](https://img.shields.io/endpoint?url=https://example.com/mutation-score.json)
+
 Contributing to Mutmut
 ----------------------
 

mutmut-3.8.0/pyproject.toml

@@ -0,0 +1,113 @@
+[project]
+name = "mutmut"
+version = "3.8.0"
+description = "mutation testing for Python 3"
+keywords = [
+    "mutmut",
+    "mutant",
+    "mutation",
+    "test",
+    "testing",
+]
+requires-python = ">=3.10"
+readme = "README.rst"
+license = "BSD-3-Clause"
+license-files = ["LICENSE"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Natural Language :: English",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
+]
+dependencies = [
+    "click>=8.4.2",
+    "coverage>=7.3.0",
+    "libcst>=1.9.0",
+    "pytest>=6.2.5",
+    "setproctitle>=1.3.7",
+    "textual>=1.0.0",
+    "toml>=0.10.2 ; python_full_version < '3.11'",
+]
+
+[[project.authors]]
+name = "Anders Hovmöller"
+email = "boxed@killingar.net"
+
+[project.urls]
+Homepage = "https://github.com/boxed/mutmut"
+Documentation = "https://mutmut.readthedocs.io/en/latest/"
+Repository = "https://github.com/boxed/mutmut"
+Issues = "https://github.com/boxed/mutmut/issues"
+Changelog = "https://github.com/boxed/mutmut/blob/main/HISTORY.rst"
+
+[project.scripts]
+mutmut = "mutmut.__main__:cli"
+
+[build-system]
+requires = ["uv_build>=0.12.3,<1"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+source-include = ["HISTORY.rst"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_default_fixture_loop_scope = "function"
+
+[tool.inline-snapshot]
+format-command = "ruff format --stdin-filename {filename}"
+
+[tool.ruff]
+line-length = 120
+target-version = "py310"
+extend-exclude = [
+    "docs/_themes/",
+    "docs/conf.py",
+    "e2e_projects/",
+    "tests/data/test_generation/",
+]
+
+[tool.ruff.lint]
+select = [
+    "E",
+    "F",
+    "W",
+    "B",
+    "C4",
+    "UP",
+    "I",
+]
+ignore = [
+    "E501",
+    "B007",
+    "B018",
+    "B024",
+    "B027",
+    "B028",
+    "B904",
+    "C405",
+    "C408",
+    "C416",
+    "F402",
+    "F841",
+    "UP007",
+]
+
+[tool.ruff.lint.isort]
+force-single-line = true
+
+[dependency-groups]
+dev = [
+    "inline-snapshot>=0.32.0",
+    "mypy>=2.3.1",
+    "pre-commit>=4.6.2",
+    "pyrefly>=0.59.1",
+    "pytest-asyncio>=1.0.0",
+    "ruff>=0.16.6",
+]

mutmut-3.7.0/pyproject.toml → mutmut-3.8.0/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "mutmut"
-version = "3.7.0"
+version = "3.8.0"
 description = "mutation testing for Python 3"
 keywords = ["mutmut", "mutant", "mutation", "test", "testing"]
 authors = [
@@ -21,14 +21,15 @@ classifiers = [
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
 ]
 
 dependencies = [
-    "click>=8.0.0",
+    "click>=8.4.2",
     "coverage>=7.3.0",
-    "libcst>=1.8.5",
+    "libcst>=1.9.0",
     "pytest>=6.2.5",
-    "setproctitle>=1.1.0",
+    "setproctitle>=1.3.7",
     "textual>=1.0.0",
     "toml>=0.10.2 ; python_full_version < '3.11'",
 ]
@@ -45,7 +46,7 @@ Changelog = "https://github.com/boxed/mutmut/blob/main/HISTORY.rst"
 mutmut = "mutmut.__main__:cli"
 
 [build-system]
-requires = ["uv_build>=0.9.5,<0.10.0"]
+requires = ["uv_build>=0.12.3,<1"]
 build-backend = "uv_build"
 
 [tool.uv.build-backend]
@@ -54,11 +55,11 @@ source-include = ["HISTORY.rst"]
 [dependency-groups]
 dev = [
     "inline-snapshot>=0.32.0",
-    "mypy>=1.20.1",
-    "pre-commit>=4.5.1",
+    "mypy>=2.3.1",
+    "pre-commit>=4.6.2",
     "pyrefly>=0.59.1",
     "pytest-asyncio>=1.0.0",
-    "ruff>=0.15.7",
+    "ruff>=0.16.6",
 ]
 
 [tool.pytest.ini_options]

mutmut-3.8.0/src/mutmut/__init__.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+import importlib.metadata
+import warnings
+
+from mutmut.configuration import config
+from mutmut.configuration import reset_config
+from mutmut.state import reset_state
+from mutmut.state import state
+
+__version__ = importlib.metadata.version("mutmut")
+
+
+_DEPRECATED_STATE_ATTRS = frozenset(
+    {
+        "stats_time",
+        "duration_by_test",
+        "tests_by_mangled_function_name",
+        "_stats",
+        "_covered_lines",
+        "_excluded_lines",
+    }
+)
+
+
+def __getattr__(name: str) -> object:
+    match name:
+        case "config":
+            warnings.warn(
+                "mutmut.config is deprecated as of 3.4.1, use mutmut.configuration.config() instead",
+                FutureWarning,
+                stacklevel=2,
+            )
+            return config()
+        case name if name in _DEPRECATED_STATE_ATTRS:
+            warnings.warn(
+                f"mutmut.{name} is deprecated, use mutmut.state.state().{name} instead",
+                FutureWarning,
+                stacklevel=2,
+            )
+            return getattr(state(), name)
+        case _:
+            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+def _reset_globals() -> None:
+    reset_config()
+    reset_state()