metaobjects 0.15.1__tar.gz → 0.15.3__tar.gz

{metaobjects-0.15.1 → metaobjects-0.15.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metaobjects
-Version: 0.15.1
+Version: 0.15.3
 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-0.15.1 → metaobjects-0.15.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "metaobjects"
-version = "0.15.1"
+version = "0.15.3"
 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-0.15.1 → metaobjects-0.15.3}/src/metaobjects/codegen/output_format_spec_emitter.py

@@ -44,10 +44,14 @@ def _prompt_field_literal(field: MetaData) -> str:
     array = "True" if fm.is_array(field) else "False"
 
     if field.sub_type == fc.FIELD_SUBTYPE_OBJECT:
-        return (
-            f'PromptField("{name}", FieldKind.OBJECT, {req}, array={array})'
-            "  # FR-010: nested prompt deferred"
-        )
+        # FR-010: nested prompt deferred — emit a FieldKind.OBJECT placeholder (nested
+        # defaults to None on PromptField). The note lives HERE, not in the returned
+        # literal: spec_literal joins every field onto ONE line, and a Python '#' inline
+        # comment would swallow the rest of that line — including the closing `])` — so a
+        # nested-object payload emitted invalid Python (unterminated list) and crashed
+        # `gen` + `verify --codegen`. The other ports use `/* */` block comments, which
+        # are inline-safe; Python has none, so the literal must carry no comment.
+        return f'PromptField("{name}", FieldKind.OBJECT, {req}, array={array})'
 
     example = _opt_string_attr(field, fc.FIELD_ATTR_EXAMPLE)
     instruction = _opt_string_attr(field, fc.FIELD_ATTR_INSTRUCTION)

{metaobjects-0.15.1 → metaobjects-0.15.3}/src/metaobjects/codegen/runtime/filter_parser.py

@@ -14,8 +14,9 @@ Returned ``FilterParseResult`` is either:
 * ``predicates`` populated + ``error_envelope`` ``None`` — success path; the
   generated router passes ``predicates`` into the repository.
 * ``error_envelope`` non-``None`` (one of ``invalid_filter_field`` /
-  ``invalid_filter_op`` / ``invalid_filter_value``) — the generated router
-  raises ``HTTPException(status_code=400, detail=result.error_envelope)``.
+  ``invalid_filter_op`` / ``invalid_filter_value`` / ``filter.in_too_large``) —
+  the generated router raises
+  ``HTTPException(status_code=400, detail=result.error_envelope)``.
 
 Mirror of the Java ``FilterParser`` / Kotlin ``KotlinFilterAllowlistGenerator`` /
 C# ``FilterParser`` ports — same wire grammar, same error envelopes, same
@@ -35,6 +36,13 @@ _INVALID_VALUE = object()
 _ERR_FIELD = "invalid_filter_field"
 _ERR_OP = "invalid_filter_op"
 _ERR_VALUE = "invalid_filter_value"
+_ERR_IN_TOO_LARGE = "filter.in_too_large"
+
+# Cross-port cap on the number of elements in an ``in``-list. A larger list is
+# rejected with the ``filter.in_too_large`` envelope so a caller cannot force an
+# unbounded ``IN (...)`` against the DB. Matches the TypeScript ``runtime-ts``
+# filter parser's ``DEFAULT_MAX_IN_LIST``.
+MAX_IN_LIST = 100
 
 
 @dataclass(frozen=True)
@@ -85,7 +93,7 @@ def parse_filter(
     validated + coerced filter list (preserving URL order); on failure,
     ``error_envelope`` is one of the cross-port envelopes
     (``invalid_filter_field`` / ``invalid_filter_op`` /
-    ``invalid_filter_value``).
+    ``invalid_filter_value`` / ``filter.in_too_large``).
     """
     allowed_set = set(allowed_fields)
     ops_map: dict[str, frozenset[str]] = {
@@ -129,6 +137,8 @@ def parse_filter(
         coerced = _coerce_value(value, op)
         if coerced is _INVALID_VALUE:
             return FilterParseResult(error_envelope={"error": _ERR_VALUE})
+        if op == "in" and isinstance(coerced, list) and len(coerced) > MAX_IN_LIST:
+            return FilterParseResult(error_envelope={"error": _ERR_IN_TOO_LARGE})
         out.append(FilterPredicate(field=field_name, op=op, value=coerced))
 
     return FilterParseResult(predicates=out)

{metaobjects-0.15.1 → metaobjects-0.15.3}/src/metaobjects/registry_manifest.py

@@ -255,6 +255,15 @@ def _sorted_children(definition: TypeDefinition) -> list[dict[str, object]]:
     return children
 
 
+METAMODEL_VERSION = "0.9"
+"""Rolled-up spec-version for the cross-port registry manifest.
+
+``"0"`` = pre-1.0 / unstable (semver major-0). Flips to ``"1.0"`` at the
+1.0 vocabulary cut. Emitted as the first top-level key in the canonical
+manifest so every port's byte-comparison gate sees it at position 0.
+"""
+
+
 def build_registry_manifest(registry: TypeRegistry) -> dict[str, object]:
     """Build the canonical registry-manifest object from an assembled registry.
 
