pytest-flakefighters 0.0.0__py3-none-any.whl

pytest_flakefighters/function_coverage.py

@@ -0,0 +1,71 @@
+"""
+This module implements the Profiler class to help measure function-level coverage.
+"""
+
+import ast
+import cProfile
+import os
+import pstats
+
+from coverage import CoverageData
+
+
+class Profiler:
+    """
+    Provides functionality to measure function-level coverage of a pytest test suite.
+
+    :ivar coverage_data: The (potentially) covered lines for each module.
+    :ivar function_defs: The lines that define a given function in a given module, accessed as
+    `function_defs[module][function]`.
+    """
+
+    def __init__(self):
+        self.coverage_data: CoverageData = CoverageData(no_disk=True)
+        self.function_defs: dict[str, dict[str, list[int]]] = {}
+        self.profiler = cProfile.Profile()
+
+    def update_function_defs(self, module: str):
+        """
+        Extract the start and end lines for defined functions in the given module and add them to `function_defs`.
+
+        :param module: The filepath of the module to process.
+        """
+        with open(module, encoding="utf8") as f:
+            tree = ast.parse(f.read())
+        self.function_defs[module] = {
+            node.name: list(range(node.lineno, node.end_lineno + 1))
+            for node in ast.walk(tree)
+            if isinstance(node, ast.FunctionDef)
+        }
+
+    def start(self):
+        """
+        Start measuring coverage.
+        """
+        self.profiler.enable()
+
+    def stop(self):
+        """
+        Stop measuring coverage.
+        """
+        self.profiler.disable()
+        p = pstats.Stats(self.profiler)
+        for module, _, function in p.stats.keys():
+            if module not in self.function_defs and os.path.exists(module):
+                self.update_function_defs(module)
+            self.coverage_data.add_lines({module: self.function_defs.get(module, {}).get(function, [])})
+
+    def switch_context(self, context: str):
+        """
+        Set the context name of the coverage measurement.
+
+        :param context: The context name to set.
+        """
+        self.profiler.clear()
+        self.coverage_data.set_context(context)
+
+    def get_data(self) -> CoverageData:
+        """
+        Return coverage data.
+        """
+        return self.coverage_data

pytest_flakefighters/main.py

