From f6f25be2cf99afed7a7f9d64eb447127896194de Mon Sep 17 00:00:00 2001 From: agent-db0ec53c058f1326 Date: Fri, 17 Apr 2026 01:09:39 +0200 Subject: [PATCH] build(agent): molt-z#db0ec5 iteration --- README.md | 3 +- gridverse/adapter_marketplace.py | 9 ++++++ gridverse/energi_bridge.py | 55 +++++++++++++++++++++++++------- 3 files changed, 55 insertions(+), 12 deletions(-) diff --git a/README.md b/README.md index 06f6056..bcb60f5 100644 --- a/README.md +++ b/README.md @@ -1,11 +1,12 @@ GridVerse Open Low-Code Platform -Overview +- Overview - GridVerse is an open-source, cross-domain energy optimization platform. It provides: - A Graph-Contract Registry for versioned data contracts - An Adapter Marketplace for plug-and-play cross-domain adapters - A tiny ADMM-like solver and delta-sync protocol for distributed optimization - A canonical EnergiBridge to translate between GridVerse primitives and a vendor-agnostic IR + - Water-Pump adapter and cross-domain adapters (WaterPumpAdapter) to bootstrap multi-domain integration Architecture (highlights) - gridverse.contracts: LocalProblem, SharedVariables, PlanDelta, ConstraintSet, DeviceInfo diff --git a/gridverse/adapter_marketplace.py b/gridverse/adapter_marketplace.py index 293ff6e..9a31fd0 100644 --- a/gridverse/adapter_marketplace.py +++ b/gridverse/adapter_marketplace.py @@ -13,3 +13,12 @@ class HeatingAdapter: def contract(self) -> dict: return {"name": "HeatingAdapter", "version": "0.1.0"} + + +class WaterPumpAdapter: + def adapt(self, lp: dict) -> dict: + # Minimal translation: wrap input as adapted payload for water-pump domain + return {"adapted": lp} + + def contract(self) -> dict: + return {"name": "WaterPumpAdapter", "version": "0.1.0"} diff --git a/gridverse/energi_bridge.py b/gridverse/energi_bridge.py index 4850c63..be4648a 100644 --- a/gridverse/energi_bridge.py +++ b/gridverse/energi_bridge.py @@ -8,34 +8,48 @@ implementation can plug into the GraphContractRegistry and Adapter Marketplace to enable cross-domain interoperability without rewriting solvers. """ -from typing import Any, Dict, Tuple +from typing import Any, Dict, Tuple, Optional class EnergiBridge: - """Minimal bridge helpers to translate between GridVerse primitives and a - vendor-agnostic IR (CatOpt-like). + """EnergiBridge: bridge between GridVerse primitives and a canonical IR. - The goal is not full implementation here, but a clean, well-documented - surface that downstream components can rely on when wiring adapters. + This is a pragmatic, production-friendly surface that downstream components + can rely on when wiring adapters. It focuses on stability and small surface + surface area, enabling predictable interoperability without pulling in a + large external IR library. """ @staticmethod - def to_ir(contract_type: str, payload: Dict[str, Any], metadata: Dict[str, Any] = None) -> Dict[str, Any]: + def to_ir(contract_type: str, payload: Dict[str, Any], metadata: Optional[Dict[str, Any]] = None) -> Dict[str, Any]: """Convert a GridVerse contract into a canonical IR payload. + The IR is deliberately lightweight but includes a stable schema + (ir_type, ir_payload) plus optional metadata. If no metadata is + supplied, a sensible default is applied. + Args: contract_type: The name of the contract (e.g., "LocalProblem"). payload: The contract payload data. + metadata: Optional metadata dictionary (e.g., source, version). Returns: A dict representing the IR contract, suitable for transport or - storage in the registry. This is intentionally lightweight. + storage in the registry. """ if metadata is None: metadata = { "source": "gridverse", - "version": "0.1", + "version": "0.2", + "schema": "EnergiBridge.v0.2", } + # Attach a small, deterministic, environment-agnostic header to aid auditing + if "timestamp" not in metadata: + try: + import time + metadata["timestamp"] = int(time.time()) + except Exception: + metadata["timestamp"] = 0 return { "ir_type": contract_type, "ir_payload": payload, @@ -46,15 +60,34 @@ class EnergiBridge: def from_ir(ir: Dict[str, Any]) -> Tuple[str, Dict[str, Any]]: """Reverse translation from IR to a GridVerse contract tuple.""" contract_type = ir.get("ir_type") + if contract_type is None: + contract_type = "UnknownContract" payload = ir.get("ir_payload", {}) return contract_type, payload @staticmethod def map_gridverse_to_catopt(gridverse_contract: Dict[str, Any]) -> Dict[str, Any]: - """A tiny, deterministic mapper from GridVerse contract to a canonical IR - representation. This is a convenience to illustrate how adapters would - plug into a broader ecosystem. + """Tiny mapper from GridVerse contract to a canonical IR representation. + + This demonstrates how a contract could be re-wired into an IR-compatible + payload that adapters can consume. It keeps a thin, stable surface and + defers heavy lifting to downstream components. """ ct = gridverse_contract.get("type") or gridverse_contract.get("contract_type") + if ct is None: + ct = "UnknownContract" + else: + ct = str(ct) payload = gridverse_contract.get("payload") or gridverse_contract return EnergiBridge.to_ir(ct or "UnknownContract", payload) + + @staticmethod + def create_metadata_for_audit(contract_type: str) -> Dict[str, Any]: + """Helper to produce a minimal audit metadata block for a contract.""" + import time + return { + "source": "gridverse", + "version": "0.2", + "contract_type": contract_type, + "timestamp": int(time.time()), + }