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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lattice-cli
-Version: 0.1.2
+Version: 0.3.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.
 
@@ -142,6 +143,17 @@ the invalid rule needs multiple antecedents.
 
 `conditional` parameters are first-class schema features. The parser expands them into concrete parameter domains and the constraint engine enforces `N/A` semantics automatically.
 
+### Values keep their text
+
+Every value in a schema (the model name, parameter names and values, and constraint references) is used exactly as written. In YAML, unquoted `1.10`, `0x1F`, `.inf` or `2026-10-26T10:00:00Z` stay as typed rather than being turned into numbers or dates. The exceptions:
+
+- Unquoted `yes`, `no`, `on`, `off`, `true` and `false` (lowercase, Capitalized or UPPERCASE) become `true` / `false`, and an empty value, `~` or `null` becomes `null`. Quote them (`"yes"`) to keep the word.
+- JSON integers are written in plain decimal form (`-0` becomes `0`).
+
+`strength` must be a whole number, and `weights` decimal numbers such as `0.7` or `1e-3`. Anchors, aliases and `<<` merge keys work; a key written twice, more than one YAML document, or a tag other than YAML's standard ones is an error.
+
+Changed in 0.3.0: earlier versions converted unquoted numbers and dates, so `0x1F` became `31`, `1.10` became `1.1`, and some values (`.inf`, timestamps) came out differently in the Ruby and Python implementations.
+
 ## Solver Notes
 
 The current engine is deterministic and self-contained. If `ortools` is installed via the `solver` extra, Lattice can use CP-SAT feasibility checks for partial assignments; otherwise it falls back to the built-in backtracking solver.

{lattice_cli-0.1.2 → lattice_cli-0.3.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.
 
@@ -114,6 +115,17 @@ the invalid rule needs multiple antecedents.
 
 `conditional` parameters are first-class schema features. The parser expands them into concrete parameter domains and the constraint engine enforces `N/A` semantics automatically.
 
+### Values keep their text
+
+Every value in a schema (the model name, parameter names and values, and constraint references) is used exactly as written. In YAML, unquoted `1.10`, `0x1F`, `.inf` or `2026-10-26T10:00:00Z` stay as typed rather than being turned into numbers or dates. The exceptions:
+
+- Unquoted `yes`, `no`, `on`, `off`, `true` and `false` (lowercase, Capitalized or UPPERCASE) become `true` / `false`, and an empty value, `~` or `null` becomes `null`. Quote them (`"yes"`) to keep the word.
+- JSON integers are written in plain decimal form (`-0` becomes `0`).
+
+`strength` must be a whole number, and `weights` decimal numbers such as `0.7` or `1e-3`. Anchors, aliases and `<<` merge keys work; a key written twice, more than one YAML document, or a tag other than YAML's standard ones is an error.
+
+Changed in 0.3.0: earlier versions converted unquoted numbers and dates, so `0x1F` became `31`, `1.10` became `1.1`, and some values (`.inf`, timestamps) came out differently in the Ruby and Python implementations.
+
 ## Solver Notes
 
 The current engine is deterministic and self-contained. If `ortools` is installed via the `solver` extra, Lattice can use CP-SAT feasibility checks for partial assignments; otherwise it falls back to the built-in backtracking solver.

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lattice-cli"
-version = "0.1.2"
+version = "0.3.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.3.0}/src/lattice/__init__.py

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

{lattice_cli-0.1.2 → lattice_cli-0.3.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.3.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.3.0}/src/lattice/parser.py

@@ -1,13 +1,12 @@
 from __future__ import annotations
 
-import json
+import math
+import re
 import sys
 from collections import OrderedDict
 from pathlib import Path
 from typing import Any
 
-import yaml
-
 from lattice.model import (
     Assignment,
     BidirectionalConstraint,
@@ -21,6 +20,7 @@ from lattice.model import (
     normalize_scalar,
     NA_VALUE,
 )
+from lattice.schema_text import load_json, load_yaml
 
 
 class ModelIOError(Exception):
@@ -88,11 +88,11 @@ def _read_model_input(path: str | None) -> tuple[str, str, str | None]:
 def _deserialize_model(text: str, source_name: str, extension: str | None) -> Any:
     loaders = []
     if extension == ".json":
-        loaders = [json.loads]
+        loaders = [load_json]
     elif extension in {".yaml", ".yml"}:
-        loaders = [yaml.safe_load]
+        loaders = [load_yaml]
     else:
-        loaders = [json.loads, yaml.safe_load]
+        loaders = [load_json, load_yaml]
 
     errors: list[str] = []
     for loader in loaders:
@@ -376,26 +376,53 @@ def _parse_weights(
         return None
 
     parsed: list[float] = []
-    for weight in raw_weights:
-        if not isinstance(weight, (int, float)):
+    for raw_weight in raw_weights:
+        weight = _parse_number(raw_weight)
+        if weight is None:
             errors.append(f"`weights` for parameter `{parameter_name}` must be numeric.")
             return None
         if weight <= 0:
             errors.append(f"`weights` for parameter `{parameter_name}` must be greater than zero.")
             return None
-        parsed.append(float(weight))
+        parsed.append(weight)
     return tuple(parsed)
 
 
+_DECIMAL_TEXT = re.compile(r"[-+]?[0-9]+(\.[0-9]+)?([eE][-+]?[0-9]+)?")
+_INTEGER_TEXT = re.compile(r"[-+]?[0-9]+")
+
+
+def _parse_number(raw: Any) -> float | None:
+    """A finite number, from a Python number or decimal text such as "0.7" or
+    "1e-3" (schema files keep numbers as text). Booleans are not numbers."""
+    if isinstance(raw, bool):
+        return None
+    if isinstance(raw, (int, float)):
+        number = float(raw)
+    elif isinstance(raw, str) and _DECIMAL_TEXT.fullmatch(raw):
+        number = float(raw)
+    else:
+        return None
+    return number if math.isfinite(number) else None
+
+
 def _parse_strength(raw_strength: Any, parameter_count: int, errors: list[str]) -> int:
+    strength: int | None
     if raw_strength is None:
         strength = 2
+    elif isinstance(raw_strength, bool):
+        strength = None
+    elif isinstance(raw_strength, int):
+        strength = raw_strength
+    elif isinstance(raw_strength, float):
+        strength = int(raw_strength) if math.isfinite(raw_strength) else None
+    elif isinstance(raw_strength, str) and _INTEGER_TEXT.fullmatch(raw_strength):
+        strength = int(raw_strength, 10)
     else:
-        try:
-            strength = int(raw_strength)
-        except (TypeError, ValueError):
-            errors.append("`strength` must be an integer.")
-            return 2
+        strength = None
+    if strength is None:
+        errors.append("`strength` must be an integer.")
+        return 2
 
     if strength < 1:
         errors.append("`strength` must be at least 1.")

lattice_cli-0.3.0/src/lattice/schema_text.py

@@ -0,0 +1,169 @@
+"""Read schema text (JSON or YAML) into plain dicts, lists and strings.
+
+Every value keeps the text the user wrote. `1.10` stays "1.10", `0x1F` stays
+"0x1F" and `2026-10-26T10:00:00Z` stays as typed, instead of being converted to
+a number or datetime and printed back differently by Python and Ruby. The only
+conversions:
+
+- unquoted yes/no/on/off/true/false (in the case forms below) become
+  True/False, and an empty value, ~ or null becomes None;
+- JSON integers are written in plain decimal form.
+
+The Ruby implementation (Lattice::SchemaText) follows the same rules, and
+tests/fixtures/scalar_text.* pins the result for both.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+import yaml
+from yaml.nodes import MappingNode, Node, ScalarNode, SequenceNode
+
+from lattice.model import normalize_scalar
+
+TRUE_WORDS = frozenset({"yes", "Yes", "YES", "true", "True", "TRUE", "on", "On", "ON"})
+FALSE_WORDS = frozenset({"no", "No", "NO", "false", "False", "FALSE", "off", "Off", "OFF"})
+NULL_WORDS = frozenset({"", "~", "null", "Null", "NULL"})
+
+YAML_TAG_PREFIX = "tag:yaml.org,2002:"
+STR_TAG = YAML_TAG_PREFIX + "str"
+MERGE_TAG = YAML_TAG_PREFIX + "merge"
+SCALAR_TAGS = frozenset(
+    YAML_TAG_PREFIX + name for name in ("str", "int", "float", "bool", "null", "timestamp", "binary", "merge", "value")
+)
+SEQUENCE_TAG = YAML_TAG_PREFIX + "seq"
+MAPPING_TAG = YAML_TAG_PREFIX + "map"
+
+
+class SchemaSyntaxError(ValueError):
+    """Raised when schema text uses YAML or JSON the schema format doesn't accept."""
+
+
+class _Loader(yaml.SafeLoader):
+    """Marks scalars tagged with the bare `!` as strings, as the YAML spec (and
+    Ruby's Psych) do; PyYAML would otherwise resolve `! true` like `true`."""
+
+    def compose_scalar_node(self, anchor: Any) -> ScalarNode:
+        explicit_string = self.peek_event().tag == "!"
+        node = super().compose_scalar_node(anchor)
+        if explicit_string:
+            node.tag = STR_TAG
+        return node
+
+
+def load_json(text: str) -> Any:
+    return json.loads(
+        text,
+        parse_float=str,
+        parse_int=lambda digits: str(int(digits)),
+        parse_constant=_reject_constant,
+        object_pairs_hook=_unique_object,
+    )
+
+
+def load_yaml(text: str) -> Any:
+    # compose (not load) keeps each scalar's text; yaml.compose raises on more
+    # than one document.
+    root = yaml.compose(text, Loader=_Loader)
+    if root is None:
+        return None
+    return _yaml_value(root, set())
+
+
+def _reject_constant(name: str) -> Any:
+    raise SchemaSyntaxError(f"`{name}` is not valid JSON")
+
+
+def _unique_object(pairs: list[tuple[str, Any]]) -> dict[str, Any]:
+    result: dict[str, Any] = {}
+    for key, value in pairs:
+        if key in result:
+            raise SchemaSyntaxError(f"duplicate key `{key}`")
+        result[key] = value
+    return result
+
+
+def _yaml_value(node: Node, building: set[int]) -> Any:
+    # yaml.compose resolves aliases to the anchored node itself, so a node met
+    # again while it is still being built is a recursive alias.
+    if id(node) in building:
+        raise SchemaSyntaxError("recursive alias")
+    building.add(id(node))
+    try:
+        if isinstance(node, ScalarNode):
+            return _yaml_scalar(node)
+        if isinstance(node, SequenceNode):
+            _check_tag(node.tag, {SEQUENCE_TAG})
+            return [_yaml_value(child, building) for child in node.value]
+        if isinstance(node, MappingNode):
+            return _yaml_mapping(node, building)
+        raise SchemaSyntaxError(f"unsupported YAML node `{type(node).__name__}`")
+    finally:
+        building.discard(id(node))
+
+
+def _yaml_scalar(node: ScalarNode) -> Any:
+    _check_tag(node.tag, SCALAR_TAGS)
+    if node.style is not None or node.tag == STR_TAG:
+        return node.value
+    if node.value in TRUE_WORDS:
+        return True
+    if node.value in FALSE_WORDS:
+        return False
+    if node.value in NULL_WORDS:
+        return None
+    return node.value
+
+
+def _yaml_mapping(node: MappingNode, building: set[int]) -> dict[Any, Any]:
+    """Keys from `<<` merges come first, earlier sources winning; the mapping's
+    own keys then override them. A key written twice is an error."""
+    _check_tag(node.tag, {MAPPING_TAG})
+    merged: dict[Any, Any] = {}
+    own: dict[Any, Any] = {}
+    seen_merge = False
+    for key_node, value_node in node.value:
+        key = _yaml_value(key_node, building)
+        if isinstance(key, (dict, list)):
+            raise SchemaSyntaxError("mapping keys must be scalars")
+
+        if _merge_key(key_node):
+            if seen_merge:
+                raise SchemaSyntaxError("duplicate key `<<`")
+            seen_merge = True
+            for source in _merge_sources(_yaml_value(value_node, building)):
+                for merged_key, merged_value in source.items():
+                    if merged_key not in merged:
+                        merged[merged_key] = merged_value
+            continue
+
+        if key in own:
+            raise SchemaSyntaxError(f"duplicate key `{normalize_scalar(key)}`")
+        own[key] = _yaml_value(value_node, building)
+
+    result = dict(merged)
+    result.update(own)
+    return result
+
+
+def _merge_key(key_node: Node) -> bool:
+    return (
+        isinstance(key_node, ScalarNode)
+        and key_node.style is None
+        and key_node.value == "<<"
+        and key_node.tag == MERGE_TAG
+    )
+
+
+def _merge_sources(value: Any) -> list[dict[Any, Any]]:
+    sources = value if isinstance(value, list) else [value]
+    if not all(isinstance(source, dict) for source in sources):
+        raise SchemaSyntaxError("merge key `<<` needs a mapping or a list of mappings")
+    return sources
+
+
+def _check_tag(tag: str, allowed: set[str] | frozenset[str]) -> None:
+    if tag not in allowed:
+        raise SchemaSyntaxError(f"unsupported YAML tag `{tag}`")

{lattice_cli-0.1.2 → lattice_cli-0.3.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.3.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.
 
@@ -142,6 +143,17 @@ the invalid rule needs multiple antecedents.
 
 `conditional` parameters are first-class schema features. The parser expands them into concrete parameter domains and the constraint engine enforces `N/A` semantics automatically.
 
+### Values keep their text
+
+Every value in a schema (the model name, parameter names and values, and constraint references) is used exactly as written. In YAML, unquoted `1.10`, `0x1F`, `.inf` or `2026-10-26T10:00:00Z` stay as typed rather than being turned into numbers or dates. The exceptions:
+
+- Unquoted `yes`, `no`, `on`, `off`, `true` and `false` (lowercase, Capitalized or UPPERCASE) become `true` / `false`, and an empty value, `~` or `null` becomes `null`. Quote them (`"yes"`) to keep the word.
+- JSON integers are written in plain decimal form (`-0` becomes `0`).
+
+`strength` must be a whole number, and `weights` decimal numbers such as `0.7` or `1e-3`. Anchors, aliases and `<<` merge keys work; a key written twice, more than one YAML document, or a tag other than YAML's standard ones is an error.
+
+Changed in 0.3.0: earlier versions converted unquoted numbers and dates, so `0x1F` became `31`, `1.10` became `1.1`, and some values (`.inf`, timestamps) came out differently in the Ruby and Python implementations.
+
 ## Solver Notes
 
 The current engine is deterministic and self-contained. If `ortools` is installed via the `solver` extra, Lattice can use CP-SAT feasibility checks for partial assignments; otherwise it falls back to the built-in backtracking solver.

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

@@ -10,6 +10,7 @@ src/lattice/formatters.py
 src/lattice/ipog.py
 src/lattice/model.py
 src/lattice/parser.py
+src/lattice/schema_text.py
 src/lattice/resources/claude/lattice-workflow/SKILL.md
 src/lattice/resources/claude/lattice-workflow/references/modeling-rules.md
 src/lattice/resources/claude/lattice-workflow/references/worked-examples.md
@@ -34,4 +35,6 @@ 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_schema_text.py
+tests/test_self_hosting_matrix.py
+tests/test_yaml_format.py

{lattice_cli-0.1.2 → lattice_cli-0.3.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.3.0/tests/test_schema_text.py

@@ -0,0 +1,184 @@
+from __future__ import annotations
+
+import json
+import math
+import sys
+import unittest
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+FIXTURES = ROOT / "tests" / "fixtures"
+sys.path.insert(0, str(ROOT / "src"))
+
+from lattice.formatters import format_json
+from lattice.ipog import generate_covering_array
+from lattice.parser import ValidationError, load_model, parse_model_data
+from lattice.schema_text import SchemaSyntaxError, load_json, load_yaml
+
+
+def values(model):
+    return {parameter.name: list(parameter.values) for parameter in model.parameters}
+
+
+class SchemaTextTests(unittest.TestCase):
+    """Schema values keep the text the user wrote (lattice.schema_text).
+
+    The Ruby gem runs the same cases in test/schema_text_test.rb, and
+    tests/fixtures/scalar_text.* is shared between the two.
+    """
+
+    def test_yaml_fixture_keeps_value_text(self) -> None:
+        model = load_model(str(FIXTURES / "scalar_text.yaml"))
+        self.assertEqual(
+            values(model),
+            {
+                "numbers": ["1.10", "0x1F", "012", "1_000", "1e3", "1.0e+20", ".inf", "-.inf", ".nan", "1:30", "+12", "-0"],
+                "times": ["2026-10-26", "2026-10-26 10:00:00", "2026-10-26T10:00:00Z", "2026-10-26T10:00:00+02:00"],
+                "words": ["true", "false", "null", "yEs", "nO", "y", "yes"],
+                "tagged": ["=", "<<", "yes", "07", "1.5"],
+                "1.10": ["x", "y"],
+                "true": ["p", "q"],
+                "weighted": ["a", "b"],
+                "merged": ["c", "d"],
+            },
+        )
+        self.assertEqual(model.parameter_lookup["merged"].weights, (0.7, 3.0))
+
+    def test_yaml_fixture_output_matches_golden(self) -> None:
+        model = load_model(str(FIXTURES / "scalar_text.yaml"))
+        result = generate_covering_array(model, strength=model.strength, seed=42, pool_size=50)
+        golden = (FIXTURES / "scalar_text.golden.json").read_text(encoding="utf-8")
+        self.assertEqual(format_json(model, result, seed=42) + "\n", golden)
+
+    def test_json_fixture_keeps_number_text(self) -> None:
+        model = load_model(str(FIXTURES / "scalar_text.json"))
+        self.assertEqual(
+            values(model),
+            {
+                "numbers": ["1.10", "1e20", "1E5", "0", "100000000000000000000.0", "12", "0.1", "-2.50"],
+                "literals": ["true", "false", "null", "true!"],
+                "weighted": ["a", "b"],
+            },
+        )
+        self.assertEqual(model.parameter_lookup["weighted"].weights, (0.25, 2.0))
+
+    def test_yaml_words(self) -> None:
+        words = "yes Yes YES true True TRUE on On ON no No NO false False FALSE off Off OFF ~ null Null NULL yEs nULL y n".split()
+        expected = [True] * 9 + [False] * 9 + [None] * 4 + ["yEs", "nULL", "y", "n"]
+        self.assertEqual(load_yaml("[" + ", ".join(words) + "]"), expected)
+        self.assertEqual(load_yaml("a:\nb: ''\n"), {"a": None, "b": ""})
+        self.assertEqual(load_yaml("[\"yes\", 'null', !!str on]"), ["yes", "null", "on"])
+        self.assertEqual(load_yaml("[! true, ! x]"), ["true", "x"])
+        self.assertEqual(load_yaml("[!!bool yes, !!bool maybe]"), [True, "maybe"])
+
+    def test_yaml_block_and_folded_scalars_keep_text(self) -> None:
+        self.assertEqual(load_yaml("a: |\n  yes\nb: >\n  1.10\n"), {"a": "yes\n", "b": "1.10\n"})
+
+    def test_yaml_empty_document(self) -> None:
+        self.assertIsNone(load_yaml(""))
+        self.assertIsNone(load_yaml("# only a comment\n"))
+
+    def test_yaml_aliases_and_merges(self) -> None:
+        data = load_yaml(
+            "base: &base {x: 1, y: 2}\n"
+            "other: &other {y: 3, z: 4}\n"
+            "list: &list [a, b]\n"
+            "copy: *list\n"
+            "one: {<<: *base, x: 9}\n"
+            "many: {<<: [*base, *other], w: 0}\n"
+        )
+        self.assertEqual(data["copy"], ["a", "b"])
+        self.assertEqual(data["one"], {"x": "9", "y": "2"})
+        self.assertEqual(data["many"], {"x": "1", "y": "2", "z": "4", "w": "0"})
+        self.assertEqual(list(data["many"]), ["x", "y", "z", "w"])
+
+    def test_yaml_merge_key_must_be_plain_untagged_or_merge_tagged(self) -> None:
+        self.assertEqual(load_yaml('{"<<": {x: 1}}'), {"<<": {"x": "1"}})
+        self.assertEqual(load_yaml("{!!str <<: {x: 1}}"), {"<<": {"x": "1"}})
+        self.assertEqual(load_yaml("{!!merge <<: {x: 1}}"), {"x": "1"})
+
+    def test_yaml_alias_as_key(self) -> None:
+        self.assertEqual(load_yaml("k: &m x\nmap: {*m : 1}\n"), {"k": "x", "map": {"x": "1"}})
+
+    def test_yaml_errors(self) -> None:
+        cases = {
+            "a: 1\na: 2\n": "duplicate key `a`",
+            "yes: 1\nYES: 2\n": "duplicate key `true`",
+            "~: 1\nnull: 2\n": "duplicate key `null`",
+            "a: !foo x\n": "unsupported YAML tag `!foo`",
+            "a: !!set {x}\n": "unsupported YAML tag `tag:yaml.org,2002:set`",
+            "a: !!omap [x: 1]\n": "unsupported YAML tag `tag:yaml.org,2002:omap`",
+            "? [a]\n: b\n": "mapping keys must be scalars",
+            "? {a: 1}\n: b\n": "mapping keys must be scalars",
+            "a: {<<: [{x: 1}, y]}\n": "merge key `<<` needs a mapping or a list of mappings",
+            "a: {<<: [[{x: 1}]]}\n": "merge key `<<` needs a mapping or a list of mappings",
+            "a: {<<: [x]}\n": "merge key `<<` needs a mapping or a list of mappings",
+            "a: {<<: {x: 1}, <<: {y: 2}}\n": "duplicate key `<<`",
+            "a: &r [*r]\n": "recursive alias",
+        }
+        for text, message in cases.items():
+            with self.subTest(text=text):
+                with self.assertRaises(SchemaSyntaxError) as raised:
+                    load_yaml(text)
+                self.assertEqual(str(raised.exception), message)
+        # PyYAML itself rejects these (Ruby reports them as SchemaText errors).
+        for text in ("a: 1\n---\nb: 2\n", "a: *nope\n"):
+            with self.subTest(text=text):
+                with self.assertRaises(Exception):
+                    load_yaml(text)
+
+    def test_json_errors(self) -> None:
+        for text in ('{"a": 1, "a": 2}', "[NaN]", "[Infinity]", "[-Infinity]"):
+            with self.subTest(text=text):
+                with self.assertRaises(ValueError):
+                    load_json(text)
+
+    def test_json_nesting_and_literals(self) -> None:
+        self.assertEqual(
+            load_json('{"a": [{"b": 1.5}, 7, true, null, "s"]}'),
+            {"a": [{"b": "1.5"}, "7", True, None, "s"]},
+        )
+
+    def weight_errors(self, weights):
+        try:
+            parse_model_data({"parameters": {"a": {"values": ["x", "y"], "weights": weights}}, "strength": 1})
+        except ValidationError as error:
+            return error.errors
+        return None
+
+    def test_weight_text(self) -> None:
+        self.assertIsNone(self.weight_errors(["0.7", "3"]))
+        self.assertIsNone(self.weight_errors(["+1.5e-1", "007"]))
+        self.assertIsNone(self.weight_errors([0.5, 2]))
+        numeric = ["`weights` for parameter `a` must be numeric."]
+        for weights in (
+            ["0x10", "1"], ["1_0", "1"], [".5", "1"], ["1.", "1"], ["inf", "1"], ["1e400", "1"],
+            [True, "1"], [None, "1"], [math.inf, 1], [math.nan, 1], ["\u0661", "1"],
+        ):
+            with self.subTest(weights=weights):
+                self.assertEqual(self.weight_errors(weights), numeric)
+        self.assertEqual(self.weight_errors(["0", "1"]), ["`weights` for parameter `a` must be greater than zero."])
+        self.assertEqual(self.weight_errors(["-1", "1"]), ["`weights` for parameter `a` must be greater than zero."])
+
+    def strength_result(self, strength):
+        try:
+            return parse_model_data(
+                {"parameters": {"a": ["x", "y"], "b": ["x", "y"], "c": ["x", "y"]}, "strength": strength}
+            ).strength
+        except ValidationError as error:
+            return error.errors
+
+    def test_strength_text(self) -> None:
+        self.assertEqual(self.strength_result("3"), 3)
+        self.assertEqual(self.strength_result("+2"), 2)
+        self.assertEqual(self.strength_result("01"), 1)
+        self.assertEqual(self.strength_result(2), 2)
+        self.assertEqual(self.strength_result(2.9), 2)
+        self.assertEqual(self.strength_result(None), 2)
+        for strength in ("2.0", "0x2", "1_0", "two", True, math.inf, [2]):
+            with self.subTest(strength=strength):
+                self.assertEqual(self.strength_result(strength), ["`strength` must be an integer."])
+
+
+if __name__ == "__main__":
+    unittest.main()

lattice_cli-0.3.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()