lattice-cli 0.1.2__tar.gz → 0.2.0__tar.gz

{lattice_cli-0.1.2/src/lattice_cli.egg-info → lattice_cli-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lattice-cli
-Version: 0.1.2
+Version: 0.2.0
 Summary: Deterministic combinatorial coverage for agent workflows and constrained variant surfaces.
 Author-email: Tyler Klose <tylerklose@gmail.com>
 License-Expression: Apache-2.0
@@ -105,11 +105,12 @@ Supported output formats:
 - `table`
 - `csv`
 - `summary`
+- `yaml` (same content as `json`, for files people edit by hand)
 
 `generate` defaults to JSON because the primary consumer is usually a coding harness. File-based schemas are supported, but the schema file is transport, not the product surface.
 
 For long higher-strength runs, use `--progress` to stream coverage progress to
-stderr while keeping stdout clean for JSON, CSV, table, or summary output.
+stderr while keeping stdout clean for JSON, YAML, CSV, table, or summary output.
 `--progress-every N` controls how many generated scenarios pass between
 updates.
 

{lattice_cli-0.1.2 → lattice_cli-0.2.0}/README.md

@@ -77,11 +77,12 @@ Supported output formats:
 - `table`
 - `csv`
 - `summary`
+- `yaml` (same content as `json`, for files people edit by hand)
 
 `generate` defaults to JSON because the primary consumer is usually a coding harness. File-based schemas are supported, but the schema file is transport, not the product surface.
 
 For long higher-strength runs, use `--progress` to stream coverage progress to
-stderr while keeping stdout clean for JSON, CSV, table, or summary output.
+stderr while keeping stdout clean for JSON, YAML, CSV, table, or summary output.
 `--progress-every N` controls how many generated scenarios pass between
 updates.
 

{lattice_cli-0.1.2 → lattice_cli-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lattice-cli"
-version = "0.1.2"
+version = "0.2.0"
 description = "Deterministic combinatorial coverage for agent workflows and constrained variant surfaces."
 readme = "README.md"
 requires-python = ">=3.11"

{lattice_cli-0.1.2 → lattice_cli-0.2.0}/src/lattice/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.1.2"
+__version__ = "0.2.0"

{lattice_cli-0.1.2 → lattice_cli-0.2.0}/src/lattice/cli.py

@@ -92,7 +92,7 @@ def _build_parser() -> argparse.ArgumentParser:
     )
     generate.add_argument("model", nargs="?", help="Path to a JSON or YAML schema. Reads stdin when omitted.")
     generate.add_argument("--strength", type=int, help="Override the schema strength.")
-    generate.add_argument("--format", default="json", choices=("table", "json", "csv", "summary"))
+    generate.add_argument("--format", default="json", choices=("table", "json", "csv", "summary", "yaml"))
     generate.add_argument("--seed", type=int, default=42)
     generate.add_argument("--pool-size", type=int, default=50)
     generate.add_argument(

{lattice_cli-0.1.2 → lattice_cli-0.2.0}/src/lattice/formatters.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import csv
 import io
 import json
+import re
 
 from lattice.ipog import GenerationResult
 from lattice.model import Model
@@ -17,6 +18,8 @@ def render_output(model: Model, result: GenerationResult, *, output_format: str,
         return format_csv(model, result)
     if output_format == "summary":
         return format_summary(model, result)
+    if output_format == "yaml":
+        return format_yaml(model, result, seed=seed)
     raise ValueError(f"Unknown format `{output_format}`.")
 
 
@@ -85,6 +88,73 @@ def format_json(model: Model, result: GenerationResult, *, seed: int) -> str:
     return json.dumps(payload, indent=2)
 
 
+def format_yaml(model: Model, result: GenerationResult, *, seed: int | None) -> str:
+    """Same content as format_json, written by hand in one fixed style.
+
+    PyYAML and Ruby's Psych quote and wrap differently, so the Python and Ruby
+    implementations write YAML themselves to emit identical bytes. Every string
+    is double-quoted, so no value can be read back as a boolean, null, number
+    or date.
+    """
+    coverage = f"{result.coverage_curve[-1].cumulative_pct:.1f}%" if result.coverage_curve else "0.0%"
+    lines = [
+        "meta:",
+        f"  model_name: {_yaml_string(model.model_name)}",
+        f"  strength: {model.strength}",
+        f"  test_count: {len(result.rows)}",
+        f"  exhaustive_count: {model.exhaustive_count}",
+        f"  reduction: {_yaml_string(_reduction_label(model.exhaustive_count, len(result.rows)))}",
+        f"  coverage: {_yaml_string(coverage)}",
+        f"  seed: {'null' if seed is None else seed}",
+    ]
+
+    if not result.coverage_curve:
+        lines.append("coverage_curve: []")
+    else:
+        lines.append("coverage_curve:")
+        for point in result.coverage_curve:
+            lines.append(f"  - scenario: {point.scenario}")
+            lines.append(f"    cumulative_pct: {json.dumps(point.cumulative_pct)}")
+
+    rows = _named_rows(model, result)
+    if not rows:
+        lines.append("scenarios: []")
+    else:
+        lines.append("scenarios:")
+        for index, row in enumerate(rows):
+            lines.append(f"  - id: {index + 1}")
+            lines.append("    values:")
+            for name in model.parameter_names:
+                lines.append(f"      {_yaml_string(name)}: {_yaml_string(row[name])}")
+    return "\n".join(lines)
+
+
+_YAML_ESCAPES = {
+    '"': '\\"',
+    "\\": "\\\\",
+    "\b": "\\b",
+    "\t": "\\t",
+    "\n": "\\n",
+    "\f": "\\f",
+    "\r": "\\r",
+}
+
+# Characters escaped inside a double-quoted YAML string: the quote and
+# backslash, C0 controls, DEL, C1 controls (U+0085 would otherwise fold to a
+# space), the Unicode line and paragraph separators, the byte-order mark, and
+# the two noncharacters YAML cannot hold. Everything else is written as UTF-8,
+# so accented letters and emoji stay readable.
+_YAML_ESCAPED_CHARS = re.compile(r'["\\\u0000-\u001f\u007f-\u009f\u2028\u2029\ufeff\ufffe\uffff]')
+
+
+def _yaml_string(value: str) -> str:
+    def escape(match: re.Match[str]) -> str:
+        char = match.group(0)
+        return _YAML_ESCAPES.get(char) or f"\\u{ord(char):04x}"
+
+    return '"' + _YAML_ESCAPED_CHARS.sub(escape, value) + '"'
+
+
 def format_csv(model: Model, result: GenerationResult) -> str:
     buffer = io.StringIO()
     writer = csv.writer(buffer)

{lattice_cli-0.1.2 → lattice_cli-0.2.0/src/lattice_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lattice-cli
-Version: 0.1.2
+Version: 0.2.0
 Summary: Deterministic combinatorial coverage for agent workflows and constrained variant surfaces.
 Author-email: Tyler Klose <tylerklose@gmail.com>
 License-Expression: Apache-2.0
@@ -105,11 +105,12 @@ Supported output formats:
 - `table`
 - `csv`
 - `summary`
+- `yaml` (same content as `json`, for files people edit by hand)
 
 `generate` defaults to JSON because the primary consumer is usually a coding harness. File-based schemas are supported, but the schema file is transport, not the product surface.
 
 For long higher-strength runs, use `--progress` to stream coverage progress to
-stderr while keeping stdout clean for JSON, CSV, table, or summary output.
+stderr while keeping stdout clean for JSON, YAML, CSV, table, or summary output.
 `--progress-every N` controls how many generated scenarios pass between
 updates.
 

{lattice_cli-0.1.2 → lattice_cli-0.2.0}/src/lattice_cli.egg-info/SOURCES.txt

@@ -34,4 +34,5 @@ tests/test_ipog.py
 tests/test_model.py
 tests/test_parser.py
 tests/test_schema_guidance_matrix.py
-tests/test_self_hosting_matrix.py
+tests/test_self_hosting_matrix.py
+tests/test_yaml_format.py

{lattice_cli-0.1.2 → lattice_cli-0.2.0}/tests/test_cli.py

@@ -168,7 +168,7 @@ class CliTests(unittest.TestCase):
             self.assertEqual(parsed["surface"], "generic")
             self.assertTrue((target / "SKILL.md").is_file())
             self.assertTrue((target / "references" / "modeling-rules.md").is_file())
-            self.assertIn("Do not strip true constraints", (target / "SKILL.md").read_text())
+            self.assertIn("do not strip them and mark invalid rows downstream", (target / "SKILL.md").read_text())
             self.assertIn(
                 "mark them invalid downstream",
                 (target / "references" / "modeling-rules.md").read_text(),

lattice_cli-0.2.0/tests/test_yaml_format.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import unittest
+from pathlib import Path
+
+import yaml
+
+ROOT = Path(__file__).resolve().parents[1]
+FIXTURES = ROOT / "tests" / "fixtures"
+sys.path.insert(0, str(ROOT / "src"))
+
+from lattice.formatters import _yaml_string, format_json, format_yaml, render_output
+from lattice.ipog import GenerationResult, generate_covering_array
+from lattice.parser import load_model
+
+
+def uescape(hex_digits: str) -> str:
+    # Built in pieces so the source stays ASCII.
+    return '"' + "\\" + "u" + hex_digits + '"'
+
+
+def quoted(*code_points: int) -> str:
+    return '"' + "".join(chr(point) for point in code_points) + '"'
+
+
+class YamlFormatTests(unittest.TestCase):
+    """`--format yaml`: the same content as `--format json`, written by hand.
+
+    tests/fixtures/yaml_edges.golden.yaml pins the exact bytes for
+    tests/fixtures/yaml_edges.json; the Ruby gem (latticerb) tests against
+    the same pair.
+    """
+
+    def generate(self, fixture: str):
+        model = load_model(str(FIXTURES / fixture))
+        return model, generate_covering_array(model, strength=model.strength, seed=42, pool_size=50)
+
+    def test_edge_case_fixture_matches_golden_bytes(self) -> None:
+        model, result = self.generate("yaml_edges.json")
+        golden = (FIXTURES / "yaml_edges.golden.yaml").read_text(encoding="utf-8")
+        self.assertEqual(format_yaml(model, result, seed=42) + "\n", golden)
+
+    def test_yaml_reads_back_as_the_json_payload(self) -> None:
+        for fixture in ("simple.json", "constrained.json", "skillit.json", "yaml_edges.json"):
+            with self.subTest(fixture=fixture):
+                model, result = self.generate(fixture)
+                self.assertEqual(
+                    yaml.safe_load(format_yaml(model, result, seed=42)),
+                    json.loads(format_json(model, result, seed=42)),
+                )
+
+    def test_empty_result_writes_empty_lists_and_null_seed(self) -> None:
+        model = load_model(str(FIXTURES / "simple.json"))
+        result = GenerationResult(rows=(), coverage_curve=(), total_valid_tuples=0)
+        expected = "\n".join(
+            [
+                "meta:",
+                '  model_name: "simple"',
+                "  strength: 2",
+                "  test_count: 0",
+                "  exhaustive_count: 8",
+                '  reduction: "inf"',
+                '  coverage: "0.0%"',
+                "  seed: null",
+                "coverage_curve: []",
+                "scenarios: []",
+            ]
+        )
+        self.assertEqual(render_output(model, result, output_format="yaml", seed=None), expected)
+
+    def test_yaml_string_escapes(self) -> None:
+        backslash = "\\"
+        cases = {
+            "plain": '"plain"',
+            "": '""',
+            "yes": '"yes"',
+            "~": '"~"',
+            'say "hi"': '"say ' + backslash + '"hi' + backslash + '""',
+            "back" + backslash + "slash": '"back' + backslash * 2 + 'slash"',
+            chr(0x08): '"' + backslash + 'b"',
+            chr(0x09): '"' + backslash + 't"',
+            chr(0x0A): '"' + backslash + 'n"',
+            chr(0x0C): '"' + backslash + 'f"',
+            chr(0x0D): '"' + backslash + 'r"',
+            chr(0x00): uescape("0000"),
+            chr(0x07): uescape("0007"),
+            chr(0x0B): uescape("000b"),
+            chr(0x1F): uescape("001f"),
+            chr(0x7E): '"~"',
+            chr(0x7F): uescape("007f"),
+            chr(0x80): uescape("0080"),
+            chr(0x85): uescape("0085"),
+            chr(0x9F): uescape("009f"),
+            chr(0xA0): quoted(0xA0),
+            "caf" + chr(0xE9): quoted(0x63, 0x61, 0x66, 0xE9),
+            chr(0x2027): quoted(0x2027),
+            chr(0x2028): uescape("2028"),
+            chr(0x2029): uescape("2029"),
+            chr(0x202A): quoted(0x202A),
+            chr(0xFEFF): uescape("feff"),
+            chr(0xFFFD): quoted(0xFFFD),
+            chr(0xFFFE): uescape("fffe"),
+            chr(0xFFFF): uescape("ffff"),
+            chr(0x1F600): quoted(0x1F600),
+        }
+        for value, expected in cases.items():
+            with self.subTest(value=ascii(value)):
+                self.assertEqual(_yaml_string(value), expected)
+
+    def test_cli_generate_format_yaml(self) -> None:
+        env = dict(os.environ)
+        env["PYTHONPATH"] = str(ROOT / "src")
+        env["PYTHONIOENCODING"] = "utf-8"
+        result = subprocess.run(
+            [sys.executable, "-m", "lattice", "generate", "--format", "yaml", str(FIXTURES / "yaml_edges.json")],
+            cwd=ROOT,
+            env=env,
+            capture_output=True,
+            check=False,
+        )
+        self.assertEqual(result.returncode, 0, msg=result.stderr)
+        self.assertEqual(result.stdout, (FIXTURES / "yaml_edges.golden.yaml").read_bytes())
+
+
+if __name__ == "__main__":
+    unittest.main()