graviton-sdk 0.1.0__tar.gz

graviton_sdk-0.1.0/.gitignore

@@ -0,0 +1,30 @@
+# Python
+__pycache__/
+.pytest_cache/
+*.pyc
+*.pyo
+*.pyd
+.Python
+env/
+.venv/
+
+# VS Code
+.vscode/
+
+# Build artifacts
+artifacts/
+infra/gcp/.terraform/
+infra/cloudflare/.terraform/
+
+# IDE
+.idea/
+
+# Mock GCS bucket
+.mock_gcs/
+
+# Secrets
+.secrets
+plan.out
+
+# infra state
+infra/gcp/current_state/projects/779429570375/SecretManagerSecret

graviton_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: graviton-sdk
+Version: 0.1.0
+Summary: Python SDK for Graviton Supercompute
+Project-URL: Homepage, https://www.g-qt.com
+Project-URL: Repository, https://github.com/CodeZeroLabs/graviton
+Author-email: CodeZero Labs <aaron@g-qt.com>
+License: MIT
+Requires-Python: >=3.8
+Requires-Dist: ipython
+Requires-Dist: requests
+Requires-Dist: sympy>=1.12
+Description-Content-Type: text/markdown
+
+# Graviton Python SDK
+
+The Graviton SDK provides a seamless way to connect your local mathematical models (built with SymPy) to the Graviton Supercompute platform.
+
+## Installation
+
+```bash
+pip install graviton-sdk
+```
+
+## Quick Start (Jupyter/Colab)
+
+The SDK is designed to work beautifully in interactive environments.
+
+```python
+import sympy as sp
+import graviton as gv
+
+# 1. Authenticate (Use the public evaluation key for prototyping)
+gv.login('a-little-more-art-than-science')
+
+# 2. Define a complex model
+x, y = sp.symbols('x y')
+f = sp.sin(x)**2 + sp.exp(-y) * sp.cos(x)
+
+# 3. Display with the Graviton "Compute" button
+gv.expr(f)
+```
+
+## Programmatic Workflow
+
+For advanced integrations, you can use the flattened API to evaluate and compute programmatically.
+
+```python
+# 1. Evaluate to get JSON data
+eval_data = gv.evaluate(f, options={"type": "JSON"})
+
+# 2. Use flattened access for cost and ID
+cost = eval_data['cost']
+job_id = eval_data['id']
+
+print(f"Estimated Cost: {cost:.2f} credits")
+
+# 3. Compute using the ID directly
+job = gv.compute(job_id, options={"auto_charge": True})
+result = job.wait()
+print(f"Result: {result}")
+```
+
+## How it Works
+
+When you call `gv(formula)`, the SDK:
+1.  Serializes the SymPy object into a structured `srepr` format.
+2.  Generates a rich HTML representation with a LaTeX preview.
+3.  Adds a secure button that opens the Graviton Dashboard with your formula pre-loaded.
+
+This allows you to leverage Graviton's massive cloud compute resources for complexity analysis and evaluation without ever leaving your research environment.
+
+## Security
+
+Graviton follows a "Data, not Code" security model. The SDK only transmits the mathematical structure of your model, not arbitrary Python code. Your local environment remains isolated, and all authentication is handled securely via the Graviton web platform.

graviton_sdk-0.1.0/README.md

@@ -0,0 +1,61 @@
+# Graviton Python SDK
+
+The Graviton SDK provides a seamless way to connect your local mathematical models (built with SymPy) to the Graviton Supercompute platform.
+
+## Installation
+
+```bash
+pip install graviton-sdk
+```
+
+## Quick Start (Jupyter/Colab)
+
+The SDK is designed to work beautifully in interactive environments.
+
+```python
+import sympy as sp
+import graviton as gv
+
+# 1. Authenticate (Use the public evaluation key for prototyping)
+gv.login('a-little-more-art-than-science')
+
+# 2. Define a complex model
+x, y = sp.symbols('x y')
+f = sp.sin(x)**2 + sp.exp(-y) * sp.cos(x)
+
+# 3. Display with the Graviton "Compute" button
+gv.expr(f)
+```
+
+## Programmatic Workflow
+
+For advanced integrations, you can use the flattened API to evaluate and compute programmatically.
+
+```python
+# 1. Evaluate to get JSON data
+eval_data = gv.evaluate(f, options={"type": "JSON"})
+
+# 2. Use flattened access for cost and ID
+cost = eval_data['cost']
+job_id = eval_data['id']
+
+print(f"Estimated Cost: {cost:.2f} credits")
+
+# 3. Compute using the ID directly
+job = gv.compute(job_id, options={"auto_charge": True})
+result = job.wait()
+print(f"Result: {result}")
+```
+
+## How it Works
+
+When you call `gv(formula)`, the SDK:
+1.  Serializes the SymPy object into a structured `srepr` format.
+2.  Generates a rich HTML representation with a LaTeX preview.
+3.  Adds a secure button that opens the Graviton Dashboard with your formula pre-loaded.
+
+This allows you to leverage Graviton's massive cloud compute resources for complexity analysis and evaluation without ever leaving your research environment.
+
+## Security
+
+Graviton follows a "Data, not Code" security model. The SDK only transmits the mathematical structure of your model, not arbitrary Python code. Your local environment remains isolated, and all authentication is handled securely via the Graviton web platform.

graviton_sdk-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "graviton-sdk"
+version = "0.1.0"
+description = "Python SDK for Graviton Supercompute"
+readme = "README.md"
+requires-python = ">=3.8"
+license = {text = "MIT"}
+authors = [
+    {name = "CodeZero Labs", email = "aaron@g-qt.com"},
+]
+dependencies = [
+    "sympy>=1.12",
+    "IPython",
+    "requests",
+]
+
+[project.urls]
+Homepage = "https://www.g-qt.com"
+Repository = "https://github.com/CodeZeroLabs/graviton"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/graviton"]

graviton_sdk-0.1.0/src/graviton/__init__.py

@@ -0,0 +1,134 @@
+import os
+import json
+import requests
+from typing import Optional, Dict, Any
+import sympy as sp
+
+# Internal Constants
+CONFIG_PATH = os.path.expanduser("~/.graviton/config.json")
+
+class GravitonSession:
+    """
+    Manages the authenticated state, API configuration, and user status 
+    for the current SDK session.
+    """
+    _instance = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(GravitonSession, cls).__new__(cls)
+            cls._instance._initialized = False
+        return cls._instance
+
+    def __init__(self):
+        if self._initialized:
+            return
+        self.api_key: Optional[str] = None
+        self.api_url: str = self._detect_api_url()
+        self.user_profile: Optional[Dict[str, Any]] = None
+        self._load_config()
+        self._initialized = True
+
+    def _detect_api_url(self) -> str:
+        if os.environ.get("GRAVITON_API_URL"):
+            return os.environ["GRAVITON_API_URL"].rstrip("/")
+        
+        # Default to production-style URL for consistency.
+        # Inside the Docker swarm, this resolves to the Nginx gateway.
+        # In a host browser, it requires /etc/hosts (optional now with browse_web.py).
+        return "https://api.g-qt.com"
+
+    def _load_config(self):
+        if os.path.exists(CONFIG_PATH):
+            try:
+                with open(CONFIG_PATH, 'r') as f:
+                    config = json.load(f)
+                    self.api_key = config.get("api_key")
+            except Exception:
+                pass
+
+    def save_config(self, api_key: str):
+        self.api_key = api_key
+        os.makedirs(os.path.dirname(CONFIG_PATH), exist_ok=True)
+        with open(CONFIG_PATH, 'w') as f:
+            json.dump({"api_key": api_key}, f)
+
+    def get_dashboard_url(self) -> str:
+        """Returns the correct dashboard URL for the current environment."""
+        # Always use the production URL. Routing is handled by the swarm DNS or host setup.
+        return "https://www.g-qt.com/dashboard.html"
+
+    @property
+    def verify(self) -> bool:
+        """Tolerates self-signed certificates in local dev environment."""
+        return False if os.environ.get("REGION") == "local-dev" else True
+
+    def get_status(self) -> Dict[str, Any]:
+        """Fetches the latest user credits and payment info from Shannon."""
+        if not self.api_key:
+            return {"authenticated": False}
+        
+        try:
+            resp = requests.get(
+                f"{self.api_url}/user",
+                headers={"X-API-KEY": self.api_key},
+                timeout=5,
+                verify=self.verify
+            )
+            if resp.status_code == 200:
+                self.user_profile = resp.json()
+                return {
+                    "authenticated": True,
+                    "credits": self.user_profile.get("credits", 0),
+                    "has_payment_method": bool(self.user_profile.get("payment_methods", {}).get("primary")),
+                    "profile": self.user_profile
+                }
+        except Exception:
+            pass
+        return {"authenticated": False, "error": "Connection failed"}
+
+# Global Session Instance
+session = GravitonSession()
+
+def login(api_key: str):
+    """
+    Authenticates the SDK with your Graviton API Key.
+    """
+    session.save_config(api_key)
+    print("✅ Authenticated with Graviton.")
+
+def evaluate(expr: sp.Expr, options: Optional[dict] = None):
+    """
+    Evaluates a SymPy expression on Graviton.
+    """
+    from .main import gv
+    return gv(expr).evaluate(options=options)
+
+def compute(expr_or_id: Any, options: Optional[Any] = None):
+    """
+    Directly executes a compute job. 
+    Accepts either a SymPy expression or a job_id string.
+    Returns a GravitonJob handle.
+    """
+    from .main import gv, GravitonExpression
+    if isinstance(options, bool):
+        options = {"auto_charge": options}
+    
+    if isinstance(expr_or_id, str):
+        auto_charge = options.get("auto_charge", False) if isinstance(options, dict) else False
+        return GravitonExpression._trigger_compute(expr_or_id, auto_charge=auto_charge)
+        
+    return gv(expr_or_id).compute(options=options)
+
+def status(job_id: str):
+    """Checks the status of a specific job."""
+    from .main import GravitonJob
+    return GravitonJob(job_id).status()
+
+def result(job_id: str):
+    """Wait for and return the result of a specific job."""
+    from .main import GravitonJob
+    return GravitonJob(job_id).result()
+
+# Legacy alias for backward compatibility
+from .main import gv, expr

graviton_sdk-0.1.0/src/graviton/main.py

@@ -0,0 +1,440 @@
+import sympy as sp
+from IPython.display import display, HTML
+import requests
+import uuid
+import time
+import json
+from typing import Optional, Dict, Any
+
+class GravitonJob:
+    """
+    A handle for a Graviton compute job. 
+    Allows for polling status and retrieving results asynchronously.
+    """
+    def __init__(self, job_id: str):
+        self.job_id = job_id
+        self._data = None
+
+    def status(self) -> str:
+        """Checks the current status of the job."""
+        from . import session
+        try:
+            resp = requests.get(
+                f"{session.api_url}/results/{self.job_id}",
+                headers={"X-API-KEY": session.api_key},
+                timeout=5,
+                verify=session.verify
+            )
+            if resp.status_code == 200:
+                self._data = resp.json()
+                return self._data.get("status", "UNKNOWN")
+        except Exception as e:
+            return f"ERROR: {str(e)}"
+        return "UNKNOWN"
+
+    def result(self, block: bool = True, poll_interval: float = 1.0) -> Any:
+        """
+        Retrieves the job result. If block=True, polls until completed.
+        """
+        from . import session
+        
+        if block:
+            while True:
+                s = self.status()
+                if s == "COMPLETED":
+                    break
+                if s in ["FAILED", "CANCELLED", "ERROR"]:
+                    raise RuntimeError(f"Job {self.job_id} failed with status: {s}")
+                time.sleep(poll_interval)
+
+        # Download results
+        try:
+            resp = requests.get(
+                f"{session.api_url}/results/{self.job_id}/download",
+                headers={"X-API-KEY": session.api_key},
+                timeout=10,
+                verify=session.verify
+            )
+            if resp.status_code == 200:
+                # Attempt to parse as JSON if it looks like it
+                try:
+                    return resp.json()
+                except:
+                    return resp.text
+            else:
+                raise RuntimeError(f"Failed to download results: {resp.status_code}")
+        except Exception as e:
+            raise RuntimeError(f"Result retrieval failed: {e}")
+
+    def wait(self, poll_interval: float = 1.0) -> Any:
+        """Alias for result(block=True)."""
+        return self.result(block=True, poll_interval=poll_interval)
+
+class GravitonEvaluation(dict):
+    """
+    A dictionary-like object that wraps the Graviton evaluation response
+    and provides flattened access to common fields like cost and ID.
+    """
+    @property
+    def id(self) -> str:
+        return super().get('id', '')
+
+    @property
+    def cost(self) -> float:
+        return super().get('cost', {}).get('total_credit_cost', 0.0)
+
+    @property
+    def estimated_time(self) -> float:
+        return super().get('estimated_duration_s', 0.1)
+
+    def __getitem__(self, key):
+        # Support flattened access for 'cost' and 'id'
+        if key == 'cost':
+            return self.cost
+        if key == 'id':
+            return self.id
+        return super().__getitem__(key)
+
+    def get(self, key, default=None):
+        if key == 'cost':
+            return self.cost
+        if key == 'id':
+            return self.id
+        return super().get(key, default)
+
+class GravitonExpression:
+    """
+    A wrapper for SymPy expressions that provides interactive evaluation 
+    and compute capabilities within notebooks.
+    """
+    def __init__(self, expr):
+        self.expr = expr
+        self.evaluation_result = None
+        self.error = None
+
+    @property
+    def cost(self) -> float:
+        """Returns the credit cost from the last evaluation."""
+        if not self.evaluation_result:
+            self.evaluate()
+        return self.evaluation_result.get('cost', {}).get('total_credit_cost', 0.0)
+
+    @property
+    def estimated_time(self) -> float:
+        """Returns the estimated duration in seconds from the last evaluation."""
+        if not self.evaluation_result:
+            self.evaluate()
+        return self.evaluation_result.get('estimated_duration_s', 0.1)
+
+    @property
+    def is_affordable(self) -> bool:
+        """Returns True if the user has enough credits for the last evaluation."""
+        from . import session
+        status = session.get_status()
+        return status.get('credits', 0) >= self.cost
+
+    def evaluate(self, options: Optional[dict] = None):
+        """
+        Performs a secure evaluation of the expression on Graviton.
+        """
+        from . import session
+        
+        if not session.api_key:
+            self.error = "Unauthenticated. Please run 'gv.login(key)' first."
+            if options and options.get("type") == "JSON":
+                raise RuntimeError(self.error)
+            return self
+
+        try:
+            srepr_str = sp.srepr(self.expr)
+            response = requests.post(
+                f"{session.api_url}/eval",
+                json={"f": srepr_str},
+                headers={"X-API-KEY": session.api_key},
+                timeout=10,
+                verify=session.verify
+            )
+            
+            if response.status_code in [200, 201]:
+                self.evaluation_result = response.json()
+                self.error = None
+            else:
+                try:
+                    err_data = response.json()
+                    err_msg = err_data.get('error', 'Unknown error')
+                    self.error = f"API Error {response.status_code}: {err_msg}"
+                except:
+                    self.error = f"API Error {response.status_code}"
+        except Exception as e:
+            self.error = f"Connection Error: {str(e)}"
+        
+        if self.error and options and options.get("type") == "JSON":
+            raise RuntimeError(self.error)
+            
+        if options and options.get("type") == "JSON":
+            return GravitonEvaluation(self.evaluation_result)
+            
+        return self
+
+    def compute(self, options: Optional[Any] = None) -> GravitonJob:
+        """
+        Executes the compute job. If not yet evaluated, evaluates first.
+        """
+        from . import session
+        
+        if isinstance(options, bool):
+            options = {"auto_charge": options}
+            
+        auto_charge = False
+        if options and isinstance(options, dict):
+            auto_charge = options.get("auto_charge", False)
+            
+        if not self.evaluation_result:
+            self.evaluate()
+            if self.error:
+                raise RuntimeError(self.error)
+
+        job_id = self.evaluation_result['id']
+        
+        # Check if we need to auto-charge (client-side check for better DX)
+        if auto_charge:
+            cost = self.evaluation_result.get('cost', {}).get('total_credit_cost', 0)
+            status = session.get_status()
+            if status.get('credits', 0) < cost:
+                if not status.get('has_payment_method'):
+                    dashboard_url = session.get_dashboard_url()
+                    if session.api_key and "localhost" in dashboard_url:
+                        dashboard_url += f"?dev_key={session.api_key}"
+                    raise RuntimeError(
+                        f"Insufficient Credits ({status.get('credits', 0):.2f}/{cost:.2f}). "
+                        f"Auto-charging is not possible because no primary payment method is configured. "
+                        f"Please add a payment method in your dashboard: {dashboard_url}"
+                    )
+
+        # Call /compute
+        return self._trigger_compute(job_id, auto_charge)
+
+    @staticmethod
+    def _trigger_compute(job_id: str, auto_charge: bool = False) -> GravitonJob:
+        """Internal helper to trigger the /compute endpoint."""
+        from . import session
+        
+        dashboard_url = session.get_dashboard_url()
+        if session.api_key and "localhost" in dashboard_url:
+            dashboard_url += f"?dev_key={session.api_key}"
+
+        resp = requests.post(
+            f"{session.api_url}/compute",
+            json={"job_id": job_id, "auto_charge": auto_charge},
+            headers={"X-API-KEY": session.api_key},
+            timeout=15,
+            verify=session.verify
+        )
+        
+        if resp.status_code in [200, 201, 202]:
+            return GravitonJob(job_id)
+        else:
+            msg = resp.text
+            try:
+                err_data = resp.json()
+                if isinstance(err_data, dict):
+                    msg = err_data.get('error', msg)
+                    # If there's a more descriptive message, use it
+                    if err_data.get('message'):
+                        msg = f"{msg}: {err_data['message']}"
+            except:
+                pass
+            
+            if "PAYMENT_METHOD_REQUIRED" in msg or "INSUFFICIENT_CREDITS" in msg:
+                msg = f"{msg}. Please visit your dashboard to manage credits: {dashboard_url}"
+                
+            raise RuntimeError(f"Compute failed: {msg}")
+
+    def wait(self) -> Any:
+        """Executes the compute job and waits for the result."""
+        return self.compute().wait()
+
+    def _repr_html_(self):
+        from . import session
+        
+        # 1. Prepare Base Info
+        try:
+            latex_str = sp.latex(self.expr)
+            srepr_str = sp.srepr(self.expr)
+        except Exception as e:
+            return f"<div style='color: #ba1a1a;'>Error preparing expression: {e}</div>"
+
+        # Unique ID for the card instance
+        card_id = f"graviton-card-{uuid.uuid4().hex[:8]}"
+        srepr_escaped = srepr_str.replace("'", "\\'")
+
+        # 2. Check Auth Status
+        auth_status = session.get_status()
+        if not auth_status.get('authenticated'):
+            return f"""
+            <div style="border: 1px solid #ccc; padding: 25px; border-radius: 16px; background: #fffbfa; font-family: 'Outfit', sans-serif; text-align: center; max-width: 500px;">
+                <div style="font-size: 1.4rem; margin-bottom: 10px; color: #1a1a1a;">$${latex_str}$$</div>
+                <div style="color: #666; margin-bottom: 20px;">Authenticate to access Graviton Supercomputing.</div>
+                <a href="http://www.g-qt.com" target="_blank" style="background: #1a1a1a; color: white; padding: 10px 25px; border-radius: 20px; text-decoration: none; font-weight: 600;">Login to Graviton</a>
+            </div>
+            """
+
+        # 3. Build the Information Grid
+        if self.evaluation_result:
+            res = self.evaluation_result
+            # Use estimated duration if available (mocked for now as 0.02s per op)
+            est_time = res.get('estimated_duration_s', 0.1)
+            cost = res.get('cost', {}).get('total_credit_cost', 0.0)
+            
+            # Determine button state
+            has_credits = auth_status.get('credits', 0) >= cost
+            has_payment = auth_status.get('has_payment_method')
+            
+            if has_credits:
+                btn_text = "Supercompute on Graviton"
+                btn_action = "runCompute()"
+            elif has_payment:
+                btn_text = "Purchase & Execute"
+                btn_action = "runPurchaseAndCompute()"
+            else:
+                btn_text = "Insufficient Credits"
+                dashboard_url = session.get_dashboard_url()
+                if session.api_key:
+                    dashboard_url += f"?dev_key={session.api_key}"
+                btn_action = f"window.open('{dashboard_url}', '_blank')"
+
+            eval_html = f"""
+            <div id="{card_id}-metrics" style="display: grid; grid-template-columns: 1fr 1fr; gap: 10px; width: 100%; margin-bottom: 15px; padding: 12px; background: rgba(0,0,0,0.03); border-radius: 8px; font-size: 0.9rem;">
+                <div><strong>Est. Time:</strong> {est_time:.1f}s</div>
+                <div><strong>Variables:</strong> {len(res.get('variables', []))}</div>
+                <div style="grid-column: span 2; text-align: center; border-top: 1px solid rgba(0,0,0,0.05); padding-top: 8px; margin-top: 4px; color: #2e7d32;">
+                    <strong>Cost:</strong> {cost:.2f} Credits
+                </div>
+            </div>
+            """
+        else:
+            btn_text = "Evaluate on Graviton"
+            btn_action = "runEvaluate()"
+            eval_html = f"""
+            <div id="{card_id}-metrics" style="color: #666; font-size: 0.85rem; margin-bottom: 15px; text-align: center;">
+                Evaluate to see estimated time and costs.
+            </div>
+            """
+
+        # 4. Final HTML with JS Logic
+        return f"""
+        <div id="{card_id}" class="graviton-card" style="border: 1px solid #ccc; padding: 25px; border-radius: 16px; background: #fdfdfd; font-family: 'Outfit', sans-serif; display: flex; flex-direction: column; align-items: center; box-shadow: 0 4px 12px rgba(0,0,0,0.05); max-width: 500px;">
+            <div style="font-size: 1.4rem; margin-bottom: 15px; color: #1a1a1a;">$${latex_str}$$</div>
+            
+            {eval_html}
+            
+            <button id="{card_id}-btn" onclick="{btn_action}" style="background: #1a1a1a; color: #ffffff; border: 1px solid rgba(255,255,255,0.2); padding: 12px 32px; border-radius: 30px; cursor: pointer; font-weight: 600; font-size: 1rem; width: 100%; transition: all 0.2s;">
+                {btn_text}
+            </button>
+            
+            <div id="{card_id}-status" style="font-size: 0.75rem; color: #777; margin-top: 12px; font-style: italic;">
+                Verified SymPy model ready for Graviton Acceleration
+            </div>
+
+            <script>
+            (function() {{
+                const card = document.getElementById('{card_id}');
+                const btn = document.getElementById('{card_id}-btn');
+                const status = document.getElementById('{card_id}-status');
+                const metrics = document.getElementById('{card_id}-metrics');
+                const api_url = '{session.api_url}';
+                const api_key = '{session.api_key}';
+
+                let currentJobId = '';
+                window.runEvaluate = async () => {{
+                    btn.disabled = true;
+                    btn.innerText = "Evaluating...";
+                    try {{
+                        const resp = await fetch(api_url + '/eval', {{
+                            method: 'POST',
+                            headers: {{ 'Content-Type': 'application/json', 'X-API-KEY': api_key }},
+                            body: JSON.stringify({{ f: '{srepr_escaped}' }})
+                        }});
+                        if (resp.ok) {{
+                            const data = await resp.json();
+                            currentJobId = data.id;
+                            status.innerText = "Evaluation complete. Ready to provision.";
+                            
+                            if (data.result !== undefined) {{
+                                metrics.innerHTML = '<div style="grid-column: span 2; text-align: center; font-size: 1.2rem; color: #1a1a1a;"><strong>Result:</strong> ' + data.result + '</div>';
+                                btn.innerText = "Compute Finished";
+                            }} else {{
+                                let costStr = (data.cost && data.cost.total_credit_cost !== undefined) ? data.cost.total_credit_cost.toFixed(2) : "0.00";
+                                let timeStr = data.estimated_duration_s !== undefined ? data.estimated_duration_s : "?";
+                                metrics.innerHTML = 'Estimated Cost: ' + costStr + ' credits | Estimated Time: ' + timeStr + 's';
+                                btn.innerText = "Compute on Swarm";
+                                btn.onclick = window.runCompute;
+                                btn.disabled = false;
+                            }}
+                        }} else {{
+                            status.innerText = "Evaluation failed: " + resp.status;
+                            btn.disabled = false;
+                        }}
+                    }} catch (e) {{
+                        status.innerText = "Connection failed.";
+                        btn.disabled = false;
+                    }}
+                }};
+
+                window.runCompute = async () => {{
+                    if (!currentJobId) return;
+                    btn.disabled = true;
+                    btn.innerText = "Provisioning...";
+                    try {{
+                        const resp = await fetch(api_url + '/compute', {{
+                            method: 'POST',
+                            headers: {{ 'Content-Type': 'application/json', 'X-API-KEY': api_key }},
+                            body: JSON.stringify({{ job_id: currentJobId }})
+                        }});
+                        if (resp.ok) {{
+                            pollResult(currentJobId);
+                        }} else {{
+                            status.innerText = "Compute failed.";
+                            btn.disabled = false;
+                        }}
+                    }} catch (e) {{
+                        status.innerText = "Network error.";
+                        btn.disabled = false;
+                    }}
+                }};
+
+                const pollResult = async (jobId) => {{
+                    status.innerText = "Executing on Graviton Swarm...";
+                    const timer = setInterval(async () => {{
+                        const resp = await fetch(api_url + '/results/' + jobId, {{
+                            headers: {{ 'X-API-KEY': api_key }}
+                        }});
+                        const data = await resp.json();
+                        if (data.status === 'COMPLETED') {{
+                            clearInterval(timer);
+                            const resResp = await fetch(api_url + '/results/' + jobId + '/download', {{
+                                headers: {{ 'X-API-KEY': api_key }}
+                            }});
+                            const result = await resResp.text();
+                            metrics.innerHTML = '<div style="grid-column: span 2; text-align: center; font-size: 1.2rem; color: #1a1a1a;"><strong>Result:</strong> ' + result + '</div>';
+                            btn.style.display = 'none';
+                            status.innerText = "Job COMPLETED";
+                        }} else if (data.status === 'FAILED') {{
+                            clearInterval(timer);
+                            status.innerText = "Job FAILED";
+                        }}
+                    }}, 1000);
+                }};
+            }})();
+            </script>
+        </div>
+        """
+
+def gv(expr):
+    """
+    Wraps a SymPy expression for Graviton integration.
+    """
+    return GravitonExpression(expr)
+
+# Alias for better readability
+expr = gv