subspacecomputing 0.1.4__tar.gz → 0.1.6__tar.gz

{subspacecomputing-0.1.4 → subspacecomputing-0.1.6}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Beausoft Inc.
+Copyright (c) 2025 Subspace Computing Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{subspacecomputing-0.1.4 → subspacecomputing-0.1.6}/MANIFEST.in

@@ -4,6 +4,12 @@ include README.md
 include LICENSE
 include pyproject.toml
 recursive-include subspacecomputing *.py
+prune tests
+prune doc
+prune examples
+recursive-exclude tests *
+recursive-exclude doc *
+recursive-exclude examples *
 recursive-exclude * __pycache__
 recursive-exclude * *.py[co]
 recursive-exclude * .git*

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

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: subspacecomputing
-Version: 0.1.4
+Version: 0.1.6
 Summary: Python SDK for ASTRIA — Subspace Computing Engine
 Home-page: https://www.subspacecomputing.com/developer
-Author: Subspace Computing
-Author-email: Subspace Computing <contact@beausoft.ca>
+Author: Subspace Computing Inc.
+Author-email: "Subspace Computing Inc." <contact@subspacecomputing.com>
 Project-URL: Documentation, https://www.subspacecomputing.com/developer
 Project-URL: Homepage, https://www.subspacecomputing.com/developer
 Project-URL: Support, https://www.subspacecomputing.com/developer
@@ -26,9 +26,9 @@ Dynamic: home-page
 Dynamic: license-file
 Dynamic: requires-python
 
-# Subspace Computing Engine - Python SDK
+# ASTRIA — Python SDK
 
-Python SDK for the Subspace Computing Engine API (by Beausoft).
+Python SDK for ASTRIA, the Subspace Computing Engine.
 
 ## Installation
 