@@ -306,8 +315,9 @@ def build_registry_manifest(registry: TypeRegistry) -> dict[str, object]:
         if default_sub is not None:
             default_sub_types[type_name] = default_sub
 
-    # Fixed top-level key order: types, commonAttrs, defaultSubTypes.
+    # Fixed top-level key order: metamodelVersion (C4), types, commonAttrs, defaultSubTypes.
     return {
+        "metamodelVersion": METAMODEL_VERSION,
         "types": types,
         "commonAttrs": common_attrs,
         "defaultSubTypes": default_sub_types,

metaobjects-0.15.3/tests/codegen/test_fr010_nested_object_prompt.py

@@ -0,0 +1,59 @@
+"""Regression: a ``template.output`` payload with a NESTED ``field.object`` must emit
+VALID Python from the output-prompt spec emitter (a ``FieldKind.OBJECT`` placeholder),
+NOT crash ``gen`` / ``verify --codegen``.
+
+The bug (0.15.0): the nested-object branch appended an inline ``# FR-010: nested prompt
+deferred`` comment to the emitted literal. ``spec_literal`` joins every field onto ONE
+line, so the Python ``#`` swallowed the rest of the line — including the closing ``])`` —
+producing an unterminated list (``SyntaxError: '[' was never closed``). The other four
+ports use ``/* */`` block comments, which are inline-safe; Python has none, so the literal
+must carry no comment.
+"""
+from __future__ import annotations
+
+import ast
+
+import metaobjects.core_types  # noqa: F401 — side-effect: registers attr classes
+from metaobjects.codegen import output_format_spec_emitter as ofs
+from metaobjects.meta.core.field import field_constants as fc
+from metaobjects.meta.core.field.meta_field import MetaField
+from metaobjects.meta.core.object.meta_object import MetaObject
+from metaobjects.meta.template import template_constants as tc
+from metaobjects.meta.template.meta_template import MetaTemplate
+from metaobjects.shared.base_types import TYPE_FIELD, TYPE_OBJECT, TYPE_TEMPLATE
+
+
+def _envelope() -> tuple[MetaObject, MetaTemplate]:
+    before = MetaField(TYPE_FIELD, fc.FIELD_SUBTYPE_STRING, "before")
+    before.set_attr(fc.FIELD_ATTR_REQUIRED, True)
+    # the nested object sits BETWEEN two scalars, so a swallowed line would eat both the
+    # trailing field and the closing bracket.
+    inner = MetaField(TYPE_FIELD, fc.FIELD_SUBTYPE_OBJECT, "inner")
+    inner.set_attr(fc.FIELD_ATTR_REQUIRED, True)
+    after = MetaField(TYPE_FIELD, fc.FIELD_SUBTYPE_STRING, "after")
+
+    vo = MetaObject(TYPE_OBJECT, "value", "Envelope")
+    vo.package = "acme::ai"
+    for f in (before, inner, after):
+        vo.add_child(f)
+
+    tmpl = MetaTemplate(TYPE_TEMPLATE, tc.TEMPLATE_SUBTYPE_OUTPUT, "EnvOutput")
+    tmpl.set_attr(tc.TEMPLATE_ATTR_PAYLOAD_REF, "Envelope")
+    tmpl.set_attr(tc.TEMPLATE_ATTR_FORMAT, "xml")
+    tmpl.set_attr(tc.TEMPLATE_ATTR_PROMPT_STYLE, "guide")
+    return vo, tmpl
+
+
+def test_nested_object_payload_emits_parseable_python() -> None:
+    vo, tmpl = _envelope()
+    lit = ofs.spec_literal(vo, tmpl, "Envelope")
+
+    # 1) the whole OutputFormatSpec(...) literal must be valid Python — the core bug.
+    ast.parse(lit)  # raised "SyntaxError: '[' was never closed" on the broken output
+
+    # 2) the nested field is a FieldKind.OBJECT placeholder …
+    assert "FieldKind.OBJECT" in lit
+    # 3) … with NO inline comment in the emitted literal (that was the swallow) …
+    assert "#" not in lit
+    # 4) … and the field AFTER the nested one survived (was not commented out).
+    assert '"after"' in lit

metaobjects-0.15.3/tests/conformance/test_provider_composition_conformance.py

@@ -0,0 +1,150 @@
+"""Provider-composition conformance runner (Python port).
+
+Five registry/provider error codes are Tier-1 cross-port invariants that the
+metadata-input -> error corpus cannot reach: they are triggered by HOW providers
+are composed and sealed, not by any metadata document. This runner gates them
+from the shared corpus at fixtures/provider-composition-conformance/.
+
+Each port supplies the SAME canonical named-provider set (see the corpus
+README). A manifest names providers by id; the runner maps names -> provider
+objects, composes, and asserts the surfaced .code. The registry-sealed scenario
+composes, seals, then runs a probe provider's register_types against the sealed
+registry.
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from metaobjects.errors import ErrorCode, ParseError
+from metaobjects.provider import Provider, compose_registry
+from metaobjects.registry import AttrSchema, ChildRule, TypeDefinition, TypeRegistry
+from metaobjects.meta.template.meta_template import MetaTemplate
+from metaobjects.shared.base_types import TYPE_ATTR
+
+# Fresh, otherwise-unused template subtype the attr-conflict / seal providers use.
+_CONFLICT_SUBTYPE = "compositionprobe"
+_CONFLICT_ATTR = "conflictAttr"
+
+
+def _corpus_root() -> Path:
+    here = Path(__file__).resolve()
+    for parent in [here, *here.parents]:
+        candidate = parent / "fixtures" / "provider-composition-conformance"
+        if candidate.is_dir():
+            return candidate
+    raise RuntimeError("could not locate fixtures/provider-composition-conformance from " + str(here))
+
+
+def _noop_provider(provider_id: str, *deps: str) -> Provider:
+    return Provider(provider_id, dependencies=tuple(deps))
+
+
+def _attr_conflict_base_provider() -> Provider:
+    """Registers a fresh test-only type carrying a single string attr."""
+    p = Provider("attr-conflict-base")
+    p.add(
+        TypeDefinition(
+            type="template",
+            sub_type=_CONFLICT_SUBTYPE,
+            factory=lambda t, s, n: MetaTemplate(t, s, n),
+            attrs=[AttrSchema(_CONFLICT_ATTR, "string")],
+            child_rules=[ChildRule(TYPE_ATTR, "*")],
+        )
+    )
+    return p
+
+
+class _AttrConflictClashProvider(Provider):
+    """Extends the base's type, redefining the same attr name -> attr conflict."""
+
+    def __init__(self) -> None:
+        super().__init__("attr-conflict-clash", dependencies=("attr-conflict-base",))
+
+    def register_types(self, registry: TypeRegistry) -> None:  # noqa: D401
+        registry.extend(
+            "template",
+            _CONFLICT_SUBTYPE,
+            attributes=[AttrSchema(_CONFLICT_ATTR, "string")],
+        )
+
+
+class _SealProbeProvider(Provider):
+    """Attempts a mutating registration — throws against a sealed registry."""
+
+    def __init__(self) -> None:
+        super().__init__("seal-probe")
+
+    def register_types(self, registry: TypeRegistry) -> None:  # noqa: D401
+        registry.register(
+            TypeDefinition(
+                type="template",
+                sub_type="sealprobe",
+                factory=lambda t, s, n: MetaTemplate(t, s, n),
+                attrs=[],
+                child_rules=[],
+            )
+        )
+
+
+def _providers() -> dict[str, Provider]:
+    return {
+        "duplicate-x": _noop_provider("duplicate-x"),
+        # Same `.id` as duplicate-x — surfaces ERR_PROVIDER_DUPLICATE_ID at compose time.
+        "duplicate-x-clone": _noop_provider("duplicate-x"),
+        "depends-on-missing": _noop_provider("depends-on-missing", "does-not-exist"),
+        "cycle-a": _noop_provider("cycle-a", "cycle-b"),
+        "cycle-b": _noop_provider("cycle-b", "cycle-a"),
+        "attr-conflict-base": _attr_conflict_base_provider(),
+        "attr-conflict-clash": _AttrConflictClashProvider(),
+        "seal-probe": _SealProbeProvider(),
+    }
+
+
+def _resolve(providers: dict[str, Provider], pid: str) -> Provider:
+    p = providers.get(pid)
+    if p is None:
+        raise ValueError(f'Unknown named provider "{pid}" in provider-composition corpus')
+    return p
+
+
+def _manifest_files() -> list[Path]:
+    return sorted(_corpus_root().glob("*.json"))
+
+
+def _error_code(exc: BaseException) -> str:
+    code = getattr(exc, "code", None)
+    if isinstance(code, ErrorCode):
+        return code.value
+    if isinstance(code, str):
+        return code
+    return "ERR_UNKNOWN"
+
+
+def test_corpus_non_empty() -> None:
+    assert len(_manifest_files()) > 0
+
+
+@pytest.mark.parametrize("manifest_path", _manifest_files(), ids=lambda p: p.name)
+def test_provider_composition(manifest_path: Path) -> None:
+    manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    providers = _providers()
+    expected = manifest["expectedError"]
+    resolved = [_resolve(providers, pid) for pid in manifest["providers"]]
+
+    if "sealThenRegister" in manifest:
+        # Compose (must succeed), seal, then run the probe against the sealed registry.
+        registry = compose_registry(resolved)
+        registry.seal()
+        probe = _resolve(providers, manifest["sealThenRegister"])
+        with pytest.raises(ParseError) as exc_info:
+            probe.register_types(registry)
+        assert _error_code(exc_info.value) == expected
+        return
+
+    # Ordinary scenario: the compose call itself throws.
+    with pytest.raises(ParseError) as exc_info:
+        compose_registry(resolved)
+    assert _error_code(exc_info.value) == expected