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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lattice-cli
-Version: 0.2.0
+Version: 0.3.1
 Summary: Deterministic combinatorial coverage for agent workflows and constrained variant surfaces.
 Author-email: Tyler Klose <tylerklose@gmail.com>
 License-Expression: Apache-2.0
@@ -143,6 +143,41 @@ 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.
 
+A schema with two constraints:
+
+```yaml
+model_name: checkout
+strength: 2
+parameters:
+  payment_method: [credit_card, paypal, apple_pay]
+  region: [US, UK, DE]
+  browser:
+    values: [chrome, safari, firefox]
+    weights: [0.6, 0.3, 0.1]
+constraints:
+  - type: invalid_pair
+    if: { parameter: payment_method, value: apple_pay }
+    then_not: { parameter: browser, value: firefox }
+  - type: conditional
+    parameter: card_type
+    values: [visa, mastercard]
+    parent: payment_method
+    applies_when: [credit_card]
+```
+
+Every constraint needs a `type` key. Run `lattice agent instructions` for an example of each type.
+
+### 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.2.0 → lattice_cli-0.3.1}/README.md

@@ -115,6 +115,41 @@ 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.
 
+A schema with two constraints:
+
+```yaml
+model_name: checkout
+strength: 2
+parameters:
+  payment_method: [credit_card, paypal, apple_pay]
+  region: [US, UK, DE]
+  browser:
+    values: [chrome, safari, firefox]
+    weights: [0.6, 0.3, 0.1]
+constraints:
+  - type: invalid_pair
+    if: { parameter: payment_method, value: apple_pay }
+    then_not: { parameter: browser, value: firefox }
+  - type: conditional
+    parameter: card_type
+    values: [visa, mastercard]
+    parent: payment_method
+    applies_when: [credit_card]
+```
+
+Every constraint needs a `type` key. Run `lattice agent instructions` for an example of each type.
+
+### 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.2.0 → lattice_cli-0.3.1}/pyproject.toml

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

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

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

{lattice_cli-0.2.0 → lattice_cli-0.3.1}/src/lattice/agent.py

@@ -25,6 +25,56 @@ DEFAULT_PROMPT = (
     "rows; and use the rows to strengthen the plan, tests, fixtures, or visual review."
 )
 