@@ -0,0 +1,162 @@
+"""
+This module adds all the FlakeFighter configuration options to pytest.
+"""
+
+import logging
+import os
+from importlib.metadata import entry_points
+
+import coverage
+import pytest
+import yaml
+
+from pytest_flakefighters.database_management import Database
+from pytest_flakefighters.flakefighters.deflaker import DeFlaker
+from pytest_flakefighters.function_coverage import Profiler
+from pytest_flakefighters.plugin import FlakeFighterPlugin
+from pytest_flakefighters.rerun_strategies import All, FlakyFailure, PreviouslyFlaky
+
+rerun_strategies = {"ALL": All, "FLAKY_FAILURE": FlakyFailure, "PREVIOUSLY_FLAKY": PreviouslyFlaky}
+
+logger = logging.getLogger(__name__)
+
+
+def rerun_strategy(strategy: str, max_reruns: int, **kwargs):
+    """
+    Instantiate the selected rerun strategy.
+    """
+    if strategy == "PREVIOUSLY_FLAKY":
+        return PreviouslyFlaky(max_reruns, kwargs["database"])
+    return rerun_strategies[strategy](max_reruns)
+
+
+def pytest_addoption(parser: pytest.Parser):
+    """
+    Add extra pytest options.
+    :param parser: The argument parser.
+    """
+    group = parser.getgroup("flakefighters")
+    group.addoption(
+        "--root",
+        dest="root",
+        action="store",
+        default=os.getcwd(),
+        help="The root directory of the project. Defaults to the current working directory.",
+    )
+    group.addoption(
+        "--suppress-flaky-failures-exit-code",
+        dest="suppress_flaky",
+        action="store_true",
+        default=False,
+        help="Return OK exit code if the only failures are flaky failures.",
+    )
+    group.addoption(
+        "--no-save",
+        action="store_true",
+        default=False,
+        help="Do not save this run to the database of previous flakefighters runs.",
+    )
+    group.addoption(
+        "--function-coverage",
+        action="store_true",
+        default=False,
+        help="Use function-level coverage instead of line coverage.",
+    )
+    group.addoption(
+        "--load-max-runs",
+        "-M",
+        action="store",
+        default=None,
+        help="The maximum number of previous runs to consider.",
+    )
+    group.addoption(
+        "--database-url",
+        "-D",
+        action="store",
+        default="sqlite:///flakefighters.db",
+        help="The database URL. Defaults to 'flakefighters.db' in current working directory.",
+    )
+    group.addoption(
+        "--store-max-runs",
+        action="store",
+        default=None,
+        type=int,
+        help="The maximum number of previous flakefighters runs to store. Default is to store all.",
+    )
+    group.addoption(
+        "--max-reruns",
+        action="store",
+        default=0,
+        type=int,
+        help="The maximum number of times to rerun tests. "
+        "By default, only failing tests marked as flaky will be rerun. "
+        "This can be changed with the --rerun-strategy parameter.",
+    )
+    group.addoption(
+        "--rerun-strategy",
+        action="store",
+        type=str,
+        choices=list(rerun_strategies),
+        default="FLAKY_FAILURE",
+        help="The strategy used to determine which tests to rerun. Supported options are:\n  "
+        + "\n  ".join(f"{name} - {strat.help()}" for name, strat in rerun_strategies.items()),
+    )
+    group.addoption(
+        "--time-immemorial",
+        action="store",
+        default=None,
+        help="How long to store flakefighters runs for, specified as `days:hours:minutes`. "
+        "E.g. to store tests for one week, use 7:0:0.",
+    )
+
+
+def pytest_configure(config: pytest.Config):
+    """
+    Initialise the FlakeFighterPlugin class.
+    :param config: The config options.
+    """
+    database = Database(
+        config.option.database_url,
+        config.option.load_max_runs,
+        config.option.store_max_runs,
+        config.option.time_immemorial,
+    )
+
+    if config.option.function_coverage:
+        cov = Profiler()
+    else:
+        cov = coverage.Coverage()
+
+    algorithms = entry_points(group="pytest_flakefighters")
+    flakefighter_configs = config.inicfg.get("pytest_flakefighters")
+
+    flakefighters = []
+    if flakefighter_configs is not None:
+        flakefighter_configs = yaml.safe_load(flakefighter_configs.value)
+        for flakefighter in algorithms:
+            if flakefighter.name in flakefighter_configs:
+                flakefighters.append(
+                    flakefighter.load().from_config(
+                        vars(config.option) | {"database": database} | flakefighter_configs[flakefighter.name]
+                    )
+                )
+
+    else:
+        logger.warning("No flakefighters specified. Using basic DeFlaker only.")
+        flakefighters.append(
+            DeFlaker(
+                run_live=True,
+                root=config.option.root,
+            )
+        )
+
+    config.pluginmanager.register(
+        FlakeFighterPlugin(
+            root=config.option.root,
+            database=database,
+            cov=cov,
+            flakefighters=flakefighters,
+            rerun_strategy=rerun_strategy(config.option.rerun_strategy, config.option.max_reruns, database=database),
+            save_run=not config.option.no_save,
+        )
+    )

pytest_flakefighters/plugin.py

