Update app.py

app.py

@@ -1,63 +1,69 @@
-from fastapi import FastAPI, Request
-from chronos import ChronosPipeline
 import torch
 import numpy as np
+from fastapi import FastAPI, Request
+from chronos import ChronosPipeline
 
 app = FastAPI()
 
-# Load the model once on startup
+# Pipeline initialization with the corrected 'dtype'
 pipeline = ChronosPipeline.from_pretrained(
-    "amazon/chronos-t5-small", # or base/large depending on your Space hardware
+    "amazon/chronos-t5-small",
     device_map="auto",
-    torch_dtype=torch.bfloat16,
+    dtype=torch.bfloat16, 
 )
 
 @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
+async def get_forecast(request: Request):
+    # 1. Receive data from your backend
+    body = await request.json()
+    history = body.get("history", [])
+    user_rr = body.get("rr_ratio", 2.0)  # Default to 2:1 if not provided
     
-    # Convert to tensor
-    context = torch.tensor(history_array)
+    if not history:
+        return {"error": "No history data provided"}
+
+    # 2. Convert history to tensor (No length limit - uses your 2-3 year data)
+    context = torch.tensor(history)
     
-    # Chronos Prediction (Probabilistic)
-    # returns shape: (num_samples, prediction_length)
-    forecast = pipeline.predict(context, prediction_length)
+    # 3. Predict (Defaulting to 12 steps ahead)
+    # Chronos returns (num_samples, prediction_length)
+    forecast = pipeline.predict(context, prediction_length=12)
     
-    # Extract Quantiles (P10, P50, P90)
+    # 4. Extract Quantiles for Bounds
+    # P10 = Lower Bound, P50 = Median (Prediction), P90 = Upper Bound
     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]
+    # 5. Trading System Logic
+    entry_price = history[-1]
+    next_move = median_pred[0]
     
-    # Stop Loss (SL) set at the Lower Bound (P10)
-    sl = p10_support
-    risk = entry_price - sl
+    # Stop Loss (SL) based on the model's P10 (statistical support)
+    # We ensure SL is actually below entry; if not, we use a 2% buffer
+    sl = min(low_bound[0], entry_price * 0.98)
     
-    # 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
+    # Calculate Take Profit (TP) based on User RR Ratio
+    risk_amount = entry_price - sl
+    tp = entry_price + (risk_amount * user_rr)
 
-    # 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"
+    # 6. Verdict Engine
+    if next_move > entry_price * 1.01:
+        verdict = "Entry Confirmed: Upward momentum detected."
+    elif next_move < entry_price * 0.99:
+        verdict = "Wait: Potential pullback or downward trend."
     else:
-        verdict = "Neutral - High Volatility"
+        verdict = "Neutral: Sideways movement expected. Wait for breakout."
 
+    # 7. Response to Backend
     return {
+        "status": "success",
+        "entry": float(entry_price),
         "prediction": median_pred.tolist(),
         "upper_bound": high_bound.tolist(),
         "lower_bound": low_bound.tolist(),
-        "suggested_tp": round(tp, 2),
-        "suggested_sl": round(sl, 2),
+        "suggested_sl": round(float(sl), 2),
+        "suggested_tp": round(float(tp), 2),
         "verdict": verdict,
-        "rr_ratio": "2:1"
+        "rr_applied": f"{user_rr}:1"
     }