+SCHEMA_REFERENCE = """
+Schema format, with one example of each constraint type:
+
+```yaml
+model_name: checkout
+strength: 2
+parameters:
+  user: [guest, member]
+  payment: [card, paypal, apple_pay, invoice]
+  device: [desktop, ios, android]
+  region: [us, eu]
+  currency: [usd, eur]
+  shipping: [standard, express, pickup]
+constraints:
+  # invalid_pair: these two assignments never appear in the same row.
+  - type: invalid_pair
+    if: { parameter: payment, value: apple_pay }
+    then_not: { parameter: device, value: android }
+  # bidirectional: each assignment requires the other.
+  - type: bidirectional
+    pair:
+      - { parameter: region, value: eu }
+      - { parameter: currency, value: eur }
+  # forward_dep: the source requires the target; the target may appear elsewhere.
+  - type: forward_dep
+    source: { parameter: shipping, value: pickup }
+    target: { parameter: region, value: us }
+  # conditional: defines a child parameter that only applies for some parent values.
+  - type: conditional
+    parameter: card_type
+    values: [visa, mastercard]
+    parent: payment
+    applies_when: [card]
+  # forced: this combination must appear in at least one row.
+  - type: forced
+    assignments:
+      - { parameter: user, value: guest }
+      - { parameter: device, value: ios }
+      - { parameter: shipping, value: express }
+  # higher_order: the last assignment is excluded only when all of if_all hold.
+  - type: higher_order
+    if_all:
+      - { parameter: user, value: guest }
+      - { parameter: region, value: eu }
+    then_not: { parameter: shipping, value: pickup }
+```
+
+Every constraint needs a `type` key. Each assignment is `{ parameter: <name>, value: <value> }`.
+"""
+
 GENERIC_AGENT_INSTRUCTIONS = f"""# Lattice Agent Instructions
 
 Lattice is harness-agnostic. Use these instructions in OpenClaw, Hermes, Codex, xAI-backed agents, Claude Code, or any agent that can run shell commands.
@@ -49,7 +99,7 @@ Prefer JSON or YAML on stdin:
 cat schema.json | lattice validate
 cat schema.json | lattice generate
 ```
-"""
+""" + SCHEMA_REFERENCE
 
 
 @dataclass(frozen=True)

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

@@ -389,7 +389,7 @@ def _run_agent_command(args: argparse.Namespace) -> int:
                 )
             )
         else:
-            print(GENERIC_AGENT_INSTRUCTIONS)
+            print(GENERIC_AGENT_INSTRUCTIONS, end="")
         return 0
 
     if args.agent_command == "doctor":

{lattice_cli-0.2.0 → lattice_cli-0.3.1}/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:
@@ -204,6 +204,12 @@ def _parse_constraints(
             continue
 
         constraint_type = raw_constraint.get("type")
+        if constraint_type is None:
+            errors.append(_missing_type_message(index, raw_constraint))
+            continue
+        if not isinstance(constraint_type, str):
+            errors.append(f"`constraints[{index}].type` must be a string, one of: {_CONSTRAINT_TYPE_LIST}.")
+            continue
         if constraint_type == "invalid_pair":
             if_assignment = _parse_assignment(raw_constraint.get("if"), parameters, f"`constraints[{index}].if`", errors)
             then_not = _parse_assignment(raw_constraint.get("then_not"), parameters, f"`constraints[{index}].then_not`", errors)
@@ -316,7 +322,7 @@ def _parse_constraints(
                 parsed.append(HigherOrderConstraint(if_all=tuple(parsed_if_all), then_not=parsed_then_not))
             continue
 
-        errors.append(f"`constraints[{index}]` has unknown type `{constraint_type}`.")
+        errors.append(f"`constraints[{index}]` has unknown type `{constraint_type}`. Use one of: {_CONSTRAINT_TYPE_LIST}.")
 
     return parsed
 
@@ -376,26 +382,78 @@ 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)
 
 
+# Each constraint type and the keys written beside `type`.
+_CONSTRAINT_FIELDS = {
+    "invalid_pair": "`if` and `then_not`",
+    "bidirectional": "`pair`",
+    "forward_dep": "`source` and `target`",
+    "conditional": "`parameter`, `values`, `parent` and `applies_when`",
+    "forced": "`assignments`",
+    "higher_order": "`if_all` and `then_not`",
+}
+_CONSTRAINT_TYPE_LIST = ", ".join(f"`{name}`" for name in _CONSTRAINT_FIELDS)
+
+
+def _missing_type_message(index: int, raw_constraint: dict[Any, Any]) -> str:
+    """Explains a constraint without `type`. A type name used as a key, as in
+    `- invalid_pair: {...}`, gets the correct form spelled out."""
+    shorthand = next((key for key in raw_constraint if isinstance(key, str) and key in _CONSTRAINT_FIELDS), None)
+    if shorthand is None:
+        return f"`constraints[{index}]` is missing `type`. Use one of: {_CONSTRAINT_TYPE_LIST}."
+    return (
+        f"`constraints[{index}]` is missing `type`. Write `type: {shorthand}` as its own key, "
+        f"with {_CONSTRAINT_FIELDS[shorthand]} beside it. "
+        "Run `lattice agent instructions` for an example of each type."
+    )
+
+
+_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.2.0 → lattice_cli-0.3.1}/src/lattice/resources/claude/lattice-workflow/SKILL.md

@@ -35,7 +35,9 @@ parameters:
   payment: [card, apple_pay, paypal]
   cart: [empty, single, multi]
 constraints:
-  - invalid_pair: {payment: apple_pay, cart: empty}
+  - type: invalid_pair
+    if: { parameter: payment, value: apple_pay }
+    then_not: { parameter: cart, value: empty }
 ```
 
 One generated row (JSON):

{lattice_cli-0.2.0 → lattice_cli-0.3.1}/src/lattice/resources/codex/lattice-workflow/SKILL.md

@@ -35,7 +35,9 @@ parameters:
   payment: [card, apple_pay, paypal]
   cart: [empty, single, multi]
 constraints:
-  - invalid_pair: {payment: apple_pay, cart: empty}
+  - type: invalid_pair
+    if: { parameter: payment, value: apple_pay }
+    then_not: { parameter: cart, value: empty }
 ```
 
 One generated row (JSON):

{lattice_cli-0.2.0 → lattice_cli-0.3.1}/src/lattice/resources/generic/lattice-workflow/SKILL.md

@@ -35,7 +35,9 @@ parameters:
   payment: [card, apple_pay, paypal]
   cart: [empty, single, multi]
 constraints:
-  - invalid_pair: {payment: apple_pay, cart: empty}
+  - type: invalid_pair
+    if: { parameter: payment, value: apple_pay }
+    then_not: { parameter: cart, value: empty }
 ```
 
 One generated row (JSON):

lattice_cli-0.3.1/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.2.0 → lattice_cli-0.3.1/src/lattice_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lattice-cli
-Version: 0.2.0
+Version: 0.3.1
 Summary: Deterministic combinatorial coverage for agent workflows and constrained variant surfaces.
 Author-email: Tyler Klose <tylerklose@gmail.com>
 License-Expression: Apache-2.0
@@ -143,6 +143,41 @@ 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.
 
+A schema with two constraints:
+
+```yaml
+model_name: checkout
+strength: 2
+parameters:
+  payment_method: [credit_card, paypal, apple_pay]
+  region: [US, UK, DE]
+  browser:
+    values: [chrome, safari, firefox]
+    weights: [0.6, 0.3, 0.1]
+constraints:
+  - type: invalid_pair
+    if: { parameter: payment_method, value: apple_pay }
+    then_not: { parameter: browser, value: firefox }
+  - type: conditional
+    parameter: card_type
+    values: [visa, mastercard]
+    parent: payment_method
+    applies_when: [credit_card]
+```
+
+Every constraint needs a `type` key. Run `lattice agent instructions` for an example of each type.
+
+### 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.2.0 → lattice_cli-0.3.1}/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
@@ -28,11 +29,14 @@ src/lattice_cli.egg-info/requires.txt
 src/lattice_cli.egg-info/top_level.txt
 tests/test_agent_bootstrap_matrix.py
 tests/test_cli.py
+tests/test_constraint_type_errors.py
 tests/test_constraints.py
+tests/test_docs_examples.py
 tests/test_examples.py
 tests/test_ipog.py
 tests/test_model.py
 tests/test_parser.py
 tests/test_schema_guidance_matrix.py
+tests/test_schema_text.py
 tests/test_self_hosting_matrix.py
 tests/test_yaml_format.py

lattice_cli-0.3.1/tests/test_constraint_type_errors.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+import json
+import unittest
+from pathlib import Path
+import sys
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT / "src"))
+
+from lattice.parser import ValidationError, load_model
+
+FIXTURES = ROOT / "tests" / "fixtures"
+# Shared with the Ruby implementation (test/fixtures/invalid and
+# test/fixtures/golden/errors there), which must print the same messages.
+CASES = ["constraint_missing_type", "constraint_type_shorthand", "constraint_type_not_string", "unknown_constraint_type"]
+
+
+class ConstraintTypeErrorTests(unittest.TestCase):
+    def test_messages_match_goldens(self) -> None:
+        for name in CASES:
+            with self.subTest(name=name):
+                golden = json.loads((FIXTURES / "golden_errors" / f"{name}.json").read_text())
+                with self.assertRaises(ValidationError) as raised:
+                    load_model(str(FIXTURES / "invalid" / f"{name}.json"))
+                self.assertEqual(golden["errors"], raised.exception.errors)
+
+
+if __name__ == "__main__":
+    unittest.main()

lattice_cli-0.3.1/tests/test_docs_examples.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import re
+import unittest
+from pathlib import Path
+import sys
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT / "src"))
+
+from lattice.agent import GENERIC_AGENT_INSTRUCTIONS
+from lattice.constraints import ConstraintEngine
+from lattice.parser import _CONSTRAINT_FIELDS, ValidationError, parse_model_data
+from lattice.schema_text import load_json, load_yaml
+
+# Every schema shown to users or agents must be one Lattice accepts. Checks
+# each ```yaml or ```json block that defines `parameters` in the shipped skill
+# files, the README and `lattice agent instructions`.
+FENCED_BLOCK = re.compile(r"^```(yaml|json)\n(.*?)^```", re.M | re.S)
+
+SOURCES = {
+    str(path.relative_to(ROOT)): path.read_text()
+    for path in sorted([*(ROOT / "src/lattice/resources").rglob("*.md"), *(ROOT / ".codex").rglob("*.md")])
+}
+SOURCES["README.md"] = (ROOT / "README.md").read_text()
+SOURCES["lattice agent instructions"] = GENERIC_AGENT_INSTRUCTIONS
+
+
+def schema_blocks():
+    for name, text in SOURCES.items():
+        for index, match in enumerate(FENCED_BLOCK.finditer(text), start=1):
+            if "parameters" in match.group(2):
+                yield name, index, match.group(1), match.group(2)
+
+
+class DocsExamplesTests(unittest.TestCase):
+    def test_finds_a_schema_in_every_skill_readme_and_the_agent_instructions(self) -> None:
+        found = {name for name, _index, _language, _body in schema_blocks()}
+        expected = {name for name in SOURCES if name.endswith("SKILL.md")} | {"README.md", "lattice agent instructions"}
+        self.assertEqual(set(), expected - found)
+
+    def test_agent_instructions_show_every_constraint_type(self) -> None:
+        for constraint_type in _CONSTRAINT_FIELDS:
+            self.assertIn(f"- type: {constraint_type}\n", GENERIC_AGENT_INSTRUCTIONS)
+
+    def test_every_schema_example_is_valid(self) -> None:
+        for name, index, language, body in schema_blocks():
+            with self.subTest(source=name, block=index):
+                data = load_json(body) if language == "json" else load_yaml(body)
+                try:
+                    model = parse_model_data(data)
+                except ValidationError as error:
+                    self.fail(f"{name} block {index} is not a valid schema: {' '.join(error.errors)}")
+                self.assertTrue(ConstraintEngine(model).can_complete({}), f"{name} block {index} has no valid rows")
+
+
+if __name__ == "__main__":
+    unittest.main()

lattice_cli-0.3.1/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()