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

{lattice_cli-0.2.0 → lattice_cli-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lattice-cli
-Version: 0.2.0
+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
@@ -143,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.2.0 → lattice_cli-0.3.0}/README.md

@@ -115,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.2.0 → lattice_cli-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lattice-cli"
-version = "0.2.0"
+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.2.0 → lattice_cli-0.3.0}/src/lattice/__init__.py

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

{lattice_cli-0.2.0 → 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.2.0 → 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.2.0
+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
@@ -143,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.2.0 → 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,5 +35,6 @@ 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.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()