behavior-contracts 0.1.2__tar.gz → 0.2.0__tar.gz

{behavior_contracts-0.1.2 → behavior_contracts-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: behavior-contracts
-Version: 0.1.2
+Version: 0.2.0
 Summary: Multi-language IR-Runtime common core (Python port). The COMMON 'thin core' primitives from dsl-contracts runtime-boundary.md — validate_envelope / evaluate_expression / render_template / run_plan / canonical_value / canonical_json / py_float_repr / assert_portable — with zero backend (DynamoDB/graphddb) dependencies.
 Author: foo-log
 License: MIT
@@ -60,12 +60,12 @@ string matching the conformance protocol's failure-code set.
 
 ## Conformance
 
-Runs the 4 shared suites (93 vectors) from `../conformance/vectors/*.json`
+Runs the 7 shared suites (147 vectors) from `../conformance/vectors/*.json`
 through this package per [`../conformance/PROTOCOL.md`](../conformance/PROTOCOL.md),
 including the pre-flight version fail-closed sweep.
 
 ```bash
-python -m behavior_contracts.conformance      # → "93 passed, 0 failed / 93 vectors across 4 suites"
+python -m behavior_contracts.conformance      # → "147 passed, 0 failed / 147 vectors across 7 suites"
 # or the console script:
 behavior-contracts-conformance
 ```

{behavior_contracts-0.1.2 → behavior_contracts-0.2.0}/README.md

@@ -48,12 +48,12 @@ string matching the conformance protocol's failure-code set.
 
 ## Conformance
 
-Runs the 4 shared suites (93 vectors) from `../conformance/vectors/*.json`
+Runs the 7 shared suites (147 vectors) from `../conformance/vectors/*.json`
 through this package per [`../conformance/PROTOCOL.md`](../conformance/PROTOCOL.md),
 including the pre-flight version fail-closed sweep.
 
 ```bash
-python -m behavior_contracts.conformance      # → "93 passed, 0 failed / 93 vectors across 4 suites"
+python -m behavior_contracts.conformance      # → "147 passed, 0 failed / 147 vectors across 7 suites"
 # or the console script:
 behavior-contracts-conformance
 ```

{behavior_contracts-0.1.2 → behavior_contracts-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "behavior-contracts"
-version = "0.1.2"
+version = "0.2.0"
 description = "Multi-language IR-Runtime common core (Python port). The COMMON 'thin core' primitives from dsl-contracts runtime-boundary.md — validate_envelope / evaluate_expression / render_template / run_plan / canonical_value / canonical_json / py_float_repr / assert_portable — with zero backend (DynamoDB/graphddb) dependencies."
 readme = "README.md"
 requires-python = ">=3.9"

{behavior_contracts-0.1.2 → behavior_contracts-0.2.0}/src/behavior_contracts/__init__.py

@@ -18,10 +18,13 @@ from __future__ import annotations
 
 # ── 対応する仕様バージョン（IR/vector の spec version。ライブラリ semver とは別管理）──
 SPEC_VERSIONS = {
-    "expression": 1,
+    "expression": 2,  # v2: obj の __proto__ own key を FORBIDDEN_KEY に（fail-closed）
     "template": 1,
     "plan": 1,
-    "canonical": 1,
+    "canonical": 2,  # v2: obj 値の __proto__ own key を FORBIDDEN_KEY に（fail-closed）
+    "behavior": 2,  # v2: map.when / map.into / map.batched / handler ctx（bc#22。v1 IR の意味論は不変）
+    "guard": 1,  # 初版（bc#25: assert_portable_component_graph の accept/reject を vector-pin）
+    "c2": 1,  # 初版（bc#28: c2-catalog-swap — catalog-swap 実行 + IR 構造一致の 5 言語 pin）
 }
 
 # validate_envelope に渡す graphddb 形式の既定 supported 版（``"<major>.<minor>"``）。
@@ -29,6 +32,7 @@ ENVELOPE_SPEC_VERSION = "1.1"
 
 # ── expression（evaluate_expression） ──────────────────────────────────────────
 from .expr_eval import (  # noqa: E402
+    FORBIDDEN_OBJECT_KEY,
     ExprFailure,
     cmp_code_points,
     encode_value,
@@ -65,8 +69,16 @@ from .envelope import (  # noqa: E402
 
 # ── guard（Portability Guard） ────────────────────────────────────────────────
 from .guard import (  # noqa: E402
+    PORTABLE_EXPR_OPERATORS,
     PortabilityError,
     assert_portable,
+    assert_portable_component_graph,
+)
+
+# ── behavior（component-graph IR + run_behavior） ──────────────────────────────
+from .behavior import (  # noqa: E402
+    BehaviorFailure,
+    run_behavior,
 )
 
 # ── conformance runner adapter 共通部 ─────────────────────────────────────────
@@ -75,6 +87,12 @@ from .codec import (  # noqa: E402
     deep_equals,
 )
 
+# ── generator 支援（共通 Generator の生成モジュールが使う fingerprint, bc#13）──
+from .fingerprint import (  # noqa: E402
+    FingerprintFailure,
+    fingerprint_component_graph,
+)
+
 __all__ = [
     "SPEC_VERSIONS",
     "ENVELOPE_SPEC_VERSION",
@@ -83,6 +101,7 @@ __all__ = [
     "encode_value",
     "cmp_code_points",
     "ExprFailure",
+    "FORBIDDEN_OBJECT_KEY",
     # template
     "render_template",
     "resolve_partial",
@@ -101,8 +120,16 @@ __all__ = [
     "EnvelopeFailure",
     # guard
     "assert_portable",
+    "assert_portable_component_graph",
+    "PORTABLE_EXPR_OPERATORS",
     "PortabilityError",
+    # behavior
+    "run_behavior",
+    "BehaviorFailure",
     # codec
     "decode_value",
     "deep_equals",
+    # generator 支援（fingerprint）
+    "fingerprint_component_graph",
+    "FingerprintFailure",
 ]

behavior_contracts-0.2.0/src/behavior_contracts/behavior.py

@@ -0,0 +1,260 @@
+"""behavior.py — component-graph IR + run_behavior 統合実行 IF（Python port）。
+
+TS 参照実装 ``ts/src/behavior.ts`` の意味論を完全一致で移植（scp-ir-architecture.md §5–§7）。
+
+component-graph IR（``components[]{name, inputPorts, body[], output, plan}``）を、既存 COMMON の
+``run_plan``（stage 実行・Skip 伝播・Policy Kind）+ ``evaluate``（Expression IR）の上に実行する。
+専用コンポーネントの実装は handler registry（catalog名 → 実装。境界注入）で名前解決して委譲する。
+
+body ノード種:
+  - componentRef: ``{id, component, ports, parent?, bindField?, relationKind?, policy?}``
+  - map:          ``{id, map:{over, as, component, ports, when?, into?, batched?, parent?,
+                   relationKind?, policy?}}``（when/into/batched は behaviorVersion 2）
+  - cond:         ``{id, cond:{if, then, else, parent?}}``（純 Expression、handler を呼ばない）
+
+behaviorVersion 2（bc#22）:
+  - ``map.when``   — per-element guard。``{cond:[when,true,false]}`` へ lower して評価
+    （strict-bool・非 bool は TYPE_MISMATCH で fail-closed）。false の要素は skip。
+  - ``map.into``   — zip-attach。結果は「over の各 guard 通過要素へ into キーで handler 結果を
+    書き戻した augment 済みリスト」（over と同じ長さ・順序。skip 要素は無変更で pass through）。
+  - ``map.batched``— guard 通過全要素の ports を先に評価し handler を 1 回だけ
+    ``handler({"items": [...]}, ctx)`` で呼ぶ。結果は items と同じ長さ・順序のリスト契約
+    （違反は MAP_BATCH_RESULT_MISMATCH）。通過 0 件なら handler は呼ばれず空リスト。
+  - handler ctx    — 全 handler 呼び出しに ``{"nodeId", "component"}``（map 非 batched は
+    さらに ``"bound"``）を渡す。追加のみ・既存 handler 互換。
+"""
+
+from __future__ import annotations
+
+import threading
+from typing import Any, Callable, Dict, List, Mapping, Optional
+
+from .expr_eval import evaluate as evaluate_expression
+from .plan import run_plan
+
+Value = Any
+
+# handler(ports: dict, ctx: dict) -> ExecOutcome（{"ok": Value} | {"error": str}）
+Handler = Callable[[Dict[str, Value], Dict[str, Any]], Mapping[str, Any]]
+Handlers = Mapping[str, Handler]
+
+
+class BehaviorFailure(Exception):
+    """run_behavior の Failure（UNKNOWN_COMPONENT / MAP_OVER_NOT_ARRAY / ...）。"""
+
+    def __init__(self, code: str, message: str) -> None:
+        super().__init__(message)
+        self.code = code
+
+
+def _bfail(code: str, message: str) -> "None":
+    raise BehaviorFailure(code, message)
+
+
+def _node_kind(n: Mapping[str, Any]) -> str:
+    if "map" in n:
+        return "map"
+    if "cond" in n:
+        return "cond"
+    if "component" in n:
+        return "componentRef"
+    _bfail("UNKNOWN_NODE_KIND", f"body node '{n.get('id', '?')}' is not componentRef/map/cond")
+
+
+def _node_parent(n: Mapping[str, Any]) -> Optional[str]:
+    if "map" in n:
+        return n["map"].get("parent")
+    if "cond" in n:
+        return n["cond"].get("parent")
+    return n.get("parent")
+
+
+def _node_bind_field(n: Mapping[str, Any]) -> Optional[str]:
+    if "map" in n or "cond" in n:
+        return None
+    return n.get("bindField")
+
+
+def _node_policy(n: Mapping[str, Any]) -> Optional[str]:
+    if "map" in n:
+        return n["map"].get("policy")
+    if "cond" in n:
+        return None
+    return n.get("policy")
+
+
+def _node_relation_kind(n: Mapping[str, Any]) -> Optional[str]:
+    if "map" in n:
+        return n["map"].get("relationKind")
+    if "cond" in n:
+        return None
+    return n.get("relationKind")
+
+
+def _eval_ports(ports: Mapping[str, Any], scope: Dict[str, Value]) -> Dict[str, Value]:
+    # key はソートせず宣言順のまま。FORBIDDEN_KEY 等は evaluate が投げる（fail-closed）。
+    return {k: evaluate_expression(v, scope) for k, v in ports.items()}
+
+
+def run_behavior(
+    ir: Mapping[str, Any],
+    handlers: Handlers,
+    input: Optional[Mapping[str, Value]] = None,
+    entry: Optional[str] = None,
+) -> Value:
+    """component-graph IR の統合実行 IF（scp-ir-architecture.md §7）。
+
+    :param ir:       component-graph 可搬 IR（``{components:[...]}``）。
+    :param handlers: 専用コンポーネント handler registry（catalog名 → 実装。境界注入）。
+    :param input:    エントリ component の inputPorts 束縛（param 値）。
+    :param entry:    実行する component 名（省略時は先頭 component）。
+    :returns:        ``output`` を評価した最終 Value（Φ 合流）。
+    """
+    input = dict(input or {})
+    components = list(ir.get("components", []))
+    comp = None
+    if entry is not None:
+        comp = next((c for c in components if c.get("name") == entry), None)
+    elif components:
+        comp = components[0]
+    if comp is None:
+        _bfail("UNKNOWN_ENTRY", f"component '{entry if entry is not None else '<first>'}' not found in IR")
+
+    body: List[Mapping[str, Any]] = list(comp["body"])
+    id_to_index = {n["id"]: i for i, n in enumerate(body)}
+
+    ops: List[Dict[str, Any]] = []
+    for n in body:
+        pid = _node_parent(n)
+        parent = id_to_index.get(pid) if pid is not None else None
+        op: Dict[str, Any] = {"id": n["id"], "parent": parent}
+        bf = _node_bind_field(n)
+        if bf is not None:
+            op["bindField"] = bf
+        rk = _node_relation_kind(n)
+        if rk is not None:
+            op["relationKind"] = rk
+        pol = _node_policy(n)
+        if pol is not None:
+            op["policy"] = pol
+        ops.append(op)
+
+    # run_plan は concurrency > 1 の stage で exec を worker thread から並行に呼ぶ（bc#23）。
+    # results への書き込みは disjoint スロット（自ノード id）だが、base_scope の dict 展開
+    # （iteration）と挿入が並行すると RuntimeError になり得るため lock で直列化する。
+    # 兄弟は互いのスロットを読まない（§1: stage 内は相互独立）ので結果は決定的。
+    results: Dict[str, Value] = {}
+    results_lock = threading.Lock()
+
+    def base_scope() -> Dict[str, Value]:
+        with results_lock:
+            return {**input, **results}
+
+    def exec_node(op: Mapping[str, Any], _bound: Optional[Value]) -> Mapping[str, Any]:
+        idx = id_to_index[op["id"]]
+        node = body[idx]
+        kind = _node_kind(node)
+
+        if kind == "cond":
+            c = node["cond"]
+            value = evaluate_expression({"cond": [c["if"], c["then"], c["else"]]}, base_scope())
+            return {"ok": value}
+
+        if kind == "map":
+            m = node["map"]
+            over = evaluate_expression(m["over"], base_scope())
+            if not isinstance(over, list):
+                _bfail("MAP_OVER_NOT_ARRAY", f"map '{op['id']}': 'over' did not evaluate to an array")
+            handler = handlers.get(m["component"])
+            if handler is None:
+                _bfail("UNKNOWN_COMPONENT", f"component '{m['component']}' has no handler (fail-closed)")
+            ctx = {"nodeId": op["id"], "component": m["component"]}
+            when = m.get("when")
+
+            def keep(scope: Dict[str, Value]) -> bool:
+                # per-element guard（v2）: `{cond:[when,true,false]}` へ lower（strict-bool）。
+                if when is None and "when" not in m:
+                    return True
+                return evaluate_expression({"cond": [when, True, False]}, scope) is True
+
+            kept_idx: List[int] = []  # guard を通過した over 内 index（into の整列用）
+
+            if m.get("batched") is True:
+                # batched（v2）: guard 通過全要素の ports を先に評価し、handler を 1 回だけ呼ぶ。
+                items: List[Value] = []
+                for i, el in enumerate(over):
+                    scope = {**base_scope(), m["as"]: el}
+                    if not keep(scope):
+                        continue
+                    items.append(_eval_ports(m["ports"], scope))
+                    kept_idx.append(i)
+                if not items:
+                    collected: List[Value] = []  # guard 全落ち: handler は呼ばれない
+                else:
+                    outcome = handler({"items": items}, ctx)
+                    if "error" in outcome:
+                        return outcome
+                    r = outcome["ok"]
+                    if not isinstance(r, list) or len(r) != len(items):
+                        _bfail(
+                            "MAP_BATCH_RESULT_MISMATCH",
+                            f"map '{op['id']}': batched handler must return a list aligned to items "
+                            f"(want {len(items)}, got {len(r) if isinstance(r, list) else type(r).__name__})",
+                        )
+                    collected = r
+            else:
+                collected = []
+                for i, el in enumerate(over):
+                    scope = {**base_scope(), m["as"]: el}
+                    if not keep(scope):
+                        continue
+                    ports = _eval_ports(m["ports"], scope)
+                    outcome = handler(ports, {**ctx, "bound": el})
+                    if "error" in outcome:
+                        return outcome
+                    collected.append(outcome["ok"])
+                    kept_idx.append(i)
+
+            into = m.get("into")
+            if into is None and "into" not in m:
+                return {"ok": collected}
+
+            # into（v2）: over と同じ長さ・順序の augment 済みリスト（skip 要素は無変更）。
+            augmented: List[Value] = []
+            k = 0
+            for i, el in enumerate(over):
+                if k < len(kept_idx) and kept_idx[k] == i:
+                    if not isinstance(el, dict):
+                        _bfail(
+                            "MAP_INTO_ELEMENT_NOT_OBJECT",
+                            f"map '{op['id']}': 'into' requires object elements (element {i} is not an object)",
+                        )
+                    augmented.append({**el, into: collected[k]})
+                    k += 1
+                else:
+                    augmented.append(el)
+            return {"ok": augmented}
+
+        # componentRef
+        handler = handlers.get(node["component"])
+        if handler is None:
+            _bfail("UNKNOWN_COMPONENT", f"component '{node['component']}' has no handler (fail-closed)")
+        ports = _eval_ports(node.get("ports", {}), base_scope())
+        return handler(ports, {"nodeId": op["id"], "component": node["component"]})
+
+    def wrapped_exec(op: Mapping[str, Any], bound: Optional[Value]) -> Mapping[str, Any]:
+        outcome = exec_node(op, bound)
+        if "ok" in outcome:
+            with results_lock:
+                results[op["id"]] = outcome["ok"]
+        return outcome
+
+    plan = comp.get("plan")
+    run = run_plan(plan, ops, wrapped_exec)
+
+    for i, s in enumerate(run["states"]):
+        if s is not None and s.get("status") == "skipped":
+            rk = _node_relation_kind(body[i])
+            results[ops[i]["id"]] = {"items": [], "cursor": None} if rk == "connection" else None
+
+    return evaluate_expression(comp["output"], base_scope())

{behavior_contracts-0.1.2 → behavior_contracts-0.2.0}/src/behavior_contracts/canonical.py

@@ -22,9 +22,11 @@ import json
 import math
 from typing import Any
 
+from .expr_eval import FORBIDDEN_OBJECT_KEY
+
 Value = Any
 
-_CANONICAL_FAILURE_CODES = frozenset({"NAN_OR_INF", "INVALID_VALUE"})
+_CANONICAL_FAILURE_CODES = frozenset({"NAN_OR_INF", "INVALID_VALUE", "FORBIDDEN_KEY"})
 
 
 class CanonicalFailure(Exception):
@@ -47,6 +49,19 @@ def _is_plain_object(v: Value) -> bool:
     return isinstance(v, dict)
 
 
+def _guard_keys(keys) -> None:
+    """obj 値の own key に "__proto__" があれば fail-closed（FORBIDDEN_KEY）。
+
+    canonical_value/canonical_json/_encode_nested の全経路で適用し、expression の obj ノードと
+    同一の禁止キー規律を持つ（expression-ir.md §2.3/§8）。
+    """
+    if FORBIDDEN_OBJECT_KEY in keys:
+        _fail(
+            "FORBIDDEN_KEY",
+            f'object key "{FORBIDDEN_OBJECT_KEY}" is forbidden (fail-closed)',
+        )
+
+
 # ── §4.1 float の正準10進（CPython repr(float)）────────────────────────────────
 def py_float_repr(n: float) -> str:
     """CPython の ``repr(float)`` / ``json.dumps(float)`` と byte 一致する 10 進表現。
@@ -157,6 +172,7 @@ def canonical_value(v: Value) -> str:
     （canonical-serialization.md §2）。
     """
     if _is_plain_object(v):
+        _guard_keys(v.keys())
         keys = sorted(v.keys(), key=_code_point_sort_key)
         parts = [f"{_json_string(k)}:{_encode_nested(v[k])}" for k in keys]
         return "{" + ",".join(parts) + "}"
@@ -167,6 +183,7 @@ def canonical_value(v: Value) -> str:
 def canonical_json(v: Value) -> str:
     """fingerprint 用。全 object 階層のキーを昇順ソート（配列は順序保持）。"""
     if _is_plain_object(v):
+        _guard_keys(v.keys())
         keys = sorted(v.keys(), key=_code_point_sort_key)
         parts = [f"{_json_string(k)}:{canonical_json(v[k])}" for k in keys]
         return "{" + ",".join(parts) + "}"
@@ -178,6 +195,7 @@ def canonical_json(v: Value) -> str:
 # ── 内部: ネスト値の直列化（canonical_value 用。ネスト object は挿入順）──────────────
 def _encode_nested(v: Value) -> str:
     if _is_plain_object(v):
+        _guard_keys(v.keys())
         parts = [f"{_json_string(k)}:{_encode_nested(v[k])}" for k in v.keys()]
         return "{" + ",".join(parts) + "}"
     if isinstance(v, list):

{behavior_contracts-0.1.2 → behavior_contracts-0.2.0}/src/behavior_contracts/codec.py

@@ -16,6 +16,8 @@ from __future__ import annotations
 import math
 from typing import Any
 
+from .expr_eval import FORBIDDEN_OBJECT_KEY, ExprFailure
+
 Value = Any
 
 
@@ -53,7 +55,16 @@ def decode_value(x: Any) -> Value:
                 return float("nan")
             if k == "inf":
                 return float("-inf") if x["inf"] < 0 else float("inf")
-        return {k: decode_value(v) for k, v in x.items()}
+        out = {}
+        for k, v in x.items():
+            # fail-closed: own key "__proto__" は言語間で発散する（expression-ir.md §2.3/§8）。
+            if k == FORBIDDEN_OBJECT_KEY:
+                raise ExprFailure(
+                    "FORBIDDEN_KEY",
+                    f'object key "{FORBIDDEN_OBJECT_KEY}" is forbidden (fail-closed)',
+                )
+            out[k] = decode_value(v)
+        return out
     raise ValueError(f"cannot decode value: {x!s}")