prisma-api 0.4.2__tar.gz → 0.4.3__tar.gz

{prisma_api-0.4.2 → prisma_api-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prisma_api
-Version: 0.4.2
+Version: 0.4.3
 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.4.2 → prisma_api-0.4.3}/prisma_api/__init__.py

@@ -1,4 +1,9 @@
-__version__ = "0.3.9"
+from importlib.metadata import PackageNotFoundError, version as _version
+
+try:
+    __version__ = _version("prisma_api")
+except PackageNotFoundError:  # running from a source tree without installing
+    __version__ = "0+unknown"
 
 
 from prisma_api.prisma_api import prisma_api as init        # Main prisma_api class for initialisation

{prisma_api-0.4.2 → prisma_api-0.4.3}/prisma_api/config.py

@@ -1,3 +1,5 @@
+import os
+import sys
 from pathlib import Path
 import pandas as pd
 import yaml
@@ -54,6 +56,12 @@ def create_config_file(api_key: str = None):
         raise ImportError("PyYAML is required. Install with: pip install pyyaml")
 
     if not api_key:
+        if not sys.stdin or not sys.stdin.isatty():
+            raise RuntimeError(
+                f"No PrISMa config file at {get_config_path()} and no API key in the "
+                f"environment. Set {', '.join(ENV_VARS)} (at least PRISMA_API_KEY), "
+                "or run interactively once to create the config file."
+            )
         val = input("Enter your PrISMa API key: ").strip()
         api_key = val
 
@@ -67,10 +75,40 @@ def create_config_file(api_key: str = None):
         yaml.safe_dump(cfg, f, sort_keys=False)
     return cfg
 
+# Environment variables read when no config file exists (or use_config_file=False)
+ENV_VARS = ("PRISMA_API_KEY", "PRISMA_API_DEV_API_KEY", "PRISMA_API_DEV_HOST_PORT")
+
+
+def config_from_env():
+    """
+    Build a config dict from PRISMA_API_* environment variables.
+
+    Returns None if none of them is set.
+    """
+    if not any(os.getenv(name) for name in ENV_VARS):
+        return None
+    prod_key = os.getenv("PRISMA_API_KEY", "")
+    return {
+        "api_key": prod_key,
+        "dev_api_key": os.getenv("PRISMA_API_DEV_API_KEY", prod_key),
+        "dev_host_port": os.getenv("PRISMA_API_DEV_HOST_PORT", "8000"),
+    }
+
+
 # Get or create config - intended use by initialisation of main prisma_api class
 def get_or_create_config():
-    """Return existing config or create it interactively if missing."""
+    """
+    Return the config, in order of preference:
+
+    1. config.yaml, if it exists;
+    2. PRISMA_API_* environment variables (nothing is written to disk);
+    3. an interactive prompt, which creates config.yaml. Without a terminal
+       (e.g. CI) this raises instead of blocking on input().
+    """
     cfg = load_config()
+    if cfg is not None:
+        return cfg
+    cfg = config_from_env()
     if cfg is not None:
         return cfg
     return create_config_file()

{prisma_api-0.4.2 → prisma_api-0.4.3}/prisma_api/prisma_api.py

@@ -25,11 +25,15 @@ def _safe_nan_check(x):
 # prisma_api main class
 class prisma_api():
 
-    def __init__(self, use_config_file=True, local_dev: bool = False):
+    def __init__(self, use_config_file=True, local_dev: bool = False,
+                 upload_timeout: int = 120):
         
         # Initialise `prisma_api` object with api_key location
         self.verbose = False
         # Initialise `prisma_api` object with api_key location
+        # use_config_file=True: config.yaml, else PRISMA_API_* env vars, else
+        # an interactive prompt (raises instead when there is no terminal).
+        # use_config_file=False: env vars only.
         if use_config_file:
             cfg = get_or_create_config()
             prod_key = cfg.get('api_key', '')
@@ -40,7 +44,9 @@ class prisma_api():
             dev_key = os.getenv('PRISMA_API_DEV_API_KEY', prod_key)
             dev_host_port = os.getenv('PRISMA_API_DEV_HOST_PORT', '8000')
 
-        # local_dev now controls target DB explicitly at init time.
+        # local_dev controls the target DB at init time:
+        #   local_dev=False (default) -> PRODUCTION (prisma-platform.org)
+        #   local_dev=True            -> local dev server on localhost:<dev_host_port>
         self.dev = bool(local_dev)
         self.dev_host_port = dev_host_port
         self.key = dev_key if self.dev else prod_key
@@ -50,8 +56,13 @@ class prisma_api():
             dev=self.dev,
             dev_host_port=getattr(self, 'dev_host_port', ''),
             return_format=getattr(self, '_return_format', 'json'),
+            upload_timeout=upload_timeout,
         )
 
