mutmut 3.1.0__tar.gz → 3.2.1__tar.gz

{mutmut-3.1.0 → mutmut-3.2.1}/AUTHORS.rst

@@ -20,3 +20,4 @@ Credits
 * Emil Stenström <emil@emilstenstrom.se>
 * Roxane Bellott <roxane.bellot@gmail.com>
 * Tomáš Chvátal <tchvatal@suse.com>
+* Frank Hoffmann <15r10nk-git@polarbit.de>

{mutmut-3.1.0 → mutmut-3.2.1}/HISTORY.rst

@@ -1,6 +1,33 @@
 Changelog
 ---------
 
+3.2.1
+~~~~~
+
+* Read `paths_to_mutate` from config file
+
+* Mutate `break` to `return` to avoid timeouts
+
+* Added debug mode. Enable with `debug=True` in `setup.cfg` under `[mutmut]`
+
+* Fixed new test detection. The old code incorrectly detected new tests when there were none, creating a much slower interaction loop for fixing mutants.
+
+* And many more fixes
+
+3.2.0
+~~~~~
+
+* Timeouts for mutants implemented.
+
+* Browser: syntax highlighting for diff view
+
+* More fixes for generators.
+
+* Fix for `src`-style layout of projects.
+
+* Fixed bug where mutmut would recollect all tests on every run, slowing down startup.
+
+
 3.1.0
 ~~~~~
 

{mutmut-3.1.0 → mutmut-3.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mutmut
-Version: 3.1.0
+Version: 3.2.1
 Summary: mutation testing for Python 3
 Home-page: https://github.com/boxed/mutmut
 Author: Anders Hovmöller
@@ -20,6 +20,7 @@ Requires-Dist: click
 Requires-Dist: junit-xml==1.8
 Requires-Dist: setproctitle
 Requires-Dist: textual
+Requires-Dist: toml>=0.10.2; python_version < "3.11"
 
 mutmut - python mutation tester
 ===============================

{mutmut-3.1.0 → mutmut-3.2.1}/mutmut/__init__.py

@@ -1,10 +1,12 @@
+from collections import defaultdict
+
 from parso.python.tree import (
     Keyword,
     Name,
     Number,
 )
 
-__version__ = '3.1.0'
+__version__ = '3.2.1'
 
 
 # We have a global whitelist for constants of the pattern __all__, __version__, etc
@@ -22,6 +24,13 @@ dunder_whitelist = [
     'copyright',
 ]
 
+duration_by_test = {}
+stats_time = None
+config = None
+
+_stats = set()
+tests_by_mangled_function_name = defaultdict(set)
+
 
 class SkipException(Exception):
     pass
@@ -156,8 +165,8 @@ def keyword_mutation(value, context, **_):
         'not': '',
         'is': 'is not',  # this will cause "is not not" sometimes, so there's a hack to fix that later
         'in': 'not in',
-        # 'break': 'continue',
-        # 'continue': 'break',
+        'break': 'return',
+        'continue': 'break',
         'True': 'False',
         'False': 'True',
     }.get(value)

{mutmut-3.1.0 → mutmut-3.2.1}/mutmut/__main__.py

@@ -5,7 +5,9 @@ import inspect
 import itertools
 import json
 import os
+import resource
 import shutil
+import signal
 import sys
 from abc import ABC
 from collections import defaultdict
@@ -25,11 +27,15 @@ from functools import lru_cache
 from hashlib import md5
 from io import TextIOBase
 from json import JSONDecodeError
+from math import ceil
 from os import (
     makedirs,
     walk,
 )
