Create ai_mode.py

ai_mode.py

@@ -0,0 +1,284 @@
+import random
+import time
+from pocketoptionapi.stable_api import PocketOption
+import logging
+import pandas as pd
+import os
+from dotenv import load_dotenv,dotenv_values
+from stock_indicators import indicators
+from stock_indicators.indicators.common.quote import Quote
+import numpy as np
+from huggingface_hub import InferenceClient
+
+load_dotenv()
+
+# logging.basicConfig(level=logging.DEBUG, format='%(asctime)s %(message)s')
+ssid=os.getenv('ssid')
+api = PocketOption(ssid, True) # DEMO=True, ELSE=False
+Token=os.getenv('token')
+client = InferenceClient(
+    "meta-llama/Meta-Llama-3-8B-Instruct",
+    token=Token,
+)
+
+def fetch_candles(api, active, period, num_candles):
+    try:
+        synced_time = api.sync_datetime()
+        logging.info(f"Time synchronized before fetching data: {synced_time}")
+
+        retries = 22
+        while retries > 0:
+            try:
+                candles = api.get_candles(active, period)
+                candles_df = pd.DataFrame(candles)
+
+                if len(candles_df) > num_candles:
+                    candles_df = candles_df.iloc[-num_candles:]
+
+                logging.info(f"Fetched {len(candles_df)} candles for {active}")
+
+                if candles_df.isnull().values.any():
+                    logging.warning("Data contains NaN values. Replacing with zeros.")
+                    candles_df.fillna(0, inplace=True)
+
+                required_columns = ['time', 'open', 'high', 'low', 'close']
+                if 'volume' in candles_df.columns:
+                    required_columns.append('volume')
+
+                for col in required_columns:
+                    if col not in candles_df.columns:
+                        logging.error(f"Data for {active} is missing '{col}' column")
+                        logging.error(f"Available columns: {candles_df.columns.tolist()}")
+                        return pd.DataFrame()
+
+                candles_df['time'] = pd.to_datetime(candles_df['time'], unit='s')
+                logging.info(f"Candles data for {active}: \n{candles_df.head()}")
+                return candles_df
+            except Exception as e:
+                logging.error(f"Error fetching candles: {e}")
+                retries -= 1
+                if retries == 0:
+                    logging.error(f"Failed to fetch candles for {active} after multiple retries.")
+                    return pd.DataFrame()
+                time.sleep(1)
+    except Exception as e:
+        logging.error(f"Error fetching candles: {e}")
+        return pd.DataFrame()
+
+def calculate_indicators(candles_df):
+    # Convert candles to a format suitable for the indicators library
+    quotes = [
+        Quote(
+            date=row['time'],
+            open=row['open'],
+            high=row['high'],
+            low=row['low'],
+            close=row['close'],
+            volume=row['volume'] if 'volume' in row else 0
+        )
+        for _, row in candles_df.iterrows()
+    ]
+
+    # Calculate various indicators
+    keltner_results = indicators.get_keltner(quotes, 7, 2.0, 7)
+    macd_results = indicators.get_macd(quotes, 5, 15, 5)
+    rsi_results = indicators.get_rsi(quotes, 7)
+    supertrend_results = indicators.get_super_trend(quotes, 3, 2)
+    bollinger_results = indicators.get_bollinger_bands(quotes, 10, 2)
+    sma_results = indicators.get_sma(quotes, 20)
+    ema_results = indicators.get_ema(quotes, 20)
+    stoch_results = indicators.get_stoch(quotes, 14, 3, 3)
+    atr_results = indicators.get_atr(quotes, 14)
+    adx_results = indicators.get_adx(quotes, 14)
+
+    return {
+        "keltner": keltner_results,
+        "macd": macd_results,
+        "rsi": rsi_results,
+        "supertrend": supertrend_results,
+        "bollinger": bollinger_results,
+        "sma": sma_results,
+        "ema": ema_results,
+        "stochastic": stoch_results,
+        "atr": atr_results,
+        "adx": adx_results,
+        "quotes": quotes
+    }
+
+def calculate_smc(candles_df):
+    # Simple implementation of SMC concept (e.g., detecting break of structure)
+    high = candles_df['high']
+    low = candles_df['low']
+    close = candles_df['close']
+
+    swing_highs = (high.shift(1) < high) & (high.shift(-1) < high)
+    swing_lows = (low.shift(1) > low) & (low.shift(-1) > low)
+
+    last_swing_high = high[swing_highs].max()
+    last_swing_low = low[swing_lows].min()
+
+    return last_swing_high, last_swing_low
+
+def calculate_fibonacci(candles_df):
+    high = candles_df['high'].max()
+    low = candles_df['low'].min()
+    diff = high - low
+
+    levels = {
+        "0.0%": high,
+        "23.6%": high - 0.236 * diff,
+        "38.2%": high - 0.382 * diff,
+        "50.0%": high - 0.5 * diff,
+        "61.8%": high - 0.618 * diff,
+        "100.0%": low
+    }
+    
+    return levels
+
+def calculate_price_action(candles_df):
+    # Simple implementation of price action concept (e.g., detecting engulfing patterns)
+    candles_df['previous_close'] = candles_df['close'].shift(1)
+    candles_df['engulfing_bullish'] = (candles_df['close'] > candles_df['open']) & (candles_df['previous_close'] < candles_df['open'])
+    candles_df['engulfing_bearish'] = (candles_df['close'] < candles_df['open']) & (candles_df['previous_close'] > candles_df['open'])
+
+    return candles_df['engulfing_bullish'].any(), candles_df['engulfing_bearish'].any()
+
+def generate_trade_insight(asset, indicator_results, smc_levels, fib_levels, price_action_signals):
+    print("Hello there")
+    messages = [
+        {"role": "user",
+         "content": f"Provide a trade insight for {asset} based on the following indicators and levels: {indicator_results}, SMC Levels: {smc_levels}, Fibonacci Levels: {fib_levels}, Price Action Signals: {price_action_signals}"}
+    ]
+    print(f"asset: {asset} ,indicator_results: {indicator_results}, SMC Levels: {smc_levels}, Fibonacci Levels:{fib_levels}, Price Action Signals: {price_action_signals}")
+
+    response = ""
+    for message in client.chat_completion(
+        messages=messages,
+        max_tokens=500,
+        stream=True,
+    ):
+        print(message.choices[0].delta.content, end="")
+        response += message.choices[0].delta.content.strip()
+
+    print()
+
+    print(f"AI Trade Insight for {asset}: {response}")
+    return response
+
+def make_trade_decision(indicator_results, smc_levels, fib_levels, price_action_signals, ai_insight):
+    try:
+        # Ensure that there are results to process
+        for key in indicator_results:
+            if not indicator_results[key]:
+                logging.error(f"Indicator results for {key} are empty.")
+                return None
+
+        last_keltner = indicator_results["keltner"][-1]
+        last_macd = indicator_results["macd"][-1]
+        last_rsi = indicator_results["rsi"][-1]
+        last_supertrend = indicator_results["supertrend"][-1]
+        last_bollinger = indicator_results["bollinger"][-1]
+        last_stoch = indicator_results["stochastic"][-1]
+        last_atr = indicator_results["atr"][-1]
+        last_adx = indicator_results["adx"][-1]
+
+        upper_band = float(last_keltner.upper_band)
+        center_line = float(last_keltner.center_line)
+        lower_band = float(last_keltner.lower_band)
+        close_price = float(indicator_results["quotes"][-1].close)
+        macd_line = float(last_macd.macd)
+        signal_line = float(last_macd.signal)
+        rsi_value = float(last_rsi.rsi)
+        super_trend = float(last_supertrend.super_trend)
+        bollinger_upper = float(last_bollinger.upper_band)
+        bollinger_lower = float(last_bollinger.lower_band)
+        stoch_k = float(last_stoch.k)
+        stoch_d = float(last_stoch.d)
+        atr_value = float(last_atr.atr)
+        adx_value = float(last_adx.adx)
+
+        # Ensure that none of the required values are None
+        if any(value is None for value in
+               [macd_line, signal_line, rsi_value, upper_band, center_line, lower_band, close_price, super_trend,
+                bollinger_upper, bollinger_lower, stoch_k, stoch_d, atr_value, adx_value]):
+            logging.error(
+                f"One of the required values for decision making is None. Check the values.")
+            return None
+
+        last_swing_high, last_swing_low = smc_levels
+        fib_levels_values = fib_levels.values()
+        engulfing_bullish, engulfing_bearish = price_action_signals
+
+        # Uptrend
+        if macd_line > signal_line and rsi_value > 70 and close_price > super_trend and close_price > bollinger_upper:
+            if close_price > last_swing_high or engulfing_bullish:
+                return 'call'
+
+        # Downtrend
+        elif macd_line < signal_line and rsi_value < 30 and close_price < super_trend and close_price < bollinger_lower:
+            if close_price < last_swing_low or engulfing_bearish:
+                return 'put'
+
+        # Fibonacci retracement levels (optional logic)
+        if close_price in fib_levels_values:
+            if close_price == fib_levels["23.6%"] or close_price == fib_levels["38.2%"]:
+                return 'call'
+            elif close_price == fib_levels["61.8%"] or close_price == fib_levels["50.0%"]:
+                return 'put'
+
+        # AI Insight
+        if "call" in ai_insight.lower():
+            return 'call'
+        elif "put" in ai_insight.lower():
+            return 'put'
+
+        return None
+    except Exception as e:
+        logging.error(f"Error making trade decision: {e}")
+        return None
+
+if __name__ == "__main__":
+    api.connect()
+    time.sleep(2)
+
+    # List of currency pairs to analyze
+    currency_pairs = [
+        "AEDCNY_otc", "AUDCAD_otc", "AUDCHF_otc", "AUDUSD_otc", "CADCHF_otc", "AUDNZD_otc", "CADJPY_otc","BHDCNY_otc",
+        "CHFJPY_otc", "CHFNOK_otc","EURNZD_otc","EURTRY_otc","GBPJPY_otc","JODCNY_otc"
+    ]
+
+    while True:
+        try:
+            if api.check_connect():
+                print("Connected to the server")
+
+                for asset in currency_pairs:
+                    period = 60  # Set the period to 1 minute
+                    num_candles = 60  # Fetch enough candles for short period analysis
+
+                    candles_df = fetch_candles(api, asset, period, num_candles)
+                    if not candles_df.empty:
+                        indicator_results = calculate_indicators(candles_df)
+                        smc_levels = calculate_smc(candles_df)
+                        fib_levels = calculate_fibonacci(candles_df)
+                        price_action_signals = calculate_price_action(candles_df)
+                        ai_insight = generate_trade_insight(asset, indicator_results, smc_levels, fib_levels, price_action_signals)
+                        trade_direction = make_trade_decision(indicator_results, smc_levels, fib_levels, price_action_signals, ai_insight)
+                        if trade_direction:
+                            ido = api.buy(5, asset, trade_direction, 120)[1]  # Trade duration set to 120 seconds (2 minutes)
+                            print(f"Placed a {trade_direction} trade with ID: {ido} for {asset}")
+                            api.check_order_closed(ido)
+                        else:
+                            print(f"No trade decision yet for {asset}")
+
+                    else:
+                        print(f"Failed to fetch candle data for {asset}")
+
+                    # Add delay between checking each asset
+                    time.sleep(4)
+        except KeyboardInterrupt:
+            print("Terminating script")
+            break
+        except Exception as e:
+            logging.error(f"Error in main loop: {e}")
+            time.sleep(5)