@@ -0,0 +1,225 @@
+"""
+This module implements the DeFlaker algorithm [Bell et al. 10.1145/3180155.3180164] as a pytest plugin.
+"""
+
+from datetime import datetime
+from enum import Enum
+from typing import Union
+
+import coverage
+import pytest
+from _pytest.runner import runtestprotocol
+
+from pytest_flakefighters.database_management import (
+    ActiveFlakeFighter,
+    Database,
+    Run,
+    Test,
+    TestException,
+    TestExecution,
+    TracebackEntry,
+)
+from pytest_flakefighters.flakefighters.abstract_flakefighter import FlakeFighter
+from pytest_flakefighters.function_coverage import Profiler
+
+
+class RerunStrategy(Enum):
+    """
+    Enum for supported test rerunning strategies.
+    :cvar ALL: Rerun all tests, regardless of outcome.
+    :cvar FLAKY_FAILURE: Rerun failing tests marked as flaky.
+    :cvar PREVIOUS_FLAKY: Rerun tests that have previously been marked as flaky as well as newly failing flaky tests.
+    """
+
+    ALL = "ALL"
+    FLAKY_FAILURE = "FLAKY_FAILURE"
+    PREVIOUSLY_FLAKY = "PREVIOUSLY_FLAKY"
+
+
+class FlakeFighterPlugin:  # pylint: disable=R0902
+    """
+    The main plugin to manage the various FlakeFighter tools.
+    """
+
+    def __init__(  # pylint: disable=R0913,R0917
+        self,
+        root: str,
+        database: Database,
+        cov: Union[coverage.Coverage, Profiler],
+        flakefighters: list[FlakeFighter],
+        save_run: bool = True,
+        rerun_strategy: RerunStrategy = RerunStrategy.FLAKY_FAILURE,
+    ):
+        self.root = root
+        self.database = database
+        self.cov = cov
+        self.flakefighters = flakefighters
+        self.save_run = save_run
+        self.rerun_strategy = rerun_strategy
+
+        self.run = Run(  # pylint: disable=E1123
+            root=root,
+            active_flakefighters=[
+                ActiveFlakeFighter(name=f.__class__.__name__, params=f.params()) for f in flakefighters
+            ],
+        )
+
+    def pytest_sessionstart(self, session: pytest.Session):  # pylint: disable=unused-argument
+        """
+        Start the coverage measurement before tests are collected so we measure class and method definitions as covered.
+        :param session: The session.
+        """
+        self.cov.start()
+        self.cov.switch_context("collection")  # pragma: no cover
+
+    def pytest_collection_finish(self, session: pytest.Session):  # pylint: disable=unused-argument
+        """
+        Stop the coverage measurement after tests are collected.
+        :param session: The session.
+        """
+        # Line cannot appear as covered on our tests because the coverage measurement is leaking into the self.cov
+        self.cov.switch_context(None)  # pragma: no cover
+        self.cov.stop()  # pragma: no cover
+
+    @pytest.hookimpl(hookwrapper=True)
+    def pytest_runtest_call(self, item: pytest.Item):
+        """
+        Start the coverage measurement and label the coverage for the current test, run the test,
+        then stop coverage measurement.
+
+        :param item: The item.
+        """
+        item.start = datetime.now().timestamp()
+        self.cov.start()
+        # Lines cannot appear as covered on our tests because the coverage measurement is leaking into the self.cov
+        self.cov.switch_context(item.nodeid)  # pragma: no cover
+        yield  # pragma: no cover
+        self.cov.stop()  # pragma: no cover
+        item.stop = datetime.now().timestamp()
+
+    @pytest.hookimpl(hookwrapper=True)
+    def pytest_runtest_makereport(self, item: pytest.Item, call: pytest.CallInfo):  # pylint: disable=unused-argument
+        """
+        Called after a test execution call (setup, call, teardown)
+        to create a TestReport.
+
+        :param item: The item.
+        :param call: The call info.
+        """
+        outcome = yield
+        report = outcome.get_result()
+        excinfo = call.excinfo
+        if excinfo is not None and call.when == "call":
+            report.exception = TestException(  # pylint: disable=E1123
+                name=excinfo.type.__name__,
+                traceback=[
+                    TracebackEntry(
+                        path=str(entry.path),
+                        lineno=entry.lineno,
+                        colno=entry.colno,
+                        statement=str(entry.statement),
+                        source=str(entry.source),
+                    )
+                    for entry in excinfo.traceback
+                    if entry.path
+                ],
+            )
+        else:
+            report.exception = None
+
+    def pytest_runtest_protocol(self, item: pytest.Item, nextitem: pytest.Item) -> bool:
+        """
+        Rerun flaky tests. Follows a similar control logic to the pytest-rerunfailures plugin.
+
+        :param item: The item.
+        :param nextitem: The next item.
+
+        :return: The return value is not used, but only stops further processing.
+        """
+        item.execution_count = 0
+        executions = []
+        skipped = False
+
+        for _ in range(self.rerun_strategy.max_reruns + 1):
+            item.execution_count += 1
+            item.ihook.pytest_runtest_logstart(nodeid=item.nodeid, location=item.location)
+            reports = runtestprotocol(item, nextitem=nextitem, log=False)
+
+            for report in reports:  # up to 3 reports: setup, call, teardown
+                if report.when == "setup" and report.skipped:
+                    skipped = True
+                if report.when == "call":
+                    line_coverage = self.cov.get_data()
+                    line_coverage.set_query_contexts(["collection", item.nodeid])
+                    captured_output = dict(report.sections)
+                    test_execution = TestExecution(  # pylint: disable=E1123
+                        outcome=report.outcome,
+                        stdout=captured_output.get("stdout"),
+                        stderr=captured_output.get("stderr"),
+                        report=str(report.longrepr),
+                        start_time=datetime.fromtimestamp(item.start),
+                        end_time=datetime.fromtimestamp(item.stop),
+                        coverage={
+                            file_path: line_coverage.lines(file_path) for file_path in line_coverage.measured_files()
+                        },
+                        exception=report.exception,
+                    )
+                    item.test_execution = test_execution
+                    executions.append(test_execution)
+                    for ff in filter(lambda ff: ff.run_live, self.flakefighters):
+                        ff.flaky_test_live(test_execution)
+                    report.flaky = any(result.flaky for result in test_execution.flakefighter_results)
+                    if item.execution_count <= self.rerun_strategy.max_reruns and self.rerun_strategy.rerun(report):
+                        break  # trigger rerun
+                item.ihook.pytest_runtest_logreport(report=report)
+            else:
+                break  # Skip further reruns
+
+        item.ihook.pytest_runtest_logfinish(nodeid=item.nodeid, location=item.location)
+        test = Test(  # pylint: disable=E1123
+            name=item.nodeid,
+            skipped=skipped,
+            executions=executions,
+        )
+        self.run.tests.append(test)
+        return True
+
+    def pytest_report_teststatus(
+        self, report: pytest.TestReport, config: pytest.Config  # pylint: disable=unused-argument
+    ) -> tuple[str, str, str]:
+        """
+        Report flaky failures as such.
+        :param report: The report object whose status is to be returned.
+        :param config: The pytest config object.
+        :returns: The test status.
+        """
+        if getattr(report, "flaky", False):
+            return report.outcome, "F", ("FLAKY", {"yellow": True})
+        return None
+
+    def pytest_sessionfinish(
+        self,
+        session: pytest.Session,
+        exitstatus: pytest.ExitCode,  # pylint: disable=unused-argument
+    ) -> None:
+        """Called after whole test run finished, right before returning the exit status to the system.
+        :param session: The pytest session object.
+        :param exitstatus: The status which pytest will return to the system.
+        """
+        for ff in filter(lambda ff: not ff.run_live, self.flakefighters):
+            ff.flaky_tests_post(self.run)
+
+        genuine_failure_observed = any(
+            not test.flaky for test in self.run.tests if any(e.outcome != "passed" for e in test.executions)
+        )
+
+        if (
+            session.config.option.suppress_flaky
+            and session.exitstatus == pytest.ExitCode.TESTS_FAILED
+            and not genuine_failure_observed
+        ):
+            session.exitstatus = pytest.ExitCode.OK
+
+        if self.save_run:
+            self.database.save(self.run)
+        self.database.engine.dispose()

