admitperf 0.0.1__py3-none-any.whl

admitperf/__init__.py

@@ -0,0 +1,43 @@
+"""AdmitPerf — standardized admission control for LLM inference.
+
+Bring your own infra. Your gateway already has raw metrics; AdmitPerf turns them
+into signals, policies decide on signals, and every decision is recorded in a form
+a report can compare across deployments.
+
+    from admitperf import Policy
+    from admitperf.core.signals import KV_PRESSURE
+
+    class KvWall(Policy):
+        name = "kv_wall"
+
+        def decide(self, metrics):
+            if KV_PRESSURE.read(metrics) >= self.threshold:
+                return self.reject("kv_pressure")
+            return self.admit()
+
+`admitperf.core` is what runs in your request path and imports nothing but the
+standard library. Everything else is a consumer of what it writes.
+"""
+
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError, version
+
+from admitperf.core import REASONS, Decision, Log, Policy, Signal, Verdict
+
+try:
+    # Read from installed metadata rather than restating it. Two copies of a version
+    # number is one too many, and the stale one is always the one a report quotes.
+    __version__ = version("admitperf")
+except PackageNotFoundError:  # a source tree with no install
+    __version__ = "0.0.0+unknown"
+
+__all__ = [
+    "REASONS",
+    "Decision",
+    "Log",
+    "Policy",
+    "Signal",
+    "Verdict",
+    "__version__",
+]

admitperf/cli.py