+        # Make the target explicit so test uploads don't go to production by mistake.
+        target = "LOCAL DEV" if self.dev else "PRODUCTION"
+        print(f"prisma_api: connected to {target} API at {self.v2._base_url()}")
+
     def set_return_format(self, fmt: str) -> None:
         """
         Set the output format for all v2 list endpoints.

{prisma_api-0.4.2 → prisma_api-0.4.3}/prisma_api/prisma_api_v2.py

@@ -26,12 +26,26 @@ import copy
 import json
 from collections import Counter
 import re
+import math
 import subprocess
-from datetime import datetime
+from datetime import date, datetime
+from urllib.parse import urlsplit, urlunsplit
 
 
 _BASE_PROD = "https://prisma-platform.org/api/v2"
 _DEFAULT_BUNDLE = object()
+_DEFAULT_UPLOAD_TIMEOUT = 120
+
+# AutoPrism table wrappers: method name -> (endpoint, wrapper key in the
+# collection payload). The wrapper key is also accepted by the single-table
+# upserts, e.g. ``{"zeopp_metrics": [...]}``.
+_AUTOPRISM_TABLES = {
+    "upsert_adsorption_singlepoint": ("/adsorption-singlepoint/", "adsorption_singlepoints"),
+    "upsert_heat_capacity": ("/heat-capacity/", "heat_capacities"),
+    "upsert_isotherm_h2": ("/isotherm-h2/", "isotherm_H2s"),
+    "upsert_mofchecker": ("/mofchecker/", "mofchecker"),
+    "upsert_zeopp_metrics": ("/zeopp-metrics/", "zeopp_metrics"),
+}
 
 # Material bundle sections, in the order the API emits them. Every section is a
 # list except ``mof_h2``, which is a single object or None.
@@ -67,11 +81,15 @@ class PrismaAPIv2:
     """
 
     def __init__(self, key: str, dev: bool = False, dev_host_port: str = "",
-                 return_format: str = "json"):
+                 return_format: str = "json",
+                 upload_timeout: int = _DEFAULT_UPLOAD_TIMEOUT):
         self._key = key
         self._dev = dev
         self._dev_host_port = dev_host_port
         self._return_format = return_format  # 'dataframe' | 'json'
+        # Default timeout (seconds) for PUT upserts; override per call with
+        # ``timeout=`` on the upsert methods that accept it.
+        self.upload_timeout = upload_timeout
 
     # ── Internal helpers ──────────────────────────────────────────────────────
 
@@ -154,10 +172,11 @@ class PrismaAPIv2:
         resp.raise_for_status()
         return resp
 
-    def _put(self, path: str, data: list) -> dict:
-        """PUT (upsert) request."""
-        resp = requests.put(self._url(path), json=data,
-                            headers=self._headers(), timeout=120)
+    def _put(self, path: str, data: list, timeout: int | None = None) -> dict:
+        """PUT (upsert) request. NaN/inf and numpy values are made JSON-safe."""
+        resp = requests.put(self._url(path), json=_json_safe(data),
+                            headers=self._headers(),
+                            timeout=timeout or self.upload_timeout)
         resp.raise_for_status()
         return resp.json()
 
@@ -1503,45 +1522,44 @@ class PrismaAPIv2:
         return []
 
     def _payload_to_records(self, payload: pd.DataFrame | list[dict] | dict) -> list[dict]:
-        """Normalise write payloads to list[dict] while preserving all fields."""
+        """
+        Normalise write payloads to list[dict] while preserving all fields.
+
+        NaN/±inf/``pd.NA``/``NaT`` become ``None`` and numpy scalars become
+        plain Python values, so the result is valid JSON.
+        """
         if isinstance(payload, pd.DataFrame):
-            return payload.to_dict(orient="records")
+            return _json_safe(payload.to_dict(orient="records"))
         if isinstance(payload, dict):
-            return [payload]
+            return [_json_safe(payload)]
         if isinstance(payload, list):
