prisma-api 0.3.10__tar.gz → 0.4.0__tar.gz

{prisma_api-0.3.10 → prisma_api-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prisma_api
-Version: 0.3.10
+Version: 0.4.0
 Summary: A package for interacting with PrISMa Platform APIs. PrISMa is a holistic system for numerical synthesis and assessment of Metal-Organic Frameworks and their applications, for Direct Air Capture of CO2. For more information, see: https://prisma.hw.ac.uk.
 Author-email: RCCS-CaptureTeam <team@prisma-platform.org>
 License: GNUv3

{prisma_api-0.3.10 → prisma_api-0.4.0}/prisma_api/prisma_api_v2.py

@@ -24,6 +24,7 @@ from urllib.parse import urlencode
 import warnings
 import json
 import re
+import subprocess
 from datetime import datetime
 
 
@@ -966,6 +967,86 @@ class PrismaAPIv2:
             return result
         return []
 
+    def _payload_to_records(self, payload: pd.DataFrame | list[dict] | dict) -> list[dict]:
+        """Normalise write payloads to list[dict] while preserving all fields."""
+        if isinstance(payload, pd.DataFrame):
+            return payload.to_dict(orient="records")
+        if isinstance(payload, dict):
+            return [payload]
+        if isinstance(payload, list):
+            return payload
+        raise TypeError("payload must be a DataFrame, dict, or list[dict]")
+
+    def _autoprism_meta_provenance(self) -> dict[str, str | None]:
+        """Build meta_provenance from local repository and pyproject metadata."""
+
+        def _git(args: list[str]) -> str | None:
+            try:
+                cp = subprocess.run(
+                    ["git", *args],
+                    cwd=Path(__file__).resolve().parents[1],
+                    check=False,
+                    capture_output=True,
+                    text=True,
+                )
+            except OSError:
+                return None
+            if cp.returncode != 0:
+                return None
+            value = cp.stdout.strip()
+            return value or None
+
+        repo_root = _git(["rev-parse", "--show-toplevel"])
+        repo_name = Path(repo_root).name if repo_root else Path(__file__).resolve().parents[1].name
+        branch = _git(["rev-parse", "--abbrev-ref", "HEAD"])
+        source_repo = (
+            repo_name
+            if branch in (None, "main")
+            else f"{repo_name} (branch: {branch})"
+        )
+
+        pyproject_version: str | None = None
+        pyproject_path = Path(__file__).resolve().parents[1] / "pyproject.toml"
+        if pyproject_path.exists():
+            text = pyproject_path.read_text(encoding="utf-8")
+            try:
+                import tomllib  # Python 3.11+
+
+                data = tomllib.loads(text)
+                project = data.get("project", {}) if isinstance(data, dict) else {}
+                value = project.get("version") if isinstance(project, dict) else None
+                pyproject_version = str(value) if value else None
+            except Exception:
+                # Fallback for environments where tomllib is unavailable.
+                m = re.search(r"(?ms)^\[project\].*?^version\s*=\s*\"([^\"]+)\"", text)
+                pyproject_version = m.group(1).strip() if m else None
+
+        return {
+            "source_repo": source_repo,
+            "source_repo_semantic_version": pyproject_version,
+            "source_repo_tag": _git(["describe", "--tags", "--abbrev=0"]),
+            "source_commit_hash": _git(["rev-parse", "HEAD"]),
+        }
+
+    def _autoprism_source_repo_url(self) -> str | None:
+        """Return the repository remote URL used for source provenance, if available."""
+        try:
+            cp = subprocess.run(
+                ["git", "remote", "get-url", "origin"],
+                cwd=Path(__file__).resolve().parents[1],
+                check=False,
+                capture_output=True,
+                text=True,
+            )
+        except OSError:
+            return None
+
+        if cp.returncode != 0:
+            return None
+
+        value = cp.stdout.strip()
+        return value or None
+
     def _properties_for(self, object_id: int, limit: int = 2000) -> list[dict]:
         """Return all Property records linked to *object_id* via GenericForeignKey.
 
@@ -1695,6 +1776,561 @@ class PrismaAPIv2:
         """GET /api/v2/carbon-zeopp-experimental/{item_id}/"""
         return self._get(f"/carbon-zeopp-experimental/{item_id}/")
 
+    # ── AutoPrism tables ─────────────────────────────────────────────────────
+
+    def get_computation_runs(
+        self,
+        workflow_id: str | None = None,
+        step: str | None = None,
+        status: str | None = None,
+        limit: int = 500,
+        offset: int = 0,
+    ) -> pd.DataFrame:
+        """
+        GET /api/v2/computation-runs/
+
+        Args:
+            workflow_id: Workflow identifier filter.
+            step: Step filter.
+            status: Status filter.
+        """
+        params = _compact(
+            workflow_id=workflow_id,
+            step=step,
+            status=status,
+            limit=limit,
+            offset=offset,
+        )
+        return self._to_df(self._get("/computation-runs/", params))
+
+    def get_computation_run(self, run_id: int) -> dict:
+        """GET /api/v2/computation-runs/{run_id}/"""
+        return self._get(f"/computation-runs/{run_id}/")
+
+    def upsert_computation_runs(self, payload: pd.DataFrame | list[dict] | dict) -> dict:
+        """
+        PUT /api/v2/computation-runs/
+
+        Accepts one object or many objects and forwards all provided fields.
+        """
+        return self._put("/computation-runs/", self._payload_to_records(payload))
+
+    def get_adsorption_singlepoint(
+        self,
+        structure: str | None = None,
+        md5: str | None = None,
+        mixture_id: str | None = None,
+        component: str | None = None,
+        limit: int = 500,
+        offset: int = 0,
+    ) -> pd.DataFrame:
+        """
+        GET /api/v2/adsorption-singlepoint/
+
+        Args:
+            structure: Structure name filter.
+            md5: Exact md5 hash filter.
+            mixture_id: Mixture identifier filter.
+            component: Component filter.
+        """
+        params = _compact(
+            structure=structure,
+            md5=md5,
+            mixture_id=mixture_id,
+            component=component,
+            limit=limit,
+            offset=offset,
+        )
+        return self._to_df(self._get("/adsorption-singlepoint/", params))
+
+    def get_adsorption_singlepoint_item(self, row_id: int) -> dict:
+        """GET /api/v2/adsorption-singlepoint/{row_id}/"""
+        return self._get(f"/adsorption-singlepoint/{row_id}/")
+
+    def upsert_adsorption_singlepoint(self, payload: pd.DataFrame | list[dict] | dict) -> dict:
+        """
+        PUT /api/v2/adsorption-singlepoint/
+
+        Accepts one object or many objects.
+        Automatically normalises ``meta_provenance`` using local repo metadata.
+        """
+        if isinstance(payload, dict) and isinstance(payload.get("adsorption_singlepoints"), list):
+            records = self._payload_to_records(payload["adsorption_singlepoints"])
+        else:
+            records = self._payload_to_records(payload)
+        meta = {
+            **self._autoprism_meta_provenance(),
+            "source_repo_url": self._autoprism_source_repo_url(),
+        }
+        enriched = [
+            {
+                **record,
+                "meta_provenance": meta,
+            }
+            if isinstance(record, dict)
+            else record
+            for record in records
+        ]
+        return self._put("/adsorption-singlepoint/", enriched)
+
+    def get_heat_capacity(
+        self,
+        structure: str | None = None,
+        temperature_K: float | None = None,
+        limit: int = 500,
+        offset: int = 0,
+    ) -> pd.DataFrame:
+        """
+        GET /api/v2/heat-capacity/
+
+        Args:
+            structure: Structure name filter.
+            temperature_K: Temperature filter [K].
+        """
+        params = _compact(
+            structure=structure,
+            temperature_K=temperature_K,
+            limit=limit,
+            offset=offset,
+        )
+        return self._to_df(self._get("/heat-capacity/", params))
+
+    def get_heat_capacity_item(self, row_id: int) -> dict:
+        """GET /api/v2/heat-capacity/{row_id}/"""
+        return self._get(f"/heat-capacity/{row_id}/")
+
+    def upsert_heat_capacity(self, payload: pd.DataFrame | list[dict] | dict) -> dict:
+        """
+        PUT /api/v2/heat-capacity/
+
+        Accepts one object or many objects.
+        Automatically normalises ``meta_provenance`` using local repo metadata.
+        """
+        if isinstance(payload, dict) and isinstance(payload.get("heat_capacities"), list):
+            records = self._payload_to_records(payload["heat_capacities"])
+        else:
+            records = self._payload_to_records(payload)
+
+        meta = {
+            **self._autoprism_meta_provenance(),
+            "source_repo_url": self._autoprism_source_repo_url(),
+        }
+        enriched = [
+            {
+                **record,
+                "meta_provenance": meta,
+            }
+            if isinstance(record, dict)
+            else record
+            for record in records
+        ]
+        return self._put("/heat-capacity/", enriched)
+
+    def get_isotherm_h2(
+        self,
+        structure: str | None = None,
+        isotherm_id: str | None = None,
+        component: str | None = None,
+        temperature_K: float | None = None,
+        pressure_bar: float | None = None,
+        limit: int = 500,
+        offset: int = 0,
+    ) -> pd.DataFrame:
+        """
+        GET /api/v2/isotherm-h2/
+
+        Args:
+            structure: Structure name filter.
+            isotherm_id: Isotherm identifier filter.
+            component: Component filter.
+            temperature_K: Temperature filter [K].
+            pressure_bar: Pressure filter [bar].
+        """
+        params = _compact(
+            structure=structure,
+            isotherm_id=isotherm_id,
+            component=component,
+            temperature_K=temperature_K,
+            pressure_bar=pressure_bar,
+            limit=limit,
+            offset=offset,
+        )
+        return self._to_df(self._get("/isotherm-h2/", params))
+
+    def get_isotherm_h2_item(self, row_id: int) -> dict:
+        """GET /api/v2/isotherm-h2/{row_id}/"""
+        return self._get(f"/isotherm-h2/{row_id}/")
+
+    def upsert_isotherm_h2(self, payload: pd.DataFrame | list[dict] | dict) -> dict:
+        """
+        PUT /api/v2/isotherm-h2/
+
+        Accepts one object or many objects.
+        Automatically normalises ``meta_provenance`` using local repo metadata.
+        """
+        if isinstance(payload, dict) and isinstance(payload.get("isotherm_H2s"), list):
+            records = self._payload_to_records(payload["isotherm_H2s"])
+        else:
+            records = self._payload_to_records(payload)
+
+        meta = self._autoprism_meta_provenance()
+        enriched = [
+            {
+                **record,
+                "meta_provenance": meta,
+            }
+            if isinstance(record, dict)
+            else record
+            for record in records
+        ]
+        return self._put("/isotherm-h2/", enriched)
+
+    def get_mofchecker(
+        self,
+        structure: str | None = None,
+        md5: str | None = None,
+        is_mof: bool | None = None,
+        MOFQ: str | None = None,
+        limit: int = 500,
+        offset: int = 0,
+    ) -> pd.DataFrame:
+        """
+        GET /api/v2/mofchecker/
+
+        Args:
+            structure: Structure name filter.
+            md5: Exact md5 hash filter.
+            is_mof: Boolean mofchecker flag.
+            MOFQ: MOFQ classifier filter.
+        """
+        params = _compact(
+            structure=structure,
+            md5=md5,
+            is_mof=None if is_mof is None else str(is_mof).lower(),
+            MOFQ=MOFQ,
+            limit=limit,
+            offset=offset,
+        )
+        return self._to_df(self._get("/mofchecker/", params))
+
+    def get_mofchecker_item(self, row_id: int) -> dict:
+        """GET /api/v2/mofchecker/{row_id}/"""
+        return self._get(f"/mofchecker/{row_id}/")
+
+    def upsert_mofchecker(self, payload: pd.DataFrame | list[dict] | dict) -> dict:
+        """
+        PUT /api/v2/mofchecker/
+
+        Accepts one object or many objects.
+        Automatically normalises ``meta_provenance`` using local repo metadata.
+        """
+        if isinstance(payload, dict) and isinstance(payload.get("mofchecker"), list):
+            records = self._payload_to_records(payload["mofchecker"])
+        else:
+            records = self._payload_to_records(payload)
+
+        meta = self._autoprism_meta_provenance()
+        enriched = [
+            {
+                **record,
+                "meta_provenance": meta,
+            }
+            if isinstance(record, dict)
+            else record
+            for record in records
+        ]
+        return self._put("/mofchecker/", enriched)
+
+    def get_zeopp_metrics(
+        self,
+        mof: str | None = None,
+        md5: str | None = None,
+        probe: str | None = None,
+        limit: int = 500,
+        offset: int = 0,
+    ) -> pd.DataFrame:
+        """
+        GET /api/v2/zeopp-metrics/
+
+        Args:
+            mof: MOF name filter.
+            md5: Exact md5 hash filter.
+            probe: Probe name filter.
+        """
+        params = _compact(mof=mof, md5=md5, probe=probe, limit=limit, offset=offset)
+        return self._to_df(self._get("/zeopp-metrics/", params))
+
+    def get_zeopp_metrics_item(self, row_id: int) -> dict:
+        """GET /api/v2/zeopp-metrics/{row_id}/"""
+        return self._get(f"/zeopp-metrics/{row_id}/")
+
+    def upsert_zeopp_metrics(self, payload: pd.DataFrame | list[dict] | dict) -> dict:
+        """
+        PUT /api/v2/zeopp-metrics/
+
+        Accepts one object or many objects.
+        Automatically normalises ``meta_provenance`` using local repo metadata.
+        """
+        if isinstance(payload, dict) and isinstance(payload.get("zeopp_metrics"), list):
+            records = self._payload_to_records(payload["zeopp_metrics"])
+        else:
+            records = self._payload_to_records(payload)
+
+        meta = self._autoprism_meta_provenance()
+        enriched = [
+            {
+                **record,
+                "meta_provenance": meta,
+            }
+            if isinstance(record, dict)
+            else record
+            for record in records
+        ]
+        return self._put("/zeopp-metrics/", enriched)
+
+    def upsert_autoprism_collection(self, payload: dict[str, Any]) -> dict[str, Any]:
+        """
+        Upsert multiple AutoPrism sections from a single combined payload.
+
+        Expected payload shape mirrors the AutoPrism collection mock payload, with
+        optional top-level keys:
+            computation_runs, adsorption_singlepoints, heat_capacities,
+            isotherm_H2s, mofchecker, zeopp_metrics, meta_provenance
+
+        Notes:
+            - Top-level ``meta_provenance`` is ignored.
+            - Each section is passed to its dedicated upsert wrapper so section-
+              specific provenance normalization rules remain in one place.
+
+        Returns:
+            dict with keys:
+                sections: per-section status details
+                totals: aggregate created/updated counters
+                overall_status: "ok" if no section failed, else "partial_failure"
+        """
+        if not isinstance(payload, dict):
+            raise TypeError("payload must be a dict matching the AutoPrism collection shape")
+
+        section_handlers: list[tuple[str, str, Any]] = [
+            ("computation_runs", "upsert_computation_runs", payload.get("computation_runs")),
+            ("adsorption_singlepoints", "upsert_adsorption_singlepoint", payload.get("adsorption_singlepoints")),
+            ("heat_capacities", "upsert_heat_capacity", payload.get("heat_capacities")),
+            ("isotherm_H2s", "upsert_isotherm_h2", payload.get("isotherm_H2s")),
+            ("mofchecker", "upsert_mofchecker", payload.get("mofchecker")),
+            ("zeopp_metrics", "upsert_zeopp_metrics", payload.get("zeopp_metrics")),
+        ]
+
+        sections: dict[str, dict[str, Any]] = {}
+        total_created = 0
+        total_updated = 0
+        failed = 0
+
+        for section_name, method_name, section_payload in section_handlers:
+            if section_payload is None:
+                sections[section_name] = {
+                    "status": "skipped",
+                    "reason": "missing section in payload",
+                }
+                continue
+
+            try:
+                method = getattr(self, method_name)
+                result = method(section_payload)
+                created = int(result.get("created", 0)) if isinstance(result, dict) else 0
+                updated = int(result.get("updated", 0)) if isinstance(result, dict) else 0
+                total_created += created
+                total_updated += updated
+                sections[section_name] = {
+                    "status": "ok",
+                    "created": created,
+                    "updated": updated,
+                    "result": result,
+                }
+            except Exception as exc:
+                failed += 1
+                sections[section_name] = {
+                    "status": "error",
+                    "error": str(exc),
+                }
+
+        return {
+            "sections": sections,
+            "totals": {
+                "created": total_created,
+                "updated": total_updated,
+                "failed_sections": failed,
+            },
+            "overall_status": "ok" if failed == 0 else "partial_failure",
+        }
+
+    def get_autoprism_collection(
+        self,
+        workflow_id: str | None = None,
+        step: str | None = None,
+        status: str | None = None,
+        structure: str | None = None,
+        mof: str | None = None,
+        md5: str | None = None,
+        mixture_id: str | None = None,
+        component: str | None = None,
+        isotherm_id: str | None = None,
+        temperature_K: float | None = None,
+        pressure_bar: float | None = None,
+        probe: str | None = None,
+        is_mof: bool | None = None,
+        MOFQ: str | None = None,
+        limit: int = 500,
+        offset: int = 0,
+    ) -> dict[str, list[dict] | dict[str, str | None]]:
+        """
+        Gather AutoPrism table records in one call flow.
+
+        Returns a dict with keys:
+            computation_runs,
+            adsorption_singlepoints, heat_capacities, isotherm_H2s,
+            mofchecker, zeopp_metrics
+            meta_provenance
+
+        Notes:
+                        - ``workflow_id``, ``step`` and ``status`` filter computation runs.
+            - ``structure`` is used for adsorption_singlepoint, heat_capacity,
+              isotherm_H2 and mofchecker.
+            - ``mof`` is used for zeopp_metrics.
+            - If ``structure`` is omitted and ``mof`` is provided, ``mof`` is
+              also used as the structure filter for convenience.
+
+        Empty payload handling:
+            - If any sub-call returns ``None`` or an unexpected scalar payload,
+              this method normalises it to an empty table representation
+              (``pd.DataFrame()`` in dataframe mode, ``[]`` in json mode).
+        """
+        structure_filter = structure or mof
+
+        def _empty_table() -> pd.DataFrame | list[dict]:
+            return [] if self._return_format == "json" else pd.DataFrame()
+
+        def _normalise_table_payload(value: Any) -> pd.DataFrame | list[dict]:
+            if value is None:
+                return _empty_table()
+            if isinstance(value, (pd.DataFrame, list)):
+                return value
+            if isinstance(value, dict):
+                return self._to_df(value)
+            return _empty_table()
+
+        def _record_count(value: Any) -> int:
+            try:
+                return len(value)
+            except TypeError:
+                return 0
+
+        def _as_record_list(value: Any) -> list[dict]:
+            records = self._as_records(value)
+            return [r for r in records if isinstance(r, dict)]
+
+        meta = {
+            **self._autoprism_meta_provenance(),
+            "source_repo_url": self._autoprism_source_repo_url(),
+        }
+
+        def _safe_fetch(section: str, fetcher, **kwargs) -> pd.DataFrame | list[dict]:
+            try:
+                return _normalise_table_payload(fetcher(**kwargs))
+            except requests.HTTPError as exc:
+                warnings.warn(
+                    f"AutoPrism section '{section}' failed ({exc}); returning empty table.",
+                    UserWarning,
+                    stacklevel=2,
+                )
+                return _empty_table()
+            except requests.RequestException as exc:
+                warnings.warn(
+                    f"AutoPrism section '{section}' request error ({exc}); returning empty table.",
+                    UserWarning,
+                    stacklevel=2,
+                )
+                return _empty_table()
+
+        collection = {
+            "computation_runs": _safe_fetch(
+                "computation_runs",
+                self.get_computation_runs,
+                workflow_id=workflow_id,
+                step=step,
+                status=status,
+                limit=limit,
+                offset=offset,
+            ),
+            "adsorption_singlepoints": _safe_fetch(
+                "adsorption_singlepoint",
+                self.get_adsorption_singlepoint,
+                structure=structure_filter,
+                md5=md5,
+                mixture_id=mixture_id,
+                component=component,
+                limit=limit,
+                offset=offset,
+            ),
+            "heat_capacities": _safe_fetch(
+                "heat_capacity",
+                self.get_heat_capacity,
+                structure=structure_filter,
+                temperature_K=temperature_K,
+                limit=limit,
+                offset=offset,
+            ),
+            "isotherm_H2s": _safe_fetch(
+                "isotherm_H2",
+                self.get_isotherm_h2,
+                structure=structure_filter,
+                isotherm_id=isotherm_id,
+                component=component,
+                temperature_K=temperature_K,
+                pressure_bar=pressure_bar,
+                limit=limit,
+                offset=offset,
+            ),
+            "mofchecker": _safe_fetch(
+                "mofchecker",
+                self.get_mofchecker,
+                structure=structure_filter,
+                md5=md5,
+                is_mof=is_mof,
+                MOFQ=MOFQ,
+                limit=limit,
+                offset=offset,
+            ),
+            "zeopp_metrics": _safe_fetch(
+                "zeopp_metrics",
+                self.get_zeopp_metrics,
+                mof=mof,
+                md5=md5,
+                probe=probe,
+                limit=limit,
+                offset=offset,
+            ),
+        }
+
+        collection = {
+            key: _as_record_list(value)
+            for key, value in collection.items()
+        }
+        collection["meta_provenance"] = meta
+
+        label = structure_filter or mof or "all"
+        print(f"AutoPrism collection for '{label}':")
+        for key in (
+            "computation_runs",
+            "adsorption_singlepoints",
+            "heat_capacities",
+            "isotherm_H2s",
+            "mofchecker",
+            "zeopp_metrics",
+        ):
+            print(f"  {key:22s}: {_record_count(collection.get(key, []))} records")
+
+        return collection
+
     # ── TEA / LCA data ────────────────────────────────────────────────────────
 
     def get_output_kpis(self,

{prisma_api-0.3.10 → prisma_api-0.4.0}/prisma_api.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prisma_api
-Version: 0.3.10
+Version: 0.4.0
 Summary: A package for interacting with PrISMa Platform APIs. PrISMa is a holistic system for numerical synthesis and assessment of Metal-Organic Frameworks and their applications, for Direct Air Capture of CO2. For more information, see: https://prisma.hw.ac.uk.
 Author-email: RCCS-CaptureTeam <team@prisma-platform.org>
 License: GNUv3

{prisma_api-0.3.10 → prisma_api-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "prisma_api"
-version = "0.3.10"
+version = "0.4.0"
 description = "A package for interacting with PrISMa Platform APIs. PrISMa is a holistic system for numerical synthesis and assessment of Metal-Organic Frameworks and their applications, for Direct Air Capture of CO2. For more information, see: https://prisma.hw.ac.uk."
 authors = [
     {name = "RCCS-CaptureTeam", email = "team@prisma-platform.org"}

{prisma_api-0.3.10 → prisma_api-0.4.0}/tests/test_prisma_api_v2.py

@@ -15,6 +15,7 @@ import pytest
 import responses as resp_lib
 from responses import matchers
 from datetime import datetime
+from numbers import Integral
 
 import pandas as pd
 
@@ -908,9 +909,9 @@ def test_get_scopes_coerces_types(api):
     df = api.get_scopes()
     row = df.iloc[0]
 
-    assert isinstance(row["id"], int)
+    assert isinstance(row["id"], Integral)
     assert isinstance(row["name"], str)
-    assert isinstance(row["active"], bool)
+    assert pd.api.types.is_bool_dtype(df["active"])
     assert isinstance(row["capture_efficiency"], float)
     assert pd.api.types.is_datetime64_any_dtype(df["created_at"])
     assert isinstance(row["tags"], list)
@@ -1294,6 +1295,570 @@ def test_get_carbon_zeopp_experimental_item_detail(api):
     assert api.get_carbon_zeopp_experimental_item(1)["mof"] == "HKUST"
 
 
+# ── AutoPrism Tables ─────────────────────────────────────────────────────────
+
+@resp_lib.activate
+def test_get_autoprism_collection_returns_all_records(api):
+    resp_lib.add(
+        resp_lib.GET,
+        f"{PROD_BASE}/computation-runs/",
+        match=[matchers.query_param_matcher({
+            "workflow_id": "wf-1",
+            "step": "adsorption",
+            "status": "done",
+            "limit": "50",
+            "offset": "0",
+        })],
+        json=_envelope([{"id": 99, "workflow_id": "wf-1", "step": "adsorption", "status": "done"}]),
+        status=200,
+    )
+    resp_lib.add(
+        resp_lib.GET,
+        f"{PROD_BASE}/adsorption-singlepoint/",
+        match=[matchers.query_param_matcher({
+            "structure": "ABEXEM",
+            "md5": "abc123",
+            "mixture_id": "mix-1",
+            "component": "CO2",
+            "limit": "50",
+            "offset": "0",
+        })],
+        json=_envelope([{"id": 1, "structure": "ABEXEM"}]),
+        status=200,
+    )
+    resp_lib.add(
+        resp_lib.GET,
+        f"{PROD_BASE}/heat-capacity/",
+        match=[matchers.query_param_matcher({
+            "structure": "ABEXEM",
+            "temperature_K": "298.0",
+            "limit": "50",
+            "offset": "0",
+        })],
+        json=_envelope([{"id": 2, "structure": "ABEXEM", "temperature_K": 298.0}]),
+        status=200,
+    )
+    resp_lib.add(
+        resp_lib.GET,
+        f"{PROD_BASE}/isotherm-h2/",
+        match=[matchers.query_param_matcher({
+            "structure": "ABEXEM",
+            "isotherm_id": "iso-1",
+            "component": "CO2",
+            "temperature_K": "298.0",
+            "pressure_bar": "1.0",
+            "limit": "50",
+            "offset": "0",
+        })],
+        json=_envelope([{"id": 3, "structure": "ABEXEM", "isotherm_id": "iso-1"}]),
+        status=200,
+    )
+    resp_lib.add(
+        resp_lib.GET,
+        f"{PROD_BASE}/mofchecker/",
+        match=[matchers.query_param_matcher({
+            "structure": "ABEXEM",
+            "md5": "abc123",
+            "is_mof": "true",
+            "MOFQ": "yes",
+            "limit": "50",
+            "offset": "0",
+        })],
+        json=_envelope([{"id": 4, "structure": "ABEXEM", "is_mof": True}]),
+        status=200,
+    )
+    resp_lib.add(
+        resp_lib.GET,
+        f"{PROD_BASE}/zeopp-metrics/",
+        match=[matchers.query_param_matcher({
+            "mof": "ABEXEM",
+            "md5": "abc123",
+            "probe": "N2",
+            "limit": "50",
+            "offset": "0",
+        })],
+        json=_envelope([{"id": 5, "mof": "ABEXEM", "probe": "N2"}]),
+        status=200,
+    )
+
+    bundle = api.get_autoprism_collection(
+        workflow_id="wf-1",
+        step="adsorption",
+        status="done",
+        structure="ABEXEM",
+        mof="ABEXEM",
+        md5="abc123",
+        mixture_id="mix-1",
+        component="CO2",
+        isotherm_id="iso-1",
+        temperature_K=298.0,
+        pressure_bar=1.0,
+        probe="N2",
+        is_mof=True,
+        MOFQ="yes",
+        limit=50,
+        offset=0,
+    )
+
+    assert set(bundle.keys()) == {
+        "computation_runs",
+        "adsorption_singlepoints",
+        "heat_capacities",
+        "isotherm_H2s",
+        "mofchecker",
+        "zeopp_metrics",
+        "meta_provenance",
+    }
+    assert len(bundle["computation_runs"]) == 1
+    assert len(bundle["adsorption_singlepoints"]) == 1
+    assert len(bundle["heat_capacities"]) == 1
+    assert len(bundle["isotherm_H2s"]) == 1
+    assert len(bundle["mofchecker"]) == 1
+    assert len(bundle["zeopp_metrics"]) == 1
+
+
+@resp_lib.activate
+def test_get_autoprism_collection_uses_mof_as_structure_fallback(api):
+    resp_lib.add(
+        resp_lib.GET,
+        f"{PROD_BASE}/computation-runs/",
+        match=[matchers.query_param_matcher({"limit": "500", "offset": "0"})],
+        json=_envelope([]),
+        status=200,
+    )
+    resp_lib.add(
+        resp_lib.GET,
+        f"{PROD_BASE}/adsorption-singlepoint/",
+        match=[matchers.query_param_matcher({"structure": "HKUST", "limit": "500", "offset": "0"})],
+        json=_envelope([]),
+        status=200,
+    )
+    resp_lib.add(
+        resp_lib.GET,
+        f"{PROD_BASE}/heat-capacity/",
+        match=[matchers.query_param_matcher({"structure": "HKUST", "limit": "500", "offset": "0"})],
+        json=_envelope([]),
+        status=200,
+    )
+    resp_lib.add(
+        resp_lib.GET,
+        f"{PROD_BASE}/isotherm-h2/",
+        match=[matchers.query_param_matcher({"structure": "HKUST", "limit": "500", "offset": "0"})],
+        json=_envelope([]),
+        status=200,
+    )
+    resp_lib.add(
+        resp_lib.GET,
+        f"{PROD_BASE}/mofchecker/",
+        match=[matchers.query_param_matcher({"structure": "HKUST", "limit": "500", "offset": "0"})],
+        json=_envelope([]),
+        status=200,
+    )
+    resp_lib.add(
+        resp_lib.GET,
+        f"{PROD_BASE}/zeopp-metrics/",
+        match=[matchers.query_param_matcher({"mof": "HKUST", "limit": "500", "offset": "0"})],
+        json=_envelope([]),
+        status=200,
+    )
+
+    api.get_autoprism_collection(mof="HKUST")
+
+
+@resp_lib.activate
+def test_get_computation_runs_filters(api):
+    resp_lib.add(
+        resp_lib.GET,
+        f"{PROD_BASE}/computation-runs/",
+        match=[matchers.query_param_matcher({
+            "workflow_id": "wf-1",
+            "step": "zeopp",
+            "status": "running",
+            "limit": "25",
+            "offset": "5",
+        })],
+        json=_envelope([{"id": 1, "workflow_id": "wf-1", "step": "zeopp", "status": "running"}]),
+        status=200,
+    )
+    df = api.get_computation_runs(workflow_id="wf-1", step="zeopp", status="running", limit=25, offset=5)
+    assert_df_columns(df, "id", "workflow_id", "step", "status")
+
+
+@resp_lib.activate
+def test_get_computation_run_detail(api):
+    resp_lib.add(
+        resp_lib.GET,
+        f"{PROD_BASE}/computation-runs/7/",
+        json={"id": 7, "workflow_id": "wf-7", "step": "mofchecker", "status": "done"},
+        status=200,
+    )
+    result = api.get_computation_run(7)
+    assert result["id"] == 7
+    assert result["status"] == "done"
+
+
+@resp_lib.activate
+def test_upsert_computation_runs_accepts_single_dict_and_new_fields(api):
+    payload = {
+        "id": 7,
+        "workflow_id": "wf-7",
+        "step": "adsorption",
+        "status": "done",
+        "new_field_from_server": "kept",
+    }
+    resp_lib.add(
+        resp_lib.PUT,
+        f"{PROD_BASE}/computation-runs/",
+        match=[matchers.json_params_matcher([payload])],
+        json={"created": 0, "updated": 1},
+        status=200,
+    )
+    result = api.upsert_computation_runs(payload)
+    assert result["updated"] == 1
+
+
+@resp_lib.activate
+def test_autoprism_detail_endpoints(api):
+    detail_endpoints = [
+        ("/adsorption-singlepoint/1/", "get_adsorption_singlepoint_item", {"id": 1, "structure": "ABEXEM"}),
+        ("/heat-capacity/2/", "get_heat_capacity_item", {"id": 2, "structure": "ABEXEM"}),
+        ("/isotherm-h2/3/", "get_isotherm_h2_item", {"id": 3, "structure": "ABEXEM"}),
+        ("/mofchecker/4/", "get_mofchecker_item", {"id": 4, "structure": "ABEXEM"}),
+        ("/zeopp-metrics/5/", "get_zeopp_metrics_item", {"id": 5, "mof": "ABEXEM"}),
+    ]
+
+    for path, _, body in detail_endpoints:
+        resp_lib.add(resp_lib.GET, f"{PROD_BASE}{path}", json=body, status=200)
+
+    assert api.get_adsorption_singlepoint_item(1)["id"] == 1
+    assert api.get_heat_capacity_item(2)["id"] == 2
+    assert api.get_isotherm_h2_item(3)["id"] == 3
+    assert api.get_mofchecker_item(4)["id"] == 4
+    assert api.get_zeopp_metrics_item(5)["id"] == 5
+
+
+@resp_lib.activate
+def test_upsert_autoprism_tables_accept_dataframes_and_pass_all_fields(api, monkeypatch):
+    fake_meta = {
+        "source_repo": "AutoPrism",
+        "source_repo_semantic_version": "0.1.0",
+        "source_repo_tag": "0.1.0",
+        "source_commit_hash": "724b0306f6b21f953fba21e424cdda230525862f",
+    }
+    fake_repo_url = "https://github.com/AutoPrism/AutoPrism"
+    monkeypatch.setattr(api, "_autoprism_meta_provenance", lambda: fake_meta)
+    monkeypatch.setattr(api, "_autoprism_source_repo_url", lambda: fake_repo_url)
+
+    adsorption_df = pd.DataFrame([
+        {
+            "structure": "ABEXEM",
+            "md5": "a1",
+            "mixture_id": "mix-1",
+            "component": "CO2",
+            "temperature_K": 298.0,
+            "pressure_bar": 1.0,
+            "new_extra_field": "pass-through",
+        }
+    ])
+    heat_capacity_df = pd.DataFrame([
+        {"structure": "ABEXEM", "temperature_K": 298.0, "Cp": 123.4, "new_extra_field": "pass-through"}
+    ])
+    isotherm_h2_df = pd.DataFrame([
+        {
+            "structure": "ABEXEM",
+            "md5": "a1",
+            "isotherm_id": "iso-1",
+            "component": "H2",
+            "temperature_K": 298.0,
+            "pressure_bar": 1.0,
+            "uptake": 2.1,
+            "new_extra_field": "pass-through",
+        }
+    ])
+    mofchecker_df = pd.DataFrame([
+        {"structure": "ABEXEM", "md5": "a1", "is_mof": True, "MOFQ": "yes", "new_extra_field": "pass-through"}
+    ])
+    zeopp_df = pd.DataFrame([
+        {"mof": "ABEXEM", "md5": "a1", "probe": "N2", "pld": 3.4, "new_extra_field": "pass-through"}
+    ])
+
+    adsorption_expected = [{
+        **adsorption_df.to_dict(orient="records")[0],
+        "meta_provenance": {**fake_meta, "source_repo_url": fake_repo_url},
+    }]
+    heat_capacity_expected = [{
+        **heat_capacity_df.to_dict(orient="records")[0],
+        "meta_provenance": {**fake_meta, "source_repo_url": fake_repo_url},
+    }]
+    isotherm_h2_expected = [{
+        **isotherm_h2_df.to_dict(orient="records")[0],
+        "meta_provenance": fake_meta,
+    }]
+    mofchecker_expected = [{
+        **mofchecker_df.to_dict(orient="records")[0],
+        "meta_provenance": fake_meta,
+    }]
+    zeopp_expected = [{
+        **zeopp_df.to_dict(orient="records")[0],
+        "meta_provenance": fake_meta,
+    }]
+
+    resp_lib.add(
+        resp_lib.PUT,
+        f"{PROD_BASE}/adsorption-singlepoint/",
+        match=[matchers.json_params_matcher(adsorption_expected)],
+        json={"created": 1, "updated": 0},
+        status=200,
+    )
+    resp_lib.add(
+        resp_lib.PUT,
+        f"{PROD_BASE}/heat-capacity/",
+        match=[matchers.json_params_matcher(heat_capacity_expected)],
+        json={"created": 1, "updated": 0},
+        status=200,
+    )
+    resp_lib.add(
+        resp_lib.PUT,
+        f"{PROD_BASE}/isotherm-h2/",
+        match=[matchers.json_params_matcher(isotherm_h2_expected)],
+        json={"created": 1, "updated": 0},
+        status=200,
+    )
+    resp_lib.add(
+        resp_lib.PUT,
+        f"{PROD_BASE}/mofchecker/",
+        match=[matchers.json_params_matcher(mofchecker_expected)],
+        json={"created": 1, "updated": 0},
+        status=200,
+    )
+    resp_lib.add(
+        resp_lib.PUT,
+        f"{PROD_BASE}/zeopp-metrics/",
+        match=[matchers.json_params_matcher(zeopp_expected)],
+        json={"created": 1, "updated": 0},
+        status=200,
+    )
+
+    assert api.upsert_adsorption_singlepoint(adsorption_df)["created"] == 1
+    assert api.upsert_heat_capacity(heat_capacity_df)["created"] == 1
+    assert api.upsert_isotherm_h2(isotherm_h2_df)["created"] == 1
+    assert api.upsert_mofchecker(mofchecker_df)["created"] == 1
+    assert api.upsert_zeopp_metrics(zeopp_df)["created"] == 1
+
+
+@resp_lib.activate
+def test_upsert_zeopp_metrics_accepts_wrapped_payload_and_overwrites_meta(api, monkeypatch):
+    fake_meta = {
+        "source_repo": "AutoPrism",
+        "source_repo_semantic_version": "0.1.0",
+        "source_repo_tag": "0.1.0",
+        "source_commit_hash": "724b0306f6b21f953fba21e424cdda230525862f",
+    }
+    monkeypatch.setattr(api, "_autoprism_meta_provenance", lambda: fake_meta)
+
+    payload = {
+        "zeopp_metrics": [
+            {
+                "mof": "UiO-66",
+                "md5": "aaaaaaaa",
+                "probe": "N2",
+                "Di": 6.4,
+                "meta_provenance": {
+                    "source_repo": "stale",
+                    "source_repo_semantic_version": "stale",
+                    "source_repo_tag": "stale",
+                    "source_commit_hash": "stale",
+                },
+            }
+        ],
+        "meta_provenance": {
+            "source_repo": "top-level-stale",
+            "source_repo_semantic_version": "top-level-stale",
+            "source_repo_tag": "top-level-stale",
+            "source_commit_hash": "top-level-stale",
+        },
+    }
+
+    expected = [{
+        "mof": "UiO-66",
+        "md5": "aaaaaaaa",
+        "probe": "N2",
+        "Di": 6.4,
+        "meta_provenance": fake_meta,
+    }]
+
+    resp_lib.add(
+        resp_lib.PUT,
+        f"{PROD_BASE}/zeopp-metrics/",
+        match=[matchers.json_params_matcher(expected)],
+        json={"created": 1, "updated": 0},
+        status=200,
+    )
+
+    result = api.upsert_zeopp_metrics(payload)
+    assert result["created"] == 1
+
+
+def test_upsert_autoprism_collection_dispatches_sections(api, monkeypatch):
+    monkeypatch.setattr(api, "upsert_computation_runs", lambda payload: {"created": 1, "updated": 0})
+    monkeypatch.setattr(api, "upsert_adsorption_singlepoint", lambda payload: {"created": 2, "updated": 0})
+    monkeypatch.setattr(api, "upsert_heat_capacity", lambda payload: {"created": 0, "updated": 3})
+    monkeypatch.setattr(api, "upsert_isotherm_h2", lambda payload: {"created": 4, "updated": 1})
+    monkeypatch.setattr(api, "upsert_mofchecker", lambda payload: {"created": 5, "updated": 0})
+    monkeypatch.setattr(api, "upsert_zeopp_metrics", lambda payload: {"created": 6, "updated": 2})
+
+    payload = {
+        "computation_runs": [{"id": "run-1"}],
+        "adsorption_singlepoints": [{"id": 1}],
+        "heat_capacities": [{"id": 2}],
+        "isotherm_H2s": [{"id": 3}],
+        "mofchecker": [{"id": 4}],
+        "zeopp_metrics": [{"id": 5}],
+        "meta_provenance": {"source_repo": "ignored"},
+    }
+
+    result = api.upsert_autoprism_collection(payload)
+
+    assert result["overall_status"] == "ok"
+    assert result["totals"]["created"] == 18
+    assert result["totals"]["updated"] == 6
+    assert result["totals"]["failed_sections"] == 0
+    assert result["sections"]["zeopp_metrics"]["status"] == "ok"
+    assert result["sections"]["mofchecker"]["status"] == "ok"
+
+
+def test_upsert_autoprism_collection_reports_skips_and_errors(api, monkeypatch):
+    monkeypatch.setattr(api, "upsert_computation_runs", lambda payload: {"created": 1, "updated": 0})
+
+    def _raise_error(payload):
+        raise RuntimeError("boom")
+
+    monkeypatch.setattr(api, "upsert_zeopp_metrics", _raise_error)
+
+    payload = {
+        "computation_runs": [{"id": "run-1"}],
+        "zeopp_metrics": [{"id": 5}],
+    }
+
+    result = api.upsert_autoprism_collection(payload)
+
+    assert result["overall_status"] == "partial_failure"
+    assert result["totals"]["created"] == 1
+    assert result["totals"]["updated"] == 0
+    assert result["totals"]["failed_sections"] == 1
+    assert result["sections"]["computation_runs"]["status"] == "ok"
+    assert result["sections"]["adsorption_singlepoints"]["status"] == "skipped"
+    assert result["sections"]["zeopp_metrics"]["status"] == "error"
+
+
+def test_get_autoprism_collection_allows_empty_payloads(api, monkeypatch):
+    monkeypatch.setattr(api, "get_computation_runs", lambda **kwargs: None)
+    monkeypatch.setattr(api, "get_adsorption_singlepoint", lambda **kwargs: None)
+    monkeypatch.setattr(api, "get_heat_capacity", lambda **kwargs: {"results": []})
+    monkeypatch.setattr(api, "get_isotherm_h2", lambda **kwargs: 0)
+    monkeypatch.setattr(api, "get_mofchecker", lambda **kwargs: [])
+    monkeypatch.setattr(api, "get_zeopp_metrics", lambda **kwargs: pd.DataFrame())
+
+    collection = api.get_autoprism_collection(mof="ABEXEM")
+
+    assert set(collection.keys()) == {
+        "computation_runs",
+        "adsorption_singlepoints",
+        "heat_capacities",
+        "isotherm_H2s",
+        "mofchecker",
+        "zeopp_metrics",
+        "meta_provenance",
+    }
+    assert len(collection["computation_runs"]) == 0
+    assert len(collection["adsorption_singlepoints"]) == 0
+    assert len(collection["heat_capacities"]) == 0
+    assert len(collection["isotherm_H2s"]) == 0
+    assert len(collection["mofchecker"]) == 0
+    assert len(collection["zeopp_metrics"]) == 0
+
+
+def test_get_autoprism_collection_tolerates_endpoint_http_error(api, monkeypatch):
+    import requests
+
+    def _raise_http_error(**kwargs):
+        raise requests.HTTPError("500 Server Error")
+
+    monkeypatch.setattr(api, "get_computation_runs", _raise_http_error)
+    monkeypatch.setattr(api, "get_adsorption_singlepoint", lambda **kwargs: [{"id": 1}])
+    monkeypatch.setattr(api, "get_heat_capacity", lambda **kwargs: [{"id": 2}])
+    monkeypatch.setattr(api, "get_isotherm_h2", lambda **kwargs: [{"id": 3}])
+    monkeypatch.setattr(api, "get_mofchecker", lambda **kwargs: [{"id": 4}])
+    monkeypatch.setattr(api, "get_zeopp_metrics", lambda **kwargs: [{"id": 5}])
+
+    collection = api.get_autoprism_collection(mof="ABEXEM")
+
+    assert len(collection["computation_runs"]) == 0
+    assert len(collection["adsorption_singlepoints"]) == 1
+    assert len(collection["heat_capacities"]) == 1
+    assert len(collection["isotherm_H2s"]) == 1
+    assert len(collection["mofchecker"]) == 1
+    assert len(collection["zeopp_metrics"]) == 1
+
+
+def test_get_autoprism_collection_includes_mofchecker_payload_shape(api, monkeypatch):
+    monkeypatch.setattr(api, "get_computation_runs", lambda **kwargs: [])
+    monkeypatch.setattr(api, "get_adsorption_singlepoint", lambda **kwargs: [])
+    monkeypatch.setattr(api, "get_heat_capacity", lambda **kwargs: [])
+    monkeypatch.setattr(api, "get_isotherm_h2", lambda **kwargs: [])
+    monkeypatch.setattr(api, "get_zeopp_metrics", lambda **kwargs: [])
+    monkeypatch.setattr(
+        api,
+        "get_mofchecker",
+        lambda **kwargs: [{"id": 4, "structure": {"name": "ABEXEM"}, "is_mof": True}],
+    )
+
+    collection = api.get_autoprism_collection(mof="ABEXEM")
+
+    assert "mofchecker" in collection
+    assert "meta_provenance" in collection
+    assert isinstance(collection["mofchecker"], list)
+    assert len(collection["mofchecker"]) == 1
+
+    meta = collection["meta_provenance"]
+    assert set(meta.keys()) >= {
+        "source_repo",
+        "source_repo_url",
+        "source_repo_semantic_version",
+        "source_repo_tag",
+        "source_commit_hash",
+    }
+
+
+def test_get_autoprism_collection_includes_zeopp_payload_shape(api, monkeypatch):
+    monkeypatch.setattr(api, "get_computation_runs", lambda **kwargs: [])
+    monkeypatch.setattr(api, "get_adsorption_singlepoint", lambda **kwargs: [])
+    monkeypatch.setattr(api, "get_heat_capacity", lambda **kwargs: [])
+    monkeypatch.setattr(api, "get_isotherm_h2", lambda **kwargs: [])
+    monkeypatch.setattr(api, "get_mofchecker", lambda **kwargs: [])
+    monkeypatch.setattr(
+        api,
+        "get_zeopp_metrics",
+        lambda **kwargs: [{"id": 5, "mof": "UiO-66", "probe": "N2"}],
+    )
+
+    collection = api.get_autoprism_collection(mof="UiO-66")
+
+    assert "zeopp_metrics" in collection
+    assert "meta_provenance" in collection
+    assert isinstance(collection["zeopp_metrics"], list)
+    assert len(collection["zeopp_metrics"]) == 1
+
+    meta = collection["meta_provenance"]
+    assert set(meta.keys()) >= {
+        "source_repo",
+        "source_repo_url",
+        "source_repo_semantic_version",
+        "source_repo_tag",
+        "source_commit_hash",
+    }
+
+
 # ── Output KPIs ───────────────────────────────────────────────────────────────
 
 @resp_lib.activate