updates

Backend/venv/lib/python3.12/site-packages/pytest_cov/__init__.py

@@ -0,0 +1,41 @@
+"""pytest-cov: avoid already-imported warning: PYTEST_DONT_REWRITE."""
+
+__version__ = '7.0.0'
+
+import pytest
+
+
+class CoverageError(Exception):
+    """Indicates that our coverage is too low"""
+
+
+class PytestCovWarning(pytest.PytestWarning):
+    """
+    The base for all pytest-cov warnings, never raised directly.
+    """
+
+
+class CovDisabledWarning(PytestCovWarning):
+    """
+    Indicates that Coverage was manually disabled.
+    """
+
+
+class CovReportWarning(PytestCovWarning):
+    """
+    Indicates that we failed to generate a report.
+    """
+
+
+class CentralCovContextWarning(PytestCovWarning):
+    """
+    Indicates that dynamic_context was set to test_function instead of using the builtin --cov-context.
+    """
+
+
+class DistCovError(Exception):
+    """
+    Raised when dynamic_context is set to test_function and xdist is also used.
+
+    See: https://github.com/pytest-dev/pytest-cov/issues/604
+    """

Backend/venv/lib/python3.12/site-packages/pytest_cov/engine.py

@@ -0,0 +1,460 @@
+"""Coverage controllers for use by pytest-cov and nose-cov."""
+
+import argparse
+import contextlib
+import copy
+import functools
+import os
+import random
+import shutil
+import socket
+import sys
+import warnings
+from pathlib import Path
+from typing import Union
+
+import coverage
+from coverage.data import CoverageData
+from coverage.sqldata import filename_suffix
+
+from . import CentralCovContextWarning
+from . import DistCovError
+
+
+class BrokenCovConfigError(Exception):
+    pass
+
+
+class _NullFile:
+    @staticmethod
+    def write(v):
+        pass
+
+
+@contextlib.contextmanager
+def _backup(obj, attr):
+    backup = getattr(obj, attr)
+    try:
+        setattr(obj, attr, copy.copy(backup))
+        yield
+    finally:
+        setattr(obj, attr, backup)
+
+
+def _ensure_topdir(meth):
+    @functools.wraps(meth)
+    def ensure_topdir_wrapper(self, *args, **kwargs):
+        try:
+            original_cwd = Path.cwd()
+        except OSError:
+            # Looks like it's gone, this is non-ideal because a side-effect will
+            # be introduced in the tests here but we can't do anything about it.
+            original_cwd = None
+        os.chdir(self.topdir)
+        try:
+            return meth(self, *args, **kwargs)
+        finally:
+            if original_cwd is not None:
+                os.chdir(original_cwd)
+
+    return ensure_topdir_wrapper
+
+
+class CovController:
+    """Base class for different plugin implementations."""
+
+    def __init__(self, options: argparse.Namespace, config: Union[None, object], nodeid: Union[None, str]):
+        """Get some common config used by multiple derived classes."""
+        self.cov_source = options.cov_source
+        self.cov_report = options.cov_report
+        self.cov_config = options.cov_config
+        self.cov_append = options.cov_append
+        self.cov_branch = options.cov_branch
+        self.cov_precision = options.cov_precision
+        self.config = config
+        self.nodeid = nodeid
+
+        self.cov = None
+        self.combining_cov = None
+        self.data_file = None
+        self.node_descs = set()
+        self.failed_workers = []
+        self.topdir = os.fspath(Path.cwd())
+        self.is_collocated = None
+        self.started = False
+
+    @contextlib.contextmanager
+    def ensure_topdir(self):
+        original_cwd = Path.cwd()
+        os.chdir(self.topdir)
+        yield
+        os.chdir(original_cwd)
+
+    @_ensure_topdir
+    def pause(self):
+        self.started = False
+        self.cov.stop()
+
+    @_ensure_topdir
+    def resume(self):
+        self.cov.start()
+        self.started = True
+
+    def start(self):
+        self.started = True
+
+    def finish(self):
+        self.started = False
+
+    @staticmethod
+    def get_node_desc(platform, version_info):
+        """Return a description of this node."""
+
+        return 'platform {}, python {}'.format(platform, '{}.{}.{}-{}-{}'.format(*version_info[:5]))
+
+    @staticmethod
+    def get_width():
+        # taken from https://github.com/pytest-dev/pytest/blob/33c7b05a/src/_pytest/_io/terminalwriter.py#L26
+        width, _ = shutil.get_terminal_size(fallback=(80, 24))
+        # The Windows get_terminal_size may be bogus, let's sanify a bit.
+        if width < 40:
+            width = 80
+        return width
+
+    def sep(self, stream, s, txt):
+        if hasattr(stream, 'sep'):
+            stream.sep(s, txt)
+        else:
+            fullwidth = self.get_width()
+            # taken from https://github.com/pytest-dev/pytest/blob/33c7b05a/src/_pytest/_io/terminalwriter.py#L126
+            # The goal is to have the line be as long as possible
+            # under the condition that len(line) <= fullwidth.
+            if sys.platform == 'win32':
+                # If we print in the last column on windows we are on a
+                # new line but there is no way to verify/neutralize this
+                # (we may not know the exact line width).
+                # So let's be defensive to avoid empty lines in the output.
+                fullwidth -= 1
+            N = max((fullwidth - len(txt) - 2) // (2 * len(s)), 1)
+            fill = s * N
+            line = f'{fill} {txt} {fill}'
+            # In some situations there is room for an extra sepchar at the right,
+            # in particular if we consider that with a sepchar like "_ " the
+            # trailing space is not important at the end of the line.
+            if len(line) + len(s.rstrip()) <= fullwidth:
+                line += s.rstrip()
+            # (end of terminalwriter borrowed code)
+            line += '\n\n'
+            stream.write(line)
+
+    @_ensure_topdir
+    def summary(self, stream):
+        """Produce coverage reports."""
+        total = None
+
+        if not self.cov_report:
+            with _backup(self.cov, 'config'):
+                return self.cov.report(show_missing=True, ignore_errors=True, file=_NullFile)
+
+        # Output coverage section header.
+        if len(self.node_descs) == 1:
+            self.sep(stream, '_', f'coverage: {"".join(self.node_descs)}')
+        else:
+            self.sep(stream, '_', 'coverage')
+            for node_desc in sorted(self.node_descs):
+                self.sep(stream, ' ', f'{node_desc}')
+
+        # Report on any failed workers.
+        if self.failed_workers:
+            self.sep(stream, '_', 'coverage: failed workers')
+            stream.write('The following workers failed to return coverage data, ensure that pytest-cov is installed on these workers.\n')
+            for node in self.failed_workers:
+                stream.write(f'{node.gateway.id}\n')
+
+        # Produce terminal report if wanted.
+        if any(x in self.cov_report for x in ['term', 'term-missing']):
+            options = {
+                'show_missing': ('term-missing' in self.cov_report) or None,
+                'ignore_errors': True,
+                'file': stream,
+                'precision': self.cov_precision,
+            }
+            skip_covered = isinstance(self.cov_report, dict) and 'skip-covered' in self.cov_report.values()
+            options.update({'skip_covered': skip_covered or None})
+            with _backup(self.cov, 'config'):
+                total = self.cov.report(**options)
+
+        # Produce annotated source code report if wanted.
+        if 'annotate' in self.cov_report:
+            annotate_dir = self.cov_report['annotate']
+
+            with _backup(self.cov, 'config'):
+                self.cov.annotate(ignore_errors=True, directory=annotate_dir)
+            # We need to call Coverage.report here, just to get the total
+            # Coverage.annotate don't return any total and we need it for --cov-fail-under.
+
+            with _backup(self.cov, 'config'):
+                total = self.cov.report(ignore_errors=True, file=_NullFile)
+            if annotate_dir:
+                stream.write(f'Coverage annotated source written to dir {annotate_dir}\n')
+            else:
+                stream.write('Coverage annotated source written next to source\n')
+
+        # Produce html report if wanted.
+        if 'html' in self.cov_report:
+            output = self.cov_report['html']
+            with _backup(self.cov, 'config'):
+                total = self.cov.html_report(ignore_errors=True, directory=output)
+            stream.write(f'Coverage HTML written to dir {self.cov.config.html_dir if output is None else output}\n')
+
+        # Produce xml report if wanted.
+        if 'xml' in self.cov_report:
+            output = self.cov_report['xml']
+            with _backup(self.cov, 'config'):
+                total = self.cov.xml_report(ignore_errors=True, outfile=output)
+            stream.write(f'Coverage XML written to file {self.cov.config.xml_output if output is None else output}\n')
+
+        # Produce json report if wanted
+        if 'json' in self.cov_report:
+            output = self.cov_report['json']
+            with _backup(self.cov, 'config'):
+                total = self.cov.json_report(ignore_errors=True, outfile=output)
+            stream.write('Coverage JSON written to file %s\n' % (self.cov.config.json_output if output is None else output))
+
+        # Produce Markdown report if wanted.
+        if 'markdown' in self.cov_report:
+            output = self.cov_report['markdown']
+            with _backup(self.cov, 'config'):
+                with Path(output).open('w') as output_file:
+                    total = self.cov.report(ignore_errors=True, file=output_file, output_format='markdown')
+            stream.write(f'Coverage Markdown information written to file {output}\n')
+
+        # Produce Markdown report if wanted, appending to output file
+        if 'markdown-append' in self.cov_report:
+            output = self.cov_report['markdown-append']
+            with _backup(self.cov, 'config'):
+                with Path(output).open('a') as output_file:
+                    total = self.cov.report(ignore_errors=True, file=output_file, output_format='markdown')
+            stream.write(f'Coverage Markdown information appended to file {output}\n')
+
+        # Produce lcov report if wanted.
+        if 'lcov' in self.cov_report:
+            output = self.cov_report['lcov']
+            with _backup(self.cov, 'config'):
+                self.cov.lcov_report(ignore_errors=True, outfile=output)
+
+                # We need to call Coverage.report here, just to get the total
+                # Coverage.lcov_report doesn't return any total and we need it for --cov-fail-under.
+                total = self.cov.report(ignore_errors=True, file=_NullFile)
+
+            stream.write(f'Coverage LCOV written to file {self.cov.config.lcov_output if output is None else output}\n')
+
+        return total
+
+
+class Central(CovController):
+    """Implementation for centralised operation."""
+
+    @_ensure_topdir
+    def start(self):
+        self.cov = coverage.Coverage(
+            source=self.cov_source,
+            branch=self.cov_branch,
+            data_suffix=True,
+            config_file=self.cov_config,
+        )
+        if self.cov.config.dynamic_context == 'test_function':
+            message = (
+                'Detected dynamic_context=test_function in coverage configuration. '
+                'This is unnecessary as this plugin provides the more complete --cov-context option.'
+            )
+            warnings.warn(CentralCovContextWarning(message), stacklevel=1)
+
+        self.combining_cov = coverage.Coverage(
+            source=self.cov_source,
+            branch=self.cov_branch,
+            data_suffix=f'{filename_suffix(True)}.combine',
+            data_file=os.path.abspath(self.cov.config.data_file),  # noqa: PTH100
+            config_file=self.cov_config,
+        )
+
+        # Erase or load any previous coverage data and start coverage.
+        if not self.cov_append:
+            self.cov.erase()
+        self.cov.start()
+
+        super().start()
+
+    @_ensure_topdir
+    def finish(self):
+        """Stop coverage, save data to file and set the list of coverage objects to report on."""
+        super().finish()
+
+        self.cov.stop()
+        self.cov.save()
+
+        self.cov = self.combining_cov
+        self.cov.load()
+        self.cov.combine()
+        self.cov.save()
+
+        node_desc = self.get_node_desc(sys.platform, sys.version_info)
+        self.node_descs.add(node_desc)
+
+
+class DistMaster(CovController):
+    """Implementation for distributed master."""
+
+    @_ensure_topdir
+    def start(self):
+        self.cov = coverage.Coverage(
+            source=self.cov_source,
+            branch=self.cov_branch,
+            data_suffix=True,
+            config_file=self.cov_config,
+        )
+        if self.cov.config.dynamic_context == 'test_function':
+            raise DistCovError(
+                'Detected dynamic_context=test_function in coverage configuration. '
+                'This is known to cause issues when using xdist, see: https://github.com/pytest-dev/pytest-cov/issues/604\n'
+                'It is recommended to use --cov-context instead.'
+            )
+        self.cov._warn_no_data = False
+        self.cov._warn_unimported_source = False
+        self.cov._warn_preimported_source = False
+        self.combining_cov = coverage.Coverage(
+            source=self.cov_source,
+            branch=self.cov_branch,
+            data_suffix=f'{filename_suffix(True)}.combine',
+            data_file=os.path.abspath(self.cov.config.data_file),  # noqa: PTH100
+            config_file=self.cov_config,
+        )
+        if not self.cov_append:
+            self.cov.erase()
+        self.cov.start()
+        self.cov.config.paths['source'] = [self.topdir]
+
+    def configure_node(self, node):
+        """Workers need to know if they are collocated and what files have moved."""
+
+        node.workerinput.update(
+            {
+                'cov_master_host': socket.gethostname(),
+                'cov_master_topdir': self.topdir,
+                'cov_master_rsync_roots': [str(root) for root in node.nodemanager.roots],
+            }
+        )
+
+    def testnodedown(self, node, error):
+        """Collect data file name from worker."""
+
+        # If worker doesn't return any data then it is likely that this
+        # plugin didn't get activated on the worker side.
+        output = getattr(node, 'workeroutput', {})
+        if 'cov_worker_node_id' not in output:
+            self.failed_workers.append(node)
+            return
+
+        # If worker is not collocated then we must save the data file
+        # that it returns to us.
+        if 'cov_worker_data' in output:
+            data_suffix = '%s.%s.%06d.%s' % (  # noqa: UP031
+                socket.gethostname(),
+                os.getpid(),
+                random.randint(0, 999999),  # noqa: S311
+                output['cov_worker_node_id'],
+            )
+
+            cov_data = CoverageData(
+                suffix=data_suffix,
+            )
+            cov_data.loads(output['cov_worker_data'])
+            path = output['cov_worker_path']
+            self.cov.config.paths['source'].append(path)
+
+        # Record the worker types that contribute to the data file.
+        rinfo = node.gateway._rinfo()
+        node_desc = self.get_node_desc(rinfo.platform, rinfo.version_info)
+        self.node_descs.add(node_desc)
+
+    @_ensure_topdir
+    def finish(self):
+        """Combines coverage data and sets the list of coverage objects to report on."""
+
+        # Combine all the suffix files into the data file.
+        self.cov.stop()
+        self.cov.save()
+        self.cov = self.combining_cov
+        self.cov.load()
+        self.cov.combine()
+        self.cov.save()
+
+
+class DistWorker(CovController):
+    """Implementation for distributed workers."""
+
+    @_ensure_topdir
+    def start(self):
+        # Determine whether we are collocated with master.
+        self.is_collocated = (
+            socket.gethostname() == self.config.workerinput['cov_master_host']
+            and self.topdir == self.config.workerinput['cov_master_topdir']
+        )
+
+        # If we are not collocated, then rewrite master paths to worker paths.
+        if not self.is_collocated:
+            master_topdir = self.config.workerinput['cov_master_topdir']
+            worker_topdir = self.topdir
+            if self.cov_source is not None:
+                self.cov_source = [source.replace(master_topdir, worker_topdir) for source in self.cov_source]
+            self.cov_config = self.cov_config.replace(master_topdir, worker_topdir)
+
+        # Erase any previous data and start coverage.
+        self.cov = coverage.Coverage(
+            source=self.cov_source,
+            branch=self.cov_branch,
+            data_suffix=True,
+            config_file=self.cov_config,
+        )
+        # Prevent workers from issuing module-not-measured type of warnings (expected for a workers to not have coverage in all the files).
+        self.cov._warn_unimported_source = False
+        self.cov.start()
+
+        super().start()
+
+    @_ensure_topdir
+    def finish(self):
+        """Stop coverage and send relevant info back to the master."""
+        super().finish()
+
+        self.cov.stop()
+
+        if self.is_collocated:
+            # We don't combine data if we're collocated - we can get
+            # race conditions in the .combine() call (it's not atomic)
+            # The data is going to be combined in the master.
+            self.cov.save()
+
+            # If we are collocated then just inform the master of our
+            # data file to indicate that we have finished.
+            self.config.workeroutput['cov_worker_node_id'] = self.nodeid
+        else:
+            self.cov.combine()
+            self.cov.save()
+            # If we are not collocated then add the current path
+            # and coverage data to the output so we can combine
+            # it on the master node.
+
+            # Send all the data to the master over the channel.
+            data = self.cov.get_data().dumps()
+
+            self.config.workeroutput.update(
+                {
+                    'cov_worker_path': self.topdir,
+                    'cov_worker_node_id': self.nodeid,
+                    'cov_worker_data': data,
+                }
+            )
+
+    def summary(self, stream):
+        """Only the master reports so do nothing."""

Backend/venv/lib/python3.12/site-packages/pytest_cov/plugin.py

@@ -0,0 +1,468 @@
+"""Coverage plugin for pytest."""
+
+import argparse
+import os
+import re
+import warnings
+from io import StringIO
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import pytest
+
+from . import CovDisabledWarning
+from . import CovReportWarning
+from . import PytestCovWarning
+
+if TYPE_CHECKING:
+    from .engine import CovController
+
+COVERAGE_SQLITE_WARNING_RE = re.compile('unclosed database in <sqlite3.Connection object at', re.I)
+
+
+def validate_report(arg):
+    file_choices = ['annotate', 'html', 'xml', 'json', 'markdown', 'markdown-append', 'lcov']
+    term_choices = ['term', 'term-missing']
+    term_modifier_choices = ['skip-covered']
+    all_choices = term_choices + file_choices
+    values = arg.split(':', 1)
+    report_type = values[0]
+    if report_type not in [*all_choices, '']:
+        msg = f'invalid choice: "{arg}" (choose from "{all_choices}")'
+        raise argparse.ArgumentTypeError(msg)
+
+    if len(values) == 1:
+        return report_type, None
+
+    report_modifier = values[1]
+    if report_type in term_choices and report_modifier in term_modifier_choices:
+        return report_type, report_modifier
+
+    if report_type not in file_choices:
+        msg = f'output specifier not supported for: "{arg}" (choose from "{file_choices}")'
+        raise argparse.ArgumentTypeError(msg)
+
+    return values
+
+
+def validate_fail_under(num_str):
+    try:
+        value = int(num_str)
+    except ValueError:
+        try:
+            value = float(num_str)
+        except ValueError:
+            raise argparse.ArgumentTypeError('An integer or float value is required.') from None
+    if value > 100:
+        raise argparse.ArgumentTypeError(
+            'Your desire for over-achievement is admirable but misplaced. The maximum value is 100. Perhaps write more integration tests?'
+        )
+    return value
+
+
+def validate_context(arg):
+    if arg != 'test':
+        raise argparse.ArgumentTypeError('The only supported value is "test".')
+    return arg
+
+
+class StoreReport(argparse.Action):
+    def __call__(self, parser, namespace, values, option_string=None):
+        report_type, file = values
+        namespace.cov_report[report_type] = file
+
+        # coverage.py doesn't set a default file for markdown output_format
+        if report_type in ['markdown', 'markdown-append'] and file is None:
+            namespace.cov_report[report_type] = 'coverage.md'
+        if all(x in namespace.cov_report for x in ['markdown', 'markdown-append']):
+            self._validate_markdown_dest_files(namespace.cov_report, parser)
+
+    def _validate_markdown_dest_files(self, cov_report_options, parser):
+        markdown_file = cov_report_options['markdown']
+        markdown_append_file = cov_report_options['markdown-append']
+        if markdown_file == markdown_append_file:
+            error_message = f"markdown and markdown-append options cannot point to the same file: '{markdown_file}'."
+            error_message += ' Please redirect one of them using :DEST (e.g. --cov-report=markdown:dest_file.md)'
+            parser.error(error_message)
+
+
+def pytest_addoption(parser):
+    """Add options to control coverage."""
+
+    group = parser.getgroup('cov', 'coverage reporting with distributed testing support')
+    group.addoption(
+        '--cov',
+        action='append',
+        default=[],
+        metavar='SOURCE',
+        nargs='?',
+        const=True,
+        dest='cov_source',
+        help='Path or package name to measure during execution (multi-allowed). '
+        'Use --cov= to not do any source filtering and record everything.',
+    )
+    group.addoption(
+        '--cov-reset',
+        action='store_const',
+        const=[],
+        dest='cov_source',
+        help='Reset cov sources accumulated in options so far. ',
+    )
+    group.addoption(
+        '--cov-report',
+        action=StoreReport,
+        default={},
+        metavar='TYPE',
+        type=validate_report,
+        help='Type of report to generate: term, term-missing, '
+        'annotate, html, xml, json, markdown, markdown-append, lcov (multi-allowed). '
+        'term, term-missing may be followed by ":skip-covered". '
+        'annotate, html, xml, json, markdown, markdown-append and lcov may be followed by ":DEST" '
+        'where DEST specifies the output location. '
+        'Use --cov-report= to not generate any output.',
+    )
+    group.addoption(
+        '--cov-config',
+        action='store',
+        default='.coveragerc',
+        metavar='PATH',
+        help='Config file for coverage. Default: .coveragerc',
+    )
+    group.addoption(
+        '--no-cov-on-fail',
+        action='store_true',
+        default=False,
+        help='Do not report coverage if test run fails. Default: False',
+    )
+    group.addoption(
+        '--no-cov',
+        action='store_true',
+        default=False,
+        help='Disable coverage report completely (useful for debuggers). Default: False',
+    )
+    group.addoption(
+        '--cov-fail-under',
+        action='store',
+        metavar='MIN',
+        type=validate_fail_under,
+        help='Fail if the total coverage is less than MIN.',
+    )
+    group.addoption(
+        '--cov-append',
+        action='store_true',
+        default=False,
+        help='Do not delete coverage but append to current. Default: False',
+    )
+    group.addoption(
+        '--cov-branch',
+        action='store_true',
+        default=None,
+        help='Enable branch coverage.',
+    )
+    group.addoption(
+        '--cov-precision',
+        type=int,
+        default=None,
+        help='Override the reporting precision.',
+    )
+    group.addoption(
+        '--cov-context',
+        action='store',
+        metavar='CONTEXT',
+        type=validate_context,
+        help='Dynamic contexts to use. "test" for now.',
+    )
+
+
+def _prepare_cov_source(cov_source):
+    """
+    Prepare cov_source so that:
+
+     --cov --cov=foobar is equivalent to --cov (cov_source=None)
+     --cov=foo --cov=bar is equivalent to cov_source=['foo', 'bar']
+    """
+    return None if True in cov_source else [path for path in cov_source if path is not True]
+
+
+@pytest.hookimpl(tryfirst=True)
+def pytest_load_initial_conftests(early_config, parser, args):
+    options = early_config.known_args_namespace
+    no_cov = options.no_cov_should_warn = False
+    for arg in args:
+        arg = str(arg)
+        if arg == '--no-cov':
+            no_cov = True
+        elif arg.startswith('--cov') and no_cov:
+            options.no_cov_should_warn = True
+            break
+
+    if early_config.known_args_namespace.cov_source:
+        plugin = CovPlugin(options, early_config.pluginmanager)
+        early_config.pluginmanager.register(plugin, '_cov')
+
+
+class CovPlugin:
+    """Use coverage package to produce code coverage reports.
+
+    Delegates all work to a particular implementation based on whether
+    this test process is centralised, a distributed master or a
+    distributed worker.
+    """
+
+    def __init__(self, options: argparse.Namespace, pluginmanager, start=True, no_cov_should_warn=False):
+        """Creates a coverage pytest plugin.
+
+        We read the rc file that coverage uses to get the data file
+        name.  This is needed since we give coverage through it's API
+        the data file name.
+        """
+
+        # Our implementation is unknown at this time.
+        self.pid = None
+        self.cov_controller = None
+        self.cov_report = StringIO()
+        self.cov_total = None
+        self.failed = False
+        self._started = False
+        self._start_path = None
+        self._disabled = False
+        self.options = options
+        self._wrote_heading = False
+
+        is_dist = getattr(options, 'numprocesses', False) or getattr(options, 'distload', False) or getattr(options, 'dist', 'no') != 'no'
+        if getattr(options, 'no_cov', False):
+            self._disabled = True
+            return
+
+        if not self.options.cov_report:
+            self.options.cov_report = ['term']
+        elif len(self.options.cov_report) == 1 and '' in self.options.cov_report:
+            self.options.cov_report = {}
+        self.options.cov_source = _prepare_cov_source(self.options.cov_source)
+
+        # import engine lazily here to avoid importing
+        # it for unit tests that don't need it
+        from . import engine
+
+        if is_dist and start:
+            self.start(engine.DistMaster)
+        elif start:
+            self.start(engine.Central)
+
+        # worker is started in pytest hook
+
+    def start(self, controller_cls: type['CovController'], config=None, nodeid=None):
+        if config is None:
+            # fake config option for engine
+            class Config:
+                option = self.options
+
+            config = Config()
+
+        self.cov_controller = controller_cls(self.options, config, nodeid)
+        self.cov_controller.start()
+        self._started = True
+        self._start_path = Path.cwd()
+        cov_config = self.cov_controller.cov.config
+        if self.options.cov_fail_under is None and hasattr(cov_config, 'fail_under'):
+            self.options.cov_fail_under = cov_config.fail_under
+        if self.options.cov_precision is None:
+            self.options.cov_precision = getattr(cov_config, 'precision', 0)
+
+    def _is_worker(self, session):
+        return getattr(session.config, 'workerinput', None) is not None
+
+    def pytest_sessionstart(self, session):
+        """At session start determine our implementation and delegate to it."""
+
+        if self.options.no_cov:
+            # Coverage can be disabled because it does not cooperate with debuggers well.
+            self._disabled = True
+            return
+
+        # import engine lazily here to avoid importing
+        # it for unit tests that don't need it
+        from . import engine
+
+        self.pid = os.getpid()
+        if self._is_worker(session):
+            nodeid = session.config.workerinput.get('workerid', session.nodeid)
+            self.start(engine.DistWorker, session.config, nodeid)
+        elif not self._started:
+            self.start(engine.Central)
+
+        if self.options.cov_context == 'test':
+            session.config.pluginmanager.register(TestContextPlugin(self.cov_controller), '_cov_contexts')
+
+    @pytest.hookimpl(optionalhook=True)
+    def pytest_configure_node(self, node):
+        """Delegate to our implementation.
+
+        Mark this hook as optional in case xdist is not installed.
+        """
+        if not self._disabled:
+            self.cov_controller.configure_node(node)
+
+    @pytest.hookimpl(optionalhook=True)
+    def pytest_testnodedown(self, node, error):
+        """Delegate to our implementation.
+
+        Mark this hook as optional in case xdist is not installed.
+        """
+        if not self._disabled:
+            self.cov_controller.testnodedown(node, error)
+
+    def _should_report(self):
+        needed = self.options.cov_report or self.options.cov_fail_under
+        return needed and not (self.failed and self.options.no_cov_on_fail)
+
+    # we need to wrap pytest_runtestloop. by the time pytest_sessionfinish
+    # runs, it's too late to set testsfailed
+    @pytest.hookimpl(wrapper=True)
+    def pytest_runtestloop(self, session):
+        if self._disabled:
+            return (yield)
+
+        # we add default warning configuration to prevent certain warnings to bubble up as errors due to rigid filterwarnings configuration
+        for _, message, category, _, _ in warnings.filters:
+            if category is ResourceWarning and message == COVERAGE_SQLITE_WARNING_RE:
+                break
+        else:
+            warnings.filterwarnings('default', 'unclosed database in <sqlite3.Connection object at', ResourceWarning)
+        for _, _, category, _, _ in warnings.filters:
+            if category is PytestCovWarning:
+                break
+        else:
+            warnings.simplefilter('once', PytestCovWarning)
+        from coverage.exceptions import CoverageWarning
+
+        for _, _, category, _, _ in warnings.filters:
+            if category is CoverageWarning:
+                break
+        else:
+            warnings.simplefilter('once', CoverageWarning)
+
+        result = yield
+
+        self.failed = bool(session.testsfailed)
+        if self.cov_controller is not None:
+            self.cov_controller.finish()
+
+        if not self._is_worker(session) and self._should_report():
+            # import coverage lazily here to avoid importing
+            # it for unit tests that don't need it
+            from coverage.misc import CoverageException
+            from coverage.results import display_covered
+            from coverage.results import should_fail_under
+
+            try:
+                self.cov_total = self.cov_controller.summary(self.cov_report)
+            except CoverageException as exc:
+                message = f'Failed to generate report: {exc}\n'
+                session.config.pluginmanager.getplugin('terminalreporter').write(f'\nWARNING: {message}\n', red=True, bold=True)
+                warnings.warn(CovReportWarning(message), stacklevel=1)
+                self.cov_total = 0
+            assert self.cov_total is not None, 'Test coverage should never be `None`'
+            cov_fail_under = self.options.cov_fail_under
+            cov_precision = self.options.cov_precision
+            if cov_fail_under is None or self.options.collectonly:
+                return
+            if should_fail_under(self.cov_total, cov_fail_under, cov_precision):
+                message = 'Coverage failure: total of {total} is less than fail-under={fail_under:.{p}f}'.format(
+                    total=display_covered(self.cov_total, cov_precision),
+                    fail_under=cov_fail_under,
+                    p=cov_precision,
+                )
+                session.config.pluginmanager.getplugin('terminalreporter').write(f'\nERROR: {message}\n', red=True, bold=True)
+                # make sure we get the EXIT_TESTSFAILED exit code
+                session.testsfailed += 1
+
+        return result
+
+    def write_heading(self, terminalreporter):
+        if not self._wrote_heading:
+            terminalreporter.write_sep('=', 'tests coverage')
+            self._wrote_heading = True
+
+    def pytest_terminal_summary(self, terminalreporter):
+        if self._disabled:
+            if self.options.no_cov_should_warn:
+                self.write_heading(terminalreporter)
+                message = 'Coverage disabled via --no-cov switch!'
+                terminalreporter.write(f'WARNING: {message}\n', red=True, bold=True)
+                warnings.warn(CovDisabledWarning(message), stacklevel=1)
+            return
+        if self.cov_controller is None:
+            return
+
+        if self.cov_total is None:
+            # we shouldn't report, or report generation failed (error raised above)
+            return
+
+        report = self.cov_report.getvalue()
+
+        if report:
+            self.write_heading(terminalreporter)
+            terminalreporter.write(report)
+
+        if self.options.cov_fail_under is not None and self.options.cov_fail_under > 0:
+            self.write_heading(terminalreporter)
+            failed = self.cov_total < self.options.cov_fail_under
+            markup = {'red': True, 'bold': True} if failed else {'green': True}
+            message = '{fail}Required test coverage of {required}% {reached}. Total coverage: {actual:.2f}%\n'.format(
+                required=self.options.cov_fail_under,
+                actual=self.cov_total,
+                fail='FAIL ' if failed else '',
+                reached='not reached' if failed else 'reached',
+            )
+            terminalreporter.write(message, **markup)
+
+    @pytest.hookimpl(hookwrapper=True)
+    def pytest_runtest_call(self, item):
+        if item.get_closest_marker('no_cover') or 'no_cover' in getattr(item, 'fixturenames', ()):
+            self.cov_controller.pause()
+            yield
+            self.cov_controller.resume()
+        else:
+            yield
+
+
+class TestContextPlugin:
+    cov_controller: 'CovController'
+
+    def __init__(self, cov_controller):
+        self.cov_controller = cov_controller
+
+    def pytest_runtest_setup(self, item):
+        self.switch_context(item, 'setup')
+
+    def pytest_runtest_teardown(self, item):
+        self.switch_context(item, 'teardown')
+
+    def pytest_runtest_call(self, item):
+        self.switch_context(item, 'run')
+
+    def switch_context(self, item, when):
+        if self.cov_controller.started:
+            self.cov_controller.cov.switch_context(f'{item.nodeid}|{when}')
+
+
+@pytest.fixture
+def no_cover():
+    """A pytest fixture to disable coverage."""
+
+
+@pytest.fixture
+def cov(request):
+    """A pytest fixture to provide access to the underlying coverage object."""
+
+    # Check with hasplugin to avoid getplugin exception in older pytest.
+    if request.config.pluginmanager.hasplugin('_cov'):
+        plugin = request.config.pluginmanager.getplugin('_cov')
+        if plugin.cov_controller:
+            return plugin.cov_controller.cov
+    return None
+
+
+def pytest_configure(config):
+    config.addinivalue_line('markers', 'no_cover: disable coverage for this test.')