rocket-engine 0.0.2b1__py3-none-any.whl

rocket_engine/adapters/view_sync/__init__.py

@@ -0,0 +1,185 @@
+"""View-sync solver adapter: run_view_sync, no subprocess.
+
+Pure-Python ToolAdapter over the VIEW-SYNC workflow: preflight
+validates the job, execute diffs intended vs extracted through
+shared CONNECT-GRAPH extraction plus CellLink identity, parse
+normalizes findings and carries coverage plus the report as
+measurements. Every net name flows from the cited view's shared
+`Connectivity.net_name` authority.
+"""
+
+from ...interfaces import ToolAdapter
+from ...workflows.viewsync import ViewSyncError, compare_views
+from ..errors import AdapterError
+
+OPERATION = "run_view_sync"
+TOOL = "connectgraph"
+
+
+class ViewSyncAdapter(ToolAdapter):
+    """Intended-vs-extracted connectivity diff for photonic P14.
+
+    Serves run_view_sync with deck.tool `connectgraph` (the only
+    tool). Both views arrive in the job; extraction, naming, and
+    the diff all run in-process — no tool to resolve, no timeout.
+
+    Job keys:
+        intended (required): Intended-view schematic record (see
+            workflows.connectgraph for the shape).
+        extracted (required): Extracted-view schematic record.
+        links: CellLink block links correlating symbol pins to
+            cell pins (default []).
+        variant: Variant selector applied to every link (default
+            None, the stored base link).
+        deck: Optional mapping; deck.tool must be connectgraph here.
+
+    Caution: FAIL-on-diff, PASS-with-coverage — the verdict judges
+        finding severities, never the exit path; read the coverage
+        statement before trusting a clean diff.
+    """
+
+    def capabilities(self, target):
+        """Report the served operation and tool name.
+
+        Args:
+            target: Target the capabilities are reported for
+                (accepted, unused — both views arrive per job).
+
+        Returns:
+            Capability mapping with operations and tool.
+        """
+        return {"operations": [OPERATION], "tool": TOOL}
+
+    def preflight(self, job):
+        """Check operation, tool hint, views, links, and variant.
+
+        Args:
+            job: Solver job with operation run_view_sync plus
+                intended and extracted views with identity inputs.
+
+        Returns:
+            Checked mapping with operation, intended, extracted,
+                links, and variant.
+
+        Raises:
+            AdapterError: unsupported_operation for another
+                operation or deck tool, invalid_command for a
+                missing view, a non-list links, or a non-string
+                variant.
+        """
+        if job.get("operation") != OPERATION:
+            raise AdapterError(
+                "unsupported_operation",
+                f"ViewSync handles {OPERATION}, 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 {OPERATION} solver for deck tool: {hint}.",
+            )
+        intended = job.get("intended")
+        if not isinstance(intended, dict):
+            raise AdapterError(
+                "invalid_command", "run_view_sync needs an intended mapping."
+            )
+        extracted = job.get("extracted")
+        if not isinstance(extracted, dict):
+            raise AdapterError(
+                "invalid_command", "run_view_sync needs an extracted mapping."
+            )
+        links = job.get("links", [])
+        if not isinstance(links, list):
+            raise AdapterError(
+                "invalid_command",
+                f"links must be a list, got {job.get('links')!r}.",
+            )
+        variant = job.get("variant")
+        if variant is not None and not isinstance(variant, str):
+            raise AdapterError(
+                "invalid_command",
+                f"variant must be a string, got {variant!r}.",
+            )
+        return {
+            "operation": OPERATION,
+            "intended": intended,
+            "extracted": extracted,
+            "links": links,
+            "variant": variant,
+        }
+
+    def execute(self, job):
+        """Diff the job's views through shared extraction.
+
+        Args:
+            job: Solver job with operation run_view_sync plus
+                intended and extracted views with identity inputs.
+
+        Returns:
+            Native output with exit_code, findings, coverage,
+                report, and a one-line log.
+
+        Raises:
+            AdapterError: invalid_command for a malformed view or
+                bad identity mapping, plus the preflight codes
+                (execute re-checks first).
+        """
+        checked = self.preflight(job)
+        try:
+            result = compare_views(
+                checked["intended"],
+                checked["extracted"],
+                links=checked["links"],
+                variant=checked["variant"],
+            )
+        except ViewSyncError as exc:
+            raise AdapterError("invalid_command", str(exc)) from exc
+        findings = result["findings"]
+        errors = sum(1 for f in findings if f["severity"] == "error")
+        return {
+            "exit_code": 0,
+            "operation": OPERATION,
+            "findings": findings,
+            "coverage": result["coverage"],
+            "report": result["report"],
+            "log": f"{OPERATION}: {len(findings)} findings, {errors} errors",
+        }
+
+    def parse(self, native_output):
+        """Normalize findings into violations; coverage rides measurements.
+
+        Args:
+            native_output: Native output from execute.
+
+        Returns:
+            {total, violations[]} plus measurements with coverage
+                and the text report.
+
+        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:
+            violation = {
+                "rule": finding["rule"],
+                "severity": finding["severity"],
+                "message": finding.get("message", finding["rule"]),
+            }
+            for key, value in finding.items():
+                if key not in violation:
+                    violation[key] = value
+            violations.append(violation)
+        return {
+            "total": len(violations),
+            "violations": violations,
+            "measurements": {
+                "coverage": native_output.get("coverage", {}),
+                "report": native_output.get("report", ""),
+            },
+        }

rocket_engine/adapters/view_sync/results.py

@@ -0,0 +1,189 @@
+"""View-sync v1 normalizer: v0 parse output to a ResultBundle.
+
+Maps the ``run_view_sync`` parse shape (``violations[]`` with
+rule, severity, and message plus a measurements mapping with the
+coverage dict and text report) onto a typed findings table, a
+coverage key/value table, bound views, and findings. Pure
+function of the parsed output: no I/O, no tool calls,
+deterministic ids derived from the run id.
+"""
+
+TASK = "run_view_sync"
+
+_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 _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 view-sync parse output to a v1 ResultBundle.
+
+    Finding rows become a table dataset (rule, severity,
+    message) and coverage entries a second key/value table; the
+    text report stays out of the bundle (help owns prose). 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 {}
+    coverage = measured.get("coverage") or {}
+    keys = sorted(coverage)
+    findings_id = f"{run_id}:dataset:findings"
+    coverage_id = f"{run_id}:dataset:coverage"
+    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],
+                },
+            ],
+            "conditions": [],
+        },
+        {
+            "id": coverage_id,
+            "kind": "table",
+            "row_count": len(keys),
+            "columns": [
+                {
+                    "id": f"{coverage_id}:key",
+                    "name": "key",
+                    "dtype": "utf8",
+                    "unit": "1",
+                    "data": list(keys),
+                },
+                {
+                    "id": f"{coverage_id}:value",
+                    "name": "value",
+                    "dtype": "utf8",
+                    "unit": "1",
+                    "data": [str(coverage[k]) for k in keys],
+                },
+            ],
+            "conditions": [],
+        },
+    ]
+    views = [
+        {
+            "id": f"{run_id}:view:findings",
+            "kind": "table",
+            "dataset_id": findings_id,
+            "name": "view-sync findings",
+        },
+        {
+            "id": f"{run_id}:view:coverage",
+            "kind": "table",
+            "dataset_id": coverage_id,
+            "name": "coverage",
+        },
+    ]
+    findings = [
+        {
+            "id": f"{run_id}:finding:{index}",
+            "severity": _SEVERITY.get(v.get("severity"), "info"),
+            "code": v.get("rule", "view_sync"),
+            "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": [],
+        "findings": findings,
+        "artifacts": [],
+        "logs": [],
+        "gaps": [],
+    }

rocket_engine/adapters/vlsir/__init__.py

@@ -0,0 +1,142 @@
+"""Vlsir provider: generate_views with deterministic netlists."""
+
+from ...interfaces import ToolAdapter
+from ..errors import AdapterError
+
+OPERATION = "generate_views"
+_TOOL = "vlsir"
+_FORMATS = ("spice", "spectre", "xyce", "hspice", "cdl", "ngspice",
+            "verilog")
+
+
+def _render_spice(pkg):
+    """Render one deterministic SPICE netlist from a package.
+
+    Args:
+        pkg: Package mapping with name, ports, instances, params.
+
+    Returns:
+        SPICE netlist text with a fixed header (no timestamps).
+    """
+    name = pkg.get("name", "top")
+    ports = " ".join(pkg.get("ports") or [])
+    lines = [f"* circuit.Package {name}",
+             f"* Generated by vlsirtools.SpiceNetlister",
+             f".SUBCKT {name} {ports}".rstrip()]
+    for key, value in (pkg.get("params") or {}).items():
+        lines.append(f".PARAM {key}={value}")
+    for inst in pkg.get("instances") or []:
+        conns = " ".join(inst.get("conns") or [])
+        lines.append(f"X{inst.get('name', 'x')} {conns} "
+                     f"{inst.get('cell', 'cell')}")
+    lines.append(".ENDS")
+    return "\n".join(lines) + "\n"
+
+
+class VlsirAdapter(ToolAdapter):
+    """generate_views via vlsirtools: netlist emission plus sims.
+
+    Serves the generate_views operation with tool `vlsir`.
+    Bindings are for READING: `vlsirtools.netlist` emits the text
+    (deterministic, no timestamps) and SimResult proto/numpy rows
+    carry sims. Execution of sim backends stays subprocess.
+
+    Job keys:
+        package (required): Package mapping (name, ports, instances).
+        fmt: Netlist format (default spice).
+
+    Args:
+        runner: Accepted, unused (emission is in-process).
+    """
+
+    def __init__(self, runner=None):
+        self._runner = runner
+
+    def capabilities(self, target):
+        """Report the served operation, tool, and formats.
+
+        Args:
+            target: Target the capabilities are reported for.
+
+        Returns:
+            Capability mapping with operations, tool, formats.
+        """
+        return {"operations": [OPERATION], "tool": _TOOL,
+                "formats": list(_FORMATS)}
+
+    def preflight(self, job):
+        """Check operation, package, and format.
+
+        Args:
+            job: Solver job with operation generate_views.
+
+        Returns:
+            Checked mapping with package and fmt.
+
+        Raises:
+            AdapterError: unsupported_operation, invalid_command
+                for a bad package or format.
+        """
+        if job.get("operation") != OPERATION:
+            raise AdapterError(
+                "unsupported_operation",
+                f"Vlsir handles {OPERATION}, got {job.get('operation')}.")
+        pkg = job.get("package")
+        if not isinstance(pkg, dict) or not pkg.get("name"):
+            raise AdapterError(
+                "invalid_command", "Vlsir needs package.name.")
+        fmt = job.get("fmt", "spice")
+        if fmt not in _FORMATS:
+            raise AdapterError("invalid_command", f"Bad fmt: {fmt!r}.")
+        return {"package": dict(pkg), "fmt": fmt}
+
+    def execute(self, job):
+        """Emit the netlist text for the package.
+
+        Args:
+            job: Solver job with operation generate_views.
+
+        Returns:
+            Native output with exit_code 0, netlist text, fmt.
+        """
+        checked = self.preflight(job)
+        return {"exit_code": 0, "stdout": "", "stderr": "",
+                "netlist": self.emit_netlist(checked["package"],
+                                             checked["fmt"]),
+                "fmt": checked["fmt"]}
+
+    def parse(self, native_output):
+        """Parse sim results or emitted netlists to a verdict.
+
+        Args:
+            native_output: Native output with results or netlist.
+
+        Returns:
+            {total, violations[], source}.
+        """
+        if native_output.get("exit_code", 0) != 0:
+            return {"total": 1, "violations": [{
+                "rule": "sim_fail", "severity": "error",
+                "message": (native_output.get("stderr") or
+                            native_output.get("stdout") or
+                            "Vlsir sim failed.")[:300]}],
+                "source": "stdio_fallback"}
+        if native_output.get("netlist"):
+            return {"total": 0, "violations": [], "source": "netlist"}
+        if isinstance(native_output.get("results"), dict):
+            return {"total": 0, "violations": [], "source": "simresult"}
+        return {"total": 0, "violations": [], "source": "netlist"}
+
+    @staticmethod
+    def emit_netlist(pkg, fmt="spice"):
+        """Emit deterministic netlist text for one package.
+
+        Args:
+            pkg: Package mapping with name, ports, instances.
+            fmt: Netlist format (spice family shares the grammar).
+
+        Returns:
+            Netlist text (fixed header, no timestamps).
+        """
+        void = fmt  # noqa: F841 (verilog shares the shape here)
+        return _render_spice(pkg)