-            return payload
+            return _json_safe(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 _autoprism_meta_provenance(self, repo_dir: str | Path | None = None) -> dict[str, str | None]:
+        """
+        Build meta_provenance from the caller's git repository.
+
+        Git runs in *repo_dir*, or the current working directory if omitted —
+        i.e. the program doing the upload, not prisma_api itself. The
+        semantic version comes from that repository's ``pyproject.toml``.
+        """
+        cwd = Path(repo_dir) if repo_dir is not None else Path.cwd()
 
         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
+            return _git_output(args, cwd)
 
         repo_root = _git(["rev-parse", "--show-toplevel"])
-        repo_name = Path(repo_root).name if repo_root else Path(__file__).resolve().parents[1].name
+        root = Path(repo_root) if repo_root else cwd.resolve()
         branch = _git(["rev-parse", "--abbrev-ref", "HEAD"])
         source_repo = (
-            repo_name
-            if branch in (None, "main")
-            else f"{repo_name} (branch: {branch})"
+            root.name
+            if branch in (None, "main", "HEAD")
+            else f"{root.name} (branch: {branch})"
         )
 
         pyproject_version: str | None = None
-        pyproject_path = Path(__file__).resolve().parents[1] / "pyproject.toml"
+        pyproject_path = root / "pyproject.toml"
         if pyproject_path.exists():
             text = pyproject_path.read_text(encoding="utf-8")
             try:
@@ -1563,24 +1581,40 @@ class PrismaAPIv2:
             "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
+    def _autoprism_source_repo_url(self, repo_dir: str | Path | None = None) -> str | None:
+        """Return the caller's ``origin`` remote URL with any credentials removed."""
+        cwd = Path(repo_dir) if repo_dir is not None else Path.cwd()
+        url = _git_output(["remote", "get-url", "origin"], cwd)
+        return _strip_url_credentials(url) if url else None
+
+    def _resolve_meta_provenance(self, meta_provenance: dict | None = None,
+                                 repo_dir: str | Path | None = None) -> dict:
+        """Return *meta_provenance* as given, or derive it from git in *repo_dir*."""
+        if meta_provenance is not None:
+            if not isinstance(meta_provenance, dict):
+                raise TypeError("meta_provenance must be a dict or None")
+            return _json_safe(dict(meta_provenance))
+        return {
+            **self._autoprism_meta_provenance(repo_dir),
+            "source_repo_url": self._autoprism_source_repo_url(repo_dir),
+        }
 
-        value = cp.stdout.strip()
-        return value or None
+    def _upsert_autoprism_table(self, method_name: str,
+                                payload: pd.DataFrame | list[dict] | dict,
+                                meta_provenance: dict | None,
+                                repo_dir: str | Path | None,
+                                timeout: int | None) -> dict:
+        """Shared body of the AutoPrism table upserts: unwrap, stamp provenance, PUT."""
+        path, wrapper_key = _AUTOPRISM_TABLES[method_name]
+        if isinstance(payload, dict) and isinstance(payload.get(wrapper_key), list):
+            payload = payload[wrapper_key]
+        records = self._payload_to_records(payload)
+        meta = self._resolve_meta_provenance(meta_provenance, repo_dir)
+        enriched = [
+            {**record, "meta_provenance": meta} if isinstance(record, dict) else record
+            for record in records
+        ]
+        return self._put(path, enriched, timeout=timeout)
 
     def _properties_for(self, object_id: int, limit: int = 2000) -> list[dict]:
         """Return all Property records linked to *object_id* via GenericForeignKey.
@@ -2342,13 +2376,15 @@ class PrismaAPIv2:
         """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:
+    def upsert_computation_runs(self, payload: pd.DataFrame | list[dict] | dict,
+                                timeout: int | None = None) -> 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))
+        return self._put("/computation-runs/", self._payload_to_records(payload),
+                         timeout=timeout)
 
     def get_adsorption_singlepoint(
         self,
@@ -2382,31 +2418,32 @@ class PrismaAPIv2:
         """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:
+    def upsert_adsorption_singlepoint(
+        self,
+        payload: pd.DataFrame | list[dict] | dict,
+        meta_provenance: dict | None = None,
+        repo_dir: str | Path | None = None,
+        timeout: int | None = None,
+    ) -> 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)
+        Accepts one object or many objects. Every row's ``meta_provenance`` is
+        replaced with the resolved provenance.
+
+        Args:
+            payload: DataFrame, one record, a list of records, or
+                ``{"adsorption_singlepoints": [...]}``.
+            meta_provenance: Provenance stamped on every row, used as-is. If
+                omitted it is derived from git in *repo_dir* (default: the
+                current working directory), with credentials removed from the
+                remote URL.
+            repo_dir: Repository to read provenance from when
+                *meta_provenance* is not given.
+            timeout: Request timeout in seconds (default: ``upload_timeout``).
+        """
+        return self._upsert_autoprism_table("upsert_adsorption_singlepoint", payload,
+                                            meta_provenance, repo_dir, timeout)
 
     def get_heat_capacity(
         self,
@@ -2434,32 +2471,32 @@ class PrismaAPIv2:
         """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:
+    def upsert_heat_capacity(
+        self,
+        payload: pd.DataFrame | list[dict] | dict,
+        meta_provenance: dict | None = None,
+        repo_dir: str | Path | None = None,
+        timeout: int | None = None,
+    ) -> 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)
+        Accepts one object or many objects. Every row's ``meta_provenance`` is
+        replaced with the resolved provenance.
 
-        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)
+        Args:
+            payload: DataFrame, one record, a list of records, or
+                ``{"heat_capacities": [...]}``.
+            meta_provenance: Provenance stamped on every row, used as-is. If
+                omitted it is derived from git in *repo_dir* (default: the
+                current working directory), with credentials removed from the
+                remote URL.
+            repo_dir: Repository to read provenance from when
+                *meta_provenance* is not given.
+            timeout: Request timeout in seconds (default: ``upload_timeout``).
+        """
+        return self._upsert_autoprism_table("upsert_heat_capacity", payload,
+                                            meta_provenance, repo_dir, timeout)
 
     def get_isotherm_h2(
         self,
@@ -2496,29 +2533,32 @@ class PrismaAPIv2:
         """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:
+    def upsert_isotherm_h2(
+        self,
+        payload: pd.DataFrame | list[dict] | dict,
+        meta_provenance: dict | None = None,
+        repo_dir: str | Path | None = None,
+        timeout: int | None = None,
+    ) -> 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)
+        Accepts one object or many objects. Every row's ``meta_provenance`` is
+        replaced with the resolved provenance.
 
-        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)
+        Args:
+            payload: DataFrame, one record, a list of records, or
+                ``{"isotherm_H2s": [...]}``.
+            meta_provenance: Provenance stamped on every row, used as-is. If
+                omitted it is derived from git in *repo_dir* (default: the
+                current working directory), with credentials removed from the
+                remote URL.
+            repo_dir: Repository to read provenance from when
+                *meta_provenance* is not given.
+            timeout: Request timeout in seconds (default: ``upload_timeout``).
+        """
+        return self._upsert_autoprism_table("upsert_isotherm_h2", payload,
+                                            meta_provenance, repo_dir, timeout)
 
     def get_mofchecker(
         self,
@@ -2552,29 +2592,32 @@ class PrismaAPIv2:
         """GET /api/v2/mofchecker/{row_id}/"""
         return self._get(f"/mofchecker/{row_id}/")
 
-    def upsert_mofchecker(self, payload: pd.DataFrame | list[dict] | dict) -> dict:
+    def upsert_mofchecker(
+        self,
+        payload: pd.DataFrame | list[dict] | dict,
+        meta_provenance: dict | None = None,
+        repo_dir: str | Path | None = None,
+        timeout: int | None = None,
+    ) -> 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)
+        Accepts one object or many objects. Every row's ``meta_provenance`` is
+        replaced with the resolved provenance.
 
-        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)
+        Args:
+            payload: DataFrame, one record, a list of records, or
+                ``{"mofchecker": [...]}``.
+            meta_provenance: Provenance stamped on every row, used as-is. If
+                omitted it is derived from git in *repo_dir* (default: the
+                current working directory), with credentials removed from the
+                remote URL.
+            repo_dir: Repository to read provenance from when
+                *meta_provenance* is not given.
+            timeout: Request timeout in seconds (default: ``upload_timeout``).
+        """
+        return self._upsert_autoprism_table("upsert_mofchecker", payload,
+                                            meta_provenance, repo_dir, timeout)
 
     def get_zeopp_metrics(
         self,
@@ -2599,31 +2642,41 @@ class PrismaAPIv2:
         """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:
+    def upsert_zeopp_metrics(
+        self,
+        payload: pd.DataFrame | list[dict] | dict,
+        meta_provenance: dict | None = None,
+        repo_dir: str | Path | None = None,
+        timeout: int | None = None,
+    ) -> 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)
+        Accepts one object or many objects. Every row's ``meta_provenance`` is
+        replaced with the resolved provenance.
 
-        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]:
+        Args:
+            payload: DataFrame, one record, a list of records, or
+                ``{"zeopp_metrics": [...]}``.
+            meta_provenance: Provenance stamped on every row, used as-is. If
+                omitted it is derived from git in *repo_dir* (default: the
+                current working directory), with credentials removed from the
+                remote URL.
+            repo_dir: Repository to read provenance from when
+                *meta_provenance* is not given.
+            timeout: Request timeout in seconds (default: ``upload_timeout``).
+        """
+        return self._upsert_autoprism_table("upsert_zeopp_metrics", payload,
+                                            meta_provenance, repo_dir, timeout)
+
+    def upsert_autoprism_collection(
+        self,
+        payload: dict[str, Any],
+        meta_provenance: dict | None = None,
+        repo_dir: str | Path | None = None,
+        timeout: int | None = None,
+        raise_on_error: bool = False,
+    ) -> dict[str, Any]:
         """
         Upsert multiple AutoPrism sections from a single combined payload.
 
