Update app.py

app.py

@@ -146,14 +146,13 @@ def build_expired_message(symbol, hi_bid, lo_ask, target_up, target_down, durati
 def monitor_price_dual(target_up, target_down, duration_minutes, symbol=SYMBOL_DEFAULT):
     """
     Monitor both upside and downside targets. Synchronous call.
-    Returns final JSON result and sends alert message to fixed webhook.
+    On hit/expired, sends alert message to fixed webhook.
+    Returns a final dict, but in async usage we don't return it to client.
     """
     if duration_minutes <= 0:
-        msg = "Configuration error: duration must be > 0."
-        return {"status": "error", "message": msg}, 400
+        return {"status": "error", "message": "Configuration error: duration must be > 0."}
     if target_up <= target_down:
-        msg = "Configuration error: target_up must be greater than target_down."
-        return {"status": "error", "message": msg}, 400
+        return {"status": "error", "message": "Configuration error: target_up must be greater than target_down."}
 
     # Initial fetch with retry
     retries, snap = 0, None
@@ -166,7 +165,7 @@ def monitor_price_dual(target_up, target_down, duration_minutes, symbol=SYMBOL_D
                 time.sleep(delay)
             else:
                 msg = "Unable to retrieve initial price snapshot."
-                return {"status": "error", "message": msg}, 502
+                return {"status": "error", "message": msg}
 
     t_start = datetime.datetime.now()
     t_end = t_start + datetime.timedelta(minutes=duration_minutes)
@@ -181,34 +180,14 @@ def monitor_price_dual(target_up, target_down, duration_minutes, symbol=SYMBOL_D
         elapsed_min = (datetime.datetime.now() - t_start).total_seconds() / 60
         message = build_upside_message(symbol, bid0, ask0, target_up, target_down, elapsed_min, hi_bid, lo_ask)
         send_alert_message(message)
-        return {
-            "status": "hit",
-            "side": "upside",
-            "message": message,
-            "symbol": symbol,
-            "bid": bid0,
-            "ask": ask0,
-            "hi_bid": hi_bid,
-            "lo_ask": lo_ask,
-            "elapsed_min": round(elapsed_min, 4)
-        }, 200
+        return {"status": "hit", "side": "upside", "message": message}
 
     if ask0 <= target_down:
         play_alert_sound()
         elapsed_min = (datetime.datetime.now() - t_start).total_seconds() / 60
         message = build_downside_message(symbol, bid0, ask0, target_up, target_down, elapsed_min, hi_bid, lo_ask)
         send_alert_message(message)
-        return {
-            "status": "hit",
-            "side": "downside",
-            "message": message,
-            "symbol": symbol,
-            "bid": bid0,
-            "ask": ask0,
-            "hi_bid": hi_bid,
-            "lo_ask": lo_ask,
-            "elapsed_min": round(elapsed_min, 4)
-        }, 200
+        return {"status": "hit", "side": "downside", "message": message}
 
     ticks = 0
     try:
@@ -228,34 +207,14 @@ def monitor_price_dual(target_up, target_down, duration_minutes, symbol=SYMBOL_D
                 elapsed_min = (datetime.datetime.now() - t_start).total_seconds() / 60
                 message = build_upside_message(symbol, bid, ask, target_up, target_down, elapsed_min, hi_bid, lo_ask)
                 send_alert_message(message)
-                return {
-                    "status": "hit",
-                    "side": "upside",
-                    "message": message,
-                    "symbol": symbol,
-                    "bid": bid,
-                    "ask": ask,
-                    "hi_bid": hi_bid,
-                    "lo_ask": lo_ask,
-                    "elapsed_min": round(elapsed_min, 4)
-                }, 200
+                return {"status": "hit", "side": "upside", "message": message}
 
             if ask <= target_down:
                 play_alert_sound()
                 elapsed_min = (datetime.datetime.now() - t_start).total_seconds() / 60
                 message = build_downside_message(symbol, bid, ask, target_up, target_down, elapsed_min, hi_bid, lo_ask)
                 send_alert_message(message)
-                return {
-                    "status": "hit",
-                    "side": "downside",
-                    "message": message,
-                    "symbol": symbol,
-                    "bid": bid,
-                    "ask": ask,
-                    "hi_bid": hi_bid,
-                    "lo_ask": lo_ask,
-                    "elapsed_min": round(elapsed_min, 4)
-                }, 200
+                return {"status": "hit", "side": "downside", "message": message}
 
             # Optional: light logging cadence
             ticks += 1
@@ -268,26 +227,33 @@ def monitor_price_dual(target_up, target_down, duration_minutes, symbol=SYMBOL_D
         # Expiry
         message = build_expired_message(symbol, hi_bid, lo_ask, target_up, target_down, duration_minutes)
         send_alert_message(message)
-        return {
-            "status": "expired",
-            "side": None,
-            "message": message,
-            "symbol": symbol,
-            "hi_bid": hi_bid,
-            "lo_ask": lo_ask,
-            "duration_minutes": duration_minutes
-        }, 200
+        return {"status": "expired", "message": message}
 
     except Exception as e:
         message = f"Unexpected error: {e}"
-        return {"status": "error", "message": message}, 500
+        send_alert_message(f"[ERROR] {message}")
+        return {"status": "error", "message": message}
+
+def start_monitor_async(symbol: str, target_up: float, target_down: float, duration_minutes: int):
+    """
+    Start monitor_price_dual in a daemon thread (non-blocking).
+    """
+    def _runner():
+        try:
+            result = monitor_price_dual(target_up, target_down, duration_minutes, symbol=symbol)
+            # Optional: log final result
+            print(f"[MONITOR-END] {symbol} result: {result}")
+        except Exception as e:
+            print(f"[MONITOR-THREAD] Error: {e}")
+    t = threading.Thread(target=_runner, daemon=True)
+    t.start()
 
 # ========== API Endpoints ==========
 
 @app.route("/monitor", methods=["POST"])
 def start_monitor():
     """
-    Start monitoring and block until it hits a target or expires.
+    Start monitoring asynchronously and immediately return 200.
     Payload:
     {
       "symbol": "XAUUSD",        // optional, default XAUUSD
@@ -295,8 +261,8 @@ def start_monitor():
       "target_down": 2475.0,     // required
       "duration_minutes": 15     // required
     }
-    Response: final result JSON (hit/expired/error)
-    Also sends POST to ALERT_WEBHOOK_URL with { "message": "..." } on hit/expired.
+    Immediate Response:
+      { "status": "accepted", "message": "Okay your alert added succes" }
     """
     try:
         data = request.get_json(force=True)
@@ -311,6 +277,7 @@ def start_monitor():
     if target_up is None or target_down is None or duration_minutes is None:
         return jsonify({"status": "error", "message": "target_up, target_down, duration_minutes are required"}), 400
 
+    # Basic type validation before starting async work
     try:
         target_up = float(target_up)
         target_down = float(target_down)
@@ -318,16 +285,26 @@ def start_monitor():
     except Exception:
         return jsonify({"status": "error", "message": "Invalid types: target_up/target_down must be float, duration_minutes must be int"}), 400
 
-    result, code = monitor_price_dual(target_up, target_down, duration_minutes, symbol=symbol)
-    return jsonify(result), code
+    if duration_minutes <= 0:
+        return jsonify({"status": "error", "message": "duration_minutes must be > 0"}), 400
+    if target_up <= target_down:
+        return jsonify({"status": "error", "message": "target_up must be greater than target_down"}), 400
+
+    # Start monitoring in background thread
+    start_monitor_async(symbol, target_up, target_down, duration_minutes)
+
+    # Immediate success response
+    return jsonify({"status": "accepted", "message": "Okay your alert added succes"}), 200
 
 @app.route("/", methods=["GET"])
 def root():
     return jsonify({
-        "service": "Forex Trade Alert API (single-system)",
+        "service": "Forex Trade Alert API (async monitor)",
         "fixed_alert_webhook": ALERT_WEBHOOK_URL,
-        "endpoint": "POST /monitor"
+        "endpoint": "POST /monitor",
+        "behavior": "returns immediately; monitoring runs in background"
     }), 200
 
 if __name__ == "__main__":
+    # threaded=True is fine; we also use daemon threads for monitors
     app.run(host="0.0.0.0", port=7860, debug=False, threaded=True)