metaobjects 1.0.9rc2__tar.gz → 1.0.9rc4__tar.gz

{metaobjects-1.0.9rc2 → metaobjects-1.0.9rc4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: metaobjects
-Version: 1.0.9rc2
+Version: 1.0.9rc4
 Summary: Cross-language metadata standard: declare typed entities once, generate idiomatic drift-checked code across languages — Python port.
 Project-URL: Homepage, https://metaobjects.dev
 Project-URL: Repository, https://github.com/metaobjectsdev/metaobjects

{metaobjects-1.0.9rc2 → metaobjects-1.0.9rc4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "metaobjects"
-version = "1.0.9rc2"
+version = "1.0.9rc4"
 description = "Cross-language metadata standard: declare typed entities once, generate idiomatic drift-checked code across languages — Python port."
 readme = "README.md"
 requires-python = ">=3.11"

{metaobjects-1.0.9rc2 → metaobjects-1.0.9rc4}/src/metaobjects/codegen/generators/extractor_generator.py

@@ -9,7 +9,7 @@ arrays-of-objects populated) in ONE call:
 
     extract_<snake>(root, text, opts=None) -> <Vo>
         r = extract_lenient_<snake>_with_loader(root, text, opts)  # nested-capable extract
-        if r.report.has_lost_required(): raise ValueError(...)
+        if r.report.has_lost_required() or r.report.has_malformed_required(): raise ValueError(...)
         return _to_strict_<vo>(r.data)                             # mirror -> strict mapper
 
 Why the loaded ``root``: the SELF-CONTAINED ``extract_<snake>(text)`` leaves nested
@@ -173,16 +173,23 @@ def render_extractor(
     lines.append("    value-object). Runs the tolerant nested-capable extract, then maps the")
     lines.append("    extracted mirror graph onto the strict Pydantic payload graph.")
     lines.append("")
-    lines.append("    :raises ValueError: iff a ``@required`` field was lost (the strict gate).")
+    lines.append("    :raises ValueError: iff a ``@required`` field was lost, or present but")
+    lines.append("        unusable (MALFORMED: an undeclared enum member, text for a number).")
     lines.append('    """')
     lines.append(f"    r = {extract_lenient_with_fn}(root, text, opts)")
-    lines.append("    if r.report.has_lost_required():")
-    lines.append("        raise ValueError(")
+    lines.append("    if r.report.has_lost_required() or r.report.has_malformed_required():")
+    lines.append("        unusable = []")
+    lines.append("        if r.report.has_lost_required():")
     lines.append(
-        f'            "{extract_fn}: lost required field(s): "'
+        '            unusable.append("lost required field(s): "'
+        ' + ", ".join(r.report.lost_required()))'
     )
-    lines.append('            + ", ".join(r.report.lost_required())')
-    lines.append("        )")
+    lines.append("        if r.report.has_malformed_required():")
+    lines.append(
+        '            unusable.append("malformed required field(s): "'
+        ' + ", ".join(r.report.malformed_required()))'
+    )
+    lines.append(f'        raise ValueError("{extract_fn}: " + "; ".join(unusable))')
     lines.append(f"    return {root_mapper}(r.data)")
     lines.append("")
     lines.append("")

{metaobjects-1.0.9rc2 → metaobjects-1.0.9rc4}/src/metaobjects/codegen/generators/trace_helper_generator.py

@@ -282,13 +282,18 @@ def render_trace_helper(entity: MetaObject, root: MetaData) -> str | None:
             "    :param redact:   optional row redaction applied before the single record.",
             '    """',
             "    outcome = extract(input.llm_response_text, _RESPONSE_SCHEMA)",
-            "    failed = outcome.report.has_lost_required()",
+            "    # A required field lost OR malformed (present but unusable) has no value,",
+            "    # so either fails the call.",
+            "    unusable = []",
+            "    if outcome.report.has_lost_required():",
+            '        unusable.append("lost required: " + ", ".join(outcome.report.lost_required()))',
+            "    if outcome.report.has_malformed_required():",
+            "        unusable.append(",
+            '            "malformed required: " + ", ".join(outcome.report.malformed_required())',
+            "        )",
+            "    failed = bool(unusable)",
             "    status = STATUS_ERROR if failed else STATUS_OK",
-            "    error_detail = (",
-            '        "lost required: " + ", ".join(outcome.report.lost_required())',
-            "        if failed",
-            "        else None",
-            "    )",
+            '    error_detail = "; ".join(unusable) if failed else None',
             "    # Extraction owns the derived status/error_detail — fold them into the input",
             "    # before building the base row (dataclasses.replace, leaving the original",
             "    # input untouched).",

{metaobjects-1.0.9rc2 → metaobjects-1.0.9rc4}/src/metaobjects/meta/core/object/object_extract.py

@@ -65,22 +65,37 @@ MAX_NEST_DEPTH = 8
 
 
 class ExtractError(Exception):
-    """Raised by :func:`or_throw` when a extraction lost one or more ``@required``
-    fields. ``lost_required`` lists the field paths that were absent/uncoercible."""
+    """Raised by :func:`or_throw` when an extraction lost, or could not use, one or more
+    ``@required`` fields. ``lost_required`` lists the absent paths, ``malformed_required``
+    the paths present in the reply but unusable (MALFORMED)."""
 
-    def __init__(self, lost_required: list[str]) -> None:
+    def __init__(
+        self, lost_required: list[str], malformed_required: list[str] | None = None
+    ) -> None:
         self.lost_required = list(lost_required)
-        joined = ", ".join(self.lost_required)
-        super().__init__(f"extract lost required field(s): {joined}")
+        self.malformed_required = list(malformed_required or [])
+        parts: list[str] = []
+        if self.lost_required:
+            parts.append("extract lost required field(s): " + ", ".join(self.lost_required))
+        if self.malformed_required:
+            prefix = (
+                "malformed required field(s): "
+                if parts
+                else "extract got malformed required field(s): "
+            )
+            parts.append(prefix + ", ".join(self.malformed_required))
+        super().__init__("; ".join(parts))
 
 
 def or_throw(result: ExtractionResult[object]) -> object:
     """Opt into strictness: return ``result.data`` iff no ``@required`` field was
-    lost, else raise :class:`ExtractError`. Mirrors the cross-port ``ExtractionResult.
-    orThrow()`` / TS free ``orThrow``. Extract itself NEVER raises — this is the
-    explicit gate a caller reaches for when a lost-required field should fail."""
-    if result.report.has_lost_required():
-        raise ExtractError(result.report.lost_required())
+    lost or malformed, else raise :class:`ExtractError`. Mirrors the cross-port
+    ``ExtractionResult.orThrow()`` / TS free ``orThrow``. Extract itself NEVER raises —
+    this is the explicit gate a caller reaches for when an unusable required field should
+    fail."""
+    report = result.report
+    if report.has_lost_required() or report.has_malformed_required():
+        raise ExtractError(report.lost_required(), report.malformed_required())
     return result.data
 
 

{metaobjects-1.0.9rc2 → metaobjects-1.0.9rc4}/src/metaobjects/render/extract/extract.py

@@ -105,7 +105,7 @@ def _extract(
             )
             continue
         if present is TRUNCATED:  # present-but-garbled (empty/cut-off value)
-            report.set(path, FieldExtraction.MALFORMED)
+            _mark_malformed(report, path, f)
             continue
         if present is NULL_LITERAL:
             # The JSON null literal is the caller's explicit "no value": leave the field null
@@ -144,16 +144,17 @@ def _extract(
             # elements into data (partial extraction), UNLIKE a MALFORMED scalar which is
             # absent from data.
             data[f.name] = out
-            report.set(
-                path, FieldExtraction.MALFORMED if any_malformed else FieldExtraction.EXTRACTED
-            )
+            if any_malformed:
+                _mark_malformed(report, path, f)
+            else:
+                report.set(path, FieldExtraction.EXTRACTED)
             continue
         if isinstance(present, list):  # a list where a singular value was expected
-            report.set(path, FieldExtraction.MALFORMED)
+            _mark_malformed(report, path, f)
             continue
         v = _extract_value(f, present, path, report, o, ci)
         if v is MALFORMED:
-            report.set(path, FieldExtraction.MALFORMED)
+            _mark_malformed(report, path, f)
         else:
             data[f.name] = v
             # FR-011: a value reached via @coerceDefault (or @default) is DEFAULTED,
@@ -161,6 +162,15 @@ def _extract(
             report.set(path, _classify_coerced(path, report))
 
 
+def _mark_malformed(report: ExtractionReport, path: str, f: FieldSpec) -> None:
+    """Classify a present-but-unusable field MALFORMED. A ``@required`` one is also recorded
+    in ``malformed_required()`` — its value is missing from data just as a lost field's is, so
+    the strict gate must fail on it (the extract-conformance corpus pins the set in every port)."""
+    report.set(path, FieldExtraction.MALFORMED)
+    if f.required:
+        report.mark_malformed_required(path)
+
+
 def _classify_coerced(path: str, report: ExtractionReport) -> FieldExtraction:
     """FR-011: classify a successfully-coerced field. DEFAULTED when its terminal
     (last-logged) coercion for this path is a default-class fallback

{metaobjects-1.0.9rc2 → metaobjects-1.0.9rc4}/src/metaobjects/render/extract/types.py

@@ -300,6 +300,7 @@ class ExtractionReport:
         self._states: dict[str, FieldExtraction] = {}
         self._coercions: list[Coercion] = []
         self._defaulted_required: list[str] = []
+        self._malformed_required: list[str] = []
         self._empty: bool = False
 
     def set(self, field_path: str, state: FieldExtraction) -> None:
@@ -329,6 +330,23 @@ class ExtractionReport:
     def has_lost_required(self) -> bool:
         return len(self.lost_required()) > 0
 
+    def malformed_required(self) -> list[str]:
+        """The ``@required`` fields the document DID answer, but with a value that could not be
+        used (an undeclared enum member, text where a number belongs, a truncated value, a
+        malformed array element) — classified MALFORMED, so they are NOT in
+        :meth:`lost_required`. Their value is absent from ``data`` exactly as a lost field's is,
+        so the strict gate (the generated extractor, :func:`or_throw`) fails on these too.
+        """
+        return list(self._malformed_required)
+
+    def has_malformed_required(self) -> bool:
+        return len(self._malformed_required) > 0
+
+    def mark_malformed_required(self, field_path: str) -> None:
+        """Called by extract when a **required** field is classified MALFORMED."""
+        if field_path not in self._malformed_required:
+            self._malformed_required.append(field_path)
+
     def mark_defaulted_required(self, field_path: str) -> None:
         """Called by extract when an absent **required** field is filled from its ``@default``."""
         if field_path not in self._defaulted_required:

{metaobjects-1.0.9rc2 → metaobjects-1.0.9rc4}/src/metaobjects/render/prompt/output_format_renderer.py

@@ -324,13 +324,16 @@ def _example_value_if_declared(field: PromptField, overrides: PromptOverrides) -
 
 
 def _example_value(field: PromptField, overrides: PromptOverrides) -> str:
+    # An enum with no declared example shows its allowed MEMBERS ("low | medium | high",
+    # the inline style's spelling), never one pre-filled member: a model shown a filled-in
+    # value copies it. Declaring @example is how an author asks for a concrete value.
     from_override = overrides.examples.get(field.name)
     if from_override is not None:
         return from_override
     if field.example is not None:
         return field.example
     if field.kind is FieldKind.ENUM and field.enum_values:
-        return field.enum_values[0]
+        return " | ".join(field.enum_values)
     return "{" + field.name + "}"
 
 

{metaobjects-1.0.9rc2 → metaobjects-1.0.9rc4}/tests/codegen/test_extractor_generator.py

@@ -208,7 +208,7 @@ def test_render_emits_extract_and_extract_and_mappers() -> None:
     # extract.
     assert "def extract_order_prompt(root, text, opts=None) -> Order:" in out
     assert "extract_lenient_order_prompt_with_loader(root, text, opts)" in out
-    assert "if r.report.has_lost_required():" in out
+    assert "if r.report.has_lost_required() or r.report.has_malformed_required():" in out
     # re-exposed extract under the public name, delegating to the nested-capable path.
     assert "def extract_lenient_order_prompt(root, text, opts=None):" in out
     # imports the strict response graph + the with-loader extract.
@@ -419,6 +419,34 @@ def test_extract_raises_on_lost_required(tmp_path, monkeypatch) -> None:
         ex.extract_order_prompt(root, '{ "lines": [] }')
 
 
+def test_extract_raises_on_malformed_required(tmp_path, monkeypatch) -> None:
+    """A required field PRESENT but unusable (an undeclared enum member) is MALFORMED, not
+    lost — the strict extractor must raise rather than build the payload with it missing."""
+    from importlib import import_module
+
+    root = _order_root()
+    pkg_dir = _materialize_package(_all_files(root), tmp_path)
+    _import_package(pkg_dir, monkeypatch)
+    ex = import_module("_gen_pkg.order_prompt_extractor")
+
+    reply = json.dumps(
+        {
+            "customer": {"name": "Ada"},
+            "lines": [{"sku": "A", "qty": 2}],
+            "tags": ["x"],
+            "scores": [3],
+            "priority": "MAYBE",
+            "labels": ["A"],
+        }
+    )
+    with pytest.raises(ValueError, match=r"malformed required field\(s\): priority"):
+        ex.extract_order_prompt(root, reply)
+    # the lenient tier never raises; its report names the unusable required field
+    r = ex.extract_lenient_order_prompt(root, reply)
+    assert r.data.priority is None
+    assert r.report.malformed_required() == ["priority"]
+
+
 def test_extract_reexposed_never_raises_and_no_lost_required(tmp_path, monkeypatch) -> None:
     from importlib import import_module
 

{metaobjects-1.0.9rc2 → metaobjects-1.0.9rc4}/tests/codegen/test_trace_helper_generator.py

@@ -168,8 +168,10 @@ def test_render_emits_record_fn_and_schema_and_persist() -> None:
     assert "persist_llm_call_row(recorder, row, redact)" in out
     assert 'row["voResponse"] = outcome.data' in out
     assert 'row["voRequest"] = input.llm_request' in out
-    # lost-required gate drives status/error_detail.
+    # the unusable-required gate (lost OR malformed) drives status/error_detail.
     assert "outcome.report.has_lost_required()" in out
+    assert "outcome.report.has_malformed_required()" in out
+    assert "failed = bool(unusable)" in out
 
 
 # ---------------------------------------------------------------------------

{metaobjects-1.0.9rc2 → metaobjects-1.0.9rc4}/tests/conformance/test_extract_conformance.py

@@ -60,7 +60,7 @@ def _cases() -> list[str]:
 def test_discovers_all_extract_conformance_cases() -> None:
     """FR-011: lock the corpus size so a deleted fixture fails CI rather than
     silently reducing coverage. Mirrors the TS / Java / C# count guards."""
-    assert len(_cases()) == 41
+    assert len(_cases()) == 42
 
 
 _NORMALIZE_MODES = {"none", "collapse", "strip"}
@@ -178,6 +178,11 @@ def test_classification_and_canonical_value_match(case_name: str) -> None:
     expected_states = {str(k): str(v) for k, v in expected["states"].items()}
     assert actual_states == expected_states, f"{case_name}: states mismatch"
 
+    # the required MALFORMED subset — the strict gate's second half (absent key = none)
+    assert sorted(outcome.report.malformed_required()) == sorted(
+        expected.get("malformedRequired", [])
+    ), f"{case_name}: malformedRequired mismatch"
+
     # Data is compared as a flat DOTTED-LEAF map (mirroring states): nested objects and arrays
     # are flattened to leaf paths (meta.score, items[0].label, tags[0], …) and every leaf VALUE
     # is asserted — including scalar-array elements and nested-object leaves.

{metaobjects-1.0.9rc2 → metaobjects-1.0.9rc4}/tests/render/test_output_prompt_conformance.py

@@ -51,7 +51,7 @@ def _find_corpus() -> Path:
 _CORPUS = _find_corpus()
 
 # Count guard: a port silently skipping cases must fail. Bump when adding cases.
-EXPECTED_CASE_COUNT = 15
+EXPECTED_CASE_COUNT = 17
 
 _FORMATS = {"json": Format.JSON, "xml": Format.XML}
 _KINDS = {