@@ -2632,10 +2685,18 @@ class PrismaAPIv2:
             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.
+        Provenance (stamped on every row of the five AutoPrism tables), in
+        order of precedence:
+            1. the *meta_provenance* argument;
+            2. the payload's top-level ``meta_provenance``;
+            3. derived from git in *repo_dir* (default: current directory).
+
+        Error handling:
+            By default a failing section does not raise: it is reported with
+            ``status: "error"`` and ``overall_status`` becomes
+            ``"partial_failure"``. Check ``overall_status``, or pass
+            ``raise_on_error=True`` to raise ``RuntimeError`` after all
+            sections have been attempted.
 
         Returns:
             dict with keys:
@@ -2646,13 +2707,14 @@ class PrismaAPIv2:
         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")),
+        if meta_provenance is None:
+            meta_provenance = payload.get("meta_provenance")
+        # Resolve once so every section carries identical provenance.
+        meta = self._resolve_meta_provenance(meta_provenance, repo_dir)
+
+        section_handlers: list[tuple[str, str]] = [
+            ("computation_runs", "upsert_computation_runs"),
+            *((key, method) for method, (_, key) in _AUTOPRISM_TABLES.items()),
         ]
 
         sections: dict[str, dict[str, Any]] = {}
@@ -2660,7 +2722,8 @@ class PrismaAPIv2:
         total_updated = 0
         failed = 0
 