@@ -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,87 @@ 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:
+
+| Method | What it does |
+|--------|----------------|
+| `get_run(run_id)` | Read metadata, stored SP Model snapshot, and `result_summary` |
+| `get_run_artifact(artifact_id)` | Read heavy results already computed (`final_values` / URL) |
+| `rerun_run(run_id, spec_patch=None)` | Re-execute the run's snapshot in Astria; creates a **new** run |
+| `replay_run(run_id, scenario_id)` | Reproduce **one** Monte Carlo scenario when seeds were stored |
+
+```python
+# Cross-language analysis: app computed → Python reads original results
+run = client.get_run(run_id)
+print(run["result_summary"])
+if run.get("artefact_id"):
+    artifact = client.get_run_artifact(run["artefact_id"])
+    print(artifact.get("final_values"))
+
+# Re-execute the exact snapshot (validation) — new run, same projection
+baseline = client.rerun_run(run_id)
+print(baseline["run_id"], baseline["source_spec_hash"], baseline["spec_changed"])
+
+# What-if: fork the snapshot with a JSON Merge Patch (source run unchanged)
+what_if = client.rerun_run(
+    run_id,
+    spec_patch={"meta": {"seed": 42}},
+)
+print(what_if["executed_spec_hash"], what_if["final_values"])
+
+# Exact MC scenario reproduction (requires meta.store_seeds_for_replay at creation)
+replay = client.replay_run(run_id, scenario_id=0)
+```
+
+**Notes**
+
+- `rerun_run` does **not** load the projection's current `dsl_template`; it uses the run's stored `spec`.
+- Requires `persist_mode=full` (headless minimal/metadata keys cannot create a new run).
+- Exact stochastic reproduction of one scenario uses `replay_run` + stored seeds; a plain `rerun_run` of a Monte Carlo may draw new samples unless `meta.seed` was in the snapshot.
+- Live `table_refs` may resolve to newer data than at original execution time.
+
 ### Validation
 
 ```python
@@ -259,7 +337,7 @@ Check out the full documentation at https://www.subspacecomputing.com/developer
 
 API reference is available at https://www.subspacecomputing.com/docs
 
-For support, reach out to contact@beausoft.ca
+For support, reach out to contact@subspacecomputing.com
 
 ## License
 
@@ -267,4 +345,4 @@ MIT License. Check the LICENSE file for details.
 
 ## Copyright
 
-© 2025 Beausoft Inc. All Rights Reserved
+© 2026 Subspace Computing Inc. All Rights Reserved

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

@@ -1,6 +1,6 @@
-# Subspace Computing Engine - Python SDK
+# ASTRIA — Python SDK
 
-Python SDK for the Subspace Computing Engine API (by Beausoft).
+Python SDK for ASTRIA, the Subspace Computing Engine.
 
 ## Installation
 
@@ -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,87 @@ 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:
+
+| Method | What it does |
+|--------|----------------|
+| `get_run(run_id)` | Read metadata, stored SP Model snapshot, and `result_summary` |
+| `get_run_artifact(artifact_id)` | Read heavy results already computed (`final_values` / URL) |
+| `rerun_run(run_id, spec_patch=None)` | Re-execute the run's snapshot in Astria; creates a **new** run |
+| `replay_run(run_id, scenario_id)` | Reproduce **one** Monte Carlo scenario when seeds were stored |
+
+```python
+# Cross-language analysis: app computed → Python reads original results
+run = client.get_run(run_id)
+print(run["result_summary"])
+if run.get("artefact_id"):
+    artifact = client.get_run_artifact(run["artefact_id"])
+    print(artifact.get("final_values"))
+
+# Re-execute the exact snapshot (validation) — new run, same projection
+baseline = client.rerun_run(run_id)
+print(baseline["run_id"], baseline["source_spec_hash"], baseline["spec_changed"])
+
+# What-if: fork the snapshot with a JSON Merge Patch (source run unchanged)
+what_if = client.rerun_run(
+    run_id,
+    spec_patch={"meta": {"seed": 42}},
+)
+print(what_if["executed_spec_hash"], what_if["final_values"])
+
+# Exact MC scenario reproduction (requires meta.store_seeds_for_replay at creation)
+replay = client.replay_run(run_id, scenario_id=0)
+```
+
+**Notes**
+
+- `rerun_run` does **not** load the projection's current `dsl_template`; it uses the run's stored `spec`.
+- Requires `persist_mode=full` (headless minimal/metadata keys cannot create a new run).
+- Exact stochastic reproduction of one scenario uses `replay_run` + stored seeds; a plain `rerun_run` of a Monte Carlo may draw new samples unless `meta.seed` was in the snapshot.
+- Live `table_refs` may resolve to newer data than at original execution time.
+
 ### Validation
 
 ```python
@@ -231,7 +309,7 @@ Check out the full documentation at https://www.subspacecomputing.com/developer
 
 API reference is available at https://www.subspacecomputing.com/docs
 
-For support, reach out to contact@beausoft.ca
+For support, reach out to contact@subspacecomputing.com
 
 ## License
 
@@ -239,4 +317,4 @@ MIT License. Check the LICENSE file for details.
 
 ## Copyright
 
-© 2025 Beausoft Inc. All Rights Reserved
+© 2026 Subspace Computing Inc. All Rights Reserved

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

@@ -6,9 +6,9 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "subspacecomputing"
-version = "0.1.4"
+version = "0.1.6"
 description = "Python SDK for ASTRIA — Subspace Computing Engine"