-from os.path import isdir
+from os.path import (
+    isdir,
+    isfile,
+)
 from pathlib import Path
 from signal import SIGTERM
 from textwrap import (
@@ -37,6 +43,10 @@ from textwrap import (
     indent,
 )
 from threading import Thread
+from time import (
+    process_time,
+    sleep,
+)
 from typing import (
     Dict,
     List,
@@ -47,37 +57,26 @@ from parso import (
     parse,
     ParserSyntaxError,
 )
+from rich.text import Text
 from setproctitle import setproctitle
 
 import mutmut
 
-mutmut.duration_by_test = {}
-
 # Document: surviving mutants are retested when you ask mutmut to retest them, interactively in the UI or via command line
 
-# TODO: only count a test for a function if the stack depth to get to the test < some configurable limit.
-
-# TODO: collect tests always: first run we collect to update the known list of tests, then we run pytest with that list for stats
-#           - when we run again, we ask for all tests, check which are new and which are gone and update by running stats collection for just these
 # TODO: pragma no mutate should end up in `skipped` category
 # TODO: hash of function. If hash changes, retest all mutants as mutant IDs are not stable
-# TODO: exclude mutating static typing
-# TODO: implement timeout
-
-# TODO: don't remove arguments to `isinstance`, as that will always fail. Same with `len`
 
 
 NEVER_MUTATE_FUNCTION_NAMES = {'__getattribute__', '__setattr__'}
 NEVER_MUTATE_FUNCTION_CALLS = {'isinstance', 'len'}
 CLASS_NAME_SEPARATOR = 'ǁ'
 
-mutmut._stats = set()
-mutmut.tests_by_mangled_function_name = defaultdict(set)
-
 
 status_by_exit_code = {
     1: 'killed',
     3: 'killed',  # internal error in pytest means a kill
+    -24: 'killed',
     0: 'survived',
     5: 'no tests',
     2: 'check was interrupted by user',
@@ -86,6 +85,9 @@ status_by_exit_code = {
     34: 'skipped',
     35: 'suspicious',
     36: 'timeout',
+    24: 'timeout',  # SIGXCPU
+    152: 'timeout',  # SIGXCPU
+    255: 'timeout',
 }
 
 emoji_by_status = {
@@ -112,23 +114,24 @@ def guess_paths_to_mutate():
     """
     this_dir = os.getcwd().split(os.sep)[-1]
     if isdir('lib'):
-        return 'lib'
+        return ['lib']
     elif isdir('src'):
-        return 'src'
+        return ['src']
     elif isdir(this_dir):
-        return this_dir
+        return [this_dir]
     elif isdir(this_dir.replace('-', '_')):
-        return this_dir.replace('-', '_')
+        return [this_dir.replace('-', '_')]
     elif isdir(this_dir.replace(' ', '_')):
-        return this_dir.replace(' ', '_')
+        return [this_dir.replace(' ', '_')]
     elif isdir(this_dir.replace('-', '')):
-        return this_dir.replace('-', '')
+        return [this_dir.replace('-', '')]
     elif isdir(this_dir.replace(' ', '')):
-        return this_dir.replace(' ', '')
+        return [this_dir.replace(' ', '')]
+    if isfile(this_dir + '.py'):
+        return [this_dir + '.py']
     raise FileNotFoundError(
         'Could not figure out where the code to mutate is. '
-        'Please specify it on the command line using --paths-to-mutate, '
-        'or by adding "paths_to_mutate=code_dir" in setup.cfg to the [mutmut] section.')
+        'Please specify it by adding "paths_to_mutate=code_dir" in setup.cfg to the [mutmut] section.')
 
 
 def record_trampoline_hit(name):
@@ -148,8 +151,7 @@ def record_trampoline_hit(name):
 
 
 def walk_all_files():
-    paths = [guess_paths_to_mutate()]
-    for path in paths:
+    for path in mutmut.config.paths_to_mutate:
         for root, dirs, files in walk(path):
             for filename in files:
                 yield root, filename
@@ -176,6 +178,8 @@ class CollectTestsFailedException(Exception):
 class BadTestExecutionCommandsException(Exception):
     pass
 
+
+# noinspection PyUnresolvedReferences
 # language=python
 trampoline_impl = """
 from inspect import signature as _mutmut_signature
@@ -189,22 +193,23 @@ def _mutmut_trampoline(orig, mutants, *args, **kwargs):
     elif mutant_under_test == 'stats':
         from mutmut.__main__ import record_trampoline_hit
         record_trampoline_hit(orig.__module__ + '.' + orig.__name__)
-        ret orig(*args, **kwargs)
-        return  # for the yield case
+        result = orig(*args, **kwargs)
+        return result  # for the yield case
     prefix = orig.__module__ + '.' + orig.__name__ + '__mutmut_'
     if not mutant_under_test.startswith(prefix):
-        ret orig(*args, **kwargs)
-        return  # for the yield case
+        result = orig(*args, **kwargs)
+        return result  # for the yield case
     mutant_name = mutant_under_test.rpartition('.')[-1]
-    ret mutants[mutant_name](*args, **kwargs)
+    result = mutants[mutant_name](*args, **kwargs)
+    return result
 
 """
-yield_from_trampoline_impl = trampoline_impl.replace('ret ', 'yield from ').replace('_mutmut_trampoline', '_mutmut_yield_from_trampoline')
-trampoline_impl = trampoline_impl.replace('ret ', 'return ')
+yield_from_trampoline_impl = trampoline_impl.replace('result = ', 'result = yield from ').replace('_mutmut_trampoline', '_mutmut_yield_from_trampoline')
 
 
 def create_mutants():
     for path in walk_source_files():
+        print(path)
         output_path = Path('mutants') / path
         makedirs(output_path.parent, exist_ok=True)
 
@@ -217,6 +222,7 @@ def create_mutants():
 def copy_also_copy_files():
     assert isinstance(mutmut.config.also_copy, list)
     for path in mutmut.config.also_copy:
+        print('     also copying', path)
         path = Path(path)
         destination = Path('mutants') / path
         if not path.exists():
@@ -257,7 +263,8 @@ def create_mutants_for_file(filename, output_path):
             exit(1)
 
     source_file_mutation_data = SourceFileMutationData(path=filename)
-    module_name = str(filename)[:-len(filename.suffix)].replace(os.sep, '.')
+    module_name = strip_prefix(str(filename)[:-len(filename.suffix)].replace(os.sep, '.'), prefix='src.')
+
     source_file_mutation_data.exit_code_by_key = {
          '.'.join([module_name, x]).replace('.__init__.', '.'): None
         for x in mutant_names
@@ -314,17 +321,18 @@ def build_trampoline(*, orig_name, mutants, class_name, is_generator):
         access_suffix = '")'
 
     if is_generator:
-        return_or_yield_statement = 'yield from'
+        yield_statement = 'yield from '  # note the space at the end!
         trampoline_name = '_mutmut_yield_from_trampoline'
     else:
-        return_or_yield_statement = 'return'
+        yield_statement = ''
         trampoline_name = '_mutmut_trampoline'
 
     return f"""
 {mutants_dict}
 
 def {orig_name}({'self, ' if class_name is not None else ''}*args, **kwargs):
-    {return_or_yield_statement} {trampoline_name}({access_prefix}{mangled_name}__mutmut_orig{access_suffix}, {access_prefix}{mangled_name}__mutmut_mutants{access_suffix}, *args, **kwargs) 
+    result = {yield_statement}{trampoline_name}({access_prefix}{mangled_name}__mutmut_orig{access_suffix}, {access_prefix}{mangled_name}__mutmut_mutants{access_suffix}, *args, **kwargs)
+    return result 
 
 {orig_name}.__signature__ = _mutmut_signature({mangled_name}__mutmut_orig)
 {mangled_name}__mutmut_orig.__name__ = '{mangled_name}'
@@ -574,6 +582,7 @@ def yield_mutants_for_module(node, no_mutate_lines):
 
 class SourceFileMutationData:
     def __init__(self, *, path):
+        self.estimated_time_of_tests_by_mutant = {}
         self.path = path
         self.meta_path = Path('mutants') / (str(path) + '.meta')
         self.meta = None
@@ -581,6 +590,7 @@ class SourceFileMutationData:
         self.exit_code_by_key = {}
         self.hash_by_function_name = {}
         self.start_time_by_pid = {}
+        self.estimated_time_of_tests_by_pid = {}
 
     def load(self):
         try:
@@ -593,13 +603,14 @@ class SourceFileMutationData:
         self.hash_by_function_name = self.meta.pop('hash_by_function_name')
         assert not self.meta, self.meta  # We should read all the data!
 
-    def register_pid(self, *, pid, key):
+    def register_pid(self, *, pid, key, estimated_time_of_tests):
         self.key_by_pid[pid] = key
         self.start_time_by_pid[pid] = datetime.now()
+        self.estimated_time_of_tests_by_pid[pid] = estimated_time_of_tests
 
     def register_result(self, *, pid, exit_code):
         assert self.key_by_pid[pid] in self.exit_code_by_key
-        self.exit_code_by_key[self.key_by_pid[pid]] = (0xFF00 & exit_code) >> 8  # The high byte contains the exit code
+        self.exit_code_by_key[self.key_by_pid[pid]] = exit_code
         # TODO: maybe rate limit this? Saving on each result can slow down mutation testing a lot if the test run is fast.
         del self.key_by_pid[pid]
         del self.start_time_by_pid[pid]
@@ -655,46 +666,55 @@ def change_cwd(path):
         os.chdir(old_cwd)
 
 
+def collected_test_names():
+    return set(mutmut.duration_by_test.keys())
+
+
 class ListAllTestsResult:
     def __init__(self, *, ids):
         assert isinstance(ids, set)
         self.ids = ids
 
-    @staticmethod
-    def old_tests():
-        return {
-            test_name
-            for _, test_names in mutmut.tests_by_mangled_function_name.items()
-            for test_name in test_names
-        }
-
     def clear_out_obsolete_test_names(self):
-        mutmut.tests_by_mangled_function_name = {
-            k: {test_name for test_name in test_names if test_name not in self.ids}
+        count_before = sum(len(x) for x in mutmut.tests_by_mangled_function_name)
+        mutmut.tests_by_mangled_function_name = defaultdict(set, **{
+            k: {test_name for test_name in test_names if test_name in self.ids}
             for k, test_names in mutmut.tests_by_mangled_function_name.items()
-        }
-        save_stats()
+        })
+        count_after = sum(len(x) for x in mutmut.tests_by_mangled_function_name)
+        if count_before != count_after:
+            print(f'Removed {count_before - count_after} obsolete test names')
+            save_stats()
 
     def new_tests(self):
-        return self.ids - self.old_tests()
+        return self.ids - collected_test_names()
 
 
 class PytestRunner(TestRunner):
+    # noinspection PyMethodMayBeStatic
     def execute_pytest(self, params, **kwargs):
         import pytest
+        params += ['--rootdir=.']
+        if mutmut.config.debug:
+            params = ['-vv'] + params
+            print('python -m pytest ', ' '.join(params))
         exit_code = int(pytest.main(params, **kwargs))
+        if mutmut.config.debug:
+            print('    exit code', exit_code)
         if exit_code == 4:
             raise BadTestExecutionCommandsException(params)
         return exit_code
 
     def run_stats(self, *, tests):
         class StatsCollector:
+            # noinspection PyMethodMayBeStatic
             def pytest_runtest_teardown(self, item, nextitem):
                 unused(nextitem)
                 for function in mutmut._stats:
                     mutmut.tests_by_mangled_function_name[function].add(strip_prefix(item._nodeid, prefix='mutants/'))
                 mutmut._stats.clear()
 
+            # noinspection PyMethodMayBeStatic
             def pytest_runtest_makereport(self, item, call):
                 mutmut.duration_by_test[item.nodeid] = call.duration
 
@@ -732,7 +752,7 @@ class HammettRunner(TestRunner):
 
     def run_stats(self, *, tests):
         import hammett
-        print('running hammett stats...')
+        print('Running hammett stats...')
 
         def post_test_callback(_name, **_):
             for function in mutmut._stats:
@@ -763,7 +783,6 @@ class HammettRunner(TestRunner):
 
 def mangle_function_name(*, name, class_name):
     assert CLASS_NAME_SEPARATOR not in name
-    prefix = ''
     if class_name:
         assert CLASS_NAME_SEPARATOR not in class_name
         prefix = f'x{CLASS_NAME_SEPARATOR}{class_name}{CLASS_NAME_SEPARATOR}'
@@ -779,12 +798,13 @@ def mangled_name_from_mutant_name(mutant_name):
 
 def orig_function_and_class_names_from_key(mutant_name):
     r = mangled_name_from_mutant_name(mutant_name)
+    _, _, r = r.rpartition('.')
     class_name = None
     if CLASS_NAME_SEPARATOR in r:
         class_name = r[r.index(CLASS_NAME_SEPARATOR) + 1: r.rindex(CLASS_NAME_SEPARATOR)]
         r = r[r.rindex(CLASS_NAME_SEPARATOR) + 1:]
     else:
-        assert r.startswith('x_')
+        assert r.startswith('x_'), r
         r = r[2:]
     return r, class_name
 
@@ -837,6 +857,7 @@ def collect_stat(m: SourceFileMutationData):
         for k in status_by_exit_code.values()
     }
     for k, v in m.exit_code_by_key.items():
+        # noinspection PyTypeChecker
         r[status_by_exit_code[v].replace(' ', '_')] += 1
     return Stat(
         **r,
@@ -866,11 +887,10 @@ def print_stats(source_file_mutation_data_by_path, force_output=False):
 
 def run_forced_fail(runner):
     os.environ['MUTANT_UNDER_TEST'] = 'fail'
-    with CatchOutput(show_spinner=True, spinner_title='running forced fail test') as catcher:
+    with CatchOutput(spinner_title='Running forced fail test') as catcher:
         try:
             if runner.run_forced_fail() == 0:
-                catcher.stop()
-                print('\n'.join(catcher.strings))
+                catcher.dump_output()
                 print("FAILED")
                 os._exit(1)
         except MutmutProgrammaticFailException:
@@ -880,9 +900,8 @@ def run_forced_fail(runner):
 
 
 class CatchOutput:
-    def __init__(self, callback=lambda s: None, show_spinner=False, spinner_title=None):
+    def __init__(self, callback=lambda s: None, spinner_title=None):
         self.strings = []
-        self.show_spinner = show_spinner
         self.spinner_title = spinner_title or ''
 
         class StdOutRedirect(TextIOBase):
@@ -891,24 +910,29 @@ class CatchOutput:
 
             def write(self, s):
                 callback(s)
-                if show_spinner:
+                if spinner_title:
                     print_status(spinner_title)
                 self.catcher.strings.append(s)
                 return len(s)
         self.redirect = StdOutRedirect(self)
 
+    # noinspection PyMethodMayBeStatic
     def stop(self):
         sys.stdout = sys.__stdout__
         sys.stderr = sys.__stderr__
 
     def start(self):
+        if self.spinner_title:
+            print_status(self.spinner_title)
         sys.stdout = self.redirect
         sys.stderr = self.redirect
+        if mutmut.config.debug:
+            self.stop()
 
     def dump_output(self):
         self.stop()
-        for l in self.strings:
-             print(l, end='')
+        for line in self.strings:
+            print(line, end='')
 
     def __enter__(self):
         self.start()
@@ -916,7 +940,7 @@ class CatchOutput:
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         self.stop()
-        if self.show_spinner:
+        if self.spinner_title:
             print()
 
 
@@ -925,6 +949,8 @@ class Config:
     also_copy: List[Path]
     do_not_mutate: List[str]
     max_stack_depth: int
+    debug: bool
+    paths_to_mutate: List[Path]
 
     def should_ignore_for_mutation(self, path):
         if not str(path).endswith('.py'):
@@ -935,36 +961,67 @@ class Config:
         return False
 
 
-@lru_cache()
-def read_config():
+def config_reader():
+    path = Path('pyproject.toml')
+    if path.exists():
+        if sys.version_info >= (3, 11):
+            from tomllib import loads
+        else:
+            # noinspection PyPackageRequirements
+            from toml import loads
+        data = loads(path.read_text('utf-8'))
+
+        try:
+            config = data['tool']['mutmut']
+        except KeyError:
+            pass
+        else:
+            def s(key, default):
+                try:
+                    result = config[key]
+                except KeyError:
+                    return default
+                return result
+            return s
+
     config_parser = ConfigParser()
     config_parser.read('setup.cfg')
 
     def s(key, default):
         try:
-            return config_parser.get('mutmut', key)
+            result = config_parser.get('mutmut', key)
         except (NoOptionError, NoSectionError):
             return default
+        if isinstance(default, list):
+            result = [x for x in result.split("\n") if x]
+        elif isinstance(default, bool):
+            result = result.lower() in ('1', 't', 'true')
+        elif isinstance(default, int):
+            result = int(result)
+        return result
+    return s
+
+
+@lru_cache()
+def read_config():
+    s = config_reader()
 
     mutmut.config = Config(
-        do_not_mutate=[
-            x
-            for x in s('do_not_mutate', '').split('\n')
-            if x
-        ],
+        do_not_mutate=s('do_not_mutate', []),
         also_copy=[
             Path(y)
-            for y in [
-                x
-                for x in s('also_copy', '').split('\n')
-                if x
-            ]
+            for y in s('also_copy', [])
         ]+[
             Path('tests/'),
             Path('test/'),
             Path('tests.py'),
         ],
-        max_stack_depth=int(s('max_stack_depth', '-1'))
+        max_stack_depth=s('max_stack_depth', -1),
+        debug=s('debug', False),
+        paths_to_mutate=[
+            Path(y)
+            for y in s('paths_to_mutate', [])
+        ] or guess_paths_to_mutate()
     )
 
 
@@ -979,7 +1036,9 @@ def run_stats_collection(runner, tests=None):
 
     os.environ['MUTANT_UNDER_TEST'] = 'stats'
     os.environ['PY_IGNORE_IMPORTMISMATCH'] = '1'
-    with CatchOutput(show_spinner=True, spinner_title='running stats') as output_catcher:
+    start_cpu_time = process_time()
+
+    with CatchOutput(spinner_title='Running stats') as output_catcher:
         collect_stats_exit_code = runner.run_stats(tests=tests)
         if collect_stats_exit_code != 0:
             output_catcher.dump_output()
@@ -987,8 +1046,10 @@ def run_stats_collection(runner, tests=None):
             exit(1)
 
     print('    done')
+    if not tests:  # again, meaning all
+        mutmut.stats_time = process_time() - start_cpu_time
 
-    if not mutmut.tests_by_mangled_function_name:
+    if not collected_test_names():
         print('failed to collect stats, no active tests found')
         exit(1)
 
@@ -1003,7 +1064,7 @@ def collect_or_load_stats(runner):
         run_stats_collection(runner)
     else:
         # Run incremental stats
-        with CatchOutput(show_spinner=True, spinner_title='collecting stats') as output_catcher:
+        with CatchOutput(spinner_title='Listing all tests') as output_catcher:
             os.environ['MUTANT_UNDER_TEST'] = 'list_all_tests'
             try:
                 all_tests_result = runner.list_all_tests()
@@ -1017,6 +1078,7 @@ def collect_or_load_stats(runner):
         new_tests = all_tests_result.new_tests()
 
         if new_tests:
+            print(f'Found {len(new_tests)} new tests, rerunning stats collection')
             run_stats_collection(runner, tests=new_tests)
 
 
@@ -1028,6 +1090,7 @@ def load_stats():
             for k, v in data.pop('tests_by_mangled_function_name').items():
                 mutmut.tests_by_mangled_function_name[k] |= set(v)
             mutmut.duration_by_test = data.pop('duration_by_test')
+            mutmut.stats_time = data.pop('stats_time')
             assert not data, data
             did_load = True
     except (FileNotFoundError, JSONDecodeError):
@@ -1040,6 +1103,7 @@ def save_stats():
         json.dump(dict(
             tests_by_mangled_function_name={k: list(v) for k, v in mutmut.tests_by_mangled_function_name.items()},
             duration_by_test=mutmut.duration_by_test,
+            stats_time=mutmut.stats_time,
         ), f, indent=4)
 
 
@@ -1118,6 +1182,23 @@ def stop_all_children(mutants):
         m.stop_children()
 
 
+def timeout_checker(mutants):
+    def inner_timout_checker():
+        while True:
+            sleep(1)
+
+            now = datetime.now()
+            for m, mutant_name, result in mutants:
+                for pid, start_time in m.start_time_by_pid.items():
+                    run_time = now - start_time
+                    if run_time.total_seconds() > (m.estimated_time_of_tests_by_mutant[mutant_name] + 1) * 4:
+                        try:
+                            os.kill(pid, signal.SIGXCPU)
+                        except ProcessLookupError:
+                            pass
+    return inner_timout_checker
+
+
 @cli.command()
 @click.option('--max-children', type=int)
 @click.argument('mutant_names', required=False, nargs=-1)
@@ -1126,13 +1207,15 @@ def run(mutant_names, *, max_children):
 
     # TODO: run no-ops once in a while to detect if we get false negatives
     # TODO: we should be able to get information on which tests killed mutants, which means we can get a list of tests and how many mutants each test kills. Those that kill zero mutants are redundant!
-
-    start = datetime.now()
-    print('generating mutants')
     os.environ['MUTANT_UNDER_TEST'] = 'mutant_generation'
     read_config()
-    create_mutants()
-    copy_also_copy_files()
+
+    start = datetime.now()
+    makedirs(Path('mutants'), exist_ok=True)
+    with CatchOutput(spinner_title='Generating mutants'):
+        create_mutants()
+        copy_also_copy_files()
+
     time = datetime.now() - start
     print(f'    done in {round(time.total_seconds()*1000)}ms', )
 
@@ -1157,13 +1240,13 @@ def run(mutant_names, *, max_children):
     mutants, source_file_mutation_data_by_path = collect_source_file_mutation_data(mutant_names=mutant_names)
 
     os.environ['MUTANT_UNDER_TEST'] = ''
-    with CatchOutput(show_spinner=True, spinner_title='running clean tests') as output_catcher:
+    with CatchOutput(spinner_title='Running clean tests') as output_catcher:
         tests = tests_for_mutant_names(mutant_names)
 
         clean_test_exit_code = runner.run_tests(mutant_name=None, tests=tests)
         if clean_test_exit_code != 0:
             output_catcher.dump_output()
-            print('failed to run clean test')
+            print('Failed to run clean test')
             exit(1)
     print('    done')
 
@@ -1173,7 +1256,10 @@ def run(mutant_names, *, max_children):
     runner.prepare_main_test_run()
 
     def read_one_child_exit_status():
-        pid, exit_code = os.wait()
+        pid, wait_status = os.wait()
+        exit_code = os.waitstatus_to_exitcode(wait_status)
+        if mutmut.config.debug:
+            print('    worker exit code', exit_code)
         source_file_mutation_data_by_pid[pid].register_result(pid=pid, exit_code=exit_code)
 
     source_file_mutation_data_by_pid: Dict[int, SourceFileMutationData] = {}  # many pids map to one MutationData
@@ -1192,6 +1278,16 @@ def run(mutant_names, *, max_children):
     try:
         print('Running mutation testing')
 
+        # Calculate times of tests
+        for m, mutant_name, result in mutants:
+            mutant_name = mutant_name.replace('__init__.', '')
+            tests = mutmut.tests_by_mangled_function_name.get(mangled_name_from_mutant_name(mutant_name), [])
+            estimated_time_of_tests = sum(mutmut.duration_by_test[test_name] for test_name in tests)
+            m.estimated_time_of_tests_by_mutant[mutant_name] = estimated_time_of_tests
+
+        Thread(target=timeout_checker(mutants), daemon=True).start()
+
+        # Now do mutation
         for m, mutant_name, result in mutants:
             print_stats(source_file_mutation_data_by_path)
 
@@ -1220,6 +1316,10 @@ def run(mutant_names, *, max_children):
                 if not tests:
                     os._exit(33)
 
+                estimated_time_of_tests = m.estimated_time_of_tests_by_mutant[mutant_name]
+                cpu_time_limit = ceil((estimated_time_of_tests + 1) * 2 + process_time()) * 10
+                resource.setrlimit(resource.RLIMIT_CPU, (cpu_time_limit, cpu_time_limit))
+
                 with CatchOutput():
                     result = runner.run_tests(mutant_name=mutant_name, tests=tests)
 
@@ -1230,7 +1330,7 @@ def run(mutant_names, *, max_children):
             else:
                 # in the parent
                 source_file_mutation_data_by_pid[pid] = m
-                m.register_pid(pid=pid, key=mutant_name)
+                m.register_pid(pid=pid, key=mutant_name, estimated_time_of_tests=estimated_time_of_tests)
                 running_children += 1
 
             if running_children >= max_children:
@@ -1246,7 +1346,7 @@ def run(mutant_names, *, max_children):
         except ChildProcessError:
             pass
     except KeyboardInterrupt:
-        print('stopping')
+        print('Stopping...')
         stop_all_children(mutants)
 
     t = datetime.now() - start
@@ -1427,7 +1527,9 @@ def browse():
     from textual.containers import Container
     from textual.widgets import Footer
     from textual.widgets import DataTable
-    from textual.widgets import TextArea
+    from textual.widgets import Static
+    from textual.widget import Widget
+    from rich.syntax import Syntax
 
     class ResultBrowser(App):
         loading_id = None
@@ -1443,7 +1545,7 @@ def browse():
         columns = [
             ('path', 'Path'),
         ] + [
-            (status, emoji)
+            (status, Text(emoji, justify='right'))
             for status, emoji in emoji_by_status.items()
         ]
 
@@ -1454,17 +1556,20 @@ def browse():
             with Container(classes='container'):
                 yield DataTable(id='files')
                 yield DataTable(id='mutants')
-            yield TextArea(id='diff_view')
+            with Widget(id="diff_view_widget"):
+                yield Static(id='diff_view')
             yield Footer()
 
         def on_mount(self):
             # files table
+            # noinspection PyTypeChecker
             files_table: DataTable = self.query_one('#files')
             files_table.cursor_type = 'row'
             for key, label in self.columns:
                 files_table.add_column(key=key, label=label)
 
             # mutants table
+            # noinspection PyTypeChecker
             mutants_table: DataTable = self.query_one('#mutants')
             mutants_table.cursor_type = 'row'
             mutants_table.add_columns('name', 'status')
@@ -1483,17 +1588,21 @@ def browse():
                 source_file_mutation_data.load()
                 stat = collect_stat(source_file_mutation_data)
 
-                self.source_file_mutation_data_and_stat_by_path[p] = source_file_mutation_data, stat
+                self.source_file_mutation_data_and_stat_by_path[str(p)] = source_file_mutation_data, stat
 
         def populate_files_table(self):
+            # noinspection PyTypeChecker
             files_table: DataTable = self.query_one('#files')
             # TODO: restore selection
             selected_row = files_table.cursor_row
             files_table.clear()
 
             for p, (source_file_mutation_data, stat) in sorted(self.source_file_mutation_data_and_stat_by_path.items()):
-                row = [p] + [getattr(stat, k.replace(' ', '_')) for k, _ in self.columns[1:]]
-                files_table.add_row(*row, key=p)
+                row = [p] + [
+                    Text(str(getattr(stat, k.replace(' ', '_'))), justify="right")
+                    for k, _ in self.columns[1:]
+                ]
+                files_table.add_row(*row, key=str(p))
 
             files_table.move_cursor(row=selected_row)
 
@@ -1501,6 +1610,7 @@ def browse():
             if not event.row_key or not event.row_key.value:
                 return
             if event.data_table.id == 'files':
+                # noinspection PyTypeChecker
                 mutants_table: DataTable = self.query_one('#mutants')
                 mutants_table.clear()
                 source_file_mutation_data, stat = self.source_file_mutation_data_and_stat_by_path[event.row_key.value]
@@ -1511,11 +1621,12 @@ def browse():
                     mutants_table.add_row(k, emoji_by_status[status], key=k)
             else:
                 assert event.data_table.id == 'mutants'
-                diff_view = self.query_one('#diff_view')
+                # noinspection PyTypeChecker
+                diff_view: Static = self.query_one('#diff_view')
                 if event.row_key.value is None:
-                    diff_view.text = ''
+                    diff_view.update('')
                 else:
-                    diff_view.text = '<loading...>'
+                    diff_view.update('<loading...>')
                     self.loading_id = event.row_key.value
 
                     def load_thread():
@@ -1523,9 +1634,9 @@ def browse():
                         try:
                             d = get_diff_for_mutant(event.row_key.value)
                             if event.row_key.value == self.loading_id:
-                                diff_view.text = d
+                                diff_view.update(Syntax(d, "diff"))
                         except Exception as e:
-                            diff_view.text = f'<{e}>'
+                            diff_view.update(f"<{type(e)} {e}>")
 
                     t = Thread(target=load_thread)
                     t.start()
@@ -1541,6 +1652,7 @@ def browse():
             self.populate_files_table()
 
         def get_mutant_name_from_selection(self):
+            # noinspection PyTypeChecker
             mutants_table: DataTable = self.query_one('#mutants')
             if mutants_table.cursor_row is None:
                 return
@@ -1558,6 +1670,7 @@ def browse():
 
         def action_apply_mutant(self):
             read_config()
+            # noinspection PyTypeChecker
             mutants_table: DataTable = self.query_one('#mutants')
             if mutants_table.cursor_row is None:
                 return

{mutmut-3.1.0 → mutmut-3.2.1}/mutmut/result_browser_layout.tcss

@@ -24,3 +24,11 @@ DataTable:focus .datatable--cursor {
     color: black;
     background: orange;
 }
+
+#diff_view_widget {
+    height: 50%;
+    overflow-y: scroll;
+}
+
+#diff_view {
+}

{mutmut-3.1.0 → mutmut-3.2.1}/mutmut.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mutmut
-Version: 3.1.0
+Version: 3.2.1
 Summary: mutation testing for Python 3
 Home-page: https://github.com/boxed/mutmut
 Author: Anders Hovmöller
@@ -20,6 +20,7 @@ Requires-Dist: click
 Requires-Dist: junit-xml==1.8
 Requires-Dist: setproctitle
 Requires-Dist: textual
+Requires-Dist: toml>=0.10.2; python_version < "3.11"
 
 mutmut - python mutation tester
 ===============================

{mutmut-3.1.0 → mutmut-3.2.1}/mutmut.egg-info/requires.txt

@@ -3,3 +3,6 @@ click
 junit-xml==1.8
 setproctitle
 textual
+
+[:python_version < "3.11"]
+toml>=0.10.2

{mutmut-3.1.0 → mutmut-3.2.1}/requirements.txt

@@ -3,3 +3,4 @@ click
 junit-xml==1.8
 setproctitle
 textual
+toml>=0.10.2; python_version < '3.11'