Update utils/forex_signals.py

utils/forex_signals.py

@@ -4,78 +4,86 @@ import numpy as np
 
 API_KEY = "89SEdLScHxHk6j8J9OoH4sLFS3Mri4oW"
 
-CURRENCY_PAIRS = [
-    "EUR/USD", "GBP/USD", "USD/JPY", "AUD/USD",
-    "CAD/JPY", "NZD/USD", "CHF/JPY", "AUD/JPY",
-    "GBP/CHF", "EUR/GBP"
-]
-
-
 def fetch_forex_data(currency_pair):
     try:
-        # Convert the pair into the format required by the API (EURUSD, GBPUSD, etc.)
+        # Convert currency pair to API format (e.g., EUR/USD -> EURUSD)
         formatted_pair = currency_pair.replace("/", "")
         url = f"https://financialmodelingprep.com/api/v3/forex/{formatted_pair}?apikey={API_KEY}"
         response = requests.get(url)
         response.raise_for_status()
 
         data = response.json()
-
         if "historical" in data and len(data["historical"]) > 0:
-            return pd.DataFrame(data["historical"])
+            df = pd.DataFrame(data["historical"])
+            df["close"] = pd.to_numeric(df["close"], errors="coerce")
+            df.dropna(inplace=True)
+            return df
         else:
             print(f"No data available for {currency_pair}.")
             return None
     except Exception as e:
-        print(f"Error fetching data for {currency_pair}: {e}")
+        print(f"Error fetching data for {currency_pair}: {str(e)}")
         return None
 
 
 def calculate_indicators(df):
-    if df is None or df.empty:
-        return None
-
     try:
         df["SMA_50"] = df["close"].rolling(window=50).mean()
         df["SMA_200"] = df["close"].rolling(window=200).mean()
         df["RSI"] = compute_rsi(df["close"])
         return df
     except Exception as e:
-        print(f"Error calculating indicators: {e}")
+        print(f"Error calculating indicators: {str(e)}")
         return None
 
 
 def compute_rsi(series, period=14):
-    delta = series.diff(1)
-    gain = delta.where(delta > 0, 0)
-    loss = -delta.where(delta < 0, 0)
-
-    avg_gain = gain.rolling(window=period).mean()
-    avg_loss = loss.rolling(window=period).mean()
-
-    rs = avg_gain / avg_loss
+    delta = series.diff()
+    gain = (delta.where(delta > 0, 0)).rolling(window=period).mean()
+    loss = (-delta.where(delta < 0, 0)).rolling(window=period).mean()
+    rs = gain / loss
     rsi = 100 - (100 / (1 + rs))
     return rsi
 
 
-def generate_forex_signals():
-    signals = []
-
-    for pair in CURRENCY_PAIRS:
-        print(f"Processing currency pair: {pair}")
+def generate_forex_signals(trading_capital, market_risk, currency_pairs):
+    all_signals = []
+    best_signal = None
 
+    for pair in currency_pairs:
+        print(f"Processing {pair}...")
         df = fetch_forex_data(pair)
-        if df is None:
+        if df is None or df.empty:
             continue
 
         df = calculate_indicators(df)
         if df is None or df.empty:
             continue
 
-        # Check for crossover signals
         if df["SMA_50"].iloc[-1] > df["SMA_200"].iloc[-1] and df["RSI"].iloc[-1] < 70:
-            signals.append({"pair": pair, "signal": "Buy"})
+            signal = {
+                "currency_pair": pair,
+                "entry_time": df["date"].iloc[-1],
+                "exit_time": df["date"].iloc[-1],  # Placeholder; use a model to predict exit
+                "roi": np.random.uniform(1, 3),  # Simulated ROI
+                "signal_strength": "Strong Buy"
+            }
+            all_signals.append(signal)
         elif df["SMA_50"].iloc[-1] < df["SMA_200"].iloc[-1] and df["RSI"].iloc[-1] > 30:
-            signals.append({"pair": pair, "signal": "Sell"})
-
-    return signals
+            signal = {
+                "currency_pair": pair,
+                "entry_time": df["date"].iloc[-1],
+                "exit_time": df["date"].iloc[-1],  # Placeholder; use a model to predict exit
+                "roi": np.random.uniform(-3, -1),  # Simulated ROI
+                "signal_strength": "Strong Sell"
+            }
+            all_signals.append(signal)
+
+    # Determine the best signal based on ROI
+    if all_signals:
+        best_signal = max(all_signals, key=lambda x: x["roi"])
+
+    return {
+        "all_signals": all_signals,
+        "best_signal": best_signal
+    }