@@ -0,0 +1,282 @@
+"""The CLI. Three verbs, and none of them is in a request path.
+
+    admitperf demo                                  try it, no GPU needed
+    admitperf watch http://host:8000/metrics --for 1h -o trace.jsonl
+    admitperf report trace.jsonl
+    admitperf compare baseline.jsonl with-policy.jsonl
+    admitperf dashboard
+
+`admitperf.core` never fetches anything, because a network round trip has no place
+on an admission decision. These commands run out of band, so `watch` scraping a
+metrics endpoint for you is a convenience rather than a contradiction.
+
+Nothing here provisions, serves, or generates load. That is your infra's job.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import click
+
+from admitperf import __version__
+
+
+def _seconds(text: str) -> float:
+    """`90`, `30s`, `15m`, `2h` — because `--for 3600` is how you mean an hour and
+    type a mistake."""
+    units = {"s": 1, "m": 60, "h": 3600}
+    if text and text[-1] in units:
+        return float(text[:-1]) * units[text[-1]]
+    return float(text)
+
+
+@click.group()
+@click.version_option(__version__)
+def main() -> None:
+    """Standardized admission control for LLM inference."""
+
+
+@main.command()
+@click.argument("url")
+@click.option("--for", "duration", default="60s", show_default=True, help="90s · 15m · 2h")
+@click.option("--every", default=1.0, show_default=True, help="seconds between scrapes")
+@click.option("-o", "--out", default="trace.jsonl", show_default=True)
+def watch(url: str, duration: str, every: float, out: str) -> None:
+    """Record what your cluster is doing. No code in your request path.
+
+    \b
+      admitperf watch http://localhost:8000/metrics --for 1h -o trace.jsonl
+
+    Answers the question no surveyed paper answers — could a policy have fired
+    here, and which signal actually moved — before you change any code.
+    """
+    from admitperf.watch import Watch
+
+    seconds = _seconds(duration)
+    click.echo(f"watching {url} every {every:g}s for {seconds:g}s -> {out}")
+    w = Watch(url, out, interval=every).run(seconds)
+    click.echo(f"{w.samples} samples, {w.failures} failed scrape(s)")
+    if w.samples == 0:
+        raise SystemExit(f"nothing was recorded. Is {url} reachable and serving Prometheus text?")
+    click.echo(f"\n  admitperf report {out}")
+
+
+@main.command()
+@click.argument("log", type=click.Path(exists=True, dir_okay=False))
+@click.option(
+    "--check",
+    is_flag=True,
+    help="exit non-zero unless the log can support a claim about the policy",
+)
+def report(log: str, check: bool) -> None:
+    """The finding from a log.
+
+    \b
+      admitperf report trace.jsonl
+      admitperf report decisions.jsonl --check     # for CI
+    """
+    from admitperf.report import Report
+
+    r = Report.from_log(log)
+    click.echo(r.text())
+    if check and r.verdict() != "LIVE":
+        raise SystemExit(f"verdict is {r.verdict()}: this log cannot support a claim")
+
+
+@main.command("experiments")
+def list_experiments() -> None:
+    """Every experiment found under this directory, and its arms."""
+    from admitperf.discover import experiments
+
+    found = experiments()
+    if not found:
+        click.echo("no logs here. `admitperf demo --repeats 5` makes some.")
+        return
+    for name, exp in sorted(found.items()):
+        click.echo(f"\n{name}   ({exp.runs} run(s))")
+        if exp.notes:
+            click.echo(f"  {exp.notes}")
+        for runs in exp.policies.values():
+            click.echo(f"    {runs.label}")
+        if exp.baseline is None:
+            click.echo("    !! no baseline, so nothing can be compared against")
+
+
+@main.command()
+@click.option("--repeats", default=1, show_default=True, help="runs per policy")
+@click.option(
+    "-o",
+    "--out",
+    default="experiments",
+    show_default=True,
+    help="logs land in <out>/<experiment>/<policy>/r<n>.jsonl",
+)
+def demo(repeats: int, out: str) -> None:
+    """Try the whole thing in one command. No GPU, no cluster, no config.
+
+    \b
+      admitperf demo
+      admitperf demo --repeats 5
+
+    Drives identical traffic through a simulated engine three times — admitting
+    everything, with a KV-pressure threshold, and with a queue bound derived from the
+    SLO — then compares the reports.
+
+    A demo, not an experiment runner: it takes no engine URL and no workload, because
+    AdmitPerf does not generate load. Against a real cluster your own load generator
+    drives traffic and `admitperf watch` records it.
+    """
+    from admitperf.demo import main as run_demo
+
+    run_demo(repeats=repeats, out=out, echo=click.echo)
+
+
+@main.command()
+@click.argument("baseline", type=click.Path(exists=True), required=False)
+@click.argument("policy", type=click.Path(exists=True), required=False)
+@click.option(
+    "--experiment",
+    "-e",
+    help="compare every policy in a named experiment against its baseline",
+)
+@click.option(
+    "--check",
+    is_flag=True,
+    help="exit non-zero unless the comparison is trustworthy: the policy fired, both "
+    "runs faced the same load, and outcomes were recorded",
+)
+def compare(baseline: str | None, policy: str | None, experiment: str | None, check: bool) -> None:
+    """What did the policy buy?
+
+    \b
+      admitperf compare --experiment demo-overload-2.5x   # every arm vs its baseline
+      admitperf compare baseline.jsonl with-policy.jsonl  # or two paths directly
+
+    The question the package exists to answer. Four checks come before any number,
+    because a comparison between a policy that never fired and a baseline is two
+    measurements of the same configuration.
+    """
+    from admitperf.comparison import Comparison
+    from admitperf.discover import find
+    from admitperf.report import Report
+
+    if experiment:
+        exp = find(experiment)
+        if exp.baseline is None:
+            raise SystemExit(
+                f"experiment {experiment!r} has no baseline, so there is nothing to "
+                "compare against. Run a policy with `baseline = True` — NoAdmission is one."
+            )
+        if not exp.candidates:
+            raise SystemExit(f"experiment {experiment!r} has only a baseline")
+        if exp.notes:
+            click.echo(f"{experiment} — {exp.notes}\n")
+        failed = False
+        base = [Report.from_log(p) for p in exp.baseline.logs]
+        for candidate in exp.candidates:
+            click.echo(f"\n### {exp.baseline.label}  vs  {candidate.label}")
+            c = Comparison(base, [Report.from_log(p) for p in candidate.logs])
+            click.echo(c.text())
+            failed = failed or not (c.fired() and c.comparable_load() and c.measurable())
+        if check and failed:
+            raise SystemExit("at least one pair cannot support a claim")
+        return
+
+    if not (baseline and policy):
+        raise SystemExit("give two logs, or --experiment NAME. `admitperf dashboard` lists them.")
+    c = Comparison.from_logs(baseline, policy)
+    click.echo(c.text())
+    if check and not (c.fired() and c.comparable_load() and c.measurable()):
+        raise SystemExit("this pair cannot support a claim — see CAN YOU TRUST THIS above")
+
+
+def _free_port(start: int, tries: int = 20) -> int:
+    """The first free port at or above `start`.
+
+    Bound on all interfaces and WITHOUT SO_REUSEADDR, because that is what Streamlit
+    does. A probe against 127.0.0.1 with SO_REUSEADDR set reports a port as free while
+    Streamlit then fails to bind it — which is exactly how "Port 8501 is not available"
+    became a dead end instead of a retry.
+    """
+    import socket
+
+    for offset in range(tries):
+        candidate = start + offset
+        with socket.socket() as s:
+            try:
+                s.bind(("", candidate))
+            except OSError:
+                continue
+            return candidate
+    raise SystemExit(f"no free port between {start} and {start + tries}")
+
+
+@main.command()
+@click.option("--port", default=8501, show_default=True, help="or the next one free")
+def dashboard(port: int) -> None:
+    """Open the dashboard: logs, findings, and what a policy bought.
+
+    \b
+      admitperf demo --repeats 5      # make some logs first
+      admitperf dashboard
+
+    It discovers logs under the current directory, so run it where your logs are.
+    """
+    import subprocess
+
+    try:
+        import streamlit  # noqa: F401
+    except ImportError:
+        raise SystemExit("the dashboard is an extra: pip install 'admitperf[dashboard]'") from None
+
+    chosen = _free_port(port)
+    if chosen != port:
+        # A stale Streamlit from another checkout holding the default port should not
+        # stop you looking at a report.
+        click.echo(f"port {port} is busy, using {chosen}")
+    click.echo(f"  http://localhost:{chosen}\n")
+    app = Path(__file__).parent / "dashboard" / "app.py"
+    subprocess.run(
+        [
+            sys.executable,
+            "-m",
+            "streamlit",
+            "run",
+            str(app),
+            "--server.port",
+            str(chosen),
+            "--server.headless",
+            "true",
+        ],
+        check=False,
+    )
+
+
+@main.command()
+def policies() -> None:
+    """The policies that ship with AdmitPerf."""
+    from admitperf import policies as shipped
+
+    for name in shipped.__all__:
+        cls = getattr(shipped, name)
+        doc = (cls.__doc__ or "").strip().splitlines()[0]
+        click.echo(f"{cls.name:<16} {doc}")
+
+
+@main.command()
+def signals() -> None:
+    """Every signal, and the metrics it reads.
+
+    Run this first: it tells you what AdmitPerf can already read from your stack,
+    and what to export (or map) for the rest.
+    """
+    from admitperf.core.signals import ALL
+
+    for s in ALL:
+        srcs = ", ".join(x if isinstance(x, str) else f"{x.__name__}()" for x in s.sources)
+        rng = f"[{s.lo:g}, {s.hi:g}]" if s.hi is not None else f">= {s.lo:g}"
+        click.echo(f"{s.name:<18} {rng:<12} {srcs}")
+        click.echo(f"{'':<18} {s.help}")
+        click.echo()

admitperf/comparison.py

@@ -0,0 +1,326 @@
+"""Two logs, side by side: what did the policy buy?"""
+
+from __future__ import annotations
+
+import math
+from pathlib import Path
+
+from admitperf.report import THIN, WIDTH, Report
+
+RULE = "=" * WIDTH
+
+
+def _reports(target: str | Path) -> list[Report]:
+    """One log, or every log in a directory.
+
+    A directory is how a policy gets more than one run. Sorted by name so `r1, r2, r10` is at
+    least stable between invocations, even though it is not numeric order — the
+    comparison does not care about sequence, only that the same set is read twice.
+    """
+    path = Path(target)
+    if path.is_dir():
+        logs = sorted(path.glob("*.jsonl"))
+        if not logs:
+            raise ValueError(f"no .jsonl logs in {path}")
+        return [Report.from_log(p) for p in logs]
+    return [Report.from_log(path)]
+
+
+class Comparison:
+    """A baseline run against a policy run.
+
+    This is the question the whole package exists to answer, and the one the survey
+    found sixteen papers answering incomparably. It is also the easiest thing to get
+    wrong, so three checks come before any number:
+
+      1. **Did the policy fire?** If it refused nothing, the two runs are the same
+         configuration measured twice and any difference between them is noise.
+      2. **Did both runs face the same load?** A policy run against half the traffic
+         will look wonderful. Offered counts are reported side by side so a mismatch
+         is visible rather than buried.
+      3. **Can cost be measured at all?** Without outcomes there is no latency and no
+         goodput, so the comparison can only report what was refused — which it says
+         rather than implying more.
+
+    Goodput divides by requests OFFERED, never by admitted. Dividing by admitted
+    rewards a policy for refusing more rather than for refusing better: refuse 95% of
+    traffic, serve the rest perfectly, and the number reads 1.00.
+    """
+
+    def __init__(
+        self,
+        baseline: Report | list[Report],
+        policy: Report | list[Report],
+    ) -> None:
+        self.baselines = [baseline] if isinstance(baseline, Report) else list(baseline)
+        self.policies = [policy] if isinstance(policy, Report) else list(policy)
+        if not self.baselines or not self.policies:
+            raise ValueError("a comparison needs at least one run on each side")
+        #: The representative run of each side, for the parts that do not vary between
+        #: repeats: which policy, its parameters, whether it fired.
+        self.baseline = self.baselines[0]
+        self.policy = self.policies[0]
+
+    @classmethod
+    def from_logs(cls, baseline: str | Path, policy: str | Path) -> Comparison:
+        """Each side is a log file, or a DIRECTORY holding every run of one policy.
+
+        A directory is how you get an error bar. One run of each has none, and a
+        gap smaller than the spread between repeats is not a result — so the tool has
+        to be able to read more than one.
+        """
+        return cls(_reports(baseline), _reports(policy))
+
+    # -- repeats -----------------------------------------------------------
+
+    @property
+    def repeats(self) -> int:
+        """The smaller of the two, since that is what the comparison is limited by."""
+        return min(len(self.baselines), len(self.policies))
+
+    @staticmethod
+    def _spread(values: list[float]) -> tuple[float, float, float]:
+        """Median, min, max. Median rather than mean because one pathological repeat
+        — a stalled scrape, a noisy neighbour — should not move the headline."""
+        ordered = sorted(values)
+        return ordered[len(ordered) // 2], ordered[0], ordered[-1]
+
+    def _arm(self, reports: list[Report], metric) -> tuple[float, float, float] | None:
+        values = [v for r in reports if (v := metric(r)) is not None]
+        return self._spread(values) if values else None
+
+    def separated(self) -> bool | None:
+        """Whether the two policies are further apart than their own runs are.
+
+        None when there is only one run each, because then the question cannot be
+        asked — and answering it anyway is how a difference inside the noise gets
+        published as a finding.
+        """
+        if self.repeats < 2:
+            return None
+        base = self._arm(self.baselines, self._goodput)
+        pol = self._arm(self.policies, self._goodput)
+        if base is None or pol is None:
+            return None
+        # No overlap between the two policies' observed ranges.
+        return base[2] < pol[1] or pol[2] < base[1]
+
+    # -- the three checks --------------------------------------------------
+
+    def fired(self) -> bool:
+        """Every repeat must have fired. One that did not is a different experiment,
+        and averaging it in hides that."""
+        return all(r.refused > 0 for r in self.policies)
+
+    def comparable_load(self) -> bool:
+        """Within 10%, across every run on both sides. Two runs offered materially
+        different traffic are not a comparison, however similar the configuration."""
+        counts = [len(r.decisions) for r in self.baselines + self.policies]
+        if not all(counts):
+            return False
+        return (max(counts) - min(counts)) / max(counts) <= 0.10
+
+    def measurable(self) -> bool:
+        return all(r.outcomes for r in self.baselines + self.policies)
+
+    # -- the numbers -------------------------------------------------------
+
+    @staticmethod
+    def _ttft(report: Report) -> dict[str, float] | None:
+        """Latency of requests that were admitted and returned."""
+        values = sorted(
+            v for r in report.outcomes if (v := r["outcome"].get("ttft_ms")) is not None
+        )
+        if not values:
+            return None
+        return {
+            "p50": values[len(values) // 2],
+            "p95": values[min(len(values) - 1, math.ceil(0.95 * len(values)) - 1)],
+            "max": values[-1],
+            "n": len(values),
+        }
+
+    @staticmethod
+    def _goodput(report: Report) -> float | None:
+        """Met-SLO over OFFERED. A refusal counts as a miss, which is the point."""
+        offered = len(report.decisions)
+        if not offered or not report.outcomes:
+            return None
+        met = sum(1 for r in report.outcomes if r["outcome"].get("ok"))
+        return met / offered
+
+    def refused_share(self) -> float:
+        shares = [r.refused / len(r.decisions) for r in self.policies if r.decisions]
+        return self._spread(shares)[0] if shares else 0.0
+
+    # -- the page ----------------------------------------------------------
+
+    def text(self) -> str:
+        lines = [RULE, "  AdmitPerf — what did the policy buy?", RULE, ""]
+        lines += self._headline()
+        lines += ["", THIN, "", "  SIDE BY SIDE", ""]
+        lines += self._table()
+        lines += ["", THIN, "", "  CAN YOU TRUST THIS?", ""]
+        lines += self._trust()
+        lines.append(RULE)
+        return "\n".join(lines)
+
+    def _headline(self) -> list[str]:
+        if not self.fired():
+            return [
+                "  NO FINDING — the policy never fired.",
+                "",
+                f"  {self.policy.policy or 'the policy'} refused 0 of "
+                f"{len(self.policy.decisions)} requests, so these two runs are the same",
+                "  configuration measured twice. Any difference between the numbers below",
+                "  is noise, and a latency improvement here would be a false result.",
+                "",
+                "  The fix is usually the LOAD, not the policy: concurrency is arrival",
+                "  rate times request duration, so short requests cannot fill a cache at",
+                "  any rate. `admitperf report` on the policy log shows which signal did",
+                "  move, if any.",
+            ]
+
+        out = [
+            f"  The policy refused {self.policy.refused} of {len(self.policy.decisions)} "
+            f"requests ({self.refused_share():.1%}).",
+            "",
+        ]
+        if not self.measurable():
+            out += [
+                "  What that bought cannot be measured: no outcomes were recorded, so",
+                "  there is no latency and no goodput. Call policy.outcome(...) after you",
+                "  forward a request and run this again.",
+            ]
+            return out
+
+        p95 = lambda r: t["p95"] if (t := self._ttft(r)) else None  # noqa: E731
+        base_t = self._arm(self.baselines, p95)
+        pol_t = self._arm(self.policies, p95)
+        base_g = self._arm(self.baselines, self._goodput)
+        pol_g = self._arm(self.policies, self._goodput)
+
+        def band(s: tuple[float, float, float], fmt: str) -> str:
+            """Median, and the observed range when there is more than one run. A bare
+            number from one run reads as more certain than it is."""
+            median, lo, hi = s
+            if self.repeats < 2 or lo == hi:
+                return fmt.format(median)
+            return f"{fmt.format(median)} ({fmt.format(lo)}-{fmt.format(hi)})"
+
+        if base_t and pol_t and base_t[0]:
+            factor = base_t[0] / pol_t[0] if pol_t[0] else float("inf")
+            direction = "lower" if factor > 1 else "HIGHER"
+            out.append(
+                f"  p95 TTFT of served requests is {abs(factor):.2f}x {direction}: "
+                f"{band(base_t, '{:.0f}')}ms -> {band(pol_t, '{:.0f}')}ms"
+            )
+        if base_g and pol_g:
+            verb = "up" if pol_g[0] > base_g[0] else "DOWN"
+            out.append(
+                f"  goodput is {verb}: {band(base_g, '{:.3f}')} -> "
+                f"{band(pol_g, '{:.3f}')}  (of offered)"
+            )
+            if pol_g[0] < base_g[0]:
+                out += [
+                    "",
+                    "  Goodput fell, so the policy refused requests the cluster could have",
+                    "  served. Faster tails bought at that price are not a win.",
+                ]
+
+        sep = self.separated()
+        if sep is False:
+            out += [
+                "",
+                f"  BUT the two overlap across {self.repeats} repeats, so this gap is",
+                "  inside the run-to-run noise. It is not a result yet — more repeats, or a",
+                "  larger effect.",
+            ]
+        return out
+
+    def _table(self) -> list[str]:
+        def med(reports: list[Report], metric, fmt: str = "{:.0f}") -> str:
+            s = self._arm(reports, metric)
+            return "--" if s is None else fmt.format(s[0])
+
+        p50 = lambda r: t["p50"] if (t := self._ttft(r)) else None  # noqa: E731
+        p95 = lambda r: t["p95"] if (t := self._ttft(r)) else None  # noqa: E731
+
+        rows = [
+            ("policy", self.baseline.policy or "-", self.policy.policy or "-"),
+            ("repeats", str(len(self.baselines)), str(len(self.policies))),
+            (
+                "offered",
+                med(self.baselines, lambda r: float(len(r.decisions))),
+                med(self.policies, lambda r: float(len(r.decisions))),
+            ),
+            (
+                "refused",
+                med(self.baselines, lambda r: float(r.refused)),
+                med(self.policies, lambda r: float(r.refused)),
+            ),
+            ("p50 TTFT ms", med(self.baselines, p50), med(self.policies, p50)),
+            ("p95 TTFT ms", med(self.baselines, p95), med(self.policies, p95)),
+            (
+                "goodput",
+                med(self.baselines, self._goodput, "{:.3f}"),
+                med(self.policies, self._goodput, "{:.3f}"),
+            ),
+        ]
+        label_row = "median of repeats" if self.repeats > 1 else ""
+        out = [f"  {label_row:<16} {'baseline':>14} {'with policy':>14}", ""]
+        out += [f"  {label:<16} {a:>14} {b:>14}" for label, a, b in rows]
+
+        # Signals, because "the policy changed the cluster" is checkable rather than
+        # assumed: KV pressure that did not move means the refusals bought nothing.
+        shared = [n for n in self.policy.signals() if n in self.baseline.signals()]
+        if shared:
+            out += ["", f"  {'signal max':<16} {'baseline':>14} {'with policy':>14}", ""]
+            for name in shared:
+                top = lambda r, n=name: (  # noqa: E731
+                    s["max"] if (s := r.signal_range(n)) else None
+                )
+                out.append(
+                    f"  {name:<16} {med(self.baselines, top, '{:.3g}'):>14} "
+                    f"{med(self.policies, top, '{:.3g}'):>14}"
+                )
+        return out
+
+    def _trust(self) -> list[str]:
+        out = []
+        mark = {True: "ok ", False: "NO "}
+        out.append(f"  {mark[self.fired()]} the policy fired at all")
+        out.append(f"  {mark[self.comparable_load()]} both were offered the same load")
+        if not self.comparable_load():
+            out.append(
+                f"      {len(self.baseline.decisions)} vs {len(self.policy.decisions)} "
+                "requests — a policy run against less traffic will look better than it is"
+            )
+        out.append(f"  {mark[self.measurable()]} outcomes recorded, so cost is measurable")
+        sep = self.separated()
+        if sep is None:
+            out.append("--  only one run per policy, so there is no error bar")
+        else:
+            out.append(f"  {mark[sep]} the two separate across {self.repeats} repeats")
+        for name, reports in (("baseline", self.baselines), ("policy", self.policies)):
+            for i, r in enumerate(reports, 1):
+                for fault in r.fault_text():
+                    tag = f"{name}" if len(reports) == 1 else f"{name} r{i}"
+                    out.append(f"  !! {tag}:{fault.strip()}")
+
+        ok = self.fired() and self.comparable_load() and self.measurable()
+        if ok and sep:
+            out += [
+                "",
+                "  All four hold, so the difference above is the policy and it is larger",
+                "  than the noise between repeats. This is a result you can quote.",
+            ]
+        elif ok and sep is None:
+            out += [
+                "",
+                "  The first three hold, but one run of each has no error bar. Run the pair",
+                "  again — a gap smaller than the spread between repeats is not a result:",
+                "",
+                "      admitperf demo --repeats 5",
+            ]
+        return out

admitperf/core/__init__.py

@@ -0,0 +1,29 @@
+"""The contract: metrics in, signals derived, policies decide.
+
+This subpackage is the part that runs in your request path, so it holds the line
+that makes AdmitPerf safe to install: no third-party imports, no sockets, no
+subprocesses, no filesystem beyond the log you asked for. A test enforces each.
+
+Everything else in the package — the CLI, the watcher, the report, the dashboard —
+is a consumer of what this produces and may do as it likes.
+"""
+
+from __future__ import annotations
+
+from admitperf.core.decision import Decision
+from admitperf.core.log import Log
+from admitperf.core.policy import Policy
+from admitperf.core.reasons import ADMITTED, REASONS
+from admitperf.core.signal import Signal, Source
+from admitperf.core.verdict import Verdict
+
+__all__ = [
+    "ADMITTED",
+    "REASONS",
+    "Decision",
+    "Log",
+    "Policy",
+    "Signal",
+    "Source",
+    "Verdict",
+]