subspacecomputing 0.1.0__py3-none-any.whl

subspacecomputing/__init__.py

@@ -0,0 +1,24 @@
+"""
+Subspace Computing Engine - Python SDK
+
+Python SDK for the Subspace Computing Engine API (by Beausoft).
+"""
+
+from .client import BSCE
+from .errors import (
+    BSCEError,
+    QuotaExceededError,
+    RateLimitError,
+    AuthenticationError,
+    ValidationError,
+)
+
+__version__ = "0.1.0"
+__all__ = [
+    "BSCE",
+    "BSCEError",
+    "QuotaExceededError",
+    "RateLimitError",
+    "AuthenticationError",
+    "ValidationError",
+]

subspacecomputing/client.py

@@ -0,0 +1,485 @@
+"""
+Python client for Subspace Computing Engine API.
+
+This module provides a simple Python interface to interact with the Subspace Computing API.
+"""
+
+import requests
+from typing import Dict, Any, Optional, List
+from .errors import (
+    BSCEError,
+    QuotaExceededError,
+    RateLimitError,
+    AuthenticationError,
+    ValidationError,
+)
+
+# Default timeout for HTTP requests (seconds)
+DEFAULT_TIMEOUT = 60
+
+
+class BSCE:
+    """Python client for Subspace Computing Engine API."""
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: Optional[str] = None,
+        timeout: Optional[int] = None,
+    ):
+        """
+        Initialize the BSCE client.
+
+        Args:
+            api_key: Your API key (format: be_live_... or sk_pro_...).
+                     Get one at https://subspacecomputing.com or via the portal.
+            base_url: API base URL (optional, defaults to https://api.subspacecomputing.com).
+                     Only useful for local testing or custom environments.
+            timeout: Request timeout in seconds (optional, defaults to 60).
+
+        Raises:
+            ValueError: If api_key is empty or None.
+        """
+        if not api_key or not str(api_key).strip():
+            raise ValueError(
+                "API key is required. Get one at https://subspacecomputing.com or via the portal."
+            )
+        self.api_key = api_key.strip()
+        self.base_url = (base_url or "https://api.subspacecomputing.com").rstrip("/")
+        self.timeout = timeout if timeout is not None else DEFAULT_TIMEOUT
+        self.session = requests.Session()
+        self.session.headers.update({
+            "X-API-Key": self.api_key,
+            "Content-Type": "application/json",
+        })
+        self.last_response = None  # Store last response for header access
+
+    def _handle_response(self, response: requests.Response):
+        """
+        Handle HTTP errors and raise appropriate exceptions.
+
+        Args:
+            response: requests Response object
+
+        Raises:
+            RateLimitError: If rate limit exceeded (429)
+            QuotaExceededError: If monthly quota exceeded (429)
+            AuthenticationError: If API key invalid (401)
+            ValidationError: If validation error (400)
+            BSCEError: For other errors
+        """
+        if response.status_code == 429:
+            # Check if it's rate limit or quota
+            error_text = response.text.lower()
+            if "rate limit" in error_text or "retry-after" in response.headers:
+                raise RateLimitError("Rate limit exceeded", response)
+            else:
+                raise QuotaExceededError("Monthly quota exceeded", response)
+        elif response.status_code == 401:
+            raise AuthenticationError(
+                "Invalid or missing API key. Get one at https://subspacecomputing.com",
+                response,
+            )
+        elif response.status_code == 403:
+            raise BSCEError("Access denied", response)
+        elif response.status_code == 400:
+            raise ValidationError("Validation error", response)
+        elif not response.ok:
+            raise BSCEError(f"API error: {response.status_code}", response)
+
+    # Main endpoints (calculations)
+
+    def project(self, spec: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Run a single projection (1 scenario).
+
+        Args:
+            spec: SP Model (must have scenarios=1)
+
+        Returns:
+            Response with trajectory and final_values
+
+        Raises:
+            ValidationError: If spec is invalid
+            QuotaExceededError: If quota exceeded
+            RateLimitError: If rate limit exceeded
+        """
+        response = self.session.post(
+            f"{self.base_url}/project", json=spec, timeout=self.timeout
+        )
+        self.last_response = response
+        self._handle_response(response)
+        return response.json()
+
+    def simulate(self, spec: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Run a Monte Carlo simulation (multiple scenarios).
+
+        Args:
+            spec: SP Model with scenarios >= 1
+
+        Returns:
+            Response with statistics, final_values, sample_path_s0
+
+        Raises:
+            ValidationError: If spec is invalid
+            QuotaExceededError: If quota exceeded
+            RateLimitError: If rate limit exceeded
+        """
+        response = self.session.post(
+            f"{self.base_url}/simulate", json=spec, timeout=self.timeout
+        )
+        self.last_response = response
+        self._handle_response(response)
+        return response.json()
+
+    def replay_scenario(
+        self,
+        original_spec: Dict[str, Any],
+        original_seeds: Dict[str, Any],
+        scenario_id: int,
+    ) -> Dict[str, Any]:
+        """
+        Rejoue un scénario spécifique d'une simulation précédente.
+
+        Args:
+            original_spec: SP Model complet de la simulation initiale
+            original_seeds: Objet seeds de la réponse de simulate() (seeds.global, seeds.scenarios)
+            scenario_id: Index du scénario à rejouer (0 à scenarios-1)
+
+        Returns:
+            Réponse simulate pour ce scénario unique (final_values, sample_path_s0, etc.)
+
+        Example:
+            result = client.simulate(spec)
+            replay = client.replay_scenario(spec, result["seeds"], scenario_id=12)
+        """
+        payload = {
+            "original_spec": original_spec,
+            "original_seeds": original_seeds,
+        }
+        response = self.session.post(
+            f"{self.base_url}/simulate/scenario/{scenario_id}",
+            json=payload,
+            timeout=self.timeout,
+        )
+        self.last_response = response
+        self._handle_response(response)
+        return response.json()
+
+    def project_batch(
+        self,
+        template: Dict[str, Any],
+        batch_params: List[Dict[str, Any]],
+        aggregations: Optional[List[Dict[str, Any]]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Run a batch projection (multiple entities).
+
+        Args:
+            template: SP Model template with batch_params.xxx references
+            batch_params: List of entities with their parameters
+            aggregations: List of global aggregations (optional)
+
+        Returns:
+            Response with entities (results per entity) and aggregations
+
+        Raises:
+            ValidationError: If spec is invalid
+            QuotaExceededError: If quota exceeded
+            RateLimitError: If rate limit exceeded
+        """
+        spec = {
+            "template": template,
+            "batch_params": batch_params,
+        }
+        if aggregations:
+            spec["aggregations"] = aggregations
+
+        response = self.session.post(
+            f"{self.base_url}/project/batch", json=spec, timeout=self.timeout
+        )
+        self.last_response = response
+        self._handle_response(response)
+        return response.json()
+
+    # Utility endpoints
+
+    def validate(self, spec: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Validate an SP Model without executing it.
+
+        Args:
+            spec: SP Model or BatchSpec to validate
+
+        Returns:
+            Response with is_valid, warnings, errors
+
+        Raises:
+            ValidationError: If validation error
+        """
+        response = self.session.post(
+            f"{self.base_url}/validate", json=spec, timeout=self.timeout
+        )
+        self.last_response = response
+        self._handle_response(response)
+        return response.json()
+
+    def get_examples(self) -> Dict[str, Any]:
+        """
+        Get ready-to-use SP Model examples.
+
+        Returns:
+            Response with list of examples
+
+        Note:
+            Public endpoint (no API key required)
+        """
+        response = self.session.get(
+            f"{self.base_url}/examples", timeout=self.timeout
+        )
+        self.last_response = response
+        self._handle_response(response)
+        return response.json()
+
+    def get_usage(self) -> Dict[str, Any]:
+        """
+        Get user usage and quotas.
+
+        Returns:
+            Response with usage, quotas, plan info
+        """
+        response = self.session.get(
+            f"{self.base_url}/usage", timeout=self.timeout
+        )
+        self.last_response = response
+        self._handle_response(response)
+        return response.json()
+
+    def get_plans(self) -> Dict[str, Any]:
+        """
+        Get list of available plans.
+
+        Returns:
+            Response with list of plans
+
+        Note:
+            Public endpoint (no API key required)
+        """
+        response = self.session.get(
+            f"{self.base_url}/plans", timeout=self.timeout
+        )
+        self.last_response = response
+        self._handle_response(response)
+        return response.json()
+
+    # CRUD endpoints (projections)
+
+    def list_projections(
+        self,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        """
+        List saved projections.
+
+        Args:
+            limit: Maximum number of results (optional)
+            offset: Offset for pagination (optional)
+
+        Returns:
+            Response with list of projections
+        """
+        params = {}
+        if limit is not None:
+            params["limit"] = limit
+        if offset is not None:
+            params["offset"] = offset
+
+        response = self.session.get(
+            f"{self.base_url}/projections",
+            params=params,
+            timeout=self.timeout,
+        )
+        self.last_response = response
+        self._handle_response(response)
+        return response.json()
+
+    def get_projection(self, projection_id: str) -> Dict[str, Any]:
+        """
+        Get a projection by ID.
+
+        Args:
+            projection_id: Projection ID
+
+        Returns:
+            Response with projection details
+        """
+        response = self.session.get(
+            f"{self.base_url}/projections/{projection_id}",
+            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.
+
+        Args:
+            projection_id: Projection ID
+
+        Raises:
+            BSCEError: If error during deletion
+        """
+        response = self.session.delete(
+            f"{self.base_url}/projections/{projection_id}",
+            timeout=self.timeout,
+        )
+        self.last_response = response
+        self._handle_response(response)
+        # 204 No Content, no body
+
+    # CRUD endpoints (runs)
+
+    def list_runs(
+        self,
+        projection_id: Optional[str] = None,
+        parent_batch_run_id: Optional[str] = None,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        """
+        List saved runs.
+
+        Args:
+            projection_id: Filter by projection_id (optional)
+            parent_batch_run_id: Filter by parent batch run (optional)
+            limit: Maximum number of results (optional)
+            offset: Offset for pagination (optional)
+
+        Returns:
+            Response with list of runs
+        """
+        params = {}
+        if projection_id:
+            params["projection_id"] = projection_id
+        if parent_batch_run_id:
+            params["parent_batch_run_id"] = parent_batch_run_id
+        if limit is not None:
+            params["limit"] = limit
+        if offset is not None:
+            params["offset"] = offset
+
+        response = self.session.get(
+            f"{self.base_url}/projection-runs",
+            params=params,
+            timeout=self.timeout,
+        )
+        self.last_response = response
+        self._handle_response(response)
+        return response.json()
+
+    def get_run(self, run_id: str) -> Dict[str, Any]:
+        """
+        Get a run by ID.
+
+        Args:
+            run_id: Run ID
+
+        Returns:
+            Response with run details
+        """
+        response = self.session.get(
+            f"{self.base_url}/projection-runs/{run_id}",
+            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]:
+        """
+        Rejoue un scénario à partir d'une run stockée (nécessite seeds persistés).
+
+        Args:
+            run_id: ID de la run (créée avec meta.store_seeds_for_replay: true)
+            scenario_id: Index du scénario à rejouer (0 à scenarios-1)
+
+        Returns:
+            Réponse simulate pour ce scénario unique (final_values, sample_path_s0, etc.)
+
+        Raises:
+            ValidationError: Si seeds non stockés ou scenario_id hors limites
+            AuthenticationError: Si clé API invalide
+
+        Example:
+            result = client.simulate(spec)  # avec store_seeds_for_replay: true
+            replay = client.replay_run(result["run_id"], scenario_id=12)
+        """
+        response = self.session.post(
+            f"{self.base_url}/projection-runs/{run_id}/replay/{scenario_id}",
+            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.
+
+        Args:
+            run_id: Run ID
+
+        Raises:
+            BSCEError: If error during deletion
+        """
+        response = self.session.delete(
+            f"{self.base_url}/projection-runs/{run_id}",
+            timeout=self.timeout,
+        )
+        self.last_response = response
+        self._handle_response(response)
+        # 204 No Content, no body
+
+    # Helper methods for accessing rate limit and quota info
+
+    def get_rate_limit_info(self) -> Optional[Dict[str, Any]]:
+        """
+        Get rate limit information from the last response.
+
+        Returns:
+            Dict with 'limit' and 'remaining' keys, or None if no response yet
+        """
+        if not self.last_response:
+            return None
+        limit = self.last_response.headers.get("X-RateLimit-Limit")
+        remaining = self.last_response.headers.get("X-RateLimit-Remaining")
+        if limit is None and remaining is None:
+            return None
+        return {
+            "limit": int(limit) if limit else None,
+            "remaining": int(remaining) if remaining else None,
+        }
+
+    def get_quota_info(self) -> Optional[Dict[str, Any]]:
+        """
+        Get quota information from the last response.
+
+        Returns:
+            Dict with 'limit', 'remaining', and 'used' keys, or None if no response yet
+        """
+        if not self.last_response:
+            return None
+        limit = self.last_response.headers.get("X-Quota-Limit")
+        remaining = self.last_response.headers.get("X-Quota-Remaining")
+        used = self.last_response.headers.get("X-Quota-Used")
+        if limit is None and remaining is None and used is None:
+            return None
+        return {
+            "limit": int(limit) if limit and limit != "unlimited" else None,
+            "remaining": int(remaining) if remaining else None,
+            "used": int(used) if used else None,
+        }

subspacecomputing/errors.py

@@ -0,0 +1,56 @@
+"""
+Custom exceptions for the Subspace Computing SDK.
+"""
+
+import requests
+from typing import Optional
+
+
+class BSCEError(Exception):
+    """Base error for the Subspace Computing SDK."""
+
+    def __init__(self, message: str, response: Optional[requests.Response] = None):
+        self.message = message
+        self.response = response
+        self.status_code = response.status_code if response else None
+        self.detail = None
+
+        # Try to extract error details from the response
+        if response is not None:
+            try:
+                error_data = response.json()
+                if isinstance(error_data, dict):
+                    self.detail = error_data.get("detail", error_data.get("message"))
+            except (ValueError, KeyError):
+                self.detail = response.text
+
+        super().__init__(self.message)
+
+    def __str__(self):
+        if self.detail:
+            return f"{self.message}: {self.detail}"
+        return self.message
+
+
+class QuotaExceededError(BSCEError):
+    """Monthly quota exceeded (429)."""
+
+    pass
+
+
+class RateLimitError(BSCEError):
+    """Rate limit exceeded (429)."""
+
+    pass
+
+
+class AuthenticationError(BSCEError):
+    """Invalid or missing API key (401)."""
+
+    pass
+
+
+class ValidationError(BSCEError):
+    """SP Model validation error (400)."""
+
+    pass

subspacecomputing/utils/__init__.py

@@ -0,0 +1 @@
+"""Utilities for Subspace Computing Engine SDK."""

subspacecomputing/utils/pandas_integration.py

@@ -0,0 +1,23 @@
+"""
+Pandas integration utilities for batch responses.
+
+Requires: pip install pandas
+"""
+
+
+def batch_response_to_dataframe(response: dict):
+    """
+    Convert a project_batch or simulate_batch response to a pandas DataFrame.
+
+    Each entity becomes one row. Columns include entity_id plus all final_values.
+    """
+    import pandas as pd
+
+    rows = []
+    for entity in response.get("entities", []):
+        row = {"entity_id": entity.get("_entity_id", "")}
+        fv = entity.get("final_values", {})
+        for k, v in fv.items():
+            row[k] = v
+        rows.append(row)
+    return pd.DataFrame(rows)

subspacecomputing-0.1.0.dist-info/METADATA

@@ -0,0 +1,258 @@
+Metadata-Version: 2.4
+Name: subspacecomputing
+Version: 0.1.0
+Summary: Python SDK for Subspace Computing Engine API (by Beausoft)
+Home-page: https://www.subspacecomputing.com/developer
+Author: Beausoft
+Author-email: Beausoft <contact@beausoft.ca>
+Project-URL: Documentation, https://www.subspacecomputing.com/developer
+Project-URL: Homepage, https://www.subspacecomputing.com/developer
+Project-URL: Support, https://www.subspacecomputing.com/developer
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.31.0
+Provides-Extra: pandas
+Requires-Dist: pandas>=2.0.0; extra == "pandas"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: fastapi>=0.100.0; extra == "dev"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# Subspace Computing Engine - Python SDK
+
+Python SDK for the Subspace Computing Engine API (by Beausoft).
+
+## Installation
+
+```bash
+pip install subspacecomputing
+```
+
+## Usage
+
+### Initialization
+
+```python
+from subspacecomputing import BSCE
+
+# Initialize the client (defaults to production URL)
+bsce = BSCE(api_key='your-api-key-here')
+
+# For local testing or custom environments (optional)
+# bsce = BSCE(api_key='your-api-key-here', base_url='http://localhost:8000')
+```
+
+### Simple Projection (1 scenario)
+
+```python
+# Create a simple SP Model
+spec = {
+    'scenarios': 1,  # Must be 1 for /project
+    'steps': 12,
+    'variables': [
+        {
+            'name': 'capital',
+            'init': 1000.0,
+            'formula': 'capital[t-1] * 1.05'  # 5% growth per period
+        }
+    ]
+}
+
+# Run the projection
+result = bsce.project(spec)
+
+# Display results
+print(f"Final capital: {result['final_values']['capital']}")
+print(f"Trajectory: {result['trajectory']['capital']}")
+```
+
+### Monte Carlo Simulation (Multiple scenarios)
+
+```python
+# SP Model with random variables
+spec = {
+    'scenarios': 1000,  # 1000 Monte Carlo scenarios
+    'steps': 12,
+    '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)'
+        }
+    ]
+}
+
+# Run the simulation
+result = bsce.simulate(spec)
+
+# Analyze results
+print(f"Mean final capital: {result['last_mean']['capital']}")
+print(f"Median: {result['statistics']['capital']['median']}")
+print(f"P5: {result['statistics']['capital']['percentiles']['5']}")
+print(f"P95: {result['statistics']['capital']['percentiles']['95']}")
+```
+
+### Batch Mode (Multiple Entities)
+
+```python
+# SP Model template
+template = {
+    'scenarios': 1,
+    'steps': '65 - batch_params.age',  # Dynamic steps
+    'variables': [
+        {
+            'name': 'age_actuel',
+            'init': 'batch_params.age'
+        },
+        {
+            'name': 'salaire',
+            'init': 'batch_params.salary',
+            'formula': 'salaire[t-1] * 1.03'  # 3% annual increase
+        },
+        {
+            'name': 'capital_retraite',
+            'init': 0.0,
+            'formula': 'capital_retraite[t-1] * 1.05 + salaire[t] * 0.10'
+        }
+    ]
+}
+
+# Entity data
+batch_params = [
+    {'entity_id': 'emp_001', 'age': 45, 'salary': 60000},
+    {'entity_id': 'emp_002', 'age': 50, 'salary': 80000},
+    {'entity_id': 'emp_003', 'age': 35, 'salary': 50000}
+]
+
+# Global aggregations (optional)
+aggregations = [
+    {
+        'name': 'capital_total',
+        'formula': 'sum(capital_retraite[t_final])'
+    },
+    {
+        'name': 'moyenne_capital',
+        'formula': 'mean(capital_retraite[t_final])'
+    }
+]
+
+# Run batch
+result = bsce.project_batch(
+    template=template,
+    batch_params=batch_params,
+    aggregations=aggregations
+)
+
+# Analyze results
+for entity in result['entities']:
+    print(f"{entity['_entity_id']}: Capital = {entity['final_values']['capital_retraite']}")
+
+print(f"Total capital: {result['aggregations']['capital_total']}")
+print(f"Average: {result['aggregations']['moyenne_capital']}")
+```
+
+### Validation
+
+```python
+# Validate an SP Model before execution
+validation = bsce.validate(spec)
+
+if validation['is_valid']:
+    print("✅ SP Model is valid")
+    if validation.get('warnings'):
+        print(f"⚠️  Warnings: {validation['warnings']}")
+else:
+    print(f"❌ Errors: {validation['errors']}")
+```
+
+### Utilities
+
+```python
+# Get examples
+examples = bsce.get_examples()
+print(f"Available examples: {len(examples['examples'])}")
+
+# Check usage
+usage = bsce.get_usage()
+print(f"Simulations used: {usage['usage']['simulations_used']}/{usage['usage']['simulations_limit']}")
+
+# Get plans
+plans = bsce.get_plans()
+for plan in plans['plans']:
+    print(f"{plan['name']}: ${plan['price_monthly']}/month")
+```
+
+### Error Handling
+
+```python
+from subspacecomputing import (
+    BSCE,
+    QuotaExceededError,
+    RateLimitError,
+    AuthenticationError,
+    ValidationError,
+    BSCEError
+)
+
+try:
+    result = bsce.simulate(spec)
+except QuotaExceededError as e:
+    print(f"Monthly quota exceeded: {e}")
+except RateLimitError as e:
+    print(f"Rate limit exceeded: {e}")
+    print(f"Retry after: {e.response.headers.get('Retry-After')} seconds")
+except AuthenticationError as e:
+    print(f"Invalid API key: {e}")
+except ValidationError as e:
+    print(f"Validation error: {e.detail}")
+except BSCEError as e:
+    print(f"API error: {e}")
+```
+
+### Rate Limit and Quota Information
+
+After making a request, you can check your rate limit and quota status:
+
+```python
+# Make a request
+result = bsce.project(spec)
+
+# Check rate limit info
+rate_limit = bsce.get_rate_limit_info()
+if rate_limit:
+    print(f"Rate limit: {rate_limit['remaining']}/{rate_limit['limit']} remaining")
+
+# Check quota info
+quota = bsce.get_quota_info()
+if quota:
+    print(f"Quota: {quota['used']}/{quota['limit']} used, {quota['remaining']} remaining")
+```
+
+## Documentation
+
+Check out the full documentation at https://www.subspacecomputing.com/developer
+
+API reference is available at https://api.subspacecomputing.com/docs
+
+For support, reach out to contact@beausoft.ca
+
+## License
+
+MIT License. Check the LICENSE file for details.
+
+## Copyright
+
+© 2025 Beausoft Inc. All Rights Reserved

subspacecomputing-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+subspacecomputing/__init__.py,sha256=cyvLCoJH1OXc-UeNdcEEFElhXzYPL-3EJsA438yUkrQ,431
+subspacecomputing/client.py,sha256=kWeb0CVARQYOdwIw-EzLodNncOiCiwDmv0Xm4MstQQ4,15372
+subspacecomputing/errors.py,sha256=NJ0KE1IAYYrXwB-e_zSh4AYP0A8XUNvEDQI2JF7jcSg,1329
+subspacecomputing/utils/__init__.py,sha256=A0fX-wEb8uDR8NktIUvJrmRapo6Chj8W-aXk42cI9DM,51
+subspacecomputing/utils/pandas_integration.py,sha256=3PJapJ34oacAszZFZgiIxfzmT-E3KG3rkRMNOGMgEPg,615
+subspacecomputing-0.1.0.dist-info/licenses/LICENSE,sha256=74YyzYmjEMtAPgWKqqEond9N8WeRZWYNwHjBi4pvoMM,1070
+subspacecomputing-0.1.0.dist-info/METADATA,sha256=ubDNgoN4gAnPmX5pF0iqTlzOXuUIu1PrViMvqlD-iqs,6420
+subspacecomputing-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+subspacecomputing-0.1.0.dist-info/top_level.txt,sha256=GHDzXuS84ahs61dBpllwd_Jv1faPFqPftINXvX8u7Z0,18
+subspacecomputing-0.1.0.dist-info/RECORD,,

subspacecomputing-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

subspacecomputing-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Beausoft 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
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

subspacecomputing-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+subspacecomputing