Update app.py

app.py

@@ -1,78 +1,63 @@
-import gradio as gr
-from chronos import ChronosBoltPipeline  # Corrected Import
+from fastapi import FastAPI, Request
+from chronos import ChronosPipeline
 import torch
 import numpy as np
 
-# 1. LOAD THE BRAIN (Matched to the correct model engine)
-pipeline = ChronosBoltPipeline.from_pretrained("amazon/chronos-bolt-tiny")
+app = FastAPI()
 
-def analyze_trade(prices_string, rr_ratio):
-    try:
-        # 1. Clean and Process Input
-        prices = [float(x.strip()) for x in prices_string.split(",")]
-        current_price = prices[-1]
-        
-        # Chronos-Bolt expects [Batch, Sequence] shape
-        context = torch.tensor(prices).unsqueeze(0)
-        
-        # 2. Run AI Prediction
-        # length 20 = roughly 2 business weeks
-        forecast = pipeline.predict(context, prediction_length=20)
-        
-        # 3. Calculate Quantiles (Bolt-Tiny outputs raw samples)
-        # forecast[0] is the matrix of possible futures
-        p10 = np.quantile(forecast[0].numpy(), 0.1)
-        p50 = np.quantile(forecast[0].numpy(), 0.5)
-        p90 = np.quantile(forecast[0].numpy(), 0.9)
-        
-        # 4. CERTAINTY (Confidence)
-        # Narrow gap = AI is certain. Wide gap = High Market Noise.
-        volatility = (p90 - p10) / p50
-        certainty = max(0, min(100, 100 * (1 - volatility)))
-        
-        # 5. DYNAMIC TRADING LOGIC
-        # Floor (Stop Loss) is the P10
-        risk_amount = current_price - p10
-        
-        if risk_amount <= 0:
-            return "Wait for Dip (Price < Floor)", "N/A", "0%", "0%", "Low Probability"
-
-        # TP = Current Price + (Risk * RR Ratio)
-        target_tp = current_price + (risk_amount * rr_ratio)
-        
-        # Potential Gain/Loss Percentages
-        gain_pct = ((target_tp - current_price) / current_price) * 100
-        loss_pct = ((current_price - p10) / current_price) * 100
-
-        # Confidence Label
-        status = " HIGH" if certainty > 75 else " MED" if certainty > 50 else " LOW"
-
-        return (
-            f"${p10:.2f}", 
-            f"${target_tp:.2f}", 
-            f"+{gain_pct:.2f}%", 
-            f"-{loss_pct:.2f}%", 
-            f"{certainty:.1f}% ({status})"
-        )
-
-    except Exception as e:
-        return f"Error: {str(e)}", "", "", "", ""
-
-# 6. INTERFACE SETUP
-demo = gr.Interface(
-    fn=analyze_trade,
-    inputs=[
-        gr.Textbox(label="Stock History (Comma Separated)", placeholder="150, 152, 151, 155..."),
-        gr.Slider(minimum=1.0, maximum=5.0, value=2.0, label="Risk/Reward Ratio")
-    ],
-    outputs=[
-        gr.Text(label="Suggested Stop Loss"),
-        gr.Text(label="Suggested Take Profit"),
-        gr.Text(label="Potential Gain if Win"),
-        gr.Text(label="Potential Loss if Stopped"),
-        gr.Text(label="AI Confidence Level")
-    ],
-    title="Chronos-Bolt Live Analytics"
+# Load the model once on startup
+pipeline = ChronosPipeline.from_pretrained(
+    "amazon/chronos-t5-small", # or base/large depending on your Space hardware
+    device_map="auto",
+    torch_dtype=torch.bfloat16,
 )
 
-demo.launch()
+@app.post("/predict")
+async def predict(info: Request):
+    data = await info.json()
+    # Accept the full history array from your backend
+    history_array = data.get("history", []) 
+    prediction_length = data.get("forecast_horizon", 12) # e.g., next 12 periods
+    
+    # Convert to tensor
+    context = torch.tensor(history_array)
+    
+    # Chronos Prediction (Probabilistic)
+    # returns shape: (num_samples, prediction_length)
+    forecast = pipeline.predict(context, prediction_length)
+    
+    # Extract Quantiles (P10, P50, P90)
+    low_bound = np.percentile(forecast.numpy(), 10, axis=0)
+    median_pred = np.percentile(forecast.numpy(), 50, axis=0)
+    high_bound = np.percentile(forecast.numpy(), 90, axis=0)
+
+    # Trading Logic Calculations (Based on the first predicted step)
+    entry_price = history_array[-1]
+    predicted_next = median_pred[0]
+    p10_support = low_bound[0]
+    
+    # Stop Loss (SL) set at the Lower Bound (P10)
+    sl = p10_support
+    risk = entry_price - sl
+    
+    # Take Profit (TP) based on 2:1 RR Ratio
+    # Formula: Entry + (Risk * 2)
+    tp = entry_price + (risk * 2) if risk > 0 else entry_price * 1.05
+
+    # Verdict Logic
+    if predicted_next > entry_price and entry_price > p10_support:
+        verdict = "Strong Entry - Trend is Up"
+    elif predicted_next < entry_price:
+        verdict = "Wait - Potential Pullback Detected"
+    else:
+        verdict = "Neutral - High Volatility"
+
+    return {
+        "prediction": median_pred.tolist(),
+        "upper_bound": high_bound.tolist(),
+        "lower_bound": low_bound.tolist(),
+        "suggested_tp": round(tp, 2),
+        "suggested_sl": round(sl, 2),
+        "verdict": verdict,
+        "rr_ratio": "2:1"
+    }