prometheus-qengine 1.0.0__tar.gz

prometheus_qengine-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Prometheus Quant Engine
+
+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.

prometheus_qengine-1.0.0/PKG-INFO

@@ -0,0 +1,132 @@
+Metadata-Version: 2.4
+Name: prometheus-qengine
+Version: 1.0.0
+Summary: Official Python SDK for the Prometheus Quant Engine (HPC Monte Carlo)
+Author-email: Prometheus Quant Engineering <dev@prometheusquantengine.com>
+Project-URL: Homepage, https://prometheusquantengine.com
+Project-URL: Documentation, https://prometheusquantengine.com/web-docs
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pandas>=1.3.0
+Dynamic: license-file
+
+# Prometheus Quant Engine: Python SDK
+
+[![PyPI version](https://badge.fury.io/py/prometheus-qengine.svg)](https://badge.fury.io/py/prometheus-qengine)
+[![Python Versions](https://img.shields.io/pypi/pyversions/prometheus-qengine.svg)](https://pypi.org/project/prometheus-qengine/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+
+**Prometheus Quant Engine** is an institutional-grade, High-Performance Computing (HPC) API for pricing path-dependent and exotic derivatives. 
+
+This SDK abstracts the complexity of our underlying C++ OpenMP infrastructure, allowing quantitative developers to offload massive stochastic matrices (up to 1,000,000,000 trajectories) directly from Python, completely bypassing the Global Interpreter Lock (GIL) and native memory bottlenecks.
+
+## 🚀 Key Architectural Features
+
+* **Strict Mathematical Validation:** Built on top of `Pydantic V2`. The SDK catches logical errors (e.g., negative time, invalid barrier boundaries) locally before wasting network latency or compute credits.
+* **Deterministic Idempotency:** Built-in Double-Spend protection. If a network partition occurs, retrying the exact same request with the same `Idempotency-Key` yields the cached mathematical matrix at strictly zero cost.
+* **Asynchronous Polling Abstraction:** Massive workloads ($N \times M > 50\text{M}$ steps) are seamlessly routed to our Celery HPC cluster. The SDK abstracts the long-polling lifecycle—you just call `.price()` and receive the finalized DataFrame.
+* **Pandas Native:** Seamless integration with `pandas` for immediate volatility surface plotting and quantitative analysis.
+
+## 📦 Installation
+
+```bash
+pip install prometheus-qengine
+```
+
+## 🔑 Authentication & Free Compute Ledger
+
+To execute simulations, you need a Master API Key.
+Register at [prometheusquantengine.com](https://prometheusquantengine.com) to instantly receive **50 Free Compute Credits** (equivalent to 12.5 Billion stochastic path evolutions).
+
+## 💻 Quickstart: European Options
+
+European options are evaluated via highly optimized Control Variates to tighten the Confidence Interval (CI) in record time.
+
+```python
+from prometheus_qengine import PrometheusClient, EuropeanOption, OptionType
+
+# 1. Initialize the client
+client = PrometheusClient(api_key="pmt_live_your_secure_api_key")
+
+# 2. Define the exact quantitative parameters
+option = EuropeanOption(
+    s_0=100.0,
+    strike=100.0,
+    volatility=0.20,
+    time_to_maturity=1.0,
+    risk_free_rate=0.05,
+    option_type=OptionType.CALL,
+    n_simulations=10_000_000,
+    label="Quickstart_European_Call"
+)
+
+# 3. Dispatch to the C++ Engine
+result = client.price(option)
+
+# 4. Analyze the output natively in Pandas
+df = result.to_pandas()
+print(df[["fair_value", "delta", "gamma", "vega", "credits_cost"]])
+```
+
+## ⚡ Heavy Workloads: Barrier Options (HPC Routing)
+
+When pricing complex path-dependent instruments with step-function discontinuities (like Knock-Out barriers), dense trajectory matrices are required to stabilize the Gamma ($\Gamma$).
+
+If your configuration exceeds 50 million total computational steps, the SDK automatically routes the payload to the asynchronous Celery broker and handles the polling loop silently.
+
+```python
+from prometheus_qengine import PrometheusClient, BarrierOption, OptionType, BarrierType
+
+client = PrometheusClient(api_key="pmt_live_your_secure_api_key")
+
+heavy_barrier = BarrierOption(
+    s_0=100.0,
+    strike=100.0,
+    volatility=0.25,
+    time_to_maturity=1.0,
+    risk_free_rate=0.05,
+    option_type=OptionType.PUT,
+    n_simulations=1_000_000,       # 1 Million Paths
+    m_steps=252,                   # Daily observations
+    barrier_type=BarrierType.DOWN_AND_OUT,
+    barrier_level=85.0
+)
+
+# The SDK detects 252,000,000 total steps.
+# It delegates the matrix to the C++ cluster and waits for the resolution.
+result = client.price(heavy_barrier)
+
+print(f"Fair Value computed: {result.fair_value}")
+print(f"Confidence Interval: [{result.ci_lower}, {result.ci_upper}]")
+```
+
+## 🛡️ Error Handling & Limits
+
+The SDK translates HTTP status codes into strict Pythonic exceptions:
+
+```python
+from prometheus_qengine.exceptions import InsufficientCreditsError, AuthenticationError
+
+try:
+    result = client.price(option)
+except InsufficientCreditsError as e:
+    print("Ledger depleted. Recharge required.")
+except AuthenticationError as e:
+    print("Invalid API Key.")
+```
+
+## 📚 Documentation & Research
+
+For in-depth mathematical proofs regarding our Finite Difference implementations, False Sharing mitigation in OpenMP, and structural REST API architecture, visit our [Papers](https://prometheusquantengine.com/papers) and [Api-docs](https://prometheusquantengine.com/web-docs).
+
+## 📄 License
+
+This SDK is distributed under the MIT License. See [`LICENSE`](https://github.com/Prometheus-Quant-Engineering/prometheus-quant-python/blob/main/LICENSE) for more information.

prometheus_qengine-1.0.0/README.md

@@ -0,0 +1,112 @@
+# Prometheus Quant Engine: Python SDK
+
+[![PyPI version](https://badge.fury.io/py/prometheus-qengine.svg)](https://badge.fury.io/py/prometheus-qengine)
+[![Python Versions](https://img.shields.io/pypi/pyversions/prometheus-qengine.svg)](https://pypi.org/project/prometheus-qengine/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+
+**Prometheus Quant Engine** is an institutional-grade, High-Performance Computing (HPC) API for pricing path-dependent and exotic derivatives. 
+
+This SDK abstracts the complexity of our underlying C++ OpenMP infrastructure, allowing quantitative developers to offload massive stochastic matrices (up to 1,000,000,000 trajectories) directly from Python, completely bypassing the Global Interpreter Lock (GIL) and native memory bottlenecks.
+
+## 🚀 Key Architectural Features
+
+* **Strict Mathematical Validation:** Built on top of `Pydantic V2`. The SDK catches logical errors (e.g., negative time, invalid barrier boundaries) locally before wasting network latency or compute credits.
+* **Deterministic Idempotency:** Built-in Double-Spend protection. If a network partition occurs, retrying the exact same request with the same `Idempotency-Key` yields the cached mathematical matrix at strictly zero cost.
+* **Asynchronous Polling Abstraction:** Massive workloads ($N \times M > 50\text{M}$ steps) are seamlessly routed to our Celery HPC cluster. The SDK abstracts the long-polling lifecycle—you just call `.price()` and receive the finalized DataFrame.
+* **Pandas Native:** Seamless integration with `pandas` for immediate volatility surface plotting and quantitative analysis.
+
+## 📦 Installation
+
+```bash
+pip install prometheus-qengine
+```
+
+## 🔑 Authentication & Free Compute Ledger
+
+To execute simulations, you need a Master API Key.
+Register at [prometheusquantengine.com](https://prometheusquantengine.com) to instantly receive **50 Free Compute Credits** (equivalent to 12.5 Billion stochastic path evolutions).
+
+## 💻 Quickstart: European Options
+
+European options are evaluated via highly optimized Control Variates to tighten the Confidence Interval (CI) in record time.
+
+```python
+from prometheus_qengine import PrometheusClient, EuropeanOption, OptionType
+
+# 1. Initialize the client
+client = PrometheusClient(api_key="pmt_live_your_secure_api_key")
+
+# 2. Define the exact quantitative parameters
+option = EuropeanOption(
+    s_0=100.0,
+    strike=100.0,
+    volatility=0.20,
+    time_to_maturity=1.0,
+    risk_free_rate=0.05,
+    option_type=OptionType.CALL,
+    n_simulations=10_000_000,
+    label="Quickstart_European_Call"
+)
+
+# 3. Dispatch to the C++ Engine
+result = client.price(option)
+
+# 4. Analyze the output natively in Pandas
+df = result.to_pandas()
+print(df[["fair_value", "delta", "gamma", "vega", "credits_cost"]])
+```
+
+## ⚡ Heavy Workloads: Barrier Options (HPC Routing)
+
+When pricing complex path-dependent instruments with step-function discontinuities (like Knock-Out barriers), dense trajectory matrices are required to stabilize the Gamma ($\Gamma$).
+
+If your configuration exceeds 50 million total computational steps, the SDK automatically routes the payload to the asynchronous Celery broker and handles the polling loop silently.
+
+```python
+from prometheus_qengine import PrometheusClient, BarrierOption, OptionType, BarrierType
+
+client = PrometheusClient(api_key="pmt_live_your_secure_api_key")
+
+heavy_barrier = BarrierOption(
+    s_0=100.0,
+    strike=100.0,
+    volatility=0.25,
+    time_to_maturity=1.0,
+    risk_free_rate=0.05,
+    option_type=OptionType.PUT,
+    n_simulations=1_000_000,       # 1 Million Paths
+    m_steps=252,                   # Daily observations
+    barrier_type=BarrierType.DOWN_AND_OUT,
+    barrier_level=85.0
+)
+
+# The SDK detects 252,000,000 total steps.
+# It delegates the matrix to the C++ cluster and waits for the resolution.
+result = client.price(heavy_barrier)
+
+print(f"Fair Value computed: {result.fair_value}")
+print(f"Confidence Interval: [{result.ci_lower}, {result.ci_upper}]")
+```
+
+## 🛡️ Error Handling & Limits
+
+The SDK translates HTTP status codes into strict Pythonic exceptions:
+
+```python
+from prometheus_qengine.exceptions import InsufficientCreditsError, AuthenticationError
+
+try:
+    result = client.price(option)
+except InsufficientCreditsError as e:
+    print("Ledger depleted. Recharge required.")
+except AuthenticationError as e:
+    print("Invalid API Key.")
+```
+
+## 📚 Documentation & Research
+
+For in-depth mathematical proofs regarding our Finite Difference implementations, False Sharing mitigation in OpenMP, and structural REST API architecture, visit our [Papers](https://prometheusquantengine.com/papers) and [Api-docs](https://prometheusquantengine.com/web-docs).
+
+## 📄 License
+
+This SDK is distributed under the MIT License. See [`LICENSE`](https://github.com/Prometheus-Quant-Engineering/prometheus-quant-python/blob/main/LICENSE) for more information.

prometheus_qengine-1.0.0/prometheus_qengine/client.py

@@ -0,0 +1,84 @@
+import requests
+import uuid
+import time
+import logging
+from typing import Union
+
+from .models import EuropeanOption, AsianOption, BarrierOption, SimulationResult
+from .exceptions import AuthenticationError, InsufficientCreditsError, EngineComputationError, PrometheusError
+
+logging.basicConfig(format='%(levelname)s: %(message)s')
+logger = logging.getLogger(__name__)
+
+class PrometheusClient:
+    def __init__(self, api_key: str, base_url: str = "https://api.prometheusquantengine.com/api/v1"):
+        if not api_key:
+            raise AuthenticationError("API Key is required to instantiate the Prometheus Client.")
+        
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self._session = requests.Session()
+        self._session.headers.update({"X-API-Key": self.api_key})
+
+    def price(
+        self, 
+        option: Union[EuropeanOption, AsianOption, BarrierOption], 
+        idempotency_key: str = None,
+        poll_interval: int = 2
+    ) -> SimulationResult:
+        """
+        Submits the mathematical payload to the C++ Engine. 
+        Automatically handles synchronous routing and asynchronous HPC polling.
+        """
+        # Auto-generate idempotency protection if not explicitly provided
+        idem_key = idempotency_key or str(uuid.uuid4())
+        
+        headers = {
+            "Idempotency-Key": idem_key,
+            "Content-Type": "application/json"
+        }
+        
+        url = f"{self.base_url}/simulations"
+        payload = option.model_dump(mode='json', exclude_none=True)
+        
+        response = self._session.post(url, json=payload, headers=headers)
+        
+        self._handle_http_errors(response)
+        data = response.json()
+        
+        # 1. Asynchronous HPC Offload Detected
+        if "task_id" in data:
+            task_id = data["task_id"]
+            logger.info(f"Massive workload detected. Delegated to Celery HPC. Task ID: {task_id}")
+            return self._poll_hpc_cluster(task_id, poll_interval)
+            
+        # 2. Synchronous Execution
+        return SimulationResult(**data)
+
+    def _poll_hpc_cluster(self, task_id: str, poll_interval: int) -> SimulationResult:
+        """Internal method to abstract the long-polling architecture from the developer."""
+        url = f"{self.base_url}/simulations/task/{task_id}"
+        
+        while True:
+            response = self._session.get(url)
+            self._handle_http_errors(response)
+            data = response.json()
+            status = data.get("status")
+            
+            if status == "SUCCESS":
+                return SimulationResult(**data)
+            elif status in ["FAILURE", "REVOKED"]:
+                raise EngineComputationError("C++ Engine collapsed during execution. Credits refunded.")
+                
+            time.sleep(poll_interval)
+
+    def _handle_http_errors(self, response: requests.Response):
+        """Translates REST errors into Pythonic Exceptions."""
+        if response.status_code >= 400:
+            if response.status_code == 401:
+                raise AuthenticationError("Invalid API Key.")
+            elif response.status_code == 402:
+                raise InsufficientCreditsError("Insufficient Compute Credits. Please recharge your ledger.")
+            else:
+                error_msg = response.json().get("detail", response.text)
+                raise PrometheusError(f"HTTP {response.status_code}: {error_msg}")

prometheus_qengine-1.0.0/prometheus_qengine/enums.py

@@ -0,0 +1,16 @@
+from enum import Enum
+
+class OptionType(str, Enum):
+    CALL = "Call"
+    PUT = "Put"
+
+class BarrierType(str, Enum):
+    DOWN_AND_OUT = "DownAndOut"
+    DOWN_AND_IN = "DownAndIn"
+    UP_AND_OUT = "UpAndOut"
+    UP_AND_IN = "UpAndIn"
+
+class SimulationType(str, Enum):
+    EUROPEAN = "European"
+    ASIAN = "Asian"
+    BARRIER = "Barrier"

prometheus_qengine-1.0.0/prometheus_qengine/exceptions.py

@@ -0,0 +1,15 @@
+class PrometheusError(Exception):
+    """Base exception for Prometheus SDK."""
+    pass
+
+class AuthenticationError(PrometheusError):
+    """Raised when the API Key is invalid or missing."""
+    pass
+
+class InsufficientCreditsError(PrometheusError):
+    """Raised when the account lacks compute credits (HTTP 402)."""
+    pass
+
+class EngineComputationError(PrometheusError):
+    """Raised when the C++ engine fails to compute the matrix."""
+    pass

prometheus_qengine-1.0.0/prometheus_qengine/init.py

@@ -0,0 +1,16 @@
+from .client import PrometheusClient
+from .models import EuropeanOption, AsianOption, BarrierOption, SimulationResult
+from .enums import OptionType, BarrierType
+from .exceptions import PrometheusError, InsufficientCreditsError
+
+__all__ = [
+    "PrometheusClient",
+    "EuropeanOption",
+    "AsianOption", 
+    "BarrierOption",
+    "SimulationResult",
+    "OptionType",
+    "BarrierType",
+    "PrometheusError",
+    "InsufficientCreditsError"
+]

prometheus_qengine-1.0.0/prometheus_qengine/models.py

@@ -0,0 +1,63 @@
+from pydantic import BaseModel, Field, model_validator
+from typing import Optional, Literal
+from .enums import OptionType, BarrierType, SimulationType
+import pandas as pd
+
+class BaseSimulationPayload(BaseModel):
+    s_0: float = Field(..., gt=0.0, description="Initial Asset Price (Spot)")
+    strike: float = Field(..., gt=0.0, description="Strike Price")
+    volatility: float = Field(..., gt=0.0, le=5.0, description="Annualized Volatility")
+    time_to_maturity: float = Field(..., gt=0.0, description="Time to maturity in years")
+    risk_free_rate: float = Field(..., description="Annualized Risk-Free Rate")
+    option_type: OptionType
+    n_simulations: int = Field(..., ge=10000, le=1000000000)
+    label: Optional[str] = None
+    
+    simulation_type: SimulationType 
+
+class EuropeanOption(BaseSimulationPayload):
+    simulation_type: Literal[SimulationType.EUROPEAN] = SimulationType.EUROPEAN
+
+class AsianOption(BaseSimulationPayload):
+    simulation_type: Literal[SimulationType.ASIAN] = SimulationType.ASIAN
+    m_steps: int = Field(..., gt=0, description="Number of temporal observation steps")
+
+class BarrierOption(BaseSimulationPayload):
+    simulation_type: Literal[SimulationType.BARRIER] = SimulationType.BARRIER
+    m_steps: int = Field(..., gt=0)
+    barrier_type: BarrierType
+    barrier_level: float = Field(..., gt=0.0)
+
+    @model_validator(mode='after')
+    def validate_barrier_logic(self):
+        """Mathematically validates that the barrier makes logical sense before computing."""
+        if self.barrier_type in [BarrierType.DOWN_AND_OUT, BarrierType.DOWN_AND_IN]:
+            if self.barrier_level >= self.s_0:
+                raise ValueError("For Down barriers, barrier_level must be strictly below s_0.")
+        elif self.barrier_type in [BarrierType.UP_AND_OUT, BarrierType.UP_AND_IN]:
+            if self.barrier_level <= self.s_0:
+                raise ValueError("For Up barriers, barrier_level must be strictly above s_0.")
+        return self
+
+class SimulationResult(BaseModel):
+    id: str
+    user_id: str
+    simulation_type: str
+    credits_cost: float
+    created_at: str
+    label: Optional[str] = None
+    fair_value: float
+    ci_lower: float
+    ci_upper: float
+    delta: Optional[float] = None
+    gamma: Optional[float] = None
+    vega: Optional[float] = None
+    rho: Optional[float] = None
+    is_gamma_stable: Optional[bool] = None
+
+    def to_pandas(self) -> pd.DataFrame:
+        """Transforms the payload into a clean Pandas DataFrame for quant analysis."""
+        df = pd.DataFrame([self.model_dump()])
+        # Optional: Set 'id' as index for cleaner display
+        df.set_index('id', inplace=True)
+        return df

prometheus_qengine-1.0.0/prometheus_qengine.egg-info/PKG-INFO

@@ -0,0 +1,132 @@
+Metadata-Version: 2.4
+Name: prometheus-qengine
+Version: 1.0.0
+Summary: Official Python SDK for the Prometheus Quant Engine (HPC Monte Carlo)
+Author-email: Prometheus Quant Engineering <dev@prometheusquantengine.com>
+Project-URL: Homepage, https://prometheusquantengine.com
+Project-URL: Documentation, https://prometheusquantengine.com/web-docs
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pandas>=1.3.0
+Dynamic: license-file
+
+# Prometheus Quant Engine: Python SDK
+
+[![PyPI version](https://badge.fury.io/py/prometheus-qengine.svg)](https://badge.fury.io/py/prometheus-qengine)
+[![Python Versions](https://img.shields.io/pypi/pyversions/prometheus-qengine.svg)](https://pypi.org/project/prometheus-qengine/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+
+**Prometheus Quant Engine** is an institutional-grade, High-Performance Computing (HPC) API for pricing path-dependent and exotic derivatives. 
+
+This SDK abstracts the complexity of our underlying C++ OpenMP infrastructure, allowing quantitative developers to offload massive stochastic matrices (up to 1,000,000,000 trajectories) directly from Python, completely bypassing the Global Interpreter Lock (GIL) and native memory bottlenecks.
+
+## 🚀 Key Architectural Features
+
+* **Strict Mathematical Validation:** Built on top of `Pydantic V2`. The SDK catches logical errors (e.g., negative time, invalid barrier boundaries) locally before wasting network latency or compute credits.
+* **Deterministic Idempotency:** Built-in Double-Spend protection. If a network partition occurs, retrying the exact same request with the same `Idempotency-Key` yields the cached mathematical matrix at strictly zero cost.
+* **Asynchronous Polling Abstraction:** Massive workloads ($N \times M > 50\text{M}$ steps) are seamlessly routed to our Celery HPC cluster. The SDK abstracts the long-polling lifecycle—you just call `.price()` and receive the finalized DataFrame.
+* **Pandas Native:** Seamless integration with `pandas` for immediate volatility surface plotting and quantitative analysis.
+
+## 📦 Installation
+
+```bash
+pip install prometheus-qengine
+```
+
+## 🔑 Authentication & Free Compute Ledger
+
+To execute simulations, you need a Master API Key.
+Register at [prometheusquantengine.com](https://prometheusquantengine.com) to instantly receive **50 Free Compute Credits** (equivalent to 12.5 Billion stochastic path evolutions).
+
+## 💻 Quickstart: European Options
+
+European options are evaluated via highly optimized Control Variates to tighten the Confidence Interval (CI) in record time.
+
+```python
+from prometheus_qengine import PrometheusClient, EuropeanOption, OptionType
+
+# 1. Initialize the client
+client = PrometheusClient(api_key="pmt_live_your_secure_api_key")
+
+# 2. Define the exact quantitative parameters
+option = EuropeanOption(
+    s_0=100.0,
+    strike=100.0,
+    volatility=0.20,
+    time_to_maturity=1.0,
+    risk_free_rate=0.05,
+    option_type=OptionType.CALL,
+    n_simulations=10_000_000,
+    label="Quickstart_European_Call"
+)
+
+# 3. Dispatch to the C++ Engine
+result = client.price(option)
+
+# 4. Analyze the output natively in Pandas
+df = result.to_pandas()
+print(df[["fair_value", "delta", "gamma", "vega", "credits_cost"]])
+```
+
+## ⚡ Heavy Workloads: Barrier Options (HPC Routing)
+
+When pricing complex path-dependent instruments with step-function discontinuities (like Knock-Out barriers), dense trajectory matrices are required to stabilize the Gamma ($\Gamma$).
+
+If your configuration exceeds 50 million total computational steps, the SDK automatically routes the payload to the asynchronous Celery broker and handles the polling loop silently.
+
+```python
+from prometheus_qengine import PrometheusClient, BarrierOption, OptionType, BarrierType
+
+client = PrometheusClient(api_key="pmt_live_your_secure_api_key")
+
+heavy_barrier = BarrierOption(
+    s_0=100.0,
+    strike=100.0,
+    volatility=0.25,
+    time_to_maturity=1.0,
+    risk_free_rate=0.05,
+    option_type=OptionType.PUT,
+    n_simulations=1_000_000,       # 1 Million Paths
+    m_steps=252,                   # Daily observations
+    barrier_type=BarrierType.DOWN_AND_OUT,
+    barrier_level=85.0
+)
+
+# The SDK detects 252,000,000 total steps.
+# It delegates the matrix to the C++ cluster and waits for the resolution.
+result = client.price(heavy_barrier)
+
+print(f"Fair Value computed: {result.fair_value}")
+print(f"Confidence Interval: [{result.ci_lower}, {result.ci_upper}]")
+```
+
+## 🛡️ Error Handling & Limits
+
+The SDK translates HTTP status codes into strict Pythonic exceptions:
+
+```python
+from prometheus_qengine.exceptions import InsufficientCreditsError, AuthenticationError
+
+try:
+    result = client.price(option)
+except InsufficientCreditsError as e:
+    print("Ledger depleted. Recharge required.")
+except AuthenticationError as e:
+    print("Invalid API Key.")
+```
+
+## 📚 Documentation & Research
+
+For in-depth mathematical proofs regarding our Finite Difference implementations, False Sharing mitigation in OpenMP, and structural REST API architecture, visit our [Papers](https://prometheusquantengine.com/papers) and [Api-docs](https://prometheusquantengine.com/web-docs).
+
+## 📄 License
+
+This SDK is distributed under the MIT License. See [`LICENSE`](https://github.com/Prometheus-Quant-Engineering/prometheus-quant-python/blob/main/LICENSE) for more information.

prometheus_qengine-1.0.0/prometheus_qengine.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+prometheus_qengine/client.py
+prometheus_qengine/enums.py
+prometheus_qengine/exceptions.py
+prometheus_qengine/init.py
+prometheus_qengine/models.py
+prometheus_qengine.egg-info/PKG-INFO
+prometheus_qengine.egg-info/SOURCES.txt
+prometheus_qengine.egg-info/dependency_links.txt
+prometheus_qengine.egg-info/requires.txt
+prometheus_qengine.egg-info/top_level.txt

prometheus_qengine-1.0.0/prometheus_qengine.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

prometheus_qengine-1.0.0/prometheus_qengine.egg-info/requires.txt

@@ -0,0 +1,3 @@
+requests>=2.25.0
+pydantic>=2.0.0
+pandas>=1.3.0

prometheus_qengine-1.0.0/prometheus_qengine.egg-info/top_level.txt

@@ -0,0 +1 @@
+prometheus_qengine

prometheus_qengine-1.0.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "prometheus-qengine"
+version = "1.0.0"
+authors = [
+  { name="Prometheus Quant Engineering", email="dev@prometheusquantengine.com" },
+]
+description = "Official Python SDK for the Prometheus Quant Engine (HPC Monte Carlo)"
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Intended Audience :: Financial and Insurance Industry",
+    "Topic :: Scientific/Engineering :: Mathematics",
+]
+dependencies = [
+    "requests>=2.25.0",
+    "pydantic>=2.0.0",
+    "pandas>=1.3.0"
+]
+
+[project.urls]
+"Homepage" = "https://prometheusquantengine.com"
+"Documentation" = "https://prometheusquantengine.com/web-docs"

prometheus_qengine-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+