-authors = [{name = "Subspace Computing", email = "contact@beausoft.ca"}]
+authors = [{name = "Subspace Computing Inc.", email = "contact@subspacecomputing.com"}]
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = [

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

@@ -9,16 +9,16 @@ try:
     with open("README.md", "r", encoding="utf-8") as fh:
         long_description = fh.read()
 except FileNotFoundError:
-    long_description = "Python SDK for Subspace Computing Engine API (by Beausoft)"
+    long_description = "Python SDK for ASTRIA — Subspace Computing Engine API"
 
 setup(
     name="subspacecomputing",
-    version="0.1.4",
+    version="0.1.6",
     description="Python SDK for ASTRIA — Subspace Computing Engine",
     long_description=long_description,
     long_description_content_type="text/markdown",
-    author="Subspace Computing",
-    author_email="contact@beausoft.ca",
+    author="Subspace Computing Inc.",
+    author_email="contact@subspacecomputing.com",
     url="https://www.subspacecomputing.com/developer",
     packages=find_packages(),
     install_requires=[

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

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

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

@@ -6,6 +6,7 @@ This module provides a simple Python interface to interact with the Subspace Com
 
 import requests
 from typing import Dict, Any, Optional, List
+from urllib.parse import quote
 from .errors import (
     SubspaceError,
     QuotaExceededError,
@@ -60,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."""
@@ -148,6 +150,56 @@ class ASTRIA:
         self._handle_response(response)
         return response.json()
 
+    # Registry — execute published capability by name (production version)
+
+    def execute(
+        self,
+        name: str,
+        inputs: Optional[Dict[str, Any]] = None,
+        *,
+        correlation_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Execute a published Registry capability by name (resolves production version).
+
+        Args:
+            name: Capability name (e.g. ``calculatePremium``).
+            inputs: Parameters merged into the stored spec (batch_params / variables).
+            correlation_id: Optional trace id (body + ``X-Correlation-Id`` header).
+
+        Returns:
+            Simulate-style response plus ``capability``, ``capability_version``,
+            and optional ``correlation_id``.
+
+        Example:
+            result = client.execute(
+                "valorisation_ebitda",
+                inputs={"capital": 1_000_000},
+                correlation_id="quote-001",
+            )
+        """
+        if not name or not str(name).strip():
+            raise ValueError("Capability name is required.")
+
+        payload: Dict[str, Any] = {"inputs": inputs or {}}
+        if correlation_id:
+            payload["correlation_id"] = correlation_id
+
+        extra_headers: Dict[str, str] = {}
+        if correlation_id:
+            extra_headers["X-Correlation-Id"] = correlation_id
+
+        safe_name = quote(str(name).strip(), safe="")
+        response = self.session.post(
+            f"{self.base_url}/capabilities/{safe_name}/execute",
+            json=payload,
+            headers=extra_headers or None,
+            timeout=self.timeout,
+        )
+        self.last_response = response
+        self._handle_response(response)
+        return response.json()
+
     def replay_scenario(
         self,
         original_spec: Dict[str, Any],
@@ -328,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}",
@@ -338,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.
@@ -414,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).
@@ -442,6 +583,53 @@ class ASTRIA:
         self._handle_response(response)
         return response.json()
 
+    def rerun_run(
+        self,
+        run_id: str,
+        spec_patch: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Re-execute the SP Model snapshot of a persisted run (optional what-if patch).
+
+        Creates a **new** run on the same projection with ``source_run_id`` set.
+        Does **not** mutate the source run or the projection's current template.
+
+        Unlike ``replay_run``, this recalculates the full snapshot (project if
+        scenarios==1, otherwise simulate). Exact Monte Carlo scenario reproduction
+        still requires ``replay_run`` with stored seeds.
+
+        Args:
+            run_id: Source run UUID.
+            spec_patch: Optional JSON Merge Patch applied to the stored spec
+                (objects merge recursively; arrays/scalars replace; null deletes).
+                Reserved fields ``run_id``, ``meta.projection_id``,
+                ``meta._replay_seeds`` are rejected by the API.
+
+        Returns:
+            Project or simulate response plus ``source_run_id``,
+            ``source_spec_hash``, ``executed_spec_hash``, ``spec_changed``.
+
+        Example:
+            baseline = client.rerun_run(run_id)
+            what_if = client.rerun_run(
+                run_id,
+                spec_patch={"meta": {"seed": 42}},
+            )
+        """
+        if not run_id or not str(run_id).strip():
+            raise ValueError("run_id is required.")
+        payload: Dict[str, Any] = {}
+        if spec_patch is not None:
+            payload["spec_patch"] = spec_patch
+        response = self.session.post(
+            f"{self.base_url}/projection-runs/{str(run_id).strip()}/rerun",
+            json=payload,
+            timeout=self.timeout,
+        )
+        self.last_response = response
+        self._handle_response(response)
+        return response.json()
+
     def delete_run(self, run_id: str) -> None:
         """
         Delete a run.