metaobjects 0.19.6__tar.gz → 0.19.8__tar.gz

{metaobjects-0.19.6 → metaobjects-0.19.8}/PKG-INFO

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

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

@@ -116,6 +116,14 @@ def py_type_for(field: MetaField) -> PyType:
         # z.unknown() (#97) — since jsonb can hold any JSON value. (Other ports whose
         # drivers return jsonb as raw text correctly keep their string type.)
         base = PyType("Any", ("from typing import Any",))
+    elif (
+        field.sub_type in (fc.FIELD_SUBTYPE_URI, fc.FIELD_SUBTYPE_INET)
+        and field.attrs().get(fc.FIELD_ATTR_LENIENT) is True
+    ):
+        # #234 — @lenient opts a field.uri / field.inet out of strict well-formedness:
+        # bind a plain ``str`` (not Pydantic AnyUrl / IPvAnyAddress, whose construction
+        # IS the validator) so a not-strictly-valid value round-trips unchanged.
+        base = PyType("str")
     else:
         base = _SCALAR.get(field.sub_type, PyType("str"))
     if field_is_array(field):

{metaobjects-0.19.6 → metaobjects-0.19.8}/src/metaobjects/core_types.py

@@ -391,6 +391,15 @@ for _def in core_provider._defs:  # noqa: SLF001 (provider build-time enrichment
         )
         break
 
+# #234 — field.uri / field.inet carry the @lenient attr (opt out of strict URI / IP-literal
+# well-formedness; codegen binds a plain string, and field.inet a text column) IN ADDITION to the
+# common field attrs. Mirrors the @stringFormat enrichment above (and TS/Java/C#).
+for _def in core_provider._defs:  # noqa: SLF001 (provider build-time enrichment)
+    if _def.type == TYPE_FIELD and _def.sub_type in (fc.FIELD_SUBTYPE_URI, fc.FIELD_SUBTYPE_INET):
+        _def.attrs.append(
+            AttrSchema(name=fc.FIELD_ATTR_LENIENT, value_type=ATTR_SUBTYPE_BOOLEAN, required=False)
+        )
+
 # field.map carries the @valueType attr (scalar value subtype) IN ADDITION to the
 # common field attrs (@objectRef is already common). The bulk loop registered
 # field.map with the common attrs; append @valueType to that definition (mirrors

{metaobjects-0.19.6 → metaobjects-0.19.8}/src/metaobjects/loader/validation_passes.py

@@ -124,21 +124,23 @@ from ..meta.core.index.index_constants import INDEX_ATTR_FIELDS, INDEX_SUBTYPE_L
 from ..source import resolved_source
 from ..naming_refs import did_you_mean_hint, resolve_object_ref
 
-# A subtype-specific template attr is valid ONLY on the subtype it is registered
+# A subtype-specific template attr is valid ONLY on the subtype(s) it is registered
 # for. The metamodel registers these per-subtype (see the core_types template block),
 # but the lenient loader does not reject a misplaced one — _validate_templates does.
 # Mirrors the per-subtype TEMPLATE_ATTRS_MAP split across the other ports.
-_TEMPLATE_SUBTYPE_ONLY_ATTRS: dict[str, str] = {
-    tc.TEMPLATE_ATTR_MAX_TOKENS: tc.TEMPLATE_SUBTYPE_PROMPT,
-    tc.TEMPLATE_ATTR_REQUIRED_SLOTS: tc.TEMPLATE_SUBTYPE_PROMPT,
-    tc.TEMPLATE_ATTR_MODEL: tc.TEMPLATE_SUBTYPE_PROMPT,
-    tc.TEMPLATE_ATTR_RESPONSE_REF: tc.TEMPLATE_SUBTYPE_PROMPT,
-    tc.TEMPLATE_ATTR_PROMPT_STYLE: tc.TEMPLATE_SUBTYPE_OUTPUT,
-    tc.TEMPLATE_ATTR_KIND: tc.TEMPLATE_SUBTYPE_OUTPUT,
-    tc.TEMPLATE_ATTR_SUBJECT_REF: tc.TEMPLATE_SUBTYPE_OUTPUT,
-    tc.TEMPLATE_ATTR_HTML_BODY_REF: tc.TEMPLATE_SUBTYPE_OUTPUT,
-    tc.TEMPLATE_ATTR_TEXT_BODY_REF: tc.TEMPLATE_SUBTYPE_OUTPUT,
-    tc.TEMPLATE_ATTR_TOOL_NAME: tc.TEMPLATE_SUBTYPE_TOOLCALL,
+# #237: @maxTokens is registered on BOTH prompt AND toolcall (a vendor-agnostic token
+# budget), so the value is a SET of allowed subtypes, not a single one.
+_TEMPLATE_SUBTYPE_ONLY_ATTRS: dict[str, frozenset[str]] = {
+    tc.TEMPLATE_ATTR_MAX_TOKENS: frozenset({tc.TEMPLATE_SUBTYPE_PROMPT, tc.TEMPLATE_SUBTYPE_TOOLCALL}),
+    tc.TEMPLATE_ATTR_REQUIRED_SLOTS: frozenset({tc.TEMPLATE_SUBTYPE_PROMPT}),
+    tc.TEMPLATE_ATTR_MODEL: frozenset({tc.TEMPLATE_SUBTYPE_PROMPT}),
+    tc.TEMPLATE_ATTR_RESPONSE_REF: frozenset({tc.TEMPLATE_SUBTYPE_PROMPT}),
+    tc.TEMPLATE_ATTR_PROMPT_STYLE: frozenset({tc.TEMPLATE_SUBTYPE_OUTPUT}),
+    tc.TEMPLATE_ATTR_KIND: frozenset({tc.TEMPLATE_SUBTYPE_OUTPUT}),
+    tc.TEMPLATE_ATTR_SUBJECT_REF: frozenset({tc.TEMPLATE_SUBTYPE_OUTPUT}),
+    tc.TEMPLATE_ATTR_HTML_BODY_REF: frozenset({tc.TEMPLATE_SUBTYPE_OUTPUT}),
+    tc.TEMPLATE_ATTR_TEXT_BODY_REF: frozenset({tc.TEMPLATE_SUBTYPE_OUTPUT}),
+    tc.TEMPLATE_ATTR_TOOL_NAME: frozenset({tc.TEMPLATE_SUBTYPE_TOOLCALL}),
 }
 
 # ---------------------------------------------------------------------------
@@ -437,18 +439,22 @@ def _validate_attr_schema(
 
         # --- Check 1: required attrs must be present (uses node.attrs() = effective,
         #     so an inherited attr from the super chain satisfies the requirement) ---
-        present_attrs = node.attrs()
-        for schema in schemas:
-            if not schema.required:
-                continue
-            if schema.name not in present_attrs:
-                errors.append(
-                    MetaError(
-                        f"{_node_label(node)} is missing required attribute '@{schema.name}'",
-                        ErrorCode.ERR_MISSING_REQUIRED_ATTR,
-                        envelope=node.source,
+        # #236: an ABSTRACT node is a template, not instantiated — it may omit a required
+        # attr for concrete subtypes / `extends` to supply. Enforcement stays at the
+        # concrete level (a concrete's resolving attrs() must satisfy it). ADR-0039.
+        if not node.is_abstract:
+            present_attrs = node.attrs()
+            for schema in schemas:
+                if not schema.required:
+                    continue
+                if schema.name not in present_attrs:
+                    errors.append(
+                        MetaError(
+                            f"{_node_label(node)} is missing required attribute '@{schema.name}'",
+                            ErrorCode.ERR_MISSING_REQUIRED_ATTR,
+                            envelope=node.source,
+                        )
                     )
-                )
 
         # --- Checks 2 + 3: own attrs only (inherited attrs were already checked on
         #     the node that declared them; re-checking would double-report) ---
@@ -3002,13 +3008,14 @@ def _validate_templates(root: MetaData, errors: list[MetaError]) -> None:
         # e.g. @maxTokens (prompt-only) on a template.output, or @promptStyle
         # (output-only) on a template.prompt. ADR-0039: resolving — a subtype-only
         # attr may be inherited via extends, so read the effective value.
-        for attr_name, allowed_sub in _TEMPLATE_SUBTYPE_ONLY_ATTRS.items():
-            if tpl.get_meta_attr(attr_name) is not None and tpl.sub_type != allowed_sub:
+        for attr_name, allowed_subs in _TEMPLATE_SUBTYPE_ONLY_ATTRS.items():
+            if tpl.get_meta_attr(attr_name) is not None and tpl.sub_type not in allowed_subs:
+                valid_on = " / ".join(f"template.{s}" for s in sorted(allowed_subs))
                 errors.append(MetaError(
                     code=ErrorCode.ERR_INVALID_TEMPLATE,
                     message=(
                         f'template.{tpl.sub_type} "{tpl.name}" carries @{attr_name}, '
-                        f"which is only valid on template.{allowed_sub}"
+                        f"which is only valid on {valid_on}"
                     ),
                     envelope=tpl.source,
                 ))

{metaobjects-0.19.6 → metaobjects-0.19.8}/src/metaobjects/meta/core/field/field_constants.py

@@ -132,6 +132,11 @@ STRING_FORMAT_EMAIL = "email"
 STRING_FORMAT_HOSTNAME = "hostname"
 STRING_FORMAT_VALUES = (STRING_FORMAT_EMAIL, STRING_FORMAT_HOSTNAME)
 
+# #234: opt a field.uri / field.inet OUT of strict well-formedness enforcement (optional boolean;
+# default strict). When true, codegen binds a plain string (no URL/IP validator, no native type;
+# field.inet uses a text column). Only on field.uri / field.inet. Mirrors TS FIELD_ATTR_LENIENT.
+FIELD_ATTR_LENIENT = "lenient"
+
 # @autoSet allowed values (cross-port).
 AUTO_SET_ON_CREATE = "onCreate"
 AUTO_SET_ON_UPDATE = "onUpdate"

{metaobjects-0.19.6 → metaobjects-0.19.8}/src/metaobjects/spec_metamodel/field.json

@@ -167,15 +167,21 @@
       "dataType": "string",
       "extendsBase": true,
       "description": "A URI/URL string (ADR-0036/0037 — a concept with a native type + behavior, so a subtype not a @stringFormat). Binds to TS string (TS has no native URI type, same as field.uuid); other ports bind to their native URI type (Java java.net.URI, C# System.Uri, Python urllib.parse, Kotlin java.net.URI) and parse scheme/authority/path. DB column is text (Postgres has no uri type). Codegen emits a URL/URI validator (TS Zod z.string().url()). v1 ships WITHOUT @kind — the native type subsumes url/urn; @kind is reserved for a later url|urn value-constraint.",
-      "whenToUse": "A field holds a URL or URI. Use it for a typed URI column + URL validation instead of a plain string."
+      "whenToUse": "A field holds a URL or URI. Use it for a typed URI column + URL validation instead of a plain string.",
+      "children": [
+        { "type": "attr", "subType": "boolean", "name": "lenient", "min": 0, "max": 1, "description": "#234: opt this field out of strict well-formedness enforcement. When true, codegen binds a plain string (no URL/IP validator, no native URI/InetAddress type; field.inet uses a text column, not the native inet type) so a not-strictly-valid value round-trips unchanged. Default (absent/false) is strict: an absolute-scheme URI / an IPv4-or-IPv6 literal." }
+      ]
     },
     {
       "type": "field",
       "subType": "inet",
       "dataType": "string",
       "extendsBase": true,
-      "description": "An IP-address string (IPv4 or IPv6) (ADR-0036/0037 — a concept with a native type + behavior, so a subtype not a @stringFormat). Binds to TS string (TS has no native IP type, same as field.uuid); other ports bind to their native IP type (Java java.net.InetAddress, C# System.Net.IPAddress, Python ipaddress, Kotlin java.net.InetAddress). DB column is the Postgres-native inet type. Codegen emits an IP validator accepting both v4 and v6 (TS Zod z.string().ip()). v1 ships WITHOUT @kind — the native type subsumes ipv4/ipv6; @kind is reserved for a later ipv4|ipv6 value-constraint.",
-      "whenToUse": "A field holds an IPv4 or IPv6 address. Use it for a native Postgres inet column + IP validation instead of a plain string."
+      "description": "An IP-address string (IPv4 or IPv6) (ADR-0036/0037 — a concept with a native type + behavior, so a subtype not a @stringFormat). Binds to TS string (TS has no native IP type, same as field.uuid); other ports bind to their native IP type (Java java.net.InetAddress, C# System.Net.IPAddress, Python ipaddress, Kotlin java.net.InetAddress). DB column is the Postgres-native inet type. Codegen emits an IPv4-or-IPv6 literal validator (a Zod regex union in TS — z.string().ip() was removed in Zod 4 — native IP-type parsing in the other ports); add @lenient to bind a plain string with no validator. v1 ships WITHOUT @kind — the native type subsumes ipv4/ipv6; @kind is reserved for a later ipv4|ipv6 value-constraint.",
+      "whenToUse": "A field holds an IPv4 or IPv6 address. Use it for a native Postgres inet column + IP validation instead of a plain string.",
+      "children": [
+        { "type": "attr", "subType": "boolean", "name": "lenient", "min": 0, "max": 1, "description": "#234: opt this field out of strict well-formedness enforcement. When true, codegen binds a plain string (no URL/IP validator, no native URI/InetAddress type; field.inet uses a text column, not the native inet type) so a not-strictly-valid value round-trips unchanged. Default (absent/false) is strict: an absolute-scheme URI / an IPv4-or-IPv6 literal." }
+      ]
     }
   ]
 }

{metaobjects-0.19.6 → metaobjects-0.19.8}/src/metaobjects/spec_metamodel/prompt.json

@@ -69,7 +69,8 @@
         { "type": "attr", "subType": "string", "name": "toolName", "min": 1, "max": 1, "description": "Wire tool name surfaced to the LLM (vendor-specific format)." },
         { "type": "attr", "subType": "string", "name": "payloadRef", "min": 1, "max": 1, "description": "Output value-object the tool produces (resolved against the metamodel)." },
         { "type": "attr", "subType": "string", "name": "owner", "min": 0, "max": 1, "description": "Governance: the owner of this toolcall." },
-        { "type": "attr", "subType": "string", "name": "since", "min": 0, "max": 1, "description": "Governance: the version this toolcall was introduced in." }
+        { "type": "attr", "subType": "string", "name": "since", "min": 0, "max": 1, "description": "Governance: the version this toolcall was introduced in." },
+        { "type": "attr", "subType": "int", "name": "maxTokens", "min": 0, "max": 1, "description": "Per-call token budget for the tool-call's structured response (LLM-specific). Vendor-agnostic config; peer of @maxTokens on template.prompt (#237)." }
       ]
     }
   ]

{metaobjects-0.19.6 → metaobjects-0.19.8}/tests/codegen/test_validation_conformance.py

@@ -15,7 +15,10 @@ model, so asserting against the read model would no longer exercise Pin 1 at all
 """
 from __future__ import annotations
 
+import importlib.util
 import json
+import sys
+import tempfile
 from pathlib import Path
 
 import pytest
@@ -52,9 +55,22 @@ def _build_generated_model() -> type[BaseModel]:
     artifact), not the plain ``Account`` read model: FR-036 Pin 1 lives on the wire
     tier only."""
     source = render_entity_model(_load_account_entity())
-    namespace: dict[str, object] = {}
-    exec(compile(source, "<generated Account.py>", "exec"), namespace)  # noqa: S102
-    model = namespace["AccountCreate"]
+    # Import the generated source as a REAL module rather than exec'ing it into a
+    # bare dict: under ``from __future__ import annotations`` Pydantic resolves
+    # type annotations lazily via the class's module globals, so a non-builtin
+    # import (e.g. ``AnyUrl``/``IPvAnyAddress`` for field.uri/field.inet) only
+    # resolves when ``__name__`` and the module's imports are in scope. A bare
+    # exec namespace has no ``__name__`` (forward refs fall back to builtins and
+    # fail — #234); a proper module import mirrors the TS runner's temp-module.
+    tmp_dir = tempfile.mkdtemp()
+    mod_path = Path(tmp_dir) / "generated_account.py"
+    mod_path.write_text(source)
+    spec = importlib.util.spec_from_file_location("generated_account", mod_path)
+    assert spec and spec.loader
+    module = importlib.util.module_from_spec(spec)
+    sys.modules["generated_account"] = module
+    spec.loader.exec_module(module)
+    model = module.AccountCreate
     assert isinstance(model, type) and issubclass(model, BaseModel)
     return model
 

{metaobjects-0.19.6 → metaobjects-0.19.8}/tests/unit/test_template_toolcall.py

@@ -51,6 +51,7 @@ def test_template_toolcall_attr_schema_does_not_inherit_generic_attrs() -> None:
         tc.TEMPLATE_ATTR_PAYLOAD_REF,
         tc.TEMPLATE_ATTR_OWNER,
         tc.TEMPLATE_ATTR_SINCE,
+        tc.TEMPLATE_ATTR_MAX_TOKENS,  # #237 — vendor-agnostic per-call token budget
     }
     assert tc.TEMPLATE_ATTR_TEXT_REF not in attrs, "toolcall must NOT carry @textRef"
     assert tc.TEMPLATE_ATTR_FORMAT not in attrs, "toolcall must NOT carry @format"
@@ -59,6 +60,7 @@ def test_template_toolcall_attr_schema_does_not_inherit_generic_attrs() -> None:
     assert attrs[tc.TEMPLATE_ATTR_PAYLOAD_REF].required is True
     assert attrs[tc.TEMPLATE_ATTR_OWNER].required is False
     assert attrs[tc.TEMPLATE_ATTR_SINCE].required is False
+    assert attrs[tc.TEMPLATE_ATTR_MAX_TOKENS].required is False
 
 
 # ---------------------------------------------------------------------------