pytest_flakefighters/rerun_strategies.py

@@ -0,0 +1,90 @@
+"""
+This module implements the various supported test rerun strategies.
+"""
+
+from abc import ABC, abstractmethod
+
+import pytest
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from pytest_flakefighters.database_management import Database, Test
+
+
+class RerunStrategy(ABC):
+    """
+    Abstract base class for test rerun strategies.
+    """
+
+    def __init__(self, max_reruns: int):
+        self.max_reruns = max_reruns
+
+    @abstractmethod
+    def rerun(self, report: pytest.TestReport) -> bool:
+        """
+        Decide whether to rerun a test case.
+        :return: Boolean true to rerun, False otherwise.
+        """
+
+    @classmethod
+    @abstractmethod
+    def help(cls) -> str:
+        """
+        Return the help string for config options.
+        """
+
+
+class All(RerunStrategy):
+    """
+    Rerun all tests, regardless of outcome.
+    """
+
+    def rerun(self, report: pytest.TestReport) -> bool:
+        """
+        Trivially rerun all tests, regardless of outcome.
+        :return: Boolean true to rerun, False otherwise.
+        """
+        return True
+
+    @classmethod
+    def help(cls):
+        return "Trivially rerun all tests, regardless of outcome."
+
+
+class FlakyFailure(RerunStrategy):
+    """
+    Strategy to rerun failed tests marked as flaky.
+    """
+
+    def rerun(self, report: pytest.TestReport) -> bool:
+        """
+        :return: Boolean true if a test fails and has been marked as flaky by live FlakeFighters.
+        """
+        return report.flaky and not report.passed
+
+    @classmethod
+    def help(cls):
+        return "Rerun failing tests that have been merked as flaky by live FlakeFighters."
+
+
+class PreviouslyFlaky(FlakyFailure):
+    """
+    Rerun failed tests marked as flaky and tests previously marked as flaky.
+    """
+
+    def __init__(self, reruns: int, database: Database):
+        super().__init__(reruns)
+        with Session(database.engine) as session:
+            tests = session.scalars(select(Test)).all()
+            self.previously_flaky = list(filter(lambda t: t.flaky, tests))
+
+    def rerun(self, report: pytest.TestReport) -> bool:
+        """
+        :return: Boolean true if a test is a flaky failure or has previously been marked as flaky and has the same name
+        as the current test.
+        """
+        return super().rerun(report) or any(test.name == report.nodeid for test in self.previously_flaky)
+
+    @classmethod
+    def help(cls):
+        return "Rerun failing tests marked as flaky, and tests that have previously been marked as flaky."

pytest_flakefighters-0.0.0.dist-info/METADATA

@@ -0,0 +1,116 @@
+Metadata-Version: 2.4
+Name: pytest-flakefighters
+Version: 0.0.0
+Summary: Pytest plugin implementing flaky test failure detection and classification.
+Author: TestFLARE Team
+License: 
+        The MIT License (MIT)
+        
+        Copyright (c) 2025 TestFLARE Team
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in
+        all copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+        THE SOFTWARE.
+        
+Project-URL: Repository, https://github.com/test-flare/pytest-flakefighter
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pytest>=6.2.0
+Requires-Dist: coverage>=7.10.6
+Requires-Dist: GitPython>=3.1.45
+Requires-Dist: unidiff>=0.7.5
+Requires-Dist: sqlalchemy>=2.0.43
+Requires-Dist: dotenv>=0.9.9
+Requires-Dist: pandas
+Requires-Dist: scipy<=1.15
+Requires-Dist: pyyaml>=6
+Requires-Dist: scikit-learn>=1.7
+Requires-Dist: nltk>=3.9
+Provides-Extra: dev
+Requires-Dist: black; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pylint; extra == "dev"
+Requires-Dist: pre_commit; extra == "dev"
+Requires-Dist: sphinx-autoapi; extra == "dev"
+Requires-Dist: sphinx_rtd_theme; extra == "dev"
+Requires-Dist: tox>=4.31.0; extra == "dev"
+Dynamic: license-file
+
+# Pytest FlakeFighters
+
+[![PyPI version](https://img.shields.io/pypi/v/pytest-flakefighters.svg)](https://pypi.org/project/pytest-flakefighters)
+[![Python versions](https://img.shields.io/pypi/pyversions/pytest-flakefighters.svg)](https://pypi.org/project/pytest-flakefighters)
+
+Pytest plugin implementing flaky test failure detection and
+classification.
+
+------------------------------------------------------------------------
+
+This [pytest](https://github.com/pytest-dev/pytest) plugin was generated with [Cookiecutter](https://github.com/audreyr/cookiecutter) along with [\@hackebrot](https://github.com/hackebrot)\'s [cookiecutter-pytest-plugin](https://github.com/pytest-dev/cookiecutter-pytest-plugin) template.
+
+## Features
+
+-   Implements the [DeFlaker algorithm](https://deflaker.com/) for pytest
+
+
+## Installation
+
+You can install \"pytest-flakefighters\" by cloning this repo and running `pip install .` from the root directory.
+If you intend to develop the plugin, run `pip install -e .[dev]` instead.
+
+We eventually intend to distribute our tool on PyPI.
+
+## Usage
+
+FlakeFighter is intended to run on git repositories that have test suites runnable with `pytest`.
+Once you have installed FlakeFighter, you can run it from the root directory of your repo simply by running `pytest` in your usual way.
+FlakeFighter has the following arguments.
+
+```
+  --target-commit=TARGET_COMMIT
+                        The target (newer) commit hash. Defaults to HEAD (the most recent commit).
+  --source-commit=SOURCE_COMMIT
+                        The source (older) commit hash. Defaults to HEAD^ (the previous commit to target).
+  --repo=REPO_ROOT      The commit hash to compare against.
+  --suppress-flaky-failures-exit-code
+                        Return OK exit code if the only failures are flaky failures.
+  --no-save             Do not save this run to the database of previous flakefighters runs.
+  -M LOAD_MAX_RUNS, --load-max-runs=LOAD_MAX_RUNS
+                        The maximum number of previous runs to consider.
+  -D DATABASE_URL, --database-url=DATABASE_URL
+                        The database URL. Defaults to 'flakefighter.db' in current working directory.
+  --store-max-runs=STORE_MAX_RUNS
+                        The maximum number of previous flakefighters runs to store. Default is to store all.
+  --time-immemorial=TIME_IMMEMORIAL
+                        How long to store flakefighters runs for, specified as `days:hours:minutes`. E.g. to store
+                        tests for one week, use 7:0:0.
+```
+
+## Contributing
+
+Contributions are very welcome.
+Tests can be run with [pytest](https://pytest.readthedocs.io/en/latest/), please ensure the coverage at least stays the same before you submit a pull request.
+
+## Flake Fighters
+Our plugin is made up of a collection of heuristics that come together to help inform whether a test failure is genuine or flaky.
+These come in two "flavours": those which run live after each test, and those which run at the end of the entire test suite.
+Both extend the base class `FlakeFighter` and implement the `flaky_failure` method, which returns `True` if the test is deemed to be flaky.
+
+## Issues
+
+If you encounter any problems, please [file an issue](https://github.com/test-flare/pytest-flakefighters/issues) along with a detailed description.

pytest_flakefighters-0.0.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+pytest_flakefighters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pytest_flakefighters/database_management.py,sha256=MDwwpF8FwmFX6is9pVPye7qEOrjZXOsfXG2UI5I7uk4,7029
+pytest_flakefighters/function_coverage.py,sha256=_WAENobGFbvlbT_CZO6_Ohf8lWaspi5DrWLZd4BdbxY,2183
+pytest_flakefighters/main.py,sha256=u2tgDVLcQ7bbCb55aLG7Nqu5KVx_9GyRAuMBdojCHeM,5148
+pytest_flakefighters/plugin.py,sha256=Y3eQRK58ydO-c77PpnQ8cjWFtOVHop4yf8iAPKEO6TU,8780
+pytest_flakefighters/rerun_strategies.py,sha256=nu6V6sqIMTVqkMBiYek30pe_zolGtdHQwTrgtj13ZG4,2532
+pytest_flakefighters/flakefighters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pytest_flakefighters/flakefighters/abstract_flakefighter.py,sha256=bchRwoNzQaFhSknT9wKDpbf3EiReHPsHsDhm5qi8y_o,1953
+pytest_flakefighters/flakefighters/coverage_independence.py,sha256=6Ic5SN1Np7vQbvNSRgWwiSF9ReQ293mvNwcn0ZS5js8,4349
+pytest_flakefighters/flakefighters/deflaker.py,sha256=L0pPCWTaKaK_lr7qGh4uhI1ofJXgDr9m-CCjOk-_2KM,5248
+pytest_flakefighters/flakefighters/traceback_matching.py,sha256=DVH8OeoDFmBQW277ap_-e2xe8UBJWkZl5HH-iMdb_Ag,6605
+pytest_flakefighters-0.0.0.dist-info/licenses/LICENSE,sha256=tTzR2CWQMPOp-mQIQqi0cTRkaogeBUmW06blQsBLdQg,1082
+pytest_flakefighters-0.0.0.dist-info/METADATA,sha256=rm_arh8KcYnTVM-qEaJNFyC_JSRvJ7hYhJugNak-9vg,5574
+pytest_flakefighters-0.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pytest_flakefighters-0.0.0.dist-info/entry_points.txt,sha256=xockvN1AszN2XqaET77JDIRdOafgm3DdvOtHgVw-aDU,424
+pytest_flakefighters-0.0.0.dist-info/top_level.txt,sha256=mRzzeCn_6fy5c4knXqUVx2n0d86SvnOpeJcSRUevhWg,21
+pytest_flakefighters-0.0.0.dist-info/RECORD,,

pytest_flakefighters-0.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+