subspacecomputing 0.1.4__tar.gz → 0.1.5__tar.gz

{subspacecomputing-0.1.4 → subspacecomputing-0.1.5}/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.5}/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.5}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: subspacecomputing
-Version: 0.1.4
+Version: 0.1.5
 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
 
@@ -176,6 +176,47 @@ print(f"Total capital: {result['aggregations']['capital_total']}")
 print(f"Average: {result['aggregations']['moyenne_capital']}")
 ```
 
+### 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 +300,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 +308,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.5}/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
 
@@ -148,6 +148,47 @@ print(f"Total capital: {result['aggregations']['capital_total']}")
 print(f"Average: {result['aggregations']['moyenne_capital']}")
 ```
 
+### 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 +272,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 +280,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.5}/pyproject.toml

@@ -6,9 +6,9 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "subspacecomputing"
-version = "0.1.4"
+version = "0.1.5"
 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.5}/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.5",
     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.5}/subspacecomputing/__init__.py

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

{subspacecomputing-0.1.4 → subspacecomputing-0.1.5}/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,
@@ -148,6 +149,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],
@@ -442,6 +493,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.

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

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: subspacecomputing
-Version: 0.1.4
+Version: 0.1.5
 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
 
@@ -176,6 +176,47 @@ print(f"Total capital: {result['aggregations']['capital_total']}")
 print(f"Average: {result['aggregations']['moyenne_capital']}")
 ```
 
+### 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 +300,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 +308,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.5}/subspacecomputing.egg-info/SOURCES.txt

@@ -12,7 +12,4 @@ subspacecomputing.egg-info/dependency_links.txt
 subspacecomputing.egg-info/requires.txt
 subspacecomputing.egg-info/top_level.txt
 subspacecomputing/utils/__init__.py
-subspacecomputing/utils/pandas_integration.py
-tests/test_client_integration.py
-tests/test_client_unit.py
-tests/test_pandas_integration.py
+subspacecomputing/utils/pandas_integration.py

subspacecomputing-0.1.4/tests/test_client_integration.py

@@ -1,320 +0,0 @@
-"""
-Tests d'intégration pour le SDK Python.
-
-Ces tests réutilisent les SP Models des tests non-régression
-et comparent les résultats SDK vs API directe.
-"""
-
-import pytest
-import sys
-from pathlib import Path
-from unittest.mock import Mock
-
-# Ajouter le répertoire parent pour importer l'API
-sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent))
-
-from fastapi.testclient import TestClient
-from api.main import app
-from subspacecomputing import ASTRIA
-
-
-@pytest.fixture
-def api_client():
-    """Client API FastAPI pour tests."""
-    return TestClient(app)
-
-
-@pytest.fixture
-def sdk_client(api_key, api_client):
-    """
-    Client SDK pour tests, utilisant TestClient au lieu de requests.
-    
-    Cette fixture crée un wrapper qui adapte TestClient pour qu'il
-    fonctionne avec le SDK qui utilise requests.Session.
-    """
-    # Créer une instance du SDK
-    client = ASTRIA(api_key=api_key, base_url="http://testserver")
-    
-    # Créer un mock pour requests.Session qui utilise TestClient
-    def make_request(method, url, **kwargs):
-        """Adapter qui convertit requests vers TestClient."""
-        path = url.replace("http://testserver", "").replace("https://testserver", "")
-        if not path.startswith("/"):
-            path = "/" + path
-        headers = dict(client.session.headers)
-        headers.update(kwargs.get("headers", {}))
-        if method.upper() == "GET":
-            response = api_client.get(path, headers=headers)
-        elif method.upper() == "POST":
-            response = api_client.post(path, json=kwargs.get("json"), headers=headers)
-        elif method.upper() == "DELETE":
-            response = api_client.delete(path, headers=headers)
-        else:
-            raise ValueError(f"Méthode HTTP non supportée: {method}")
-        
-        # Créer un mock Response qui ressemble à requests.Response
-        mock_response = Mock()
-        mock_response.status_code = response.status_code
-        mock_response.json = lambda: response.json()
-        mock_response.text = response.text
-        mock_response.headers = response.headers
-        mock_response.ok = 200 <= response.status_code < 300
-        mock_response.content = response.content
-        
-        return mock_response
-    
-    # Remplacer les méthodes du session pour utiliser TestClient
-    client.session.request = make_request
-    client.session.get = lambda url, **kwargs: make_request("GET", url, **kwargs)
-    client.session.post = lambda url, **kwargs: make_request("POST", url, **kwargs)
-    client.session.delete = lambda url, **kwargs: make_request("DELETE", url, **kwargs)
-    
-    return client
-
-
-class TestProjectIntegration:
-    """Tests d'intégration pour project()."""
-
-    def test_project_same_result_as_api(self, api_client, sdk_client, simple_spec):
-        """Test que SDK et API donnent les mêmes résultats pour project()."""
-        # Test via API directe
-        api_response = api_client.post('/project', json=simple_spec)
-        assert api_response.status_code == 200
-        api_result = api_response.json()
-
-        # Test via SDK
-        sdk_result = sdk_client.project(simple_spec)
-
-        # Vérifier que les résultats sont identiques
-        assert sdk_result['scenarios'] == api_result['scenarios']
-        assert sdk_result['steps'] == api_result['steps']
-        assert abs(sdk_result['final_values']['capital'] - api_result['final_values']['capital']) < 0.01
-        
-        # Vérifier trajectory
-        assert len(sdk_result['trajectory']['capital']) == len(api_result['trajectory']['capital'])
-        for i in range(len(sdk_result['trajectory']['capital'])):
-            assert abs(sdk_result['trajectory']['capital'][i] - api_result['trajectory']['capital'][i]) < 0.01
-
-
-class TestSimulateIntegration:
-    """Tests d'intégration pour simulate()."""
-
-    def test_simulate_same_result_as_api(self, api_client, sdk_client, simulation_spec):
-        """Test que SDK et API donnent les mêmes résultats pour simulate()."""
-        # Test via API directe
-        api_response = api_client.post('/simulate', json=simulation_spec)
-        assert api_response.status_code == 200
-        api_result = api_response.json()
-
-        # Test via SDK
-        sdk_result = sdk_client.simulate(simulation_spec)
-
-        # Vérifier que les résultats sont identiques
-        assert sdk_result['scenarios'] == api_result['scenarios']
-        assert sdk_result['steps'] == api_result['steps']
-        
-        # Vérifier last_mean (devrait être identique avec seed explicite)
-        # Note: Avec seed explicite, les résultats doivent être identiques
-        assert abs(sdk_result['last_mean']['capital'] - api_result['last_mean']['capital']) < 0.01
-        
-        # Vérifier statistics si présentes (devrait être identique avec seed explicite)
-        if 'statistics' in api_result and 'capital' in api_result['statistics']:
-            api_stats = api_result['statistics']['capital']
-            sdk_stats = sdk_result.get('statistics', {}).get('capital', {})
-            
-            # Avec seed explicite, les statistiques doivent être identiques
-            if 'mean' in api_stats:
-                assert abs(sdk_stats.get('mean', 0) - api_stats['mean']) < 0.01
-            if 'median' in api_stats:
-                assert abs(sdk_stats.get('median', 0) - api_stats['median']) < 0.01
-
-
-class TestBatchIntegration:
-    """Tests d'intégration pour project_batch()."""
-
-    def test_batch_same_result_as_api(self, api_client, sdk_client, batch_spec_simple):
-        """Test que SDK et API donnent les mêmes résultats pour project_batch()."""
-        # Test via API directe
-        api_response = api_client.post('/project/batch', json=batch_spec_simple)
-        assert api_response.status_code == 200
-        api_result = api_response.json()
-
-        # Test via SDK
-        sdk_result = sdk_client.project_batch(
-            template=batch_spec_simple['template'],
-            batch_params=batch_spec_simple['batch_params']
-        )
-
-        # Vérifier que les résultats sont identiques
-        assert len(sdk_result['entities']) == len(api_result['entities'])
-        
-        for i, entity in enumerate(sdk_result['entities']):
-            api_entity = api_result['entities'][i]
-            assert entity['_entity_id'] == api_entity['_entity_id']
-            
-            # Vérifier final_values (liste de dicts, un par scénario)
-            if 'final_values' in entity and 'final_values' in api_entity:
-                # final_values est une liste de dicts (un par scénario)
-                if len(entity['final_values']) > 0 and len(api_entity['final_values']) > 0:
-                    sdk_fv = entity['final_values'][0]  # Premier scénario
-                    api_fv = api_entity['final_values'][0]  # Premier scénario
-                    for var_name in sdk_fv:
-                        if var_name in api_fv:
-                            assert abs(sdk_fv[var_name] - api_fv[var_name]) < 0.01
-
-
-class TestValidateIntegration:
-    """Tests d'intégration pour validate()."""
-
-    def test_validate_same_result_as_api(self, api_client, sdk_client, simple_spec):
-        """Test que SDK et API donnent les mêmes résultats pour validate()."""
-        # Test via API directe
-        api_response = api_client.post('/validate', json=simple_spec)
-        assert api_response.status_code == 200
-        api_result = api_response.json()
-
-        # Test via SDK
-        sdk_result = sdk_client.validate(simple_spec)
-
-        # Vérifier que les résultats sont identiques
-        assert sdk_result['valid'] == api_result['valid']
-        assert len(sdk_result['errors']) == len(api_result['errors'])
-        assert len(sdk_result['warnings']) == len(api_result['warnings'])
-
-
-class TestGetExamplesIntegration:
-    """Tests d'intégration pour get_examples()."""
-
-    def test_get_examples_same_result_as_api(self, api_client, sdk_client):
-        """Test que SDK et API donnent les mêmes résultats pour get_examples()."""
-        # Test via API directe
-        api_response = api_client.get('/examples')
-        assert api_response.status_code == 200
-        api_result = api_response.json()
-
-        # Test via SDK
-        sdk_result = sdk_client.get_examples()
-
-        # Vérifier que les résultats sont identiques
-        assert len(sdk_result['examples']) == len(api_result['examples'])
-        
-        # Vérifier que les noms sont identiques
-        sdk_names = [ex.get('name') for ex in sdk_result['examples']]
-        api_names = [ex.get('name') for ex in api_result['examples']]
-        assert set(sdk_names) == set(api_names)
-
-
-class TestGetUsageIntegration:
-    """Tests d'intégration pour get_usage()."""
-
-    def test_get_usage_structure(self, api_client, sdk_client):
-        """Test que get_usage() retourne la bonne structure."""
-        # Test via SDK (nécessite API key valide, peut échouer en dev)
-        try:
-            sdk_result = sdk_client.get_usage()
-            
-            # Vérifier structure de base
-            assert 'usage' in sdk_result or 'plan' in sdk_result
-        except Exception:
-            # En développement sans Supabase, peut échouer
-            pytest.skip("get_usage() requires valid API key and Supabase configuration")
-
-
-class TestReplayRunIntegration:
-    """Tests d'intégration pour replay_run()."""
-
-    def test_replay_run_same_result_as_api(self, api_client, sdk_client, monkeypatch):
-        """Test que SDK.replay_run() et API directe donnent les mêmes résultats."""
-        import copy
-        # FakeSupabase minimal pour le test replay (évite import cross-package)
-        class _FakeTableQuery:
-            def __init__(self, dataset):
-                self.dataset = dataset
-                self._filters = []
-                self._limit = None
-            def select(self, columns="*", count=None): return self
-            def match(self, criteria):
-                self._filters.append(lambda r, c=criteria: all(r.get(k) == v for k, v in c.items()))
-                return self
-            def limit(self, v): self._limit = v; return self
-            def execute(self):
-                rows = [r for r in self.dataset if all(f(r) for f in self._filters)]
-                if self._limit: rows = rows[:self._limit]
-                return type('R', (), {'data': [copy.deepcopy(r) for r in rows], 'error': None})()
-        class _FakeSupabase:
-            def __init__(self, tables):
-                self.tables = {n: [copy.deepcopy(r) for r in rows] for n, rows in tables.items()}
-
-            def table(self, name):
-                if name not in self.tables:
-                    self.tables[name] = []
-                return _FakeTableQuery(self.tables[name])
-
-            def rpc(self, name, params):
-                """Mock rpc pour check_monthly_quota, check_replay_quota, etc."""
-                class _RpcResult:
-                    def execute(self):
-                        return type("R", (), {"data": [{"is_ok": True}], "error": None})()
-                return _RpcResult()
-
-        run_id = "run-replay-integ"
-        spec_stored = {
-            "meta": {"seed": 999},
-            "scenarios": 3,
-            "steps": 5,
-            "variables": [
-                {"name": "taux", "dist": "uniform", "params": {"min": 0.03, "max": 0.07}, "per": "scenario"},
-                {"name": "capital", "init": 1000.0, "formula": "capital[t-1] * (1 + taux)"},
-            ],
-        }
-        seeds_stored = {"global": 999, "scenarios": [100, 200, 300], "variables": {}}
-        projection_runs = [
-            {
-                "id": run_id,
-                "user_id": "user-int",
-                "spec": spec_stored,
-                "seeds": seeds_stored,
-                "scenarios": 3,
-                "steps": 5,
-                "projection_id": None,
-                "api_key_id": "api-key-int",
-            }
-        ]
-        tables = {"projection_runs": projection_runs, "projections": [], "run_artifacts": []}
-        fake_supabase = _FakeSupabase(tables)
-
-        async def fake_require(api_key):
-            return "business", {
-                "user_id": "user-int",
-                "api_key_id": "api-key-int",
-                "max_cpus": 4,
-                "max_scenarios": 1000,
-                "name": "Business",
-            }
-
-        monkeypatch.setattr("api.main.require_authenticated_user", fake_require)
-        monkeypatch.setattr("api.main.get_supabase_or_503", lambda: fake_supabase)
-
-        # API directe
-        api_response = api_client.post(
-            f"/projection-runs/{run_id}/replay/1",
-            headers={"X-API-Key": "test-key"}
-        )
-        if api_response.status_code != 200:
-            pytest.skip(
-                f"Replay requires full Supabase mock (INSERT, etc.): "
-                f"{api_response.status_code} - {api_response.json().get('detail', '')}"
-            )
-        api_result = api_response.json()
-
-        # SDK
-        sdk_result = sdk_client.replay_run(run_id=run_id, scenario_id=1)
-
-        # Vérifier résultats identiques
-        assert sdk_result["scenarios"] == api_result["scenarios"]
-        assert sdk_result["steps"] == api_result["steps"]
-        assert sdk_result["run_id"] == api_result["run_id"]
-        sdk_fv = sdk_result["final_values"][0] if isinstance(sdk_result["final_values"], list) else sdk_result["final_values"]
-        api_fv = api_result["final_values"][0] if isinstance(api_result["final_values"], list) else api_result["final_values"]
-        assert abs(sdk_fv.get("capital", 0) - api_fv.get("capital", 0)) < 0.01
-

subspacecomputing-0.1.4/tests/test_client_unit.py

@@ -1,380 +0,0 @@
-"""
-Tests unitaires pour le SDK Python (avec mocks).
-
-Ces tests vérifient le comportement du SDK sans dépendre de l'API réelle.
-"""
-
-import pytest
-from unittest.mock import Mock, patch
-from subspacecomputing import (
-    ASTRIA,
-    SubspaceError,
-    QuotaExceededError,
-    RateLimitError,
-    AuthenticationError,
-    ValidationError,
-)
-
-
-class TestClientInitialization:
-    """Tests d'initialisation du client."""
-
-    def test_init_with_api_key(self, api_key, base_url):
-        """Test initialisation avec API key."""
-        client = ASTRIA(api_key=api_key, base_url=base_url)
-        assert client.api_key == api_key
-        assert client.base_url == base_url
-        assert 'X-API-Key' in client.session.headers
-        assert client.session.headers['X-API-Key'] == api_key
-
-    def test_init_default_base_url(self, api_key):
-        """Test initialisation avec URL par défaut."""
-        client = ASTRIA(api_key=api_key)
-        assert client.base_url == 'https://api.subspacecomputing.com'
-
-    def test_init_strips_trailing_slash(self, api_key):
-        """Test que l'URL est nettoyée (pas de slash final)."""
-        client = ASTRIA(api_key=api_key, base_url='http://localhost:8000/')
-        assert client.base_url == 'http://localhost:8000'
-
-    def test_init_rejects_empty_api_key(self):
-        """Test que api_key vide lève ValueError."""
-        with pytest.raises(ValueError, match="API key is required"):
-            ASTRIA(api_key="")
-        with pytest.raises(ValueError, match="API key is required"):
-            ASTRIA(api_key="   ")
-        with pytest.raises(ValueError, match="API key is required"):
-            ASTRIA(api_key=None)
-
-
-class TestErrorHandling:
-    """Tests de gestion des erreurs HTTP."""
-
-    def test_rate_limit_error(self, api_key, base_url):
-        """Test gestion erreur 429 (rate limit)."""
-        client = ASTRIA(api_key=api_key, base_url=base_url)
-
-        mock_response = Mock()
-        mock_response.status_code = 429
-        mock_response.text = "Rate limit exceeded"
-        mock_response.headers = {"Retry-After": "60"}
-        mock_response.ok = False
-
-        with patch.object(client.session, 'post', return_value=mock_response):
-            with pytest.raises(RateLimitError) as exc_info:
-                client.simulate({'scenarios': 100, 'steps': 12, 'variables': []})
-            assert "Rate limit" in str(exc_info.value)
-
-    def test_quota_exceeded_error(self, api_key, base_url):
-        """Test gestion erreur 429 (quota mensuel)."""
-        client = ASTRIA(api_key=api_key, base_url=base_url)
-
-        mock_response = Mock()
-        mock_response.status_code = 429
-        mock_response.text = "Monthly quota exceeded"
-        mock_response.headers = {}
-        mock_response.ok = False
-
-        with patch.object(client.session, 'post', return_value=mock_response):
-            with pytest.raises(QuotaExceededError) as exc_info:
-                client.simulate({'scenarios': 100, 'steps': 12, 'variables': []})
-            assert "quota" in str(exc_info.value).lower()
-
-    def test_authentication_error(self, api_key, base_url):
-        """Test gestion erreur 401 (API key invalide)."""
-        client = ASTRIA(api_key=api_key, base_url=base_url)
-
-        mock_response = Mock()
-        mock_response.status_code = 401
-        mock_response.text = "Invalid API key"
-        mock_response.ok = False
-
-        with patch.object(client.session, 'post', return_value=mock_response):
-            with pytest.raises(AuthenticationError) as exc_info:
-                client.simulate({'scenarios': 100, 'steps': 12, 'variables': []})
-            assert "API key" in str(exc_info.value)
-
-    def test_validation_error(self, api_key, base_url):
-        """Test gestion erreur 400 (validation)."""
-        client = ASTRIA(api_key=api_key, base_url=base_url)
-
-        mock_response = Mock()
-        mock_response.status_code = 400
-        mock_response.text = "Invalid SP Model"
-        mock_response.json.return_value = {'detail': 'Invalid formula'}
-        mock_response.ok = False
-
-        with patch.object(client.session, 'post', return_value=mock_response):
-            with pytest.raises(ValidationError) as exc_info:
-                client.validate({'scenarios': 1, 'steps': 12, 'variables': []})
-            assert "validation" in str(exc_info.value).lower()
-
-    def test_generic_error(self, api_key, base_url):
-        """Test gestion erreur générique (500)."""
-        client = ASTRIA(api_key=api_key, base_url=base_url)
-
-        mock_response = Mock()
-        mock_response.status_code = 500
-        mock_response.text = "Internal server error"
-        mock_response.ok = False
-
-        with patch.object(client.session, 'post', return_value=mock_response):
-            with pytest.raises(SubspaceError) as exc_info:
-                client.simulate({'scenarios': 100, 'steps': 12, 'variables': []})
-            assert "500" in str(exc_info.value)
-
-
-class TestEndpoints:
-    """Tests des endpoints du SDK."""
-
-    def test_project_success(self, api_key, base_url, simple_spec):
-        """Test endpoint project() avec succès."""
-        client = ASTRIA(api_key=api_key, base_url=base_url)
-
-        mock_response = Mock()
-        mock_response.status_code = 200
-        mock_response.ok = True
-        mock_response.json.return_value = {
-            'scenarios': 1,
-            'steps': 12,
-            'final_values': {'capital': 1795.86},
-            'trajectory': {'capital': [1000.0, 1050.0, 1102.5]},
-            'performance': {'execution_time_ms': 0.5}
-        }
-
-        with patch.object(client.session, 'post', return_value=mock_response):
-            result = client.project(simple_spec)
-            assert result['scenarios'] == 1
-            assert 'final_values' in result
-            assert 'trajectory' in result
-
-    def test_simulate_success(self, api_key, base_url, simulation_spec):
-        """Test endpoint simulate() avec succès."""
-        client = ASTRIA(api_key=api_key, base_url=base_url)
-
-        mock_response = Mock()
-        mock_response.status_code = 200
-        mock_response.ok = True
-        mock_response.json.return_value = {
-            'scenarios': 100,
-            'steps': 12,
-            'last_mean': {'capital': 1712.34},
-            'statistics': {
-                'capital': {
-                    'mean': 1712.34,
-                    'median': 1703.55,
-                    'percentiles': {'5': 1650.0, '95': 1780.0}
-                }
-            },
-            'performance': {'execution_time_ms': 12.5}
-        }
-
-        with patch.object(client.session, 'post', return_value=mock_response):
-            result = client.simulate(simulation_spec)
-            assert result['scenarios'] == 100
-            assert 'last_mean' in result
-            assert 'statistics' in result
-
-    def test_project_batch_success(self, api_key, base_url, batch_spec_simple):
-        """Test endpoint project_batch() avec succès."""
-        client = ASTRIA(api_key=api_key, base_url=base_url)
-
-        mock_response = Mock()
-        mock_response.status_code = 200
-        mock_response.ok = True
-        mock_response.json.return_value = {
-            'entities': [
-                {
-                    '_entity_id': 'emp_001',
-                    'final_values': {'capital': 1795.86}
-                },
-                {
-                    '_entity_id': 'emp_002',
-                    'final_values': {'capital': 3591.72}
-                }
-            ],
-            'aggregations': {},
-            'performance': {'execution_time_ms': 25.0}
-        }
-
-        with patch.object(client.session, 'post', return_value=mock_response):
-            result = client.project_batch(
-                template=batch_spec_simple['template'],
-                batch_params=batch_spec_simple['batch_params']
-            )
-            assert len(result['entities']) == 2
-            assert result['entities'][0]['_entity_id'] == 'emp_001'
-
-    def test_validate_success(self, api_key, base_url, simple_spec):
-        """Test endpoint validate() avec succès."""
-        client = ASTRIA(api_key=api_key, base_url=base_url)
-
-        mock_response = Mock()
-        mock_response.status_code = 200
-        mock_response.ok = True
-        mock_response.json.return_value = {
-            'valid': True,
-            'errors': [],
-            'warnings': []
-        }
-
-        with patch.object(client.session, 'post', return_value=mock_response):
-            result = client.validate(simple_spec)
-            assert result['valid'] is True
-            assert len(result['errors']) == 0
-
-    def test_get_examples_success(self, api_key, base_url):
-        """Test endpoint get_examples() avec succès."""
-        client = ASTRIA(api_key=api_key, base_url=base_url)
-
-        mock_response = Mock()
-        mock_response.status_code = 200
-        mock_response.ok = True
-        mock_response.json.return_value = {
-            'examples': [
-                {'name': 'Intérêt Simple', 'spec': {}},
-                {'name': 'Portfolio Simple', 'spec': {}}
-            ]
-        }
-
-        client.session.get = Mock(return_value=mock_response)
-        result = client.get_examples()
-        assert len(result['examples']) == 2
-
-    def test_get_usage_success(self, api_key, base_url):
-        """Test endpoint get_usage() avec succès."""
-        client = ASTRIA(api_key=api_key, base_url=base_url)
-
-        mock_response = Mock()
-        mock_response.status_code = 200
-        mock_response.ok = True
-        mock_response.json.return_value = {
-            'usage': {
-                'simulations_used': 45,
-                'simulations_limit': 50
-            },
-            'plan': {
-                'name': 'Essentials',
-                'max_scenarios_per_request': 1000
-            }
-        }
-
-        with patch.object(client.session, 'get', return_value=mock_response):
-            result = client.get_usage()
-            assert 'usage' in result
-            assert result['usage']['simulations_used'] == 45
-
-    def test_replay_run_success(self, api_key, base_url):
-        """Test endpoint replay_run() avec succès."""
-        client = ASTRIA(api_key=api_key, base_url=base_url)
-
-        mock_response = Mock()
-        mock_response.status_code = 200
-        mock_response.ok = True
-        mock_response.json.return_value = {
-            'scenarios': 1,
-            'steps': 6,
-            'final_values': [{'capital': 1298.39, 'taux': 0.053}],
-            'last_mean': {'capital': 1298.39, 'taux': 0.053},
-            'statistics': {'capital': {'mean': 1298.39}},
-            'performance': {'execution_time_ms': 15.2},
-            'run_id': 'run-123'
-        }
-
-        with patch.object(client.session, 'post', return_value=mock_response):
-            result = client.replay_run(run_id='run-123', scenario_id=2)
-            assert result['scenarios'] == 1
-            assert result['steps'] == 6
-            assert 'final_values' in result
-            assert result['run_id'] == 'run-123'
-
-
-class TestBatchParameters:
-    """Tests de gestion des paramètres batch."""
-
-    def test_project_batch_with_aggregations(self, api_key, base_url):
-        """Test project_batch() avec agrégations."""
-        client = ASTRIA(api_key=api_key, base_url=base_url)
-
-        template = {
-            'scenarios': 1,
-            'steps': 12,
-            'variables': [
-                {'name': 'capital', 'init': 'batch_params.initial', 'formula': 'capital[t-1] * 1.05'}
-            ]
-        }
-        batch_params = [
-            {'entity_id': 'emp_001', 'initial': 1000},
-            {'entity_id': 'emp_002', 'initial': 2000}
-        ]
-        aggregations = [
-            {'name': 'capital_total', 'formula': 'sum(capital[t_final])'}
-        ]
-
-        mock_response = Mock()
-        mock_response.status_code = 200
-        mock_response.ok = True
-        mock_response.json.return_value = {
-            'entities': [],
-            'aggregations': {'capital_total': 3000.0}
-        }
-
-        with patch.object(client.session, 'post', return_value=mock_response) as mock_post:
-            result = client.project_batch(
-                template=template,
-                batch_params=batch_params,
-                aggregations=aggregations
-            )
-            
-            # Vérifier que les agrégations sont bien envoyées
-            call_args = mock_post.call_args
-            assert 'aggregations' in call_args[1]['json']
-            assert result['aggregations']['capital_total'] == 3000.0
-
-
-class TestRateLimitQuotaInfo:
-    """Tests for get_rate_limit_info and get_quota_info with _safe_int."""
-
-    def test_get_rate_limit_info_unlimited(self, api_key, base_url):
-        """get_rate_limit_info handles 'unlimited' without crashing."""
-        client = ASTRIA(api_key=api_key, base_url=base_url)
-        mock_response = Mock()
-        mock_response.headers = {"X-RateLimit-Limit": "unlimited", "X-RateLimit-Remaining": "999"}
-        client.last_response = mock_response
-
-        result = client.get_rate_limit_info()
-        assert result["limit"] is None
-        assert result["remaining"] == 999
-
-    def test_get_quota_info_unlimited(self, api_key, base_url):
-        """get_quota_info handles 'unlimited' in X-Quota-Limit."""
-        client = ASTRIA(api_key=api_key, base_url=base_url)
-        mock_response = Mock()
-        mock_response.headers = {
-            "X-Quota-Limit": "unlimited",
-            "X-Quota-Remaining": "100",
-            "X-Quota-Used": "50",
-        }
-        client.last_response = mock_response
-
-        result = client.get_quota_info()
-        assert result["limit"] is None
-        assert result["remaining"] == 100
-        assert result["used"] == 50
-
-    def test_get_quota_info_invalid_values(self, api_key, base_url):
-        """get_quota_info handles non-numeric values gracefully."""
-        client = ASTRIA(api_key=api_key, base_url=base_url)
-        mock_response = Mock()
-        mock_response.headers = {
-            "X-Quota-Limit": "N/A",
-            "X-Quota-Remaining": "remaining",
-            "X-Quota-Used": "50",
-        }
-        client.last_response = mock_response
-
-        result = client.get_quota_info()
-        assert result["limit"] is None
-        assert result["remaining"] is None
-        assert result["used"] == 50
-

subspacecomputing-0.1.4/tests/test_pandas_integration.py

@@ -1,41 +0,0 @@
-"""
-Unit tests for pandas integration utilities.
-"""
-
-import pytest
-
-pandas = pytest.importorskip("pandas")
-
-from subspacecomputing.utils.pandas_integration import batch_response_to_dataframe
-
-
-class TestBatchResponseToDataframe:
-    """Tests for batch_response_to_dataframe."""
-
-    def test_entities_null_does_not_crash(self):
-        """batch_response_to_dataframe handles entities=null without TypeError."""
-        response = {"entities": None, "aggregations": {}, "summary": {}}
-        df = batch_response_to_dataframe(response)
-        assert len(df) == 0
-
-    def test_entities_missing_uses_empty_list(self):
-        """batch_response_to_dataframe handles missing entities key."""
-        response = {"aggregations": {}, "summary": {}}
-        df = batch_response_to_dataframe(response)
-        assert len(df) == 0
-
-    def test_entities_normal(self):
-        """batch_response_to_dataframe converts entities to DataFrame."""
-        response = {
-            "entities": [
-                {"_entity_id": "e1", "final_values": {"capital": 1000, "taux": 0.05}},
-                {"_entity_id": "e2", "final_values": {"capital": 2000, "taux": 0.06}},
-            ],
-            "aggregations": {},
-            "summary": {},
-        }
-        df = batch_response_to_dataframe(response)
-        assert len(df) == 2
-        assert list(df.columns) == ["entity_id", "capital", "taux"]
-        assert df["entity_id"].tolist() == ["e1", "e2"]
-        assert df["capital"].tolist() == [1000, 2000]