-        for section_name, method_name, section_payload in section_handlers:
+        for section_name, method_name in section_handlers:
+            section_payload = payload.get(section_name)
             if section_payload is None:
                 sections[section_name] = {
                     "status": "skipped",
@@ -2670,7 +2733,10 @@ class PrismaAPIv2:
 
             try:
                 method = getattr(self, method_name)
-                result = method(section_payload)
+                if method_name in _AUTOPRISM_TABLES:
+                    result = method(section_payload, meta_provenance=meta, timeout=timeout)
+                else:
+                    result = method(section_payload, timeout=timeout)
                 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
@@ -2688,7 +2754,7 @@ class PrismaAPIv2:
                     "error": str(exc),
                 }
 
-        return {
+        summary = {
             "sections": sections,
             "totals": {
                 "created": total_created,
@@ -2697,6 +2763,14 @@ class PrismaAPIv2:
             },
             "overall_status": "ok" if failed == 0 else "partial_failure",
         }
+        if raise_on_error and failed:
+            errors = "; ".join(
+                f"{name}: {info['error']}"
+                for name, info in sections.items()
+                if info["status"] == "error"
+            )
+            raise RuntimeError(f"AutoPrism upsert failed for {failed} section(s): {errors}")
+        return summary
 
     def get_autoprism_collection(
         self,
@@ -2763,10 +2837,7 @@ class PrismaAPIv2:
             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(),
-        }
+        meta = self._resolve_meta_provenance()
 
         def _safe_fetch(section: str, fetcher, **kwargs) -> pd.DataFrame | list[dict]:
             try:
@@ -3314,6 +3385,63 @@ def _compact(**kwargs) -> dict:
     return {k: v for k, v in kwargs.items() if v is not None}
 
 
+def _json_safe(value: Any) -> Any:
+    """
+    Recursively convert *value* into something ``json.dumps(allow_nan=False)``
+    accepts: NaN/±inf/``pd.NA``/``NaT`` -> None, numpy scalars and arrays ->
+    Python values, timestamps -> ISO strings.
+    """
+    if isinstance(value, dict):
+        return {k: _json_safe(v) for k, v in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [_json_safe(v) for v in value]
+    if value is None or isinstance(value, (str, bool)):
+        return value
+    if isinstance(value, float):
+        return value if math.isfinite(value) else None
+    if isinstance(value, int):
+        return value
+    if value is pd.NA or value is pd.NaT:
+        return None
+    if isinstance(value, (pd.Timestamp, datetime, date)):
+        return value.isoformat()
+    tolist = getattr(value, "tolist", None)  # numpy scalars and arrays
+    if callable(tolist):
+        return _json_safe(tolist())
+    try:
+        if pd.isna(value):
+            return None
+    except (TypeError, ValueError):
+        pass
+    return value
+
+
+def _git_output(args: list[str], cwd: Path) -> str | None:
+    """Run ``git <args>`` in *cwd*; return stripped stdout, or None on failure."""
+    try:
+        cp = subprocess.run(
+            ["git", *args],
+            cwd=cwd,
+            check=False,
+            capture_output=True,
+            text=True,
+        )
+    except OSError:
+        return None
+    if cp.returncode != 0:
+        return None
+    return cp.stdout.strip() or None
+
+
+def _strip_url_credentials(url: str) -> str:
+    """Drop ``user:token@`` from an http(s) remote URL (CI checkouts embed tokens)."""
+    parts = urlsplit(url)
+    if parts.scheme in ("http", "https") and "@" in parts.netloc:
+        host = parts.netloc.rsplit("@", 1)[1]
+        return urlunsplit(parts._replace(netloc=host))
+    return url
+
+
 def _as_material_names(value: str | list[str] | None) -> list[str]:
     """Normalise a name argument to a list of non-empty names."""
     if value is None:

{prisma_api-0.4.2 → prisma_api-0.4.3}/prisma_api.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prisma_api
-Version: 0.4.2
+Version: 0.4.3
 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.4.2 → prisma_api-0.4.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "prisma_api"
-version = "0.4.2"
+version = "0.4.3"
 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.4.2 → prisma_api-0.4.3}/tests/test_prisma_api.py

@@ -380,3 +380,39 @@ def test_get_materials_data_empty_data_list():
     df = result.get("data") if "data" in result else result.get("simulated")
     if df is not None:
         assert isinstance(df, pd.DataFrame)
+
+
+# ── Config fallback (no config file) ──────────────────────────────────────────
+
+def test_get_or_create_config_falls_back_to_env(monkeypatch):
+    from prisma_api import config
+    monkeypatch.setattr(config, "load_config", lambda: None)
+    monkeypatch.setenv("PRISMA_API_KEY", "env-prod")
+    monkeypatch.delenv("PRISMA_API_DEV_API_KEY", raising=False)
+    monkeypatch.setenv("PRISMA_API_DEV_HOST_PORT", "9000")
+    monkeypatch.setattr("builtins.input", lambda *a: pytest.fail("must not prompt"))
+
+    cfg = config.get_or_create_config()
+
+    assert cfg == {"api_key": "env-prod", "dev_api_key": "env-prod", "dev_host_port": "9000"}
+
+
+def test_get_or_create_config_raises_without_tty(monkeypatch):
+    from prisma_api import config
+    monkeypatch.setattr(config, "load_config", lambda: None)
+    for name in config.ENV_VARS:
+        monkeypatch.delenv(name, raising=False)
+    monkeypatch.setattr(config.sys.stdin, "isatty", lambda: False, raising=False)
+    monkeypatch.setattr("builtins.input", lambda *a: pytest.fail("must not prompt"))
+
+    with pytest.raises(RuntimeError, match="PRISMA_API_KEY"):
+        config.get_or_create_config()
+
+
+def test_version_matches_installed_metadata():
+    import prisma_api as pkg
+    from importlib.metadata import version, PackageNotFoundError
+    try:
+        assert pkg.__version__ == version("prisma_api")
+    except PackageNotFoundError:
+        assert pkg.__version__ == "0+unknown"

{prisma_api-0.4.2 → prisma_api-0.4.3}/tests/test_prisma_api_v2.py

@@ -1549,8 +1549,8 @@ def test_upsert_autoprism_tables_accept_dataframes_and_pass_all_fields(api, monk
         "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)
+    monkeypatch.setattr(api, "_autoprism_meta_provenance", lambda repo_dir=None: fake_meta)
+    monkeypatch.setattr(api, "_autoprism_source_repo_url", lambda repo_dir=None: fake_repo_url)
 
     adsorption_df = pd.DataFrame([
         {
@@ -1595,15 +1595,15 @@ def test_upsert_autoprism_tables_accept_dataframes_and_pass_all_fields(api, monk
     }]
     isotherm_h2_expected = [{
         **isotherm_h2_df.to_dict(orient="records")[0],
-        "meta_provenance": fake_meta,
+        "meta_provenance": {**fake_meta, "source_repo_url": fake_repo_url},
     }]
     mofchecker_expected = [{
         **mofchecker_df.to_dict(orient="records")[0],
-        "meta_provenance": fake_meta,
+        "meta_provenance": {**fake_meta, "source_repo_url": fake_repo_url},
     }]
     zeopp_expected = [{
         **zeopp_df.to_dict(orient="records")[0],
-        "meta_provenance": fake_meta,
+        "meta_provenance": {**fake_meta, "source_repo_url": fake_repo_url},
     }]
 
     resp_lib.add(
@@ -1657,7 +1657,8 @@ def test_upsert_zeopp_metrics_accepts_wrapped_payload_and_overwrites_meta(api, m
         "source_repo_tag": "0.1.0",
         "source_commit_hash": "724b0306f6b21f953fba21e424cdda230525862f",
     }
-    monkeypatch.setattr(api, "_autoprism_meta_provenance", lambda: fake_meta)
+    monkeypatch.setattr(api, "_autoprism_meta_provenance", lambda repo_dir=None: fake_meta)
+    monkeypatch.setattr(api, "_autoprism_source_repo_url", lambda repo_dir=None: None)
 
     payload = {
         "zeopp_metrics": [
@@ -1687,7 +1688,7 @@ def test_upsert_zeopp_metrics_accepts_wrapped_payload_and_overwrites_meta(api, m
         "md5": "aaaaaaaa",
         "probe": "N2",
         "Di": 6.4,
-        "meta_provenance": fake_meta,
+        "meta_provenance": {**fake_meta, "source_repo_url": None},
     }]
 
     resp_lib.add(
@@ -1703,13 +1704,22 @@ def test_upsert_zeopp_metrics_accepts_wrapped_payload_and_overwrites_meta(api, m
 
 
 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})
-
+    calls = {}
+
+    def _fake(name, result):
+        def _method(payload, **kwargs):
+            calls[name] = kwargs
+            return result
+        return _method
+
+    monkeypatch.setattr(api, "upsert_computation_runs", _fake("computation_runs", {"created": 1, "updated": 0}))
+    monkeypatch.setattr(api, "upsert_adsorption_singlepoint", _fake("adsorption", {"created": 2, "updated": 0}))
+    monkeypatch.setattr(api, "upsert_heat_capacity", _fake("heat", {"created": 0, "updated": 3}))
+    monkeypatch.setattr(api, "upsert_isotherm_h2", _fake("h2", {"created": 4, "updated": 1}))
+    monkeypatch.setattr(api, "upsert_mofchecker", _fake("mofchecker", {"created": 5, "updated": 0}))
+    monkeypatch.setattr(api, "upsert_zeopp_metrics", _fake("zeopp", {"created": 6, "updated": 2}))
+
+    top_level_meta = {"source_repo": "AutoPrism", "source_commit_hash": "abc123"}
     payload = {
         "computation_runs": [{"id": "run-1"}],
         "adsorption_singlepoints": [{"id": 1}],
@@ -1717,7 +1727,7 @@ def test_upsert_autoprism_collection_dispatches_sections(api, monkeypatch):
         "isotherm_H2s": [{"id": 3}],
         "mofchecker": [{"id": 4}],
         "zeopp_metrics": [{"id": 5}],
-        "meta_provenance": {"source_repo": "ignored"},
+        "meta_provenance": top_level_meta,
     }
 
     result = api.upsert_autoprism_collection(payload)
@@ -1728,12 +1738,33 @@ def test_upsert_autoprism_collection_dispatches_sections(api, monkeypatch):
     assert result["totals"]["failed_sections"] == 0
     assert result["sections"]["zeopp_metrics"]["status"] == "ok"
     assert result["sections"]["mofchecker"]["status"] == "ok"
+    # Top-level meta_provenance is passed down to every AutoPrism table.
+    for name in ("adsorption", "heat", "h2", "mofchecker", "zeopp"):
+        assert calls[name]["meta_provenance"] == top_level_meta
+    assert "meta_provenance" not in calls["computation_runs"]
+
+
+def test_upsert_autoprism_collection_argument_meta_overrides_payload(api, monkeypatch):
+    seen = {}
+
+    def _capture(payload, **kwargs):
+        seen.update(kwargs)
+        return {"created": 1, "updated": 0}
+
+    monkeypatch.setattr(api, "upsert_zeopp_metrics", _capture)
+    override = {"source_repo": "explicit"}
+    api.upsert_autoprism_collection(
+        {"zeopp_metrics": [{"id": 5}], "meta_provenance": {"source_repo": "payload"}},
+        meta_provenance=override,
+    )
+    assert seen["meta_provenance"] == override
 
 
 def test_upsert_autoprism_collection_reports_skips_and_errors(api, monkeypatch):
-    monkeypatch.setattr(api, "upsert_computation_runs", lambda payload: {"created": 1, "updated": 0})
+    monkeypatch.setattr(api, "upsert_computation_runs", lambda payload, **kw: {"created": 1, "updated": 0})
+    monkeypatch.setattr(api, "_resolve_meta_provenance", lambda meta=None, repo_dir=None: meta or {})
 
-    def _raise_error(payload):
+    def _raise_error(payload, **kwargs):
         raise RuntimeError("boom")
 
     monkeypatch.setattr(api, "upsert_zeopp_metrics", _raise_error)
@@ -1753,6 +1784,111 @@ def test_upsert_autoprism_collection_reports_skips_and_errors(api, monkeypatch):
     assert result["sections"]["adsorption_singlepoints"]["status"] == "skipped"
     assert result["sections"]["zeopp_metrics"]["status"] == "error"
 
+    with pytest.raises(RuntimeError, match="zeopp_metrics: boom"):
+        api.upsert_autoprism_collection(payload, raise_on_error=True)
+
+
+@resp_lib.activate
+def test_upsert_explicit_meta_provenance_used_as_is(api, monkeypatch):
+    def _no_git(*args, **kwargs):
+        raise AssertionError("git provenance must not be derived when meta_provenance is given")
+
+    monkeypatch.setattr(api, "_autoprism_meta_provenance", _no_git)
+    meta = {"source_repo": "AutoPrism", "source_commit_hash": "abc123"}
+    resp_lib.add(
+        resp_lib.PUT,
+        f"{PROD_BASE}/isotherm-h2/",
+        match=[matchers.json_params_matcher([{"structure": "X", "meta_provenance": meta}])],
+        json={"created": 1, "updated": 0},
+    )
+    assert api.upsert_isotherm_h2({"structure": "X"}, meta_provenance=meta)["created"] == 1
+
+
+def _init_git_repo(path, remote):
+    import subprocess
+    run = lambda *a: subprocess.run(["git", *a], cwd=path, check=True, capture_output=True)
+    run("init", "-q", "-b", "main")
+    run("config", "user.email", "t@example.com")
+    run("config", "user.name", "t")
+    (path / "pyproject.toml").write_text('[project]\nname = "caller"\nversion = "9.8.7"\n')
+    run("add", ".")
+    run("commit", "-q", "-m", "init")
+    run("tag", "v9.8.7")
+    run("remote", "add", "origin", remote)
+
+
+def test_meta_provenance_describes_caller_repo_not_prisma_api(api, tmp_path, monkeypatch):
+    repo = tmp_path / "caller_repo"
+    repo.mkdir()
+    _init_git_repo(repo, "https://x-access-token:SECRET@github.com/org/caller_repo.git")
+    monkeypatch.chdir(repo)
+
+    meta = api._resolve_meta_provenance()
+
+    assert meta["source_repo"] == "caller_repo"
+    assert meta["source_repo_semantic_version"] == "9.8.7"
+    assert meta["source_repo_tag"] == "v9.8.7"
+    assert meta["source_commit_hash"] and len(meta["source_commit_hash"]) == 40
+    assert meta["source_repo_url"] == "https://github.com/org/caller_repo.git"
+    assert "SECRET" not in json.dumps(meta)
+
+    # repo_dir= takes precedence over the working directory.
+    monkeypatch.chdir(tmp_path)
+    assert api._resolve_meta_provenance(repo_dir=repo)["source_repo"] == "caller_repo"
+
+
+@pytest.mark.parametrize("url, expected", [
+    ("https://x-access-token:tok@github.com/o/r.git", "https://github.com/o/r.git"),
+    ("https://user@github.com/o/r", "https://github.com/o/r"),
+    ("https://github.com/o/r", "https://github.com/o/r"),
+    ("git@github.com:o/r.git", "git@github.com:o/r.git"),
+])
+def test_strip_url_credentials(url, expected):
+    from prisma_api.prisma_api_v2 import _strip_url_credentials
+    assert _strip_url_credentials(url) == expected
+
+
+def test_payload_to_records_is_strict_json_safe(api):
+    import numpy as np
+    df = pd.DataFrame({
+        "structure": ["A", "B", None],
+        "value": [1.0, np.nan, np.inf],
+        "count": pd.array([1, None, 3], dtype="Int64"),
+        "when": [pd.Timestamp("2026-01-01"), pd.NaT, pd.Timestamp("2026-01-02")],
+        "flag": [np.bool_(True), np.bool_(False), np.bool_(True)],
+    })
+    records = api._payload_to_records(df)
+    json.dumps(records, allow_nan=False)
+    assert records[1]["value"] is None
+    assert records[2]["value"] is None
+    assert records[1]["count"] is None
+    assert records[1]["when"] is None
+    assert records[0]["flag"] is True
+
+    nested = api._payload_to_records([{"a": float("nan"), "b": {"c": np.float64("-inf"), "d": [np.int64(2)]}}])
+    json.dumps(nested, allow_nan=False)
+    assert nested == [{"a": None, "b": {"c": None, "d": [2]}}]
+
+
+@resp_lib.activate
+def test_put_body_has_no_nan_and_honours_timeout(api, monkeypatch):
+    import numpy as np
+    captured = {}
+    real_put = requests.put
+
+    def _spy(url, **kwargs):
+        captured["timeout"] = kwargs.get("timeout")
+        return real_put(url, **kwargs)
+
+    monkeypatch.setattr(requests, "put", _spy)
+    resp_lib.add(resp_lib.PUT, f"{PROD_BASE}/region-costs/", json={"created": 1})
+    api.upload_timeout = 999
+    api.upsert_region_costs(pd.DataFrame({"region": ["UK"], "cost": [np.nan]}))
+
+    body = resp_lib.calls[0].request.body
+    json.loads(body, parse_constant=lambda c: pytest.fail(f"non-JSON constant {c}"))
+    assert captured["timeout"] == 999
+
 
 def test_get_autoprism_collection_allows_empty_payloads(api, monkeypatch):
     monkeypatch.setattr(api, "get_computation_runs", lambda **kwargs: None)