subspacecomputing 0.1.5__tar.gz → 0.1.6__tar.gz

{subspacecomputing-0.1.5/subspacecomputing.egg-info → subspacecomputing-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: subspacecomputing
-Version: 0.1.5
+Version: 0.1.6
 Summary: Python SDK for ASTRIA — Subspace Computing Engine
 Home-page: https://www.subspacecomputing.com/developer
 Author: Subspace Computing Inc.
@@ -45,9 +45,6 @@ from subspacecomputing import ASTRIA
 
 # Initialize the client (defaults to production URL)
 client = ASTRIA(api_key='your-api-key-here')
-
-# For local testing or custom environments (optional)
-# client = ASTRIA(api_key='your-api-key-here', base_url='http://localhost:8000')
 ```
 
 ### Teams (`X-Team-Id`)
@@ -176,6 +173,46 @@ print(f"Total capital: {result['aggregations']['capital_total']}")
 print(f"Average: {result['aggregations']['moyenne_capital']}")
 ```
 
+### Run a stored model (`projection_id` + inputs)
+
+Execute a projection already saved in Subspace. Load `run_inputs` once (cache in your app), build UI/batch from that descriptor, then call `run_model` many times with only the overrides. Astria runs the calculation; model structure (`formula`, dist type, `per`) is never overridable.
+
+```python
+proj = client.load_model(projection_id)  # get_projection + in-memory cache on this client
+# Or: proj = client.get_projection(projection_id)
+
+result = client.run_model(projection_id, inputs={"capital": 25000})
+print(result["final_values"]["capital"])
+```
+
+Input shapes by `run_inputs.kind`:
+
+| `kind` | Example value in `inputs` |
+|--------|---------------------------|
+| `init` | `{"capital": 25000}` |
+| `params` | `{"taux": {"min": 0.02, "max": 0.05}}` |
+| `values` | `{"inflation": [0.01, 0.02, 0.03]}` |
+| `table_ref` / `table` | `{"mortality": "<uuid>"}` or `{"grid": {...}}` |
+| `run` | `{"scenarios": 100, "steps": 12}` |
+
+Unknown input keys → API **400** `unknown_run_input`. `rerun_run(run_id)` re-executes a past **run snapshot**, not the live model.
+
+Pattern for a dynamic form / batch loop:
+
+```python
+proj = client.load_model(projection_id)
+inputs = {}
+for desc in proj.get("run_inputs") or []:
+    kind = desc.get("kind")
+    name = desc["name"]
+    if kind == "init":
+        inputs[name] = desc.get("default")  # or from UI
+    elif kind == "params":
+        inputs[name] = dict(desc.get("default") or {})
+    # elif kind == "values": ...
+result = client.run_model(projection_id, inputs=inputs)
+```
+
 ### Runs: read, artifact, rerun, replay
 
 Four distinct operations on persisted runs:

{subspacecomputing-0.1.5 → subspacecomputing-0.1.6}/README.md

@@ -17,9 +17,6 @@ from subspacecomputing import ASTRIA
 
 # Initialize the client (defaults to production URL)
 client = ASTRIA(api_key='your-api-key-here')
-
-# For local testing or custom environments (optional)
-# client = ASTRIA(api_key='your-api-key-here', base_url='http://localhost:8000')
 ```
 
 ### Teams (`X-Team-Id`)
@@ -148,6 +145,46 @@ print(f"Total capital: {result['aggregations']['capital_total']}")
 print(f"Average: {result['aggregations']['moyenne_capital']}")
 ```
 
+### Run a stored model (`projection_id` + inputs)
+
+Execute a projection already saved in Subspace. Load `run_inputs` once (cache in your app), build UI/batch from that descriptor, then call `run_model` many times with only the overrides. Astria runs the calculation; model structure (`formula`, dist type, `per`) is never overridable.
+
+```python
+proj = client.load_model(projection_id)  # get_projection + in-memory cache on this client
+# Or: proj = client.get_projection(projection_id)
+
+result = client.run_model(projection_id, inputs={"capital": 25000})
+print(result["final_values"]["capital"])
+```
+
+Input shapes by `run_inputs.kind`:
+
+| `kind` | Example value in `inputs` |
+|--------|---------------------------|
+| `init` | `{"capital": 25000}` |
+| `params` | `{"taux": {"min": 0.02, "max": 0.05}}` |
+| `values` | `{"inflation": [0.01, 0.02, 0.03]}` |
+| `table_ref` / `table` | `{"mortality": "<uuid>"}` or `{"grid": {...}}` |
+| `run` | `{"scenarios": 100, "steps": 12}` |
+
+Unknown input keys → API **400** `unknown_run_input`. `rerun_run(run_id)` re-executes a past **run snapshot**, not the live model.
+
+Pattern for a dynamic form / batch loop:
+
+```python
+proj = client.load_model(projection_id)
+inputs = {}
+for desc in proj.get("run_inputs") or []:
+    kind = desc.get("kind")
+    name = desc["name"]
+    if kind == "init":
+        inputs[name] = desc.get("default")  # or from UI
+    elif kind == "params":
+        inputs[name] = dict(desc.get("default") or {})
+    # elif kind == "values": ...
+result = client.run_model(projection_id, inputs=inputs)
+```
+
 ### Runs: read, artifact, rerun, replay
 
 Four distinct operations on persisted runs:

{subspacecomputing-0.1.5 → subspacecomputing-0.1.6}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "subspacecomputing"
-version = "0.1.5"
+version = "0.1.6"
 description = "Python SDK for ASTRIA — Subspace Computing Engine"
 authors = [{name = "Subspace Computing Inc.", email = "contact@subspacecomputing.com"}]
 readme = "README.md"

{subspacecomputing-0.1.5 → subspacecomputing-0.1.6}/setup.py

@@ -13,7 +13,7 @@ except FileNotFoundError:
 
 setup(
     name="subspacecomputing",
-    version="0.1.5",
+    version="0.1.6",
     description="Python SDK for ASTRIA — Subspace Computing Engine",
     long_description=long_description,
     long_description_content_type="text/markdown",

{subspacecomputing-0.1.5 → subspacecomputing-0.1.6}/subspacecomputing/__init__.py

@@ -14,7 +14,7 @@ from .errors import (
     ValidationError,
 )
 
-__version__ = "0.1.5"
+__version__ = "0.1.6"
 __all__ = [
     "ASTRIA",
     "SubspaceError",

{subspacecomputing-0.1.5 → subspacecomputing-0.1.6}/subspacecomputing/client.py

@@ -61,6 +61,7 @@ class ASTRIA:
             headers["X-Team-Id"] = self._team_id
         self.session.headers.update(headers)
         self.last_response = None  # Store last response for header access
+        self._model_cache: Dict[str, Dict[str, Any]] = {}
 
     def set_team_id(self, team_id: Optional[str] = None) -> None:
         """Set or clear ``X-Team-Id`` for subsequent requests."""
@@ -379,7 +380,7 @@ class ASTRIA:
             projection_id: Projection ID
 
         Returns:
-            Response with projection details
+            Response with projection details (includes ``run_inputs`` when present)
         """
         response = self.session.get(
             f"{self.base_url}/projections/{projection_id}",
@@ -389,6 +390,60 @@ class ASTRIA:
         self._handle_response(response)
         return response.json()
 
+    def load_model(self, projection_id: str) -> Dict[str, Any]:
+        """
+        Load a projection (schema + ``run_inputs``) with a simple in-memory cache
+        on this client instance. Prefer this once per session; still avoid calling
+        on every ``run_model``.
+        """
+        if not projection_id or not str(projection_id).strip():
+            raise ValueError("projection_id is required.")
+        pid = str(projection_id).strip()
+        cached = self._model_cache.get(pid)
+        if cached is not None:
+            return cached
+        proj = self.get_projection(pid)
+        self._model_cache[pid] = proj
+        return proj
+
+    def clear_model_cache(self, projection_id: Optional[str] = None) -> None:
+        """Clear in-memory model cache from :meth:`load_model`."""
+        if projection_id and str(projection_id).strip():
+            self._model_cache.pop(str(projection_id).strip(), None)
+        else:
+            self._model_cache.clear()
+
+    def run_model(
+        self,
+        projection_id: str,
+        inputs: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Run a stored projection by ID with optional runtime input overrides.
+
+        Applies ``run_inputs`` by kind (init, params, values, tables, run knobs).
+        Does not change formula / dist type / per. Distinct from :meth:`rerun_run`.
+
+        Args:
+            projection_id: Stored projection UUID
+            inputs: Optional overrides keyed by run_input name
+                    (e.g. ``{"capital": 25000}``, ``{"taux": {"min": 0.02, "max": 0.05}}``)
+
+        Returns:
+            Same shape as ``project()`` or ``simulate()`` depending on scenarios
+        """
+        if not projection_id or not str(projection_id).strip():
+            raise ValueError("projection_id is required.")
+        safe_id = quote(str(projection_id).strip(), safe="")
+        response = self.session.post(
+            f"{self.base_url}/projections/{safe_id}/run",
+            json={"inputs": inputs or {}},
+            timeout=self.timeout,
+        )
+        self.last_response = response
+        self._handle_response(response)
+        return response.json()
+
     def delete_projection(self, projection_id: str) -> None:
         """
         Delete a projection.
@@ -465,6 +520,41 @@ class ASTRIA:
         self._handle_response(response)
         return response.json()
 
+    def get_run_proof(self, run_id: str, *, include_spec: bool = False) -> Dict[str, Any]:
+        """
+        Fetch Astria run proof pack for a projection run.
+
+        Args:
+            run_id: Projection run ID
+            include_spec: If True, include resolved SP snapshot in the proof
+
+        Returns:
+            Proof pack (schema_version, hashes, seed, …)
+        """
+        params = {"include_spec": "true"} if include_spec else None
+        response = self.session.get(
+            f"{self.base_url}/projection-runs/{run_id}/proof",
+            params=params,
+            timeout=self.timeout,
+        )
+        self.last_response = response
+        self._handle_response(response)
+        return response.json()
+
+    def get_execution_proof(self, execution_id: str) -> Dict[str, Any]:
+        """
+        Fetch Astria run proof pack from a Registry execution (lineage.astria).
+
+        Requires Console JWT auth on the session (same as other /executions routes).
+        """
+        response = self.session.get(
+            f"{self.base_url}/executions/{execution_id}/proof",
+            timeout=self.timeout,
+        )
+        self.last_response = response
+        self._handle_response(response)
+        return response.json()
+
     def replay_run(self, run_id: str, scenario_id: int) -> Dict[str, Any]:
         """
         Replay a scenario from a stored run (requires persisted seeds).

{subspacecomputing-0.1.5 → subspacecomputing-0.1.6/subspacecomputing.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: subspacecomputing
-Version: 0.1.5
+Version: 0.1.6
 Summary: Python SDK for ASTRIA — Subspace Computing Engine
 Home-page: https://www.subspacecomputing.com/developer
 Author: Subspace Computing Inc.
@@ -45,9 +45,6 @@ from subspacecomputing import ASTRIA
 
 # Initialize the client (defaults to production URL)
 client = ASTRIA(api_key='your-api-key-here')
-
-# For local testing or custom environments (optional)
-# client = ASTRIA(api_key='your-api-key-here', base_url='http://localhost:8000')
 ```
 
 ### Teams (`X-Team-Id`)
@@ -176,6 +173,46 @@ print(f"Total capital: {result['aggregations']['capital_total']}")
 print(f"Average: {result['aggregations']['moyenne_capital']}")
 ```
 
+### Run a stored model (`projection_id` + inputs)
+
+Execute a projection already saved in Subspace. Load `run_inputs` once (cache in your app), build UI/batch from that descriptor, then call `run_model` many times with only the overrides. Astria runs the calculation; model structure (`formula`, dist type, `per`) is never overridable.
+
+```python
+proj = client.load_model(projection_id)  # get_projection + in-memory cache on this client
+# Or: proj = client.get_projection(projection_id)
+
+result = client.run_model(projection_id, inputs={"capital": 25000})
+print(result["final_values"]["capital"])
+```
+
+Input shapes by `run_inputs.kind`:
+
+| `kind` | Example value in `inputs` |
+|--------|---------------------------|
+| `init` | `{"capital": 25000}` |
+| `params` | `{"taux": {"min": 0.02, "max": 0.05}}` |
+| `values` | `{"inflation": [0.01, 0.02, 0.03]}` |
+| `table_ref` / `table` | `{"mortality": "<uuid>"}` or `{"grid": {...}}` |
+| `run` | `{"scenarios": 100, "steps": 12}` |
+
+Unknown input keys → API **400** `unknown_run_input`. `rerun_run(run_id)` re-executes a past **run snapshot**, not the live model.
+
+Pattern for a dynamic form / batch loop:
+
+```python
+proj = client.load_model(projection_id)
+inputs = {}
+for desc in proj.get("run_inputs") or []:
+    kind = desc.get("kind")
+    name = desc["name"]
+    if kind == "init":
+        inputs[name] = desc.get("default")  # or from UI
+    elif kind == "params":
+        inputs[name] = dict(desc.get("default") or {})
+    # elif kind == "values": ...
+result = client.run_model(projection_id, inputs=inputs)
+```
+
 ### Runs: read, artifact, rerun, replay
 
 Four distinct operations on persisted runs: