rocket-engine 0.0.2b1__py3-none-any.whl

rocket_engine/adapters/connectivity/__init__.py

@@ -0,0 +1,196 @@
+"""Connectgraph solver adapter: run_connectivity/run_erc, no subprocess.
+
+Pure-Python ToolAdapter over the shared extraction plus raw-IR
+emitters. run_connectivity extracts the graph, emits the requested
+netlists, and reports connectivity findings (shorts fail, the rest
+warn); run_erc judges the same findings with unconnected pins
+escalated to errors. Every net name in findings and netlists flows
+from the shared `Connectivity.net_name` authority.
+"""
+
+from ...interfaces import ToolAdapter
+from ...workflows.connectgraph import (
+    RULE_UNCONNECTED_PIN,
+    ConnectGraphError,
+    erc_findings,
+    prepare_netlist_structs,
+)
+from ...workflows.connectgraph_emit import LANGUAGES, emit_netlists, to_raw_ir
+from ..errors import AdapterError
+
+OPERATIONS = ("run_connectivity", "run_erc")
+TOOL = "connectgraph"
+
+CONNECTIVITY_POLICY = {RULE_UNCONNECTED_PIN: "warning"}
+ERC_POLICY = {RULE_UNCONNECTED_PIN: "error"}
+
+
+class ConnectivityAdapter(ToolAdapter):
+    """Shared-graph connectivity checks plus netlist emission.
+
+    Serves run_connectivity and run_erc with deck.tool
+    `connectgraph` (the only tool). Extraction, naming, and emission
+    all run in-process; there is no tool to resolve and no timeout.
+
+    Job keys:
+        schematic (required): Schematic record (see
+            workflows.connectgraph for the shape).
+        languages: Netlist languages for run_connectivity
+            (default all of spice, verilog, vhdl).
+        run_key: Explicit extraction-cache key; uncached when omitted.
+        deck: Optional mapping; deck.tool must be connectgraph here.
+
+    Caution: run_erc fails on unconnected pins while
+        run_connectivity only warns — same findings, different
+        policy; read the verdict, never the exit path.
+    """
+
+    def capabilities(self, target):
+        """Report the served operations and tool name.
+
+        Args:
+            target: Target the capabilities are reported for
+                (accepted, unused — one schematic per job).
+
+        Returns:
+            Capability mapping with operations and tool.
+        """
+        return {"operations": list(OPERATIONS), "tool": TOOL}
+
+    def preflight(self, job):
+        """Check operation, tool hint, schematic, and languages.
+
+        Args:
+            job: Solver job with operation run_connectivity or
+                run_erc plus schematic and language inputs.
+
+        Returns:
+            Checked mapping with operation, schematic, languages,
+                and run_key.
+
+        Raises:
+            AdapterError: unsupported_operation for another
+                operation or deck tool, invalid_command for a
+                missing schematic or an unknown language.
+        """
+        if job.get("operation") not in OPERATIONS:
+            raise AdapterError(
+                "unsupported_operation",
+                f"Connectivity handles {', '.join(OPERATIONS)}, "
+                f"got {job.get('operation')}.",
+            )
+        hint = (job.get("deck") or {}).get("tool")
+        if hint is not None and hint != TOOL:
+            raise AdapterError(
+                "unsupported_operation",
+                f"No {job.get('operation')} solver for deck tool: {hint}.",
+            )
+        schematic = job.get("schematic")
+        if not isinstance(schematic, dict):
+            raise AdapterError(
+                "invalid_command", "run_connectivity needs a schematic mapping."
+            )
+        languages = job.get("languages", list(LANGUAGES))
+        if not isinstance(languages, list) or any(
+            language not in LANGUAGES for language in languages
+        ):
+            raise AdapterError(
+                "invalid_command",
+                f"languages must be a list from {list(LANGUAGES)}, "
+                f"got {job.get('languages')!r}.",
+            )
+        return {
+            "operation": job.get("operation"),
+            "schematic": schematic,
+            "languages": list(languages),
+            "run_key": job.get("run_key"),
+        }
+
+    def execute(self, job):
+        """Extract the graph, emit netlists, collect ERC findings.
+
+        Args:
+            job: Solver job with operation run_connectivity or
+                run_erc plus schematic and language inputs.
+
+        Returns:
+            Native output with exit_code, findings, netlists, net
+                table, counts, and a one-line log.
+
+        Raises:
+            AdapterError: invalid_command for a malformed
+                schematic, plus the preflight codes (execute
+                re-checks first).
+        """
+        checked = self.preflight(job)
+        try:
+            structs = prepare_netlist_structs(
+                checked["schematic"], run_key=checked["run_key"]
+            )
+        except ConnectGraphError as exc:
+            raise AdapterError("invalid_command", str(exc)) from exc
+        policy = ERC_POLICY if checked["operation"] == "run_erc" else CONNECTIVITY_POLICY
+        findings = erc_findings(structs.connectivity, policy=policy)
+        try:
+            raw = to_raw_ir(structs)
+            netlists = emit_netlists(raw, languages=checked["languages"])
+        except ConnectGraphError as exc:
+            raise AdapterError("invalid_command", str(exc)) from exc
+        nets = [net["name"] for net in raw["nets"]]
+        errors = sum(1 for f in findings if f["severity"] == "error")
+        return {
+            "exit_code": 0,
+            "operation": checked["operation"],
+            "findings": findings,
+            "netlists": netlists,
+            "nets": nets,
+            "net_count": len(nets),
+            "instance_count": len(raw["instances"]),
+            "skipped": raw["skipped"],
+            "log": (
+                f"{checked['operation']}: {len(nets)} nets, "
+                f"{len(raw['instances'])} instances, {errors} errors"
+            ),
+        }
+
+    def parse(self, native_output):
+        """Normalize findings into violations; netlists ride measurements.
+
+        Args:
+            native_output: Native output from execute.
+
+        Returns:
+            {total, violations[]} plus measurements with netlists,
+                the net table, counts, and skipped instances.
+
+        Raises:
+            AdapterError: runner_unavailable when the output has
+                no findings list.
+        """
+        findings = native_output.get("findings")
+        if not isinstance(findings, list):
+            raise AdapterError(
+                "runner_unavailable", "connectgraph output has no findings list."
+            )
+        violations = []
+        for finding in findings:
+            violations.append(
+                {
+                    "rule": finding["rule"],
+                    "severity": finding["severity"],
+                    "message": finding.get("message", finding["rule"]),
+                    "net": finding.get("net"),
+                    "net_id": finding.get("net_id"),
+                }
+            )
+        return {
+            "total": len(violations),
+            "violations": violations,
+            "measurements": {
+                "netlists": native_output.get("netlists", {}),
+                "nets": native_output.get("nets", []),
+                "net_count": native_output.get("net_count", 0),
+                "instance_count": native_output.get("instance_count", 0),
+                "skipped": native_output.get("skipped", []),
+            },
+        }

rocket_engine/adapters/connectivity/results.py

@@ -0,0 +1,214 @@
+"""Connectivity v1 normalizer: v0 parse output to a ResultBundle.
+
+Maps the ``run_connectivity``/``run_erc`` parse shape
+(``violations[]`` with rule, severity, message, and net plus a
+measurements mapping with the net inventory and counts) onto a
+typed findings table, a nets table, bound views, count
+measurements, and findings. Pure function of the parsed output:
+no I/O, no tool calls, deterministic ids derived from the run
+id.
+"""
+
+TASK = "run_connectivity"
+
+_DIAG_CAP = 240
+
+_SEVERITY = {"error": "error", "warning": "warning"}
+
+
+def _cap(text):
+    """Cap one diagnostic string at the bundle prose limit.
+
+    Args:
+        text: Raw diagnostic text, possibly unbounded tool prose.
+
+    Returns:
+        The text unchanged when short, else truncated with an
+            ellipsis marker.
+    """
+    text = text if isinstance(text, str) else str(text)
+    if len(text) <= _DIAG_CAP:
+        return text
+    return text[: _DIAG_CAP - 3] + "..."
+
+
+def _quantity(value, unit):
+    """Build one v1 Quantity, mapping unitless to dimensionless.
+
+    Args:
+        value: Numeric value.
+        unit: Unit string, possibly empty for unitless measures.
+
+    Returns:
+        Quantity mapping with an explicit unit.
+    """
+    return {"value": float(value), "unit": unit if unit else "1"}
+
+
+def _provenance(project_id, run_id, tools, provenance):
+    """Build ResultProvenance, defaulting to a placeholder closure.
+
+    Args:
+        project_id: Project the run belongs to.
+        run_id: Run the bundle describes.
+        tools: Tool ingredient mappings (id, version, digest?).
+        provenance: Full provenance mapping when the caller has
+            one; a deterministic placeholder otherwise.
+
+    Returns:
+        Provenance mapping valid against the v1 schema.
+    """
+    if provenance is not None:
+        return provenance
+    ref = {"scope": "project", "id": project_id, "revision": "r1"}
+    return {
+        "snapshot": dict(ref),
+        "input_lock": dict(ref),
+        "closure_hash": "0" * 64,
+        "tools": [
+            {
+                "id": item["id"],
+                "version": item.get("version", ""),
+                "digest": item.get("digest", "0" * 64),
+            }
+            for item in tools
+        ],
+        "parents": [],
+    }
+
+
+def normalize(parsed, *, run_id, project_id="project", target=None,
+              tools=(), provenance=None):
+    """Normalize one connectivity parse output to a v1 ResultBundle.
+
+    Finding rows become a table dataset (rule, severity, message,
+    net) and the net inventory a second table; net and instance
+    counts ride PASS measurements. Every violation also becomes a
+    finding with a capped message.
+
+    Args:
+        parsed: v0 parse mapping with ``violations[]`` and a
+            measurements mapping.
+        run_id: Run the bundle describes (anchors all ids).
+        project_id: Project the run belongs to.
+        target: v1 target mapping; project kind by default.
+        tools: Tool ingredient mappings for provenance.
+        provenance: Full provenance mapping when the caller has
+            one; a deterministic placeholder otherwise.
+
+    Returns:
+        Schema-valid ResultBundle mapping.
+    """
+    violations = parsed.get("violations") or []
+    measured = parsed.get("measurements") or {}
+    nets = measured.get("nets") or []
+    findings_id = f"{run_id}:dataset:findings"
+    nets_id = f"{run_id}:dataset:nets"
+    datasets = [
+        {
+            "id": findings_id,
+            "kind": "table",
+            "row_count": len(violations),
+            "columns": [
+                {
+                    "id": f"{findings_id}:rule",
+                    "name": "rule",
+                    "dtype": "utf8",
+                    "unit": "1",
+                    "data": [v.get("rule", "") for v in violations],
+                },
+                {
+                    "id": f"{findings_id}:severity",
+                    "name": "severity",
+                    "dtype": "utf8",
+                    "unit": "1",
+                    "data": [v.get("severity", "") for v in violations],
+                },
+                {
+                    "id": f"{findings_id}:message",
+                    "name": "message",
+                    "dtype": "utf8",
+                    "unit": "1",
+                    "data": [_cap(v.get("message", "")) for v in violations],
+                },
+                {
+                    "id": f"{findings_id}:net",
+                    "name": "net",
+                    "dtype": "utf8",
+                    "unit": "1",
+                    "data": [str(v.get("net") or "") for v in violations],
+                },
+            ],
+            "conditions": [],
+        },
+        {
+            "id": nets_id,
+            "kind": "table",
+            "row_count": len(nets),
+            "columns": [
+                {
+                    "id": f"{nets_id}:net",
+                    "name": "net",
+                    "dtype": "utf8",
+                    "unit": "1",
+                    "data": [str(net) for net in nets],
+                },
+            ],
+            "conditions": [],
+        },
+    ]
+    views = [
+        {
+            "id": f"{run_id}:view:findings",
+            "kind": "table",
+            "dataset_id": findings_id,
+            "name": "connectivity findings",
+        },
+        {
+            "id": f"{run_id}:view:nets",
+            "kind": "table",
+            "dataset_id": nets_id,
+            "name": "net inventory",
+        },
+    ]
+    measurements = []
+    for name in ("net_count", "instance_count"):
+        value = measured.get(name)
+        if value is None:
+            continue
+        measurements.append(
+            {
+                "name": name,
+                "value": _quantity(value, "1"),
+                "status": "PASS",
+            }
+        )
+    findings = [
+        {
+            "id": f"{run_id}:finding:{index}",
+            "severity": _SEVERITY.get(v.get("severity"), "info"),
+            "code": v.get("rule", "connectivity"),
+            "message": _cap(v.get("message", "")),
+        }
+        for index, v in enumerate(violations)
+    ]
+    return {
+        "schema": "rocketeda/results/v1",
+        "ref": {"scope": "project", "id": run_id, "revision": "r1"},
+        "run_id": run_id,
+        "task": TASK,
+        "target": dict(target)
+        if target is not None
+        else {"project_id": project_id, "kind": "project"},
+        "state": "complete",
+        "freshness": "current",
+        "convergence": "not_applicable",
+        "provenance": _provenance(project_id, run_id, tools, provenance),
+        "datasets": datasets,
+        "views": views,
+        "measurements": measurements,
+        "findings": findings,
+        "artifacts": [],
+        "logs": [],
+        "gaps": [],
+    }

rocket_engine/adapters/cosim/README.md

@@ -0,0 +1,9 @@
+# Coupled mixed-signal co-simulation adapter
+
+CosimAdapter serves run_cosim. It runs an ngspice transient, samples the analog output into a digital bitstream, passes that stream to the Icarus HDL adapter, and evaluates the combined analog and digital checks.
+
+The job supplies its analog sources, digital bench, and loop settings. PDK model references resolve through the PDK store; an invalid or changed model fails preflight. Model-free behavioral jobs can omit the PDK reference.
+
+The verdict comes from parsed measurements and digital findings, not the tool exit code. Missing samples or tool failures remain failures or NOT_RUN with a reason. The adapter currently composes its digital half through HdlSimAdapter.
+
+See the [SEAM-COSIM report](../../../docs/work/SEAM-COSIM/report.md) for qualification evidence and known limits.