Fixe s for HF hosting

README.md

@@ -4,7 +4,7 @@ colorFrom: blue
 colorTo: indigo
 sdk: gradio
 sdk_version: 6.18.0
-app_file: app.py
+app_file: server.py
 pinned: false
 ---
 

app.py

@@ -1,876 +0,0 @@
-"""
-dashboard_server.py
-====================
-Iroha Financial Intelligence — gr.Server entry point.
-
-Architecture
-------------
-gr.Server (extends FastAPI)
-├── GET  /           → serves frontend/index.html
-├── GET  /static/*   → serves frontend/{style.css, app.js}  (StaticFiles)
-│
-├── @server.api  run_inference   → DoFlow / SCM causal query (via BACKEND_API)
-│
-├── GET  /v2/health              → health-check
-│
-└── All existing /v2/* routers from main.py are included here too
-    (so this server is a superset of main.py).
-
-Usage
------
-    python dashboard_server.py
-
-Or with uvicorn:
-    uvicorn dashboard_server:server --host 0.0.0.0 --port 7860 --reload
-"""
-
-from __future__ import annotations
-
-import os
-import sys
-import json
-import logging
-import urllib.error
-import urllib.parse
-import urllib.request
-from pathlib import Path
-import gradio as gr
-from typing import Any, Dict, List, Optional
-from dotenv import load_dotenv
-
-load_dotenv()
-
-BASE_DIR = Path(__file__).parent.resolve()
-if str(BASE_DIR) not in sys.path:
-    sys.path.insert(0, str(BASE_DIR))
-
-# Also add the backend directory to sys.path so we can import 'app', 'causal', etc.
-BACKEND_DIR = (BASE_DIR.parent / "noisy_boy_backend").resolve()
-if BACKEND_DIR.exists() and str(BACKEND_DIR) not in sys.path:
-    sys.path.insert(0, str(BACKEND_DIR))
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Logging
-# ─────────────────────────────────────────────────────────────────────────────
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
-    handlers=[logging.StreamHandler()],
-)
-logger = logging.getLogger("dashboard-server")
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Backend URL
-# ─────────────────────────────────────────────────────────────────────────────
-
-_BACKEND_BASE_URL: str = os.environ.get("BACKEND_API_URL", "http://localhost:8000")
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Public API
-# ─────────────────────────────────────────────────────────────────────────────
-
-def run_pipeline(
-    ticker: str = "RELIANCE",
-    threshold: float = 0.5,
-    treatment: Optional[str] = None,
-    outcome: Optional[str] = None,
-    include_pywhyllm: bool = False,
-) -> Dict[str, Any]:
-    """
-    Fetch the validated causal matrix for *ticker* from the backend API.
-
-    Parameters
-    ----------
-    ticker          : NSE symbol (e.g. RELIANCE, HDFCBANK)
-    threshold       : adjacency threshold for DAG construction
-    treatment       : optional treatment node for pywhyllm assumptions
-    outcome         : optional outcome node  for pywhyllm assumptions
-    include_pywhyllm: request pywhyllm assumption report from backend
-
-    Returns
-    -------
-    dict with keys:
-        nodes, adj_matrix, dag_adj, equations, data_level,
-        topological_order, nodes_graph, links_graph
-    Raises RuntimeError if the backend cannot be reached or returns an error.
-    """
-    params: dict = {"threshold": threshold}
-    if treatment:
-        params["treatment"] = treatment
-    if outcome:
-        params["outcome"] = outcome
-    if include_pywhyllm:
-        params["include_pywhyllm"] = "true"
-
-    qs = urllib.parse.urlencode(params)
-    url = f"{_BACKEND_BASE_URL}/v2/api/singular-causal/causal-matrix/{ticker.upper()}?{qs}"
-    logger.info("run_pipeline: fetching %s", url)
-
-    try:
-        with urllib.request.urlopen(url, timeout=60) as resp:
-            raw = resp.read()
-    except urllib.error.URLError as exc:
-        raise RuntimeError(
-            f"Could not reach backend at {_BACKEND_BASE_URL}. "
-            f"Ensure noisy_boy_backend is running. Original error: {exc}"
-        ) from exc
-
-    payload = json.loads(raw)
-
-    status = payload.get("status")
-    if status == "not_found":
-        raise RuntimeError(
-            payload.get(
-                "detail",
-                f"No cached pipeline data for {ticker} on backend. "
-                "Run the singular-causal pipeline on the backend first.",
-            )
-        )
-    if status not in ("success", None, "ok"):
-        raise RuntimeError(
-            f"Backend returned unexpected status '{status}' for {ticker}. "
-            f"Payload: {payload}"
-        )
-
-    # Build frontend-friendly graph representation
-    nodes: List[str] = payload.get("nodes", [])
-    adj_matrix = payload.get("adj_matrix", [])
-    dag_adj = payload.get("dag_adj", [])
-
-    nodes_graph = [{"id": n, "label": n} for n in nodes]
-    links_graph = []
-    for i, src in enumerate(nodes):
-        for j, dst in enumerate(nodes):
-            if i != j:
-                try:
-                    score = float(adj_matrix[i][j])
-                except (IndexError, TypeError, ValueError):
-                    score = 0.0
-                if score >= threshold:
-                    links_graph.append({"source": src, "target": dst, "score": round(score, 4)})
-
-    return {
-        **payload,
-        "nodes_graph": nodes_graph,
-        "links_graph": links_graph,
-    }
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Helpers
-# ─────────────────────────────────────────────────────────────────────────────
-
-def _fetch_causal_matrix(
-    ticker: str,
-    treatment: Optional[str] = None,
-    outcome: Optional[str] = None,
-    include_pywhyllm: bool = False,
-    threshold: float = 0.5,
-) -> Optional[dict]:
-    """
-    Fetch the fully validated causal matrix from the backend API.
-
-    Calls GET {BACKEND_BASE_URL}/v2/api/singular-causal/causal-matrix/{ticker}
-    and returns the parsed JSON payload, or None on failure.
-
-    The payload contains:
-      nodes        — ordered list of node names
-      adj_matrix   — raw float adjacency matrix
-      dag_adj      — thresholded 0/1 DAG
-      equations    — per-node structural equations (coefficients, intercepts, residual_std)
-      data_level   — (T, N) time-series observations used to fit the SCM
-      topological_order — nodes in topological traversal order
-      pywhyllm_report   — (optional) assumption analysis for treatment→outcome
-    """
-    import urllib.request
-    import urllib.error
-    import urllib.parse
-
-    params: dict = {"threshold": threshold}
-    if treatment:
-        params["treatment"] = treatment
-    if outcome:
-        params["outcome"] = outcome
-    if include_pywhyllm:
-        params["include_pywhyllm"] = "true"
-
-    query_string = urllib.parse.urlencode(params)
-    url = f"{_BACKEND_BASE_URL}/v2/api/singular-causal/causal-matrix/{ticker.upper()}?{query_string}"
-
-    try:
-        with urllib.request.urlopen(url, timeout=30) as resp:
-            raw = resp.read()
-        data = json.loads(raw)
-        if data.get("status") not in ("success", None):
-            logger.warning(
-                "_fetch_causal_matrix: backend returned status=%s for URL %s. Payload: %s",
-                data.get("status"), url, data,
-            )
-            return None
-        return data
-    except Exception as exc:
-        logger.warning("_fetch_causal_matrix failed for %s: %s", ticker, exc)
-        return None
-
-
-def _safe_json(obj: Any) -> Any:
-    """Recursively make numpy types JSON-serialisable."""
-    try:
-        import numpy as np
-        if isinstance(obj, np.ndarray):
-            return obj.tolist()
-        if isinstance(obj, np.integer):
-            return int(obj)
-        if isinstance(obj, np.floating):
-            return float(obj)
-    except ImportError:
-        pass
-    if isinstance(obj, dict):
-        return {k: _safe_json(v) for k, v in obj.items()}
-    if isinstance(obj, (list, tuple)):
-        return [_safe_json(v) for v in obj]
-    return obj
-
-
-def _resolve_value(value: float, value_type: str, current: float) -> float:
-    """Convert a user-supplied value + value_type to the absolute node value."""
-    vt = value_type.strip().lower()
-    if vt == "absolute":
-        return value
-    if vt == "multiplier":
-        return current * value
-    if vt == "percent_change":
-        return current * (1.0 + value / 100.0)
-    # default: treat as absolute
-    return value
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Pure-numpy inference helpers (no local causal training imports)
-# These functions work entirely from the payload returned by the backend API.
-# ──────────────────────────────────────────────────────────────��──────────────
-
-def _build_dag_from_payload(payload: dict):
-    """
-    Return a numpy bool DAG adjacency matrix and list of node names
-    from the backend causal-matrix payload.
-    """
-    import numpy as np
-    nodes = payload["nodes"]
-    dag_adj = np.array(payload["dag_adj"], dtype=bool)
-    adj_matrix = np.array(payload["adj_matrix"], dtype=float)
-    return nodes, dag_adj, adj_matrix
-
-
-def _propagate_intervention(
-    nodes: list,
-    dag_adj,
-    equations: dict,
-    data_level,
-    topological_order: list,
-    treatment: str,
-    abs_value: float,
-    targets: list,
-    horizon: int = 5,
-):
-    """
-    Propagate a hard intervention (do(treatment=abs_value)) through the
-    structural equations for `horizon` steps, returning ATE per target node.
-    Uses only numpy — no local causal model imports.
-    """
-    import numpy as np
-
-    node_to_idx = {n: i for i, n in enumerate(nodes)}
-    n = len(nodes)
-    T = data_level.shape[0]
-
-    # Start from the last observed time step
-    state = data_level[-1].copy().astype(float)
-
-    # Fix the treatment node
-    t_idx = node_to_idx[treatment]
-    state[t_idx] = abs_value
-
-    ate_per_target: Dict[str, float] = {}
-    baseline = data_level[-1].copy().astype(float)
-
-    for _ in range(horizon):
-        new_state = state.copy()
-        for node_name in topological_order:
-            if node_name == treatment:
-                continue
-            eq = equations.get(node_name)
-            if eq is None:
-                continue
-            parents = eq.get("parents", [])
-            coefficients = eq.get("coefficients", {})
-            intercept = float(eq.get("intercept", 0.0))
-            if not parents:
-                continue
-            val = intercept
-            for p in parents:
-                p_idx = node_to_idx.get(p)
-                if p_idx is not None:
-                    val += float(coefficients.get(p, 0.0)) * float(state[p_idx])
-            n_idx = node_to_idx[node_name]
-            new_state[n_idx] = val
-        state = new_state
-
-    for target in targets:
-        t_i = node_to_idx.get(target)
-        if t_i is not None:
-            ate_per_target[target] = float(state[t_i] - baseline[t_i])
-
-    return ate_per_target, state
-
-
-def _abduct_and_predict(
-    nodes: list,
-    dag_adj,
-    equations: dict,
-    data_level,
-    topological_order: list,
-    treatment: str,
-    cf_value: float,
-    target: str,
-    observed_t: int,
-):
-    """
-    Simple SCM abduction for counterfactual:
-      1. Abduct residuals from the observed time step.
-      2. Re-run structural equations with treatment fixed to cf_value.
-      3. Return factual_outcome, cf_outcome, ITE.
-    """
-    import numpy as np
-
-    node_to_idx = {n: i for i, n in enumerate(nodes)}
-    obs = data_level[observed_t].copy().astype(float)
-
-    # Abduct residuals
-    residuals: Dict[str, float] = {}
-    for node_name in topological_order:
-        eq = equations.get(node_name)
-        if eq is None or not eq.get("parents"):
-            residuals[node_name] = 0.0
-            continue
-        parents = eq.get("parents", [])
-        coefficients = eq.get("coefficients", {})
-        intercept = float(eq.get("intercept", 0.0))
-        predicted = intercept
-        for p in parents:
-            p_idx = node_to_idx.get(p)
-            if p_idx is not None:
-                predicted += float(coefficients.get(p, 0.0)) * float(obs[node_to_idx[p]])
-        residuals[node_name] = float(obs[node_to_idx[node_name]]) - predicted
-
-    # Counterfactual: fix treatment, replay equations with abducted noise
-    cf_state = obs.copy()
-    cf_state[node_to_idx[treatment]] = cf_value
-
-    for node_name in topological_order:
-        if node_name == treatment:
-            continue
-        eq = equations.get(node_name)
-        if eq is None or not eq.get("parents"):
-            continue
-        parents = eq.get("parents", [])
-        coefficients = eq.get("coefficients", {})
-        intercept = float(eq.get("intercept", 0.0))
-        predicted = intercept
-        for p in parents:
-            p_idx = node_to_idx.get(p)
-            if p_idx is not None:
-                predicted += float(coefficients.get(p, 0.0)) * float(cf_state[p_idx])
-        n_idx = node_to_idx[node_name]
-        cf_state[n_idx] = predicted + residuals.get(node_name, 0.0)
-
-    factual_outcome = float(obs[node_to_idx[target]])
-    cf_outcome = float(cf_state[node_to_idx[target]])
-    ite = cf_outcome - factual_outcome
-    return factual_outcome, cf_outcome, ite
-
-
-# ── API: Causal inference (assert / intervene / counterfactual) ───────────
-#
-# Architecture:
-#   1. Fetch the VALIDATED causal matrix from noisy_boy_backend via HTTP.
-#      The backend has already run CUTS+ learning + pywhyllm + DoWhy validation.
-#   2. Use the payload data (equations, adj, data_level) for inference
-#      using pure numpy/pandas — no local causal training imports required.
-#   3. Optionally consult pywhyllm guidance from the backend payload.
-from huggingface_hub import spaces
-
-@spaces.GPU
-def run_inference(
-    ticker: str = "RELIANCE",
-    mode: str = "assert",
-    treatment: str = "Revenue",
-    outcome: Optional[str] = "NetIncome",
-    target: Optional[str] = None,
-    value: float = 1.1,
-    cf_value: Optional[float] = None,
-    value_type: str = "multiplier",
-    horizon: int = 5,
-    observed_t: int = -1,
-    threshold: float = 0.5,
-    use_pywhyllm: bool = False,
-    return_assumption_report: bool = False,
-) -> Dict[str, Any]:
-    """
-    Three-layer causal inference driven by the backend's validated causal matrix.
-
-    Parameters
-    ----------
-    ticker       : NSE ticker (backend must have a cached pipeline run for it)
-    mode         : "assert" | "intervene" | "counterfactual"
-    treatment    : source node name
-    outcome      : outcome node  (assert / Layer-1 association)
-    target       : target node   (counterfactual / Layer-3); if None, falls back to outcome
-    value        : intervention magnitude (Layer 2)
-    cf_value     : explicit counterfactual value (Layer 3); if None, 'value' + 'value_type' used
-    value_type   : "absolute" | "multiplier" | "percent_change"
-    horizon      : propagation horizon for intervention (Layer 2, steps)
-    observed_t   : time index for counterfactual abduction (Layer 3; -1 = last obs)
-    threshold    : adjacency threshold used when loading the graph
-    use_pywhyllm : consult pywhyllm for structural assumptions before running DoWhy
-    return_assumption_report : include the pywhyllm report dict in the response
-
-    Returns
-    -------
-    JSON with ate, ci_lower, ci_upper, probability, ripple_effects,
-    and (for counterfactual) factual_outcome, counterfactual_outcome, ite,
-    shapley_contributions.
-    """
-    import numpy as np
-    import pandas as pd
-
-    try:
-        # ── 0. Determine target node ──────────────────────────────────────────
-        target_node = target if target else outcome
-        if not target_node:
-            return {"status": "error", "detail": "Either 'outcome' or 'target' must be provided."}
-
-        # ── 1. Fetch validated causal matrix from backend ─────────────────────
-        #      This includes the adjacency matrix, fitted structural equations,
-        #      level-domain data, and optionally a pywhyllm assumption report.
-        payload = _fetch_causal_matrix(
-            ticker=ticker,
-            treatment=treatment if use_pywhyllm else None,
-            outcome=target_node if use_pywhyllm else None,
-            include_pywhyllm=use_pywhyllm,
-            threshold=threshold,
-        )
-
-        if payload is None:
-            return {
-                "status": "error",
-                "detail": (
-                    f"Could not fetch causal matrix for {ticker} from backend. "
-                    "Ensure noisy_boy_backend is running and the pipeline has been run for this ticker."
-                ),
-            }
-
-        if payload.get("status") == "not_found":
-            return {
-                "status": "error",
-                "detail": payload.get("detail", f"No cached pipeline data for {ticker}."),
-            }
-
-        # ── 2. Unpack payload (no local causal training imports) ──────────────
-        nodes, dag_adj, adj_matrix = _build_dag_from_payload(payload)
-        node_to_idx = {n: i for i, n in enumerate(nodes)}
-        data_level = np.array(payload["data_level"], dtype=float)
-        equations_raw = payload.get("equations", {})
-        topo_order = payload.get("topological_order", nodes)
-
-        T = data_level.shape[0]
-        df = pd.DataFrame(data_level, columns=nodes)
-
-        if treatment not in node_to_idx:
-            return {"status": "error", "detail": f"Unknown treatment node: {treatment}"}
-        if target_node not in node_to_idx:
-            return {"status": "error", "detail": f"Unknown outcome/target node: {target_node}"}
-        if df.shape[0] < 5:
-            return {
-                "status": "error",
-                "detail": f"Insufficient observations ({df.shape[0]}) to run inference.",
-            }
-
-        # ── 3. pywhyllm structural guidance (from backend payload) ────────────
-        pywhyllm_report: Optional[dict] = payload.get("pywhyllm_report")
-        adjustment_sets: List[List[str]] = []
-
-        if use_pywhyllm and pywhyllm_report and pywhyllm_report.get("available"):
-            raw_backdoor = pywhyllm_report.get("suggested_backdoor_sets") or []
-            valid_nodes = set(nodes) - {treatment, target_node}
-            for suggested_set in raw_backdoor:
-                clean = [n for n in suggested_set if n in valid_nodes]
-                if clean and clean not in adjustment_sets:
-                    adjustment_sets.append(clean)
-
-            confounders = [
-                n for n in (pywhyllm_report.get("suggested_confounders") or [])
-                if n in valid_nodes
-            ]
-            if confounders and confounders not in adjustment_sets:
-                adjustment_sets.append(confounders)
-
-        result: Dict[str, Any] = {}
-
-        # ═══════════════════════════════════════════════════════════════════════
-        # LAYER 1 — Association: "What does Y look like given X?"
-        # Uses DoWhy with the backend-provided DAG, falling back to OLS.
-        # ═══════════════════════════════════════════════════════════════════════
-        if mode == "assert":
-            try:
-                from dowhy import CausalModel
-
-                # Build DOT graph string from dag_adj
-                edges = []
-                for si, src in enumerate(nodes):
-                    for di, dst in enumerate(nodes):
-                        if dag_adj[si, di]:
-                            edges.append(f"{src} -> {dst}")
-                graph_dot = "digraph{" + "; ".join(edges) + "}"
-
-                dowhy_model = CausalModel(
-                    data=df,
-                    treatment=treatment,
-                    outcome=target_node,
-                    graph=graph_dot,
-                )
-                identified_estimand = dowhy_model.identify_effect(
-                    proceed_when_unidentifiable=True
-                )
-                estimate = dowhy_model.estimate_effect(
-                    identified_estimand,
-                    method_name="backdoor.linear_regression",
-                )
-                ate = float(estimate.value)
-
-                # Confidence interval from OLS residuals
-                se: float = 0.0
-                try:
-                    import numpy.linalg as nla
-                    X = df[[c for c in df.columns if c != target_node]].values
-                    y = df[target_node].values
-                    XtX_inv = nla.pinv(X.T @ X)
-                    resid = y - X @ nla.lstsq(X, y, rcond=None)[0]
-                    sigma2 = float(np.sum(resid ** 2) / max(1, len(y) - X.shape[1]))
-                    t_idx_local = list(df.columns).index(treatment)
-                    se = float(np.sqrt(max(0.0, sigma2 * XtX_inv[t_idx_local, t_idx_local])))
-                except Exception:
-                    se = abs(ate) * 0.15  # graceful fallback
-
-                ci_lower = ate - 1.96 * se
-                ci_upper = ate + 1.96 * se
-                prob = min(1.0, abs(ate) / (abs(ate) + se + 1e-9))
-
-                # Ripple effects: direct downstream neighbours of treatment
-                ripple_effects = []
-                t_idx_g = node_to_idx[treatment]
-                for j, node in enumerate(nodes):
-                    if node == treatment or node == target_node:
-                        continue
-                    if dag_adj[t_idx_g, j]:
-                        edge_score = float(adj_matrix[t_idx_g, j])
-                        ripple_effects.append({
-                            "ticker": node,
-                            "direction": 1 if ate > 0 else -1,
-                            "magnitude": round(edge_score * abs(ate), 4),
-                        })
-
-                result = {
-                    "ate": ate,
-                    "ci_lower": ci_lower,
-                    "ci_upper": ci_upper,
-                    "probability": prob,
-                    "strategy": "backdoor.linear_regression",
-                    "adjustment_set": adjustment_sets[0] if adjustment_sets else [],
-                    "ripple_effects": ripple_effects,
-                }
-
-            except Exception as dowhy_exc:
-                # DoWhy not installed or identification failed — fall back to OLS
-                logger.warning("DoWhy association failed (%s), falling back to OLS", dowhy_exc)
-                t_idx_g = node_to_idx[treatment]
-                out_idx = node_to_idx[target_node]
-
-                # Simple OLS: regress target on treatment
-                X = df[[treatment]].values
-                y = df[target_node].values
-                import numpy.linalg as nla
-                coef = nla.lstsq(np.c_[np.ones(len(X)), X], y, rcond=None)[0]
-                ate = float(coef[1])
-                se = abs(ate) * 0.15
-                ci_lower = ate - 1.96 * se
-                ci_upper = ate + 1.96 * se
-
-                ripple_effects = []
-                for j, node in enumerate(nodes):
-                    if node == treatment or node == target_node:
-                        continue
-                    if dag_adj[t_idx_g, j]:
-                        ripple_effects.append({
-                            "ticker": node,
-                            "direction": 1 if ate > 0 else -1,
-                            "magnitude": round(float(adj_matrix[t_idx_g, j]) * abs(ate), 4),
-                        })
-
-                result = {
-                    "ate": ate,
-                    "ci_lower": ci_lower,
-                    "ci_upper": ci_upper,
-                    "probability": min(1.0, abs(ate) / (abs(ate) + se + 1e-9)),
-                    "strategy": "ols_fallback",
-                    "adjustment_set": adjustment_sets[0] if adjustment_sets else [],
-                    "ripple_effects": ripple_effects,
-                }
-
-        # ═══════════════════════════════════════════════════════════════════════
-        # LAYER 2 — Intervention: "What will happen to Y if we do X=value?"
-        # Propagates through structural equations from the backend payload.
-        # ═══════════════════════════════════════════════════════════════════════
-        elif mode == "intervene":
-            current_val = float(data_level[-1, node_to_idx[treatment]])
-            abs_value = _resolve_value(value, value_type, current_val)
-
-            # Try DoWhy for ATE estimation first
-            ate = 0.0
-            method_used = "scm_propagation"
-            try:
-                from dowhy import CausalModel
-
-                edges = []
-                for si, src in enumerate(nodes):
-                    for di, dst in enumerate(nodes):
-                        if dag_adj[si, di]:
-                            edges.append(f"{src} -> {dst}")
-                graph_dot = "digraph{" + "; ".join(edges) + "}"
-
-                dowhy_model = CausalModel(
-                    data=df,
-                    treatment=treatment,
-                    outcome=target_node,
-                    graph=graph_dot,
-                )
-                identified_estimand = dowhy_model.identify_effect(
-                    proceed_when_unidentifiable=True
-                )
-                estimate = dowhy_model.estimate_effect(
-                    identified_estimand,
-                    method_name="backdoor.linear_regression",
-                )
-                ate_unit = float(estimate.value)
-                delta = abs_value - current_val
-                ate = ate_unit * delta
-                method_used = "backdoor.linear_regression"
-            except Exception as dowhy_exc:
-                logger.warning("DoWhy intervention failed (%s), using SCM propagation", dowhy_exc)
-
-            # SCM propagation for ripple effects (pure numpy, no training imports)
-            ate_per_target, final_state = _propagate_intervention(
-                nodes=nodes,
-                dag_adj=dag_adj,
-                equations=equations_raw,
-                data_level=data_level,
-                topological_order=topo_order,
-                treatment=treatment,
-                abs_value=abs_value,
-                targets=[target_node] + [n for n in nodes if n != treatment],
-                horizon=horizon,
-            )
-
-            if method_used == "scm_propagation" and target_node in ate_per_target:
-                ate = float(ate_per_target[target_node])
-
-            se = abs(ate) * 0.12
-            ci_lower = ate - 1.96 * se
-            ci_upper = ate + 1.96 * se
-
-            ripple_effects = []
-            for node, delta_val in ate_per_target.items():
-                if node == treatment:
-                    continue
-                ripple_effects.append({
-                    "ticker": node,
-                    "direction": 1 if float(delta_val) > 0 else -1,
-                    "magnitude": round(abs(float(delta_val)), 4),
-                })
-
-            result = {
-                "ate": ate,
-                "ci_lower": ci_lower,
-                "ci_upper": ci_upper,
-                "probability": min(1.0, abs(ate) / (abs(ate) + abs(ci_upper - ci_lower) / 2 + 1e-9)),
-                "strategy": method_used,
-                "intervention_value": abs_value,
-                "value_type": value_type,
-                "horizon": horizon,
-                "ripple_effects": ripple_effects,
-                "adjustment_set": adjustment_sets[0] if adjustment_sets else [],
-            }
-
-        # ═══════════════════════════════════════════════════════════════════════
-        # LAYER 3 — Counterfactual: "What if X had been different in the past?"
-        # Uses SCM abduction via pure numpy structural equations.
-        # ═══════════════════════════════════════════════════════════════════════
-        elif mode in ("counterfactual", "counter"):
-            # Resolve observed timestep
-            t = observed_t if observed_t >= 0 else (T + observed_t)
-            t = max(0, min(T - 1, t))
-
-            # Resolve counterfactual value
-            current_val = float(data_level[t, node_to_idx[treatment]])
-            if cf_value is not None:
-                abs_cf_value = float(cf_value)
-            else:
-                abs_cf_value = _resolve_value(value, value_type, current_val)
-
-            # Try DoWhy GCM first
-            gcm_used = False
-            factual_outcome = 0.0
-            cf_outcome_val = 0.0
-            ite = 0.0
-
-            try:
-                import dowhy.gcm as gcm_module
-                import networkx as nx
-
-                causal_graph = nx.DiGraph()
-                for si, src in enumerate(nodes):
-                    for di, dst in enumerate(nodes):
-                        if dag_adj[si, di]:
-                            causal_graph.add_edge(src, dst)
-                for node in nodes:
-                    if node not in causal_graph.nodes:
-                        causal_graph.add_node(node)
-
-                gcm_model = gcm_module.InvertibleStructuralCausalModel(causal_graph)
-                gcm_module.auto.assign_mechanisms(gcm_model, df)
-                gcm_module.fit(gcm_model, df)
-
-                observed_data = df.iloc[[t]]
-                cf_val_fixed = abs_cf_value
-                cf_samples = gcm_module.counterfactual_samples(
-                    gcm_model,
-                    {treatment: lambda x, v=cf_val_fixed: np.full(x.shape, v)},
-                    observed_data=observed_data,
-                    num_samples_to_draw=1,
-                )
-
-                factual_outcome = float(observed_data[target_node].iloc[0])
-                cf_outcome_val = float(cf_samples[target_node].iloc[0])
-                ite = cf_outcome_val - factual_outcome
-                gcm_used = True
-
-            except Exception as gcm_exc:
-                logger.warning("DoWhy GCM counterfactual failed (%s), using SCM abduction", gcm_exc)
-
-            if not gcm_used:
-                factual_outcome, cf_outcome_val, ite = _abduct_and_predict(
-                    nodes=nodes,
-                    dag_adj=dag_adj,
-                    equations=equations_raw,
-                    data_level=data_level,
-                    topological_order=topo_order,
-                    treatment=treatment,
-                    cf_value=abs_cf_value,
-                    target=target_node,
-                    observed_t=t,
-                )
-
-            # Shapley: single-treatment — just use the ITE directly
-            shapley = {treatment: ite}
-
-            # SE from residual_std of the target equation (from backend payload)
-            target_eq_data = equations_raw.get(target_node, {})
-            se = float(target_eq_data.get("residual_std", abs(ite) * 0.15))
-            ci_lower = ite - 1.96 * se
-            ci_upper = ite + 1.96 * se
-
-            result = {
-                "ate": ite,
-                "ite": ite,
-                "factual_outcome": factual_outcome,
-                "counterfactual_outcome": cf_outcome_val,
-                "ci_lower": ci_lower,
-                "ci_upper": ci_upper,
-                "probability": min(1.0, abs(ite) / (abs(ite) + se + 1e-9)),
-                "strategy": "dowhy_gcm" if gcm_used else "scm_abduction",
-                "counterfactual_value": abs_cf_value,
-                "value_type": value_type,
-                "observed_t": t,
-                "shapley_contributions": shapley,
-                "ripple_effects": [],
-            }
-
-        else:
-            return {
-                "status": "error",
-                "detail": f"Unknown mode '{mode}'. Must be one of: assert, intervene, counterfactual.",
-            }
-
-        # ── Attach pywhyllm assumption report if requested ────────────────────
-        if return_assumption_report and pywhyllm_report:
-            result["pywhyllm_report"] = pywhyllm_report
-
-        return _safe_json({"status": "ok", "ticker": ticker.upper(), "mode": mode, **result})
-
-    except Exception as exc:
-        logger.exception("run_inference failed")
-        return {"status": "error", "detail": str(exc)}
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Gradio UI & Entry point
-# ─────────────────────────────────────────────────────────────────────────────
-
-with gr.Blocks(title="Iroha Causal Terminal") as demo:
-    gr.Markdown("# Iroha Causal Terminal")
-    gr.Markdown("Iroha Financial Intelligence — real-time causal probability matrix, HHKD decomposition, DoFlow inference and sector hierarchy over NIFTY50.")
-    
-    with gr.Row():
-        ticker = gr.Textbox(label="Ticker", value="RELIANCE")
-        mode = gr.Dropdown(choices=["assert", "intervene", "counterfactual"], label="Mode", value="assert")
-        treatment = gr.Textbox(label="Treatment", value="Revenue")
-        outcome = gr.Textbox(label="Outcome", value="NetIncome")
-        target = gr.Textbox(label="Target", value="")
-        
-    with gr.Row():
-        value = gr.Number(label="Value", value=1.1)
-        cf_value = gr.Number(label="CF Value")
-        value_type = gr.Dropdown(choices=["absolute", "multiplier", "percent_change"], label="Value Type", value="multiplier")
-        horizon = gr.Number(label="Horizon", value=5, precision=0)
-        observed_t = gr.Number(label="Observed T", value=-1, precision=0)
-        threshold = gr.Number(label="Threshold", value=0.5)
-        
-    with gr.Row():
-        use_pywhyllm = gr.Checkbox(label="Use PyWhyLLM", value=False)
-        return_assumption_report = gr.Checkbox(label="Return Assumption Report", value=False)
-        
-    btn = gr.Button("Run Inference")
-    out = gr.JSON(label="Result")
-    
-    btn.click(
-        fn=run_inference,
-        inputs=[
-            ticker, mode, treatment, outcome, target, value, cf_value, value_type,
-            horizon, observed_t, threshold, use_pywhyllm, return_assumption_report
-        ],
-        outputs=out,
-        api_name="run_inference"
-    )
-
-if __name__ == "__main__":
-    port = int(os.environ.get("GRADIO_SERVER_PORT", os.environ.get("PORT", "7860")))
-    host = os.environ.get("GRADIO_SERVER_NAME", "0.0.0.0")
-
-    logger.info(f"Starting Iroha Causal Terminal on {host}:{port}")
-
-    demo.launch(
-        server_name=host,
-        server_port=port,
-        show_error=True,
-        ssr_mode="cdn"
-    )

server.py

@@ -883,4 +883,5 @@ if __name__ == "__main__":
         server_name=host,
         server_port=port,
         show_error=True,
+        ssr_mode="cdn"
     )