tenseleyflow/sway / 98ad941

 Differential testing for fine-tuned causal language models.

 in a meaningful way, or is the model just defaulting to the pretrained

 base?*

 purpose-built primitives, each z-scored against a null-adapter baseline.

 No LLM judges. No external APIs. Deterministic on CPU where possible.

 ## Install

 ```bash

 ## 90-second smoke test

 ```bash

 ```

 Outputs a verdict in under a minute on CPU for small models: *your

   ft:   {kind: hf, base: "HuggingFaceTB/SmolLM2-135M-Instruct",

          adapter: "./runs/adapter/v0003"}

 suite:

   - {name: section_attribution, kind: section_internalization}

 ```

 ```bash

 ```

 ## Why it exists

 move the model toward what I wrote?"* — and existing tools answer this

 poorly.

 | Category      | Primitives                                            |

 |---------------|-------------------------------------------------------|

 crash. Nobody else does this because nobody else gets this close to the

 adapter math.

 ## The `.dlm` integration

 If you trained your adapter via the [DocumentLanguageModel

 ```bash

 pip install "dlm-sway[hf,dlm]"

 ```

 Per-section attribution tells you *which* parts of your document

 ]

 [project.scripts]

 [project.urls]

 [dependency-groups]

 dev = [

 from __future__ import annotations

     def as_base(self) -> Iterator[_HFView]:

         self._enter("base")

         try:

                 yield self._make_view("base")

         finally:

             self._exit()

 ``pip install dlm-sway`` installs this module's :func:`main` as the

 library-level function so the CLI surface mirrors what programmatic

 callers get.

 """

 from dlm_sway.cli import commands

 app = typer.Typer(

     no_args_is_help=True,

     add_completion=False,

     help="Differential testing for fine-tuned causal language models.",

 def _version_callback(value: bool) -> None:

     if value:

         raise typer.Exit()

 Each function here is wired to a subcommand in :mod:`dlm_sway.cli.app`.

 Commands deliberately do as little as possible themselves — the real

         typer.Option("--out", "-o", help="Where to write the generated sway.yaml."),

     ] = Path("sway.yaml"),

 ) -> None:

     import importlib

     try:

 def doctor_cmd() -> None:

     """Print backend availability and version info."""

     console = Console()

     console.print(f"  python:    {sys.version.split()[0]}")

     console.print(f"  platform:  {sys.platform}")

     console.print()

 def _render_markdown_from_json(raw: dict[str, Any]) -> str:

     score: dict[str, Any] = raw.get("score", {})

     lines: list[str] = [

         "",

         f"**Overall:** {score.get('overall', 0.0):.2f} (`{score.get('band', '?')}`)  ",

         f"**Base:** `{raw.get('base_model_id', '?')}`  ",

     import xml.etree.ElementTree as ET

     probes: list[dict[str, Any]] = raw.get("probes", [])

     for p in probes:

         tc = ET.SubElement(testsuite, "testcase", {"classname": p["kind"], "name": p["name"]})

         if p["verdict"] == "fail":

 Every error sway raises inherits from :class:`SwayError` so callers can

 catch the whole family with a single ``except``. Subclasses carry enough

 class SwayError(Exception):

 class SpecValidationError(SwayError):

 :class:`SuiteResult` dataclass but flattened for easy downstream parsing

 (dashboards, diff tools, history tracking).

 integrates with existing test dashboards with no extra glue.

 """

     c = console or Console()

     header = Text.assemble(

         (suite.base_model_id, "cyan"),

         ("  vs  ", "dim"),

         (_adapter_label(suite.adapter_id), "cyan"),

     testsuite = ET.Element(

         "testsuite",

         {

             "tests": str(len(suite.probes)),

             "failures": str(sum(1 for p in suite.probes if p.verdict == Verdict.FAIL)),

             "errors": str(sum(1 for p in suite.probes if p.verdict == Verdict.ERROR)),

 def to_markdown(suite: SuiteResult, score: SwayScore) -> str:

     """A portable, CI-friendly markdown report."""

     buf = StringIO()

     buf.write(f"**Overall:** {score.overall:.2f} (`{score.band}`)  \n")

     buf.write(f"**Base:** `{suite.base_model_id}`  \n")

     buf.write(f"**Adapter:** `{_adapter_label(suite.adapter_id)}`  \n")

     instead of toggling on one. More memory-heavy; only useful when a

     backend can't do in-place toggling."""

     coverage_threshold: Annotated[float, Field(ge=0.0, le=1.0)] = 0.6

 class SwaySpec(BaseModel):

     """Optional path to a ``.dlm`` file. When present, the runner asks

     :mod:`dlm_sway.integrations.dlm.resolver` for typed sections and

     hands them to probes via :attr:`RunContext.sections`. Auto-populated

     def check_version(self) -> None:

         """Raise ``ValueError`` if the spec version is unsupported.

 We avoid exercising backends (they need real models) and instead test

 arg parsing, error paths, and the read-only commands (``doctor``,

 def test_version_exits_zero() -> None:

     result = CliRunner().invoke(app, ["--version"])

     assert result.exit_code == 0

 def test_help_lists_all_commands() -> None:

     result = CliRunner().invoke(app, ["doctor"])

     assert result.exit_code == 0

     # Rich applies color codes by default; assert the bare product name appears.

     assert "backends" in result.stdout

     md = CliRunner().invoke(app, ["report", str(path), "--format", "md"])

     assert md.exit_code == 0

     junit = CliRunner().invoke(app, ["report", str(path), "--format", "junit"])

     assert junit.exit_code == 0

         )

         s = score.compute(suite)

         md = report.to_markdown(suite, s)

         assert "| p1 | `__score_adherence`" in md

         console = Console(file=buf, force_terminal=False, width=120)

         report.to_terminal(suite, s, console=console)

         out = buf.getvalue()

         assert "overall:" in out

         assert "p1" in out

         assert "p2" in out