flakeguard 0.1.0__py3-none-any.whl

flakeguard/__init__.py

@@ -0,0 +1,21 @@
+"""flakeguard - find, rank, and quarantine flaky tests.
+
+A language-agnostic tool: point it at the test reports your CI already
+produces (JUnit XML and friends) and it tells you which tests are flaky,
+how flaky, and why it thinks so.
+"""
+
+__version__ = "0.1.0"
+
+from .models import Outcome, TestCase
+from .scoring import FlakeStats, analyze
+from .parsers.junit_xml import parse_junit_xml
+
+__all__ = [
+    "__version__",
+    "Outcome",
+    "TestCase",
+    "FlakeStats",
+    "analyze",
+    "parse_junit_xml",
+]

flakeguard/__main__.py

@@ -0,0 +1,6 @@
+"""Allow ``python -m flakeguard`` to work like the ``flakeguard`` script."""
+
+from .cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

flakeguard/cli.py

@@ -0,0 +1,149 @@
+"""Command-line entry point.
+
+    flakeguard scan ./reports
+    flakeguard scan run1.xml run2.xml run3.xml --format json
+    flakeguard scan ./ci-artifacts --min-runs 5 --min-score 0.2
+"""
+
+from __future__ import annotations
+
+import argparse
+import glob
+import os
+import sys
+from typing import List
+
+from . import __version__
+from .parsers import by_suffix
+from .report import RENDERERS
+from .scoring import analyze
+
+
+def _discover(paths: List[str]) -> List[str]:
+    """Expand the given paths into a sorted list of report files.
+
+    Directories are walked recursively; files are taken as-is. Sorting
+    keeps run order deterministic so results are reproducible.
+    """
+    found: List[str] = []
+    for path in paths:
+        if os.path.isdir(path):
+            for root, _dirs, files in os.walk(path):
+                for fname in files:
+                    if os.path.splitext(fname)[1].lower() in by_suffix:
+                        found.append(os.path.join(root, fname))
+        else:
+            matches = sorted(glob.glob(path))
+            if matches:
+                found.extend(matches)
+            elif os.path.exists(path):
+                found.append(path)
+    return sorted(set(found))
+
+
+def _load_runs(files: List[str]) -> tuple[list, list]:
+    """Parse each file into a run. Returns (runs, errors)."""
+    runs, errors = [], []
+    for path in files:
+        suffix = os.path.splitext(path)[1].lower()
+        parser = by_suffix.get(suffix)
+        if parser is None:
+            errors.append(f"{path}: unsupported format '{suffix}'")
+            continue
+        if not os.path.exists(path):
+            errors.append(f"{path}: file not found")
+            continue
+        try:
+            runs.append(parser(path))
+        except Exception as exc:  # noqa: BLE001 - report, don't crash
+            errors.append(f"{path}: {exc}")
+    return runs, errors
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="flakeguard",
+        description="Find, rank, and quarantine flaky tests from test reports.",
+    )
+    p.add_argument("--version", action="version", version=f"flakeguard {__version__}")
+    sub = p.add_subparsers(dest="command", required=True)
+
+    scan = sub.add_parser("scan", help="analyse one or more report files/dirs")
+    scan.add_argument("paths", nargs="+", help="report files, globs, or directories")
+    scan.add_argument(
+        "--min-runs",
+        type=int,
+        default=2,
+        help="minimum runs a test must appear in to be reported (default: 2)",
+    )
+    scan.add_argument(
+        "--min-score",
+        type=float,
+        default=0.0,
+        help="only report tests at or above this flakiness score, 0-1 (default: 0)",
+    )
+    scan.add_argument(
+        "--format",
+        choices=sorted(RENDERERS),
+        default="text",
+        help="output format (default: text)",
+    )
+    scan.add_argument(
+        "--output", "-o", default=None, help="write the report to a file instead of stdout"
+    )
+    scan.add_argument(
+        "--fail-on-flaky",
+        action="store_true",
+        help="exit with code 1 if any flaky tests are found (for CI gating)",
+    )
+    return p
+
+
+def main(argv: List[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+
+    files = _discover(args.paths)
+    if not files:
+        print(
+            "flakeguard: no test report files found.\n"
+            "  I look for JUnit XML (.xml) files - give me a file, a glob, or a\n"
+            "  directory. Need to make one? Most frameworks can, for example:\n"
+            "      pytest --junitxml=report.xml",
+            file=sys.stderr,
+        )
+        return 2
+
+    runs, errors = _load_runs(files)
+    for err in errors:
+        print(f"flakeguard: warning: {err}", file=sys.stderr)
+    if not runs:
+        print(
+            f"flakeguard: none of the {len(files)} file(s) could be parsed.\n"
+            "  See the warnings above - is the file valid JUnit XML?",
+            file=sys.stderr,
+        )
+        return 2
+
+    stats = analyze(runs)
+    # Apply the minimum-score filter on top of the renderers' min-runs filter.
+    if args.min_score > 0:
+        stats = [s for s in stats if s.score >= args.min_score or not s.is_flaky()]
+
+    report = RENDERERS[args.format](stats, args.min_runs)
+
+    if args.output:
+        with open(args.output, "w", encoding="utf-8") as fh:
+            fh.write(report + "\n")
+        print(f"flakeguard: wrote {args.output} ({len(runs)} runs)", file=sys.stderr)
+    else:
+        print(report)
+
+    flaky_count = sum(1 for s in stats if s.is_flaky() and s.considered >= args.min_runs)
+    if args.fail_on_flaky and flaky_count > 0:
+        print(f"flakeguard: {flaky_count} flaky test(s) found", file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())

flakeguard/models.py

@@ -0,0 +1,60 @@
+"""Core data types shared across parsers, scoring and reporting."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Iterable, Optional
+
+
+class Outcome(str, Enum):
+    """The result of a single test in a single run."""
+
+    PASSED = "passed"
+    FAILED = "failed"
+    ERROR = "error"
+    SKIPPED = "skipped"
+
+
+def join_unique(parts: Iterable[str]) -> str:
+    """Join non-empty parts with '::', dropping repeats.
+
+    Frameworks disagree about how they name things: pytest sets a suite and
+    a classname, while jest-junit sets classname == name. Dropping repeats
+    keeps a test's identity stable and readable for both.
+    """
+    seen: list[str] = []
+    for part in parts:
+        if part and part not in seen:
+            seen.append(part)
+    return "::".join(seen)
+
+
+@dataclass(frozen=True)
+class TestCase:
+    """One test's result, as observed in one run.
+
+    ``suite`` is the file/grouping the framework reported (e.g. a test
+    file), ``classname`` is the class or module, and ``name`` is the test
+    itself. Together they form a stable identity so the same test can be
+    matched across runs.
+    """
+
+    name: str
+    suite: str = ""
+    classname: str = ""
+    outcome: Outcome = Outcome.PASSED
+    duration: float = 0.0
+    message: Optional[str] = None
+
+    # Not a field (no annotation): tells pytest this is data, not a test.
+    __test__ = False
+
+    @property
+    def key(self) -> str:
+        """A stable identity for this test across runs."""
+        return join_unique([self.suite, self.classname, self.name]) or "<unnamed>"
+
+    @property
+    def display_name(self) -> str:
+        return join_unique([self.classname, self.name]) or self.name or "<unnamed>"

flakeguard/parsers/__init__.py

@@ -0,0 +1,21 @@
+"""Report parsers.
+
+Each parser turns a framework's native test report into a list of
+:class:`flakeguard.models.TestCase`. Adding support for a new framework
+means adding one module here and registering it in ``by_suffix``.
+"""
+
+from __future__ import annotations
+
+from typing import Callable, List
+
+from ..models import TestCase
+from .junit_xml import parse_junit_xml
+
+# Map of file suffix -> parser callable. Used by the CLI to auto-detect
+# the format of each report file it is handed.
+by_suffix: dict[str, Callable[[str], List[TestCase]]] = {
+    ".xml": parse_junit_xml,
+}
+
+__all__ = ["parse_junit_xml", "by_suffix"]

flakeguard/parsers/junit_xml.py

@@ -0,0 +1,98 @@
+"""Parser for JUnit XML - the de-facto interchange format for test results.
+
+Almost every test framework can emit this: pytest (``--junitxml``), Maven
+and Gradle Surefire, Go's ``gotestsum --junitfile``, Jest
+(``jest-junit``), RSpec (``rspec_junit_formatter``), .NET, PHPUnit, and
+more. That is what makes flakeguard language-agnostic.
+"""
+
+from __future__ import annotations
+
+import xml.etree.ElementTree as ET
+from typing import Iterator, List, Optional, Tuple
+
+from ..models import Outcome, TestCase
+
+
+def _localname(tag: str) -> str:
+    """Strip an XML namespace, if present (``{ns}testcase`` -> ``testcase``)."""
+    return tag.split("}")[-1].lower()
+
+
+def _outcome_and_message(case: ET.Element) -> Tuple[Outcome, Optional[str]]:
+    """Decide a test's outcome from its child elements.
+
+    Per the JUnit schema, a ``<failure>`` means an assertion failed, an
+    ``<error>`` means the test blew up unexpectedly, and a ``<skipped>``
+    means it did not run. A ``<testcase>`` with none of these passed.
+    """
+    for child in case:
+        tag = _localname(child.tag)
+        if tag in ("failure", "error"):
+            text = (child.get("message") or (child.text or "").strip())
+            text = " ".join(text.split())  # collapse whitespace/newlines
+            return (
+                Outcome.FAILED if tag == "failure" else Outcome.ERROR,
+                text[:300] or None,
+            )
+        if tag == "skipped":
+            return Outcome.SKIPPED, child.get("message")
+    return Outcome.PASSED, None
+
+
+def _iter_suites(suite: ET.Element) -> Iterator[ET.Element]:
+    """Yield every ``<testsuite>`` at any depth (they can nest)."""
+    yield suite
+    for child in suite:
+        if _localname(child.tag) == "testsuite":
+            yield from _iter_suites(child)
+
+
+def _collect_cases(container: ET.Element, suite_name: str) -> Iterator[TestCase]:
+    for child in container:
+        tag = _localname(child.tag)
+        if tag == "testcase":
+            outcome, message = _outcome_and_message(child)
+            raw_time = child.get("time")
+            try:
+                duration = float(raw_time) if raw_time else 0.0
+            except ValueError:
+                duration = 0.0
+            yield TestCase(
+                name=child.get("name") or "",
+                suite=suite_name,
+                classname=child.get("classname") or "",
+                outcome=outcome,
+                duration=duration,
+                message=message,
+            )
+        elif tag == "testsuite":
+            nested_name = child.get("name") or suite_name
+            yield from _collect_cases(child, nested_name)
+
+
+def parse_junit_xml(path: str) -> List[TestCase]:
+    """Parse a JUnit XML file into a list of test cases.
+
+    Handles the three common root shapes: ``<testsuites>`` (a bundle of
+    suites), a bare ``<testsuite>``, and nested suites.
+    """
+    try:
+        root = ET.parse(path).getroot()
+    except ET.ParseError as exc:
+        raise ValueError(f"not valid XML ({exc})") from exc
+    root_tag = _localname(root.tag)
+
+    cases: List[TestCase] = []
+
+    if root_tag == "testsuites":
+        for suite in root:
+            if _localname(suite.tag) == "testsuite":
+                cases.extend(_collect_cases(suite, suite.get("name") or ""))
+    elif root_tag == "testsuite":
+        cases.extend(_collect_cases(root, root.get("name") or ""))
+    else:
+        # Unknown root: be permissive and look for testcases anywhere.
+        cases.extend(_collect_cases(root, ""))
+
+    return cases

flakeguard/report.py

@@ -0,0 +1,108 @@
+"""Render analysis results as text, JSON, or Markdown."""
+
+from __future__ import annotations
+
+import json
+from typing import List, Sequence
+
+from .scoring import FlakeStats
+
+
+def _bar(score: float, width: int = 10) -> str:
+    filled = round(score * width)
+    return "#" * filled + "." * (width - filled)
+
+
+def render_text(stats: Sequence[FlakeStats], min_runs: int) -> str:
+    """A human-readable terminal report."""
+    flaky = [s for s in stats if s.is_flaky() and s.considered >= min_runs]
+
+    lines: List[str] = []
+    total = len(stats)
+    lines.append("")
+    lines.append("flakeguard report")
+    lines.append("=" * 60)
+    lines.append(f"tests analysed : {total}")
+    lines.append(f"flaky (>= {min_runs} runs): {len(flaky)}")
+    lines.append("")
+
+    if not flaky:
+        lines.append("No flaky tests found. Your suite is behaving.")
+        lines.append("")
+        return "\n".join(lines)
+
+    lines.append(f"{'score':>6}  {'bar':<10}  {'runs':>4}  {'pass':>4}  {'fail':>4}  test")
+    lines.append("-" * 60)
+    for s in flaky:
+        lines.append(
+            f"{s.score:>6.2f}  {_bar(s.score):<10}  {s.considered:>4}  "
+            f"{s.passed:>4}  {s.failures:>4}  {s.display_name}"
+        )
+
+    # Show the most recent failure message for the worst offender - the
+    # thing a developer actually wants to read.
+    worst = flaky[0]
+    if worst.last_message:
+        lines.append("")
+        lines.append(f"latest failure in {worst.display_name}:")
+        lines.append(f"  {worst.last_message}")
+
+    lines.append("")
+    return "\n".join(lines)
+
+
+def _stats_to_dict(s: FlakeStats) -> dict:
+    return {
+        "key": s.key,
+        "name": s.name,
+        "suite": s.suite,
+        "classname": s.classname,
+        "runs": s.considered,
+        "passed": s.passed,
+        "failed": s.failed,
+        "errored": s.errored,
+        "skipped": s.skipped,
+        "score": round(s.score, 4),
+        "last_message": s.last_message,
+    }
+
+
+def render_json(stats: Sequence[FlakeStats], min_runs: int) -> str:
+    flaky = [s for s in stats if s.is_flaky() and s.considered >= min_runs]
+    payload = {
+        "schema_version": 1,
+        "summary": {
+            "tests_analysed": len(stats),
+            "flaky": len(flaky),
+            "min_runs": min_runs,
+        },
+        "flaky_tests": [_stats_to_dict(s) for s in flaky],
+        "all_tests": [_stats_to_dict(s) for s in stats],
+    }
+    return json.dumps(payload, indent=2)
+
+
+def render_markdown(stats: Sequence[FlakeStats], min_runs: int) -> str:
+    flaky = [s for s in stats if s.is_flaky() and s.considered >= min_runs]
+    lines = ["## flakeguard report", ""]
+    if not flaky:
+        lines.append("No flaky tests found.")
+        return "\n".join(lines)
+    lines.append(f"**{len(flaky)}** flaky test(s) found across {len(stats)} analysed.")
+    lines.append("")
+    lines.append("| score | runs | pass | fail | test |")
+    lines.append("|------:|-----:|-----:|-----:|:-----|")
+    for s in flaky:
+        lines.append(
+            f"| {s.score:.2f} | {s.considered} | {s.passed} | {s.failures} | `{s.display_name}` |"
+        )
+    lines.append("")
+    return "\n".join(lines)
+
+
+RENDERERS = {
+    "text": render_text,
+    "json": render_json,
+    "markdown": render_markdown,
+    "md": render_markdown,
+}

flakeguard/scoring.py

@@ -0,0 +1,122 @@
+"""The heart of flakeguard: turning many runs into a flakiness score.
+
+The idea is simple and explainable. Take every test, look at how it
+behaved across all the runs we were given, and ask: *how often does it
+disagree with itself?*
+
+We ignore skips (a skipped test tells us nothing about flakiness) and
+count only passes vs. non-passes. A test that always passes, or always
+fails, is **not flaky** - it is consistent. Flakiness is disagreement.
+"""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from dataclasses import dataclass, field
+from typing import Iterable, List, Optional
+
+from .models import Outcome, TestCase, join_unique
+
+
+@dataclass
+class FlakeStats:
+    """Aggregated behaviour of one test across all observed runs."""
+
+    key: str
+    name: str
+    suite: str
+    classname: str
+    runs: int = 0
+    passed: int = 0
+    failed: int = 0
+    errored: int = 0
+    skipped: int = 0
+    score: float = 0.0
+    last_message: Optional[str] = None
+    messages: List[str] = field(default_factory=list)
+
+    @property
+    def considered(self) -> int:
+        """Runs that actually inform flakiness (passes + failures + errors)."""
+        return self.passed + self.failed + self.errored
+
+    @property
+    def failures(self) -> int:
+        """Non-passes that were not skips (failures + errors)."""
+        return self.failed + self.errored
+
+    @property
+    def display_name(self) -> str:
+        return join_unique([self.classname, self.name]) or self.name or self.key
+
+    def is_flaky(self, min_score: float = 0.0) -> bool:
+        """A test is flaky if it both passed and failed, and clears the bar."""
+        return self.passed > 0 and self.failures > 0 and self.score > min_score
+
+
+def _score(passed: int, failures: int) -> float:
+    """Flakiness score in [0, 1].
+
+    Defined as ``2 * min(passes, failures) / (passes + failures)``.
+
+    * all passes, or all failures  -> 0.0  (consistent, not flaky)
+    * perfectly alternating 50/50  -> 1.0  (maximally flaky)
+
+    Doubling means the score reads the way people expect: a coin-flip test
+    is "100% flaky", not "50% flaky".
+    """
+    total = passed + failures
+    if total == 0:
+        return 0.0
+    return min(1.0, 2.0 * min(passed, failures) / total)
+
+
+def analyze(runs: Iterable[Iterable[TestCase]]) -> List[FlakeStats]:
+    """Aggregate several runs of test cases into per-test flake statistics.
+
+    ``runs`` is an iterable of runs; each run is an iterable of
+    :class:`TestCase`. Returns stats for every distinct test seen, sorted
+    most-flaky first.
+    """
+    agg: dict[str, FlakeStats] = {}
+
+    for run in runs:
+        seen_in_run: set[str] = set()
+        for case in run:
+            key = case.key
+            # If a framework reports the same key twice in one run (e.g.
+            # parametrised tests without unique names) count it once.
+            if key in seen_in_run:
+                continue
+            seen_in_run.add(key)
+
+            stats = agg.get(key)
+            if stats is None:
+                stats = FlakeStats(
+                    key=key, name=case.name, suite=case.suite, classname=case.classname
+                )
+                agg[key] = stats
+
+            stats.runs += 1
+            if case.outcome is Outcome.PASSED:
+                stats.passed += 1
+            elif case.outcome is Outcome.FAILED:
+                stats.failed += 1
+            elif case.outcome is Outcome.ERROR:
+                stats.errored += 1
+            else:
+                stats.skipped += 1
+
+            if case.message:
+                stats.last_message = case.message
+                if case.message not in stats.messages:
+                    stats.messages.append(case.message)
+
+    for stats in agg.values():
+        stats.score = _score(stats.passed, stats.failures)
+
+    return sorted(
+        agg.values(),
+        key=lambda s: (s.score, s.failures, s.runs),
+        reverse=True,
+    )

flakeguard-0.1.0.dist-info/METADATA

@@ -0,0 +1,141 @@
+Metadata-Version: 2.5
+Name: flakeguard
+Version: 0.1.0
+Summary: Find, rank, and quarantine flaky tests from any language's test reports.
+Project-URL: Homepage, https://github.com/PrathameshKulkarni2k4/flakeguard
+Author: Prathamesh Kulkarni
+License: MIT
+License-File: LICENSE
+Keywords: ci,developer-tools,flaky-tests,junit,test-reports,testing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.9
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# flakeguard
+
+### Your test suite is lying to you.
+
+![flakeguard demo](docs/demo.gif)
+
+Flakeguard finds the tests that **randomly pass and fail**, ranks them by how
+unreliable they are, and shows you why — so you can trust your tests again.
+
+**Free · private · works with any language.** No account, no sign-up, and
+nothing leaves your machine.
+
+[![CI](https://github.com/PrathameshKulkarni2k4/flakeguard/actions/workflows/ci.yml/badge.svg)](https://github.com/PrathameshKulkarni2k4/flakeguard/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![Python 3.9+](https://img.shields.io/badge/python-3.9%2B-blue.svg)](https://www.python.org/)
+
+---
+
+## The problem, in 30 seconds
+
+You have a test that fails once in a while. You re-run it. It passes. Was
+that a real bug? A flaky test? Nobody knows — so everyone ignores it, and
+that is exactly how real bugs hide.
+
+A flaky test costs a team hours, and slowly destroys trust in the entire
+test suite. Flakeguard fixes the hard half of the problem: it tells you
+**exactly which tests are unreliable**, and how unreliable.
+
+## Try it in 60 seconds
+
+```bash
+pipx install flakeguard
+flakeguard scan ./reports        # a folder of test reports
+```
+
+No reports yet? Run it against the examples bundled in this repo:
+
+```bash
+git clone https://github.com/PrathameshKulkarni2k4/flakeguard
+cd flakeguard
+flakeguard scan examples/reports
+```
+
+## What it does
+
+- Reads your test results from **many runs** (the more runs, the sharper the
+  picture).
+- Finds the tests that **disagree with themselves** across those runs.
+- Gives each one a score from **0 (solid) to 1 (a coin-flip)**.
+- Shows the **latest failure message**, so you can go fix it.
+- Runs in your **CI** and can leave a comment on the pull request — or block
+  it when flakiness spikes.
+
+## Works with any language
+
+Flakeguard reads **JUnit XML**, the report format almost every test
+framework can produce. One tool, every language:
+
+| Language / framework | How to produce the report |
+|---|---|
+| Python (pytest) | `pytest --junitxml=report.xml` |
+| Java (Maven / Gradle) | Surefire writes JUnit XML automatically |
+| Go | `gotestsum --junitfile report.xml` |
+| JavaScript (Jest) | the `jest-junit` reporter |
+| Ruby (RSpec) | the `rspec_junit_formatter` gem |
+| .NET, PHPUnit, … | built-in or plugin JUnit output |
+
+## Use in CI (GitHub Actions)
+
+```yaml
+- name: Flakeguard
+  uses: PrathameshKulkarni2k4/flakeguard@main
+  with:
+    reports: reports      # dir/glob of JUnit XML files
+    min-runs: 3           # ignore tests seen in fewer runs
+    max-flaky: 0          # fail if any flaky test is found (-1 = never fail)
+    comment: "true"       # post the report as a PR comment
+```
+
+See [`.github/workflows/example.yml`](.github/workflows/example.yml) for a
+complete workflow that runs a suite several times and feeds the reports in.
+
+To gate locally or in any other CI, use the exit code:
+
+```bash
+flakeguard scan ./reports --fail-on-flaky   # exits 1 if anything is flaky
+```
+
+## How the score works
+
+For each test we count passes vs. non-passes across all runs (skips are
+ignored). The flakiness score is:
+
+```
+score = 2 * min(passes, failures) / (passes + failures)
+```
+
+- always passes, or always fails → **0.0** (consistent, *not* flaky)
+- flips on every run (50/50) → **1.0** (maximally flaky)
+
+It is deliberately explainable — no black box. You can read the number and
+know exactly how it was derived.
+
+## Roadmap
+
+- [x] JUnit XML parsing, flakiness scoring, text/JSON/Markdown reports
+- [x] GitHub Action with PR comments and a flakiness budget
+- [ ] TAP and native JSON report formats
+- [ ] CI history so it learns across builds
+- [ ] Failure-signature clustering (group the *same* flake across tests)
+- [ ] Quarantine file so known flakes are set aside, not deleted
+
+## Contributing
+
+Contributions are very welcome — see [CONTRIBUTING.md](CONTRIBUTING.md).
+Adding support for a new report format is a great first contribution and is
+designed to be small. Please be kind; this project follows a
+[Code of Conduct](CODE_OF_CONDUCT.md).
+
+## License
+
+MIT — see [LICENSE](LICENSE).

flakeguard-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+flakeguard/__init__.py,sha256=EjV4fmMO0AcBER6iHiLs9OVJwCPO6wkiMcfiJCvjo_8,509
+flakeguard/__main__.py,sha256=jyPbPPn4AGYrVhojF1k7rEKBnFSjycbV_azmzH2lZ4A,157
+flakeguard/cli.py,sha256=OkWOUS6Oqd64Jr3AD9affnFQ9dLSDgSkWzhvk-2xyOE,4871
+flakeguard/models.py,sha256=HVJV7g06GKrWsx0K8gJ8sC0Rzcl5SmGNHlXsmB4Bdgk,1751
+flakeguard/report.py,sha256=Syr06YulzcIuYD1tYDZKcYgm_h3TeL6YYsMf9XsUtVg,3301
+flakeguard/scoring.py,sha256=EWInlr2hrAzLJVY1D9_OW6F9n--kAhBDT7LFoBSeklU,3927
+flakeguard/parsers/__init__.py,sha256=TEnhrPd3Xih53TD4q_Ak07KlWFdUMjKDzvRUCeUtP-8,622
+flakeguard/parsers/junit_xml.py,sha256=wpzHGRz-MWWkt8U7g_sLtoh4FoqfoBPdhk9PO6PXyQw,3527
+flakeguard-0.1.0.dist-info/METADATA,sha256=Vc7UDxvaqE_iSIJYlzsG8u_Azxru_XLRDeigtpivUgU,4876
+flakeguard-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+flakeguard-0.1.0.dist-info/entry_points.txt,sha256=Ns1hCKxs63kg6RRdZz2yZNk7y2FcA4BrT27ImLzjYoI,51
+flakeguard-0.1.0.dist-info/licenses/LICENSE,sha256=iOnuFk0Tr21BAqhvxGbrkBFTkM_8EJlb4WqrtOBbknc,1076
+flakeguard-0.1.0.dist-info/RECORD,,

flakeguard-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

flakeguard-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+flakeguard = flakeguard.cli:main

flakeguard-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Prathamesh Kulkarni
+
+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.