patchahead 0.3.0__py3-none-any.whl

patchahead/observability.py

@@ -0,0 +1,223 @@
+"""Logging, timing, and optional error reporting.
+
+Three rules this module exists to enforce:
+
+1. **Nothing fails silently.** Optional integrations degrade to a no-op, but the
+   degradation itself is logged at debug level with the reason.
+2. **Nothing sensitive is logged.** :func:`redact` scrubs values that look like
+   credentials, and source code is never logged above debug level.
+3. **Timing is measured, not claimed.** :class:`Timer` records real durations so
+   performance statements come from instrumentation.
+
+Sentry is entirely optional; PatchAhead has no runtime dependency on it.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import logging
+import os
+import re
+import sys
+import time
+from collections.abc import Iterator
+from typing import Any
+
+log = logging.getLogger("patchahead")
+
+#: Environment variables whose values must never reach a log or an error report.
+_SECRET_PATTERN = re.compile(
+    r"(?i)(api[_-]?key|secret|token|password|passwd|authorization|dsn|credential)"
+)
+_SECRET_VALUE = re.compile(r"(?i)\b(sk-[A-Za-z0-9_\-]{8,}|ghp_[A-Za-z0-9]{8,})\b")
+
+
+def redact(value: Any) -> Any:
+    """Return ``value`` with anything credential-shaped replaced.
+
+    Applied to every structured log field. Conservative by design: a redacted
+    log line is a mild inconvenience, a leaked key is an incident.
+    """
+    if isinstance(value, str):
+        return _SECRET_VALUE.sub("[REDACTED]", value)
+    if isinstance(value, dict):
+        return {
+            key: ("[REDACTED]" if _SECRET_PATTERN.search(str(key)) else redact(val))
+            for key, val in value.items()
+        }
+    if isinstance(value, (list, tuple)):
+        return type(value)(redact(v) for v in value)
+    return value
+
+
+class _RedactingFilter(logging.Filter):
+    """Scrub credential-shaped substrings from every formatted message."""
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        if isinstance(record.msg, str):
+            record.msg = _SECRET_VALUE.sub("[REDACTED]", record.msg)
+        if record.args:
+            record.args = redact(record.args)
+        return True
+
+
+class _Formatter(logging.Formatter):
+    """Plain, greppable output. Level prefix only when it matters."""
+
+    def format(self, record: logging.LogRecord) -> str:
+        message = record.getMessage()
+        if record.levelno >= logging.WARNING:
+            prefix = f"{record.levelname.lower()}: "
+        elif record.levelno <= logging.DEBUG:
+            prefix = f"debug [{record.name}] "
+        else:
+            prefix = ""
+        if record.exc_info:
+            message = f"{message}\n{self.formatException(record.exc_info)}"
+        return f"{prefix}{message}"
+
+
+def configure_logging(level: int = logging.INFO, stream: Any = None) -> None:
+    """Install PatchAhead's log handler. Idempotent.
+
+    Logs go to stderr so that ``--json`` output on stdout stays machine-readable
+    even at debug verbosity.
+    """
+    logger = logging.getLogger("patchahead")
+    logger.setLevel(level)
+    logger.propagate = False
+
+    for handler in list(logger.handlers):
+        logger.removeHandler(handler)
+
+    handler = logging.StreamHandler(stream if stream is not None else sys.stderr)
+    handler.setFormatter(_Formatter())
+    handler.addFilter(_RedactingFilter())
+    logger.addHandler(handler)
+
+
+class Timer:
+    """Accumulates named wall-clock durations for one run.
+
+    Used for the ``timings`` field on results, so any performance claim
+    PatchAhead makes is backed by a measurement the user can see.
+    """
+
+    def __init__(self) -> None:
+        self.durations: dict[str, int] = {}
+
+    @contextlib.contextmanager
+    def stage(self, name: str) -> Iterator[None]:
+        start = time.perf_counter()
+        try:
+            yield
+        finally:
+            elapsed = int((time.perf_counter() - start) * 1000)
+            self.durations[name] = self.durations.get(name, 0) + elapsed
+            log.debug("stage %s took %dms", name, elapsed)
+
+    def as_dict(self) -> dict[str, int]:
+        return dict(self.durations)
+
+
+# --------------------------------------------------------------------------
+# Optional Sentry integration
+# --------------------------------------------------------------------------
+
+_sentry_state: dict[str, Any] = {
+    "initialized": False,
+    "enabled": False,
+    "reason": "not initialized",
+}
+
+
+def init_error_reporting() -> bool:
+    """Initialize Sentry if ``SENTRY_DSN`` is set and the SDK is installed.
+
+    Returns whether reporting is active. Never raises: a broken optional
+    integration must not break a migration run. The reason for any degradation
+    is recorded and available from :func:`error_reporting_status`.
+    """
+    if _sentry_state["initialized"]:
+        return bool(_sentry_state["enabled"])
+    _sentry_state["initialized"] = True
+
+    dsn = os.environ.get("SENTRY_DSN", "").strip()
+    if not dsn:
+        _sentry_state["reason"] = "SENTRY_DSN not set"
+        log.debug("error reporting disabled: %s", _sentry_state["reason"])
+        return False
+    try:
+        import sentry_sdk
+    except ImportError:
+        _sentry_state["reason"] = "sentry-sdk not installed (pip install 'patchahead[sentry]')"
+        log.debug("error reporting disabled: %s", _sentry_state["reason"])
+        return False
+    try:
+        from patchahead import __version__
+
+        sentry_sdk.init(
+            dsn=dsn,
+            release=f"patchahead@{__version__}",
+            traces_sample_rate=float(os.environ.get("PATCHAHEAD_TRACES_SAMPLE_RATE", "0")),
+            # Repository source is the user's proprietary code. Never attach it.
+            send_default_pii=False,
+            # On by default in sentry-sdk: every stack frame would carry its
+            # local variables, and here those are `source`, `original`, a
+            # patched file -- the repository's code, in full.
+            include_local_variables=False,
+            max_request_body_size="never",
+            before_send=_scrub_event,
+        )
+    except Exception as exc:
+        _sentry_state["reason"] = f"sentry_sdk.init failed: {exc}"
+        log.warning("error reporting could not start: %s", _sentry_state["reason"])
+        return False
+
+    _sentry_state["enabled"] = True
+    _sentry_state["reason"] = "active"
+    log.debug("error reporting enabled")
+    return True
+
+
+def _scrub_event(event: dict[str, Any], _hint: Any) -> dict[str, Any]:
+    """Strip environment variables, request bodies, and frame locals from events.
+
+    Frame locals are also disabled at ``init``; removing them here as well means
+    a future change to that setting cannot quietly start sending source code.
+    """
+    event.pop("request", None)
+    for section in ("exception", "threads"):
+        for value in (event.get(section) or {}).get("values") or []:
+            for frame in (value.get("stacktrace") or {}).get("frames") or []:
+                frame.pop("vars", None)
+    contexts = event.get("contexts")
+    if isinstance(contexts, dict):
+        contexts.pop("env", None)
+    extra = event.get("extra")
+    if isinstance(extra, dict):
+        event["extra"] = redact(extra)
+    return event
+
+
+def error_reporting_status() -> str:
+    """Human-readable state of the optional error reporting integration."""
+    if not _sentry_state["initialized"]:
+        return "not initialized"
+    return "active" if _sentry_state["enabled"] else f"disabled ({_sentry_state['reason']})"
+
+
+def capture_exception(exc: BaseException, **context: Any) -> None:
+    """Report an exception if Sentry is active. Always logs it either way."""
+    log.debug("captured exception: %s", exc, exc_info=exc)
+    if not _sentry_state.get("enabled"):
+        return
+    try:
+        import sentry_sdk
+
+        with sentry_sdk.push_scope() as scope:
+            for key, value in redact(context).items():
+                scope.set_extra(key, value)
+            sentry_sdk.capture_exception(exc)
+    except Exception:  # pragma: no cover - reporting must never break a run
+        log.debug("failed to report exception to Sentry", exc_info=True)

patchahead/reporting.py

@@ -0,0 +1,451 @@
+"""Rendering results for humans: terminal text and a review-ready Markdown PR.
+
+Every number here comes from a result object. Nothing is computed a second time,
+so what the CLI prints and what the JSON output says cannot drift apart.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from patchahead.domain.change import BreakingChange, Confidence
+from patchahead.domain.completeness import CompletenessReport, ResidualKind
+from patchahead.domain.impact import ImpactReport
+from patchahead.domain.result import AnalysisResult, MigrationResult, MigrationRun, Outcome
+from patchahead.domain.validation import GateStatus, ValidationResult
+
+_COLORS = {
+    "bold": "1",
+    "dim": "90",
+    "red": "91",
+    "green": "92",
+    "yellow": "93",
+    "cyan": "96",
+}
+
+
+def _use_color(stream) -> bool:
+    if os.environ.get("NO_COLOR"):
+        return False
+    return bool(getattr(stream, "isatty", lambda: False)())
+
+
+class Style:
+    """Colors, switched off when output is redirected or ``NO_COLOR`` is set."""
+
+    def __init__(self, enabled: bool) -> None:
+        self.enabled = enabled
+
+    def __call__(self, text: str, color: str) -> str:
+        if not self.enabled or color not in _COLORS:
+            return text
+        return f"\033[{_COLORS[color]}m{text}\033[0m"
+
+    @classmethod
+    def for_stream(cls, stream) -> Style:
+        return cls(_use_color(stream))
+
+
+_CONFIDENCE_COLOR = {
+    Confidence.HIGH: "green",
+    Confidence.MEDIUM: "yellow",
+    Confidence.LOW: "dim",
+}
+
+_OUTCOME_COLOR = {
+    Outcome.MIGRATED: "green",
+    Outcome.VALIDATION_FAILED: "red",
+    Outcome.PATCHED_UNVERIFIED: "yellow",
+    Outcome.PATCH_FAILED: "red",
+    Outcome.NO_IMPACT: "dim",
+    Outcome.UNSUPPORTED_CHANGE: "yellow",
+    Outcome.NOT_PLANNABLE: "yellow",
+    Outcome.DRY_RUN: "cyan",
+}
+
+
+def relative(path: str) -> str:
+    """Shorten an absolute path against the working directory, when shorter."""
+    try:
+        candidate = os.path.relpath(path, Path.cwd())
+    except (ValueError, OSError):
+        return path
+    return candidate if len(candidate) < len(path) else path
+
+
+# --------------------------------------------------------------------------
+# terminal rendering
+# --------------------------------------------------------------------------
+
+
+def render_change(change: BreakingChange, style: Style) -> list[str]:
+    lines = [
+        style(change.title, "bold"),
+        f"  kind        {style(change.kind.value, 'cyan')}",
+        f"  severity    {change.severity.value}    confidence {change.confidence.value}",
+    ]
+    if change.target.is_rename:
+        owner = f" on `{change.target.owner}`" if change.target.owner else ""
+        lines.append(
+            f"  rename      `{change.target.symbol}` -> `{change.target.replacement}`{owner}"
+        )
+    if change.old_behavior:
+        lines.append(f"  before      {change.old_behavior}")
+    if change.new_behavior:
+        lines.append(f"  after       {change.new_behavior}")
+    if change.classification_reason:
+        lines.append(style(f"  why         {change.classification_reason}", "dim"))
+    return lines
+
+
+def render_impact(report: ImpactReport, style: Style, verbose: bool = False) -> list[str]:
+    if report.unsupported_reason:
+        return [style(f"  unsupported: {report.unsupported_reason}", "yellow")]
+    if not report.findings:
+        return [style("  no affected code found", "dim")]
+
+    lines = [
+        f"  {len(report.findings)} finding(s) in "
+        f"{len(report.affected_files)} file(s), "
+        f"scanned {report.files_scanned} file(s) in {report.analysis_ms}ms",
+    ]
+    for finding in report.findings:
+        marker = "+" if finding.patchable else "-"
+        color = _CONFIDENCE_COLOR[finding.confidence]
+        lines.append(
+            f"  {style(marker, color)} {finding.reference}"
+            f"  {style(finding.confidence.value, color)}"
+            f"  {finding.symbol}  {finding.matched_contract}"
+        )
+        if verbose or not finding.patchable:
+            lines.append(style(f"      {finding.reason}", "dim"))
+        if finding.reference.snippet:
+            lines.append(style(f"      | {finding.reference.snippet}", "dim"))
+
+    if report.related_tests:
+        lines.append(f"  relevant tests: {', '.join(report.related_tests)}")
+    if report.graph and verbose:
+        lines.append("")
+        lines.extend(f"  {line}" for line in report.graph.render().splitlines())
+    return lines
+
+
+def render_validation(validation: ValidationResult, style: Style) -> list[str]:
+    marks = {
+        GateStatus.PASSED: (style("pass", "green"), "green"),
+        GateStatus.FAILED: (style("FAIL", "red"), "red"),
+        GateStatus.SKIPPED: (style("skip", "dim"), "dim"),
+    }
+    lines = []
+    for gate in validation.gates:
+        mark, _ = marks[gate.status]
+        timing = f" ({gate.duration_ms}ms)" if gate.duration_ms else ""
+        lines.append(f"  [{mark}] {gate.name.value:<20}{timing} {gate.detail}")
+    return lines
+
+
+def render_analysis(result: AnalysisResult, verbose: bool = False, stream=None) -> str:
+    style = Style.for_stream(stream)
+    lines = [
+        style(f"repository     {relative(result.repo)}", "dim"),
+        style(f"change document {relative(result.change_document)}", "dim"),
+        "",
+    ]
+    for report in result.reports:
+        lines.extend(render_change(report.change, style))
+        lines.extend(render_impact(report, style, verbose))
+        lines.append("")
+
+    for warning in result.warnings:
+        lines.append(style(f"warning: {warning}", "yellow"))
+
+    if result.total_findings:
+        lines.append(
+            style(
+                f"{result.total_findings} finding(s). Run `patchahead migrate` with "
+                f"the same arguments to propose a migration.",
+                "bold",
+            )
+        )
+    else:
+        lines.append(style("No affected code found.", "dim"))
+    if verbose and result.timings:
+        lines.append(
+            style(
+                "timings: " + ", ".join(f"{k}={v}ms" for k, v in sorted(result.timings.items())),
+                "dim",
+            )
+        )
+    return "\n".join(lines)
+
+
+def render_migration(
+    result: MigrationResult, verbose: bool = False, show_diff: bool = True, stream=None
+) -> str:
+    style = Style.for_stream(stream)
+    color = _OUTCOME_COLOR.get(result.outcome, "bold")
+    lines = list(render_change(result.impact.change, style))
+    lines.append("")
+    lines.extend(render_impact(result.impact, style, verbose))
+    lines.append("")
+
+    if result.plan and not result.plan.blocked_reason:
+        lines.append(style("plan", "bold"))
+        lines.extend(f"  {line}" for line in result.plan.render().splitlines()[1:])
+        lines.append("")
+    elif result.plan and result.plan.blocked_reason:
+        lines.append(style(f"plan blocked: {result.plan.blocked_reason}", "yellow"))
+        for skipped in result.plan.skipped:
+            lines.append(style(f"  skipped {skipped}", "dim"))
+        lines.append("")
+
+    if show_diff and result.diff:
+        lines.append(style("proposed diff", "bold"))
+        for line in result.diff.splitlines():
+            if line.startswith("+++") or line.startswith("---"):
+                lines.append(style(f"  {line}", "dim"))
+            elif line.startswith("+"):
+                lines.append(style(f"  {line}", "green"))
+            elif line.startswith("-"):
+                lines.append(style(f"  {line}", "red"))
+            elif line.startswith("@@"):
+                lines.append(style(f"  {line}", "cyan"))
+            else:
+                lines.append(f"  {line}")
+        lines.append("")
+
+    if result.validation:
+        lines.append(style("validation", "bold"))
+        lines.extend(render_validation(result.validation, style))
+        lines.append("")
+
+    if result.completeness:
+        lines.append(style("completeness", "bold"))
+        lines.extend(render_completeness(result.completeness, style, verbose))
+        lines.append("")
+
+    lines.append(style(f"{result.outcome.value}: {result.message}", color))
+    if result.artifacts:
+        for key, path in sorted(result.artifacts.items()):
+            lines.append(style(f"  {key:<8} {relative(path)}", "dim"))
+    if result.workspace_path:
+        lines.append(style(f"  workspace {result.workspace_path}", "dim"))
+    if verbose and result.timings:
+        lines.append(
+            style(
+                "  timings: " + ", ".join(f"{k}={v}ms" for k, v in sorted(result.timings.items())),
+                "dim",
+            )
+        )
+    return "\n".join(lines)
+
+
+#: How many unfinished residuals the terminal lists before summarizing the rest.
+_RESIDUALS_SHOWN = 10
+_MENTION_KINDS = (
+    ResidualKind.STRING,
+    ResidualKind.COMMENT,
+    ResidualKind.CONFIG,
+    ResidualKind.DOCS,
+)
+
+
+def render_completeness(
+    report: CompletenessReport, style: Style, verbose: bool = False
+) -> list[str]:
+    """Where the old name survives: unfinished work first, mentions summarized."""
+    names = f"`{report.old}` -> `{report.new}`"
+    unfinished = report.unfinished
+    lines = [
+        style(f"  {names}: no code, dynamic access, or test still uses `{report.old}`", "green")
+        if not unfinished
+        else style(f"  {names}: {len(unfinished)} place(s) still use `{report.old}`", "yellow")
+    ]
+    for residual in unfinished[:_RESIDUALS_SHOWN]:
+        lines.append(
+            f"  [{residual.kind.value:<7}] {residual.path}:{residual.line}  {residual.snippet}"
+        )
+        lines.append(style(f"            {residual.reason}", "dim"))
+    if len(unfinished) > _RESIDUALS_SHOWN:
+        lines.append(style(f"  ... and {len(unfinished) - _RESIDUALS_SHOWN} more (--json)", "dim"))
+
+    other = report.count(ResidualKind.OTHER_OBJECT)
+    if other:
+        lines.append(
+            style(f"  {other} site(s) on a different object, left alone on purpose", "dim")
+        )
+    mentions = [(kind, report.count(kind)) for kind in _MENTION_KINDS if report.count(kind)]
+    if mentions:
+        counted = ", ".join(f"{n} {kind.value}" for kind, n in mentions)
+        lines.append(style(f"  mentions to review: {counted}", "dim"))
+        if verbose:
+            for residual in report.residuals:
+                if residual.kind in _MENTION_KINDS:
+                    lines.append(
+                        style(f"    {residual.path}:{residual.line}  {residual.snippet}", "dim")
+                    )
+    return lines
+
+
+def render_run(
+    run: MigrationRun, verbose: bool = False, show_diff: bool = True, stream=None
+) -> str:
+    style = Style.for_stream(stream)
+    blocks = [
+        style(f"repository      {relative(run.repo)}", "dim"),
+        style(f"change document {relative(run.change_document)}", "dim"),
+        "",
+    ]
+    for index, result in enumerate(run.results):
+        if index:
+            blocks.append(style("-" * 60, "dim"))
+        blocks.append(render_migration(result, verbose, show_diff, stream))
+    for warning in run.warnings:
+        blocks.append(style(f"warning: {warning}", "yellow"))
+    if not run.results:
+        blocks.append(style("No breaking changes were parsed from the document.", "yellow"))
+    return "\n".join(blocks)
+
+
+# --------------------------------------------------------------------------
+# Markdown, for a pull request body
+# --------------------------------------------------------------------------
+
+
+def render_pr_markdown(result: MigrationResult) -> str:
+    """A review-ready Markdown summary of one migration.
+
+    Ordered by what a reviewer needs to decide: what upstream changed, where it
+    hit us, exactly what we propose to do about it, and what evidence says it
+    worked. Then the diff. The checklist at the end is what the human is being
+    asked to confirm -- PatchAhead does not merge anything.
+    """
+    change = result.impact.change
+    report = result.impact
+    lines: list[str] = []
+
+    title = (
+        f"Migrate `{change.target.symbol}` -> `{change.target.replacement}`"
+        if change.target.is_rename
+        else f"Migrate for: {change.title}"
+    )
+    lines += [
+        f"# {title}",
+        "",
+        "> Proposed by **PatchAhead**. Not merged, not applied. Review before approving.",
+        "",
+        "## 1. Upstream change",
+        "",
+        f"- **Kind:** `{change.kind.value}`",
+        f"- **Severity:** {change.severity.value}",
+        f"- **Reading confidence:** {change.confidence.value} ({change.classification_reason})",
+    ]
+    if change.old_behavior:
+        lines.append(f"- **Before:** {change.old_behavior}")
+    if change.new_behavior:
+        lines.append(f"- **After:** {change.new_behavior}")
+    if change.migration_hint:
+        lines.append(f"- **Migration guidance:** {change.migration_hint}")
+    if change.evidence:
+        lines += ["", "<details><summary>Evidence from the change document</summary>", ""]
+        for evidence in change.evidence:
+            location = f" (line {evidence.line})" if evidence.line else ""
+            lines.append(f"- {evidence.quote}{location}")
+        lines += ["", "</details>"]
+
+    lines += ["", "## 2. Downstream impact", ""]
+    if report.findings:
+        lines += [
+            "| Location | Symbol | Matched | Confidence | Patched |",
+            "|---|---|---|---|---|",
+        ]
+        for finding in report.findings:
+            lines.append(
+                f"| `{finding.reference}` | `{finding.symbol}` | "
+                f"`{finding.matched_contract}` | {finding.confidence.value} | "
+                f"{'yes' if finding.patchable else 'no'} |"
+            )
+        unpatched = [f for f in report.findings if not f.patchable]
+        if unpatched:
+            lines += ["", "**Reported but not changed:**", ""]
+            lines += [f"- `{f.reference}` -- {f.unpatchable_reason or f.reason}" for f in unpatched]
+    else:
+        lines.append("_No affected code was found._")
+
+    lines += ["", "## 3. Proposed change", ""]
+    if result.plan and not result.plan.blocked_reason:
+        lines += [
+            f"- **Handler:** `{result.plan.handler}`",
+            f"- **Risk:** {result.plan.risk.value}",
+            f"- **Rationale:** {result.plan.rationale}",
+            "",
+            "```",
+            result.plan.render(),
+            "```",
+        ]
+    elif result.plan:
+        lines.append(f"_No migration could be planned:_ {result.plan.blocked_reason}")
+
+    lines += ["", "## 4. Evidence", ""]
+    if result.validation:
+        lines += ["| Gate | Status | Detail |", "|---|---|---|"]
+        for gate in result.validation.gates:
+            lines.append(f"| `{gate.name.value}` | {gate.status.value} | {gate.detail} |")
+    else:
+        lines.append("_Validation did not run._")
+
+    if result.baseline_tests:
+        lines += [
+            "",
+            f"Tests before the patch: `{result.baseline_tests.summary}`",
+        ]
+
+    if result.diff:
+        lines += ["", "## 5. Diff", "", "```diff", result.diff.rstrip(), "```"]
+
+    if result.completeness:
+        lines += ["", "## 6. What is left of the old API", ""]
+        lines += _completeness_markdown(result.completeness)
+
+    lines += [
+        "",
+        "## 7. Human review",
+        "",
+        f"- **Outcome:** `{result.outcome.value}` -- {result.message}",
+        "- **Auto-merge:** disabled. PatchAhead proposes; a human approves.",
+        "",
+        "### Checklist",
+        "",
+        "- [ ] The upstream change is characterized correctly",
+        "- [ ] The diff is minimal and changes no unrelated code",
+        "- [ ] The tests genuinely exercise the migrated behavior",
+        "- [ ] Findings reported but not patched have been looked at",
+        "- [ ] Every place the old name survives (section 6) has been looked at",
+        "",
+    ]
+    return "\n".join(lines)
+
+
+def _completeness_markdown(report: CompletenessReport) -> list[str]:
+    unfinished = report.unfinished
+    if unfinished:
+        lines = [
+            f"**{len(unfinished)} place(s) still use `{report.old}`.** Passing tests do "
+            f"not cover these.",
+            "",
+            "| Location | Kind | Code | Why |",
+            "|---|---|---|---|",
+        ]
+        lines += [
+            f"| `{r.path}:{r.line}` | {r.kind.value} | `{r.snippet}` | {r.reason} |"
+            for r in unfinished
+        ]
+    else:
+        lines = [f"No code, dynamic access, or test still uses `{report.old}`."]
+    rest = [r for r in report.residuals if not r.kind.unfinished]
+    if rest:
+        lines += ["", "<details><summary>Left on purpose, and mentions to review</summary>", ""]
+        lines += [f"- `{r.path}:{r.line}` ({r.kind.value}) -- {r.reason}" for r in rest]
+        lines += ["", "</details>"]
+    return lines

patchahead/testing/__init__.py

@@ -0,0 +1,22 @@
+"""Test discovery and execution."""
+
+from patchahead.testing import discovery, runner
+from patchahead.testing.discovery import (
+    has_any_tests,
+    scoped_command,
+    tests_by_file,
+    tests_for_path,
+    tests_for_paths,
+)
+from patchahead.testing.runner import run_tests
+
+__all__ = [
+    "discovery",
+    "run_tests",
+    "runner",
+    "has_any_tests",
+    "scoped_command",
+    "tests_by_file",
+    "tests_for_path",
+    "tests_for_paths",
+]