initialize

YOLO_WITH_ZSCORE/data.py

@@ -0,0 +1,61 @@
+import json
+import os
+
+# Load YOLO detection data (from the given file)
+yolo_file_path = '/media/gjin/New Volume/BACKTEST_DATA/black_edition_rolling_window_20_candlestick_5/json_data_folder/LINK_USDT_2024-12-02/LINK_USDT_17-27-55.json'
+
+with open(yolo_file_path, 'r') as f:
+    yolo_data = json.load(f)
+
+# Load Zscore signal data (from the given file)
+zscore_file_path = '/home/gjin/Documents/zscore/signalsLINK.json'
+
+with open(zscore_file_path, 'r') as f:
+    zscore_data = json.load(f)
+
+# Define a function to update the YOLO trend based on zscore detection
+def update_trend_with_zscore(yolo_data, zscore_data):
+    for yolo_entry in yolo_data:
+        symbol = yolo_entry['symbol']
+        date_and_time = yolo_entry['date_and_time']
+
+        # Normalize the symbol from zscore data (remove slash to match YOLO format)
+        normalized_symbol = symbol.replace('/', '')  # Example: "ADA/USDT" becomes "ADAUSDT"
+
+        # Match the YOLO entry with the zscore entry by symbol and timestamp
+        zscore_entry = next((item for item in zscore_data if item['symbol'].replace('/', '') == normalized_symbol and item['date_and_time'] == date_and_time), None)
+
+        if zscore_entry:
+            # If zscore detection is True and trend is "no trend", keep it as "no trend"
+            if zscore_entry['detection'] == 'True':
+                # Do not modify the trend if already set
+                if yolo_entry['trend'] == "no trend":
+                    # Only set zscore detection flag if trend is "no trend"
+                    yolo_entry['zscore_detection'] = True
+                else:
+                    # Keep existing trend, just add zscore detection flag
+                    if 'zscore_detection' not in yolo_entry:
+                        yolo_entry['zscore_detection'] = True
+            else:
+                # If zscore detection is False, set the trend to "no trend based on zscore detection"
+                yolo_entry['trend'] = "no trend based on zscore detection"
+                if 'zscore_detection' in yolo_entry:
+                    del yolo_entry['zscore_detection']
+
+        else:
+            print(f"No zscore data found for {symbol} at {date_and_time}")
+
+# Apply the function to update the YOLO data
+update_trend_with_zscore(yolo_data, zscore_data)
+
+# Define the output file path where the updated YOLO data will be saved
+output_file_path = '/home/gjin/Documents/zscore/YOLO_WITH_ZSCORE/LINK_USDT_19-09-41_updated.json'
+
+# Ensure the directory exists
+os.makedirs(os.path.dirname(output_file_path), exist_ok=True)
+
+# Save the updated YOLO data to the output file
+with open(output_file_path, 'w') as f:
+    json.dump(yolo_data, f, indent=4)
+
+print(f"Updated YOLO data has been saved to {output_file_path}")

alarm.py

@@ -0,0 +1,226 @@
+import json
+import os
+# import pyttsx3
+import telepot  # Import the Telepot library
+from datetime import datetime, timedelta, timezone
+from apscheduler.schedulers.blocking import BlockingScheduler
+from apscheduler.triggers.cron import CronTrigger
+import time  # Import the time module for sleep functionality
+
+# Path to the signals JSON file
+json_file_path = "/home/gjin/Documents/zscore/signals.json"
+
+# Telegram bot credentials
+BOT_TOKEN = '6787349532:AAGSwuiEJeykI2rQgsoB8C_iXZYKYuJyoOM'  # Replace with your bot token
+CHAT_ID = '-4284060853'  # Replace with your chat ID
+
+# Initialize the Telegram bot
+bot = telepot.Bot(BOT_TOKEN)
+
+# Initialize the pyttsx3 engine
+# engine = pyttsx3.init()
+
+# # Set a more natural speaking rate (around 150-160 words per minute)
+# engine.setProperty('rate', 155)  # Adjust this as needed
+# engine.setProperty('volume', 1.0)  # Max volume (range: 0.0 to 1.0)
+
+# Maintain a set of already processed alarms
+triggered_alarms = set()
+
+# Function to play alarm sound
+def play_alarm_sound():
+    try:
+        os.system("echo -e '\a'")  # Produces a beep sound on Linux/Unix. For Windows, use `winsound.Beep()`.
+    except Exception as e:
+        print(f"Error playing sound: {e}")
+
+# Function to speak the output (symbol, signal, zscore)
+# def speak_zscore_signal(symbol, signal, zscore, timeframe, realtime_ph_time):
+#     message = f"The signal for {symbol} is {signal} with a zscore of {zscore:.2f} timeframe is {timeframe}\n realtime_ph_time:{realtime_ph_time}"
+#     print(message)  # Print the message to the console as well
+#     engine.say(message)
+#     engine.runAndWait()
+
+# Function to send a Telegram message
+def send_telegram_message(symbol, signal, zscore, timeframe, realtime_ph_time):
+    try:
+        message = f"🚨 Alarm Triggered! \nSymbol: {symbol}\nSignal: {signal}\nZ-score: {zscore:.2f} \nTimeframe: {timeframe} \n realtime_ph_time:{realtime_ph_time}"
+        bot.sendMessage(CHAT_ID, message)
+        print(f"Telegram message sent: {message}")
+    except Exception as e:
+        print(f"Error sending Telegram message: {e}")
+
+# def check_recent_zscore_and_alarm(json_file_path):
+#     global triggered_alarms  # Access the global set of triggered alarms
+#     try:
+#         # Load the JSON data
+#         with open(json_file_path, "r") as file:
+#             data = json.load(file)
+
+#         # Get current UTC time and 1 hour ago in UTC
+#         current_utc_time = datetime.now(timezone.utc)
+#         one_hour_ago = current_utc_time - timedelta(hours=1)
+
+#         btcdom_triggered = False  # Flag to track if BTCDOM/USDT alarm has been triggered
+#         btcdom_zscore = None  # Variable to store the zscore for BTCDOM/USDT
+
+#         # Get the zscore for BTCDOM/USDT from the data
+#         for signal in data:
+#             if signal["symbol"] == "BTCDOM/USDT":
+#                 btcdom_zscore = signal["zscore"]
+#                 break
+
+#         for signal in data:
+#             # Parse signal date and time as UTC
+#             date_and_time = datetime.strptime(signal["date_and_time"], "%Y-%m-%d %H:%M:%S").replace(tzinfo=timezone.utc)
+#             zscore = signal["zscore"]
+#             symbol = signal["symbol"]
+#             time_frame = signal["time_frame"]
+#             realtime_ph_time = signal["realtime_ph_time"]
+
+#             # Create a unique identifier for this alarm
+#             alarm_id = f"{symbol}_{date_and_time.isoformat()}_{zscore:.2f}"
+
+#             # Check if the signal is within the last 1 hour in UTC
+#             if one_hour_ago <= date_and_time <= current_utc_time:
+#                 # If BTCDOM/USDT zscore is < -2 and the altcoin zscore is > +2
+#                 if btcdom_zscore < -2 and zscore > 2 and alarm_id not in triggered_alarms:
+#                     print(f"Strongly Sell Signal! {symbol} at {signal['date_and_time']} with zscore {zscore} time frame is {time_frame}, realtime_ph_time {realtime_ph_time}")
+#                     play_alarm_sound()
+#                     speak_zscore_signal(symbol, "Strongly Sell", zscore, time_frame, realtime_ph_time)
+#                     send_telegram_message(symbol, "Strongly Sell", zscore, time_frame, realtime_ph_time)
+#                     triggered_alarms.add(alarm_id)
+
+#                 # If BTCDOM/USDT zscore is > +2 and the altcoin zscore is < -2
+#                 elif btcdom_zscore > 2 and zscore < -2 and alarm_id not in triggered_alarms:
+#                     print(f"Strongly Buy Signal! {symbol} at {signal['date_and_time']} with zscore {zscore} time frame is {time_frame}")
+#                     play_alarm_sound()
+#                     speak_zscore_signal(symbol, "Strongly Buy", zscore, time_frame, realtime_ph_time)
+#                     send_telegram_message(symbol, "Strongly Buy", zscore, time_frame, realtime_ph_time)
+#                     triggered_alarms.add(alarm_id)
+
+#                 # Check for other conditions for Sell, Buy, Prepare for Sell, or Prepare for Buy
+#                 elif zscore > 2 and alarm_id not in triggered_alarms:  # Sell signal (zscore > +2)
+#                     print(f"Sell Signal! {symbol} at {signal['date_and_time']} with zscore {zscore} time frame is {time_frame}")
+#                     play_alarm_sound()
+#                     speak_zscore_signal(symbol, "Sell", zscore, time_frame, realtime_ph_time)
+#                     send_telegram_message(symbol, "Sell", zscore, time_frame, realtime_ph_time)
+#                     triggered_alarms.add(alarm_id)
+
+#                 elif zscore < -2 and alarm_id not in triggered_alarms:  # Buy signal (zscore < -2)
+#                     print(f"Buy Signal! {symbol} at {signal['date_and_time']} with zscore {zscore} time frame is {time_frame}")
+#                     play_alarm_sound()
+#                     speak_zscore_signal(symbol, "Buy", zscore, time_frame, realtime_ph_time)
+#                     send_telegram_message(symbol, "Buy", zscore, time_frame, realtime_ph_time)
+#                     triggered_alarms.add(alarm_id)
+
+#                 elif 1.5 < zscore <= 2 and alarm_id not in triggered_alarms:  # Prepare for Sell signal (0 < zscore <= 2)
+#                     print(f"Prepare for Sell! {symbol} at {signal['date_and_time']} with zscore {zscore} time frame is {time_frame}")
+#                     play_alarm_sound()
+#                     speak_zscore_signal(symbol, "Prepare for Sell/HOLD", zscore, time_frame, realtime_ph_time)
+#                     send_telegram_message(symbol, "Prepare for Sell/HOLD", zscore, time_frame, realtime_ph_time)
+#                     triggered_alarms.add(alarm_id)
+
+#                 elif -2 < zscore < -1.5 and alarm_id not in triggered_alarms:  # Prepare for Buy signal (-2 < zscore < 0)
+#                     print(f"Prepare for Buy! {symbol} at {signal['date_and_time']} with zscore {zscore} time frame is {time_frame}")
+#                     play_alarm_sound()
+#                     speak_zscore_signal(symbol, "Prepare for Buy/HOLD", zscore, time_frame, realtime_ph_time)
+#                     send_telegram_message(symbol, "Prepare for Buy/HOLD", zscore, time_frame, realtime_ph_time)
+#                     triggered_alarms.add(alarm_id)
+
+#         # Wait for 1 minute to avoid spamming
+#         time.sleep(60)
+
+#     except Exception as e:
+#         print(f"Error: {e}")
+# State tracking for each symbol
+zscore_states = {}
+
+def save_data(symbol, zscore, time_frame, realtime_ph_time):
+    # Save the Z-score data to a file or database for review
+    with open("zscore_data_log.txt", "a") as file:
+        file.write(f"{datetime.now()}, {symbol}, {zscore}, {time_frame}, {realtime_ph_time}\n")
+
+def check_recent_zscore_and_alarm(json_file_path):
+    global zscore_states  # Access the global state tracking
+    try:
+        with open(json_file_path, "r") as file:
+            data = json.load(file)
+
+        current_utc_time = datetime.now(timezone.utc)
+        one_hour_ago = current_utc_time - timedelta(hours=1)
+
+        for signal in data:
+            # Parse signal details
+            symbol = signal["symbol"]
+            zscore = signal["zscore"]
+            date_and_time = datetime.strptime(signal["date_and_time"], "%Y-%m-%d %H:%M:%S").replace(tzinfo=timezone.utc)
+            time_frame = signal["time_frame"]
+            realtime_ph_time = signal["realtime_ph_time"]
+            
+            # Skip processing signals outside the 1-hour window
+            if not (one_hour_ago <= date_and_time <= current_utc_time):
+                continue
+
+            # Initialize state tracking for the symbol
+            if symbol not in zscore_states:
+                zscore_states[symbol] = {"was_low": False, "was_high": False}
+
+            # Determine if an alarm should be triggered
+            state = zscore_states[symbol]
+
+            # Save data if Z-score hits extreme values (-2 or 2)
+            if zscore == -2 or zscore == 2:
+                save_data(symbol, zscore, time_frame, realtime_ph_time)
+                print(f"Data saved for {symbol} at Z-score: {zscore}")
+
+            # Alarm conditions
+            if zscore < -2:  # Z-score is very low (below -2, no alarm yet)
+                state["was_low"] = True
+                state["was_high"] = False
+
+            elif zscore > 2:  # Z-score is very high (above 2, no alarm yet)
+                state["was_high"] = True
+                state["was_low"] = False
+
+            elif -1.85 <= zscore < -1:  # Returning to mid-range from low extreme
+                if state["was_low"]:  # Trigger only if it was previously low
+                    print(f"Buy Alarm! {symbol} returning to range with Z-score {zscore}")
+                    play_alarm_sound()
+                    # speak_zscore_signal(symbol, "Buy Alarm", zscore, time_frame, realtime_ph_time)
+                    send_telegram_message(symbol, "Buy Alarm", zscore, time_frame, realtime_ph_time)
+                    state["was_low"] = False  # Reset the state
+
+            elif 1 <= zscore <= 1.85:  # Returning to mid-range from high extreme
+                if state["was_high"]:  # Trigger only if it was previously high
+                    print(f"Sell Alarm! {symbol} returning to range with Z-score {zscore}")
+                    play_alarm_sound()
+                    # speak_zscore_signal(symbol, "Sell Alarm", zscore, time_frame, realtime_ph_time)
+                    send_telegram_message(symbol, "Sell Alarm", zscore, time_frame, realtime_ph_time)
+                    state["was_high"] = False  # Reset the state
+
+        # Wait for 1 minute to avoid spamming
+        time.sleep(60)
+
+    except Exception as e:
+        print(f"Error: {e}")
+
+
+# Scheduler function to run every 3:55 to 4:10 and 7:55 to 8:10
+def scheduled_task():
+    check_recent_zscore_and_alarm(json_file_path)
+
+# Set up the scheduler
+scheduler = BlockingScheduler()
+trigger1 = CronTrigger(minute="55-59")
+trigger2 = CronTrigger(minute="00-10")
+# Define triggers
+# trigger1 = CronTrigger(minute="55-59", hour="3,7,11,15,19,23")
+# trigger2 = CronTrigger(minute="00-10", hour="4,8,12,16,20,0")
+
+# Add the jobs to the scheduler
+scheduler.add_job(scheduled_task, trigger1)
+scheduler.add_job(scheduled_task, trigger2)
+
+# Start the scheduler
+scheduler.start()

app.py

@@ -1,5 +0,0 @@
-import time
-
-while True:
-    print('hello world')
-    time.sleep(2)

image_coordinate.py

@@ -0,0 +1,54 @@
+import cv2
+
+# Load your image
+image = cv2.imread('/media/gjin/New Volume/BACKTEST_DATA/black_edition_rolling_window_50_candlestick_10/images_detection/4h/ADA_USDT_output_result_2024-10-09_16-00-00.jpg')
+original_image = image.copy()  # Keep a copy of the original image to reset after every frame
+
+# Get the dimensions of the image
+height, width, _ = image.shape
+
+# Define the step size for the grid
+step_x = 50  # Step size for x-axis
+step_y = 50  # Step size for y-axis
+
+# Draw grid lines
+def draw_grid(img):
+    for x in range(0, width, step_x):
+        cv2.line(img, (x, 0), (x, height), (0, 255, 0), 1)  # Draw green vertical lines
+        cv2.putText(img, str(x), (x + 5, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1)
+
+    for y in range(0, height, step_y):
+        cv2.line(img, (0, y), (width, y), (0, 255, 0), 1)  # Draw green horizontal lines
+        cv2.putText(img, str(y), (5, y + 15), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1)
+
+# Mouse callback function to display cursor details
+def show_mouse_position(event, x, y, flags, param):
+    global image
+    if event == cv2.EVENT_MOUSEMOVE:  # Track mouse movement
+        image = original_image.copy()  # Reset to original image every frame
+        draw_grid(image)
+
+        # Get the BGR color of the pixel at the cursor position
+        b, g, r = image[y, x]
+
+        # Display the x, y coordinates and BGR color values on the image
+        info_text = f"X: {x}, Y: {y}, Color: B: {b}, G: {g}, R: {r}"
+        cv2.putText(image, info_text, (10, height - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 0), 1)  # Text in black
+
+# Create a window
+cv2.namedWindow('Image with Grid and Coordinates', cv2.WND_PROP_FULLSCREEN)
+cv2.setWindowProperty('Image with Grid and Coordinates', cv2.WND_PROP_FULLSCREEN, cv2.WINDOW_FULLSCREEN)
+
+# Set the mouse callback function to track the cursor movement
+cv2.setMouseCallback('Image with Grid and Coordinates', show_mouse_position)
+
+# Draw initial grid
+draw_grid(image)
+
+# Display the image with grid and cursor details
+while True:
+    cv2.imshow('Image with Grid and Coordinates', image)
+    if cv2.waitKey(20) & 0xFF == 27:  # Press 'Esc' to exit
+        break
+
+cv2.destroyAllWindows()

main_with_plot copy.py

@@ -0,0 +1,205 @@
+import pandas as pd
+import ccxt
+import matplotlib.pyplot as plt
+import matplotlib.dates as mdates
+import json
+from datetime import datetime, timedelta
+import pytz
+
+# Prompt for the symbol and time frame
+symbols = input('Please input Symbol: ')
+timeframe = input("Please input time frame: ")
+
+# Initialize Binance Futures API
+binance = ccxt.binance({
+    'options': {'defaultType': 'future'},  # Specify futures
+})
+
+# Function to fetch historical data and calculate Z-Score
+def fetch_and_calculate_zscore(symbol, timeframe, since, limit=200, rolling_window=30):
+    data = binance.fetch_ohlcv(symbol, timeframe=timeframe, since=since, limit=limit)
+    df = pd.DataFrame(data, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
+    
+    # Convert timestamp to UTC datetime format
+    df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms', utc=True)
+    
+    # Calculate rolling mean, std, and Z-Score
+    df['mean'] = df['close'].rolling(window=rolling_window).mean()
+    df['std'] = df['close'].rolling(window=rolling_window).std()
+    df['z_score'] = (df['close'] - df['mean']) / df['std']
+    
+    # Initialize signal columns
+    df['buy_signal'] = 0
+    df['sell_signal'] = 0
+    
+    # Variables to track thresholds
+    in_sell_signal = False
+    in_buy_signal = False
+    signal_triggered = False  # Track if any signal was triggered
+
+    # Iterate through the dataframe to track signals
+    for i in range(1, len(df)):
+        current_z = df.loc[i, 'z_score']
+        previous_z = df.loc[i - 1, 'z_score']
+        
+        # Handle Z-score crossing extreme thresholds for sell signal
+        if not in_sell_signal:
+            # Z-score crosses above 1.85 (potential sell signal)
+            if current_z > 1.85 and previous_z <= 1.85:
+                print(f"Sell signal candidate at index {i}, Z-score = {current_z}")
+                in_sell_signal = True
+        
+        # Handle Z-score crossing extreme thresholds for buy signal
+        if not in_buy_signal:
+            # Z-score crosses below -1.85 (potential buy signal)
+            if current_z < -1.85 and previous_z >= -1.85:
+                print(f"Buy signal candidate at index {i}, Z-score = {current_z}")
+                in_buy_signal = True
+        
+        # Keep the signal active if the Z-score remains within the range
+        if in_sell_signal:
+            # Sell signal is triggered between 1.85 and 1
+            if 1 <= current_z <= 1.85:
+                df.loc[i, 'sell_signal'] = 1  # Sell signal active
+                print(f"Sell signal active at index {i}, Z-score = {current_z}")
+                signal_triggered = True
+            # Exit sell signal if Z-score falls below 1
+            elif current_z < 1:
+                in_sell_signal = False
+                print(f"Sell signal exited at index {i}, Z-score = {current_z}")
+        
+        if in_buy_signal:
+            # Buy signal is triggered between -1.85 and -1
+            if -1.85 <= current_z <= -1:
+                df.loc[i, 'buy_signal'] = 1  # Buy signal active
+                print(f"Buy signal active at index {i}, Z-score = {current_z}")
+                signal_triggered = True
+            # Exit buy signal if Z-score rises above -1
+            elif current_z > -1:
+                in_buy_signal = False
+                print(f"Buy signal exited at index {i}, Z-score = {current_z}")
+    
+    return df
+
+
+# Convert time to local timezone (Philippine Time)
+utc_time = datetime.utcnow()
+philippine_tz = pytz.timezone('Asia/Manila')
+philippine_time = pytz.utc.localize(utc_time).astimezone(philippine_tz)
+
+# Format the time in your preferred format
+formatted_ph_time = philippine_time.strftime("%Y-%m-%d %H:%M:%S")
+
+
+
+# Function to update signals in JSON with Z-Score (Appending to file)
+def update_signal_json(symbol, df, json_data):
+    # Extract latest data point
+    latest_data = df.iloc[-1]
+
+    # Check if the latest Z-score has a signal
+    signal_status = "True" if latest_data['buy_signal'] == 1 or latest_data['sell_signal'] == 1 else "False"
+
+    # Prepare new entry with real-time Z-Score
+    signal_entry = {
+        "symbol": symbol,
+        "time_frame": timeframe,
+        "date_and_time": latest_data['timestamp'].strftime("%Y-%m-%d %H:%M:%S"),
+        "realtime_ph_time": formatted_ph_time,  # Add the local Philippine time (UTC+8)
+        "current_price": latest_data['close'],
+        "zscore": latest_data['z_score'],
+        "detection": signal_status  # Add signal status
+    }
+
+    # Append new data to the existing list in json_data
+    json_data.append(signal_entry)
+
+    return json_data
+
+# Function to plot data
+def plot_data(btcdom_df, pair_df, btc_df, ax):
+    ax.clear()  # Clear previous plots
+
+    # Plot Z-Scores for all pairs
+    ax.plot(btcdom_df['timestamp'], btcdom_df['z_score'], label="BTCDOM/USDT Z-Score", color='blue', linestyle='-')
+    ax.plot(pair_df['timestamp'], pair_df['z_score'], label=f"{symbols}/USDT Z-Score", color='orange', linestyle='-')
+    ax.plot(btc_df['timestamp'], btc_df['z_score'], label="BTC/USDT Z-Score", color='gray', linestyle='-')
+    
+    # Add thresholds
+    ax.axhline(y=2, color='red', linestyle='--', label='Overbought Threshold')
+    ax.axhline(y=-2, color='green', linestyle='--', label='Oversold Threshold')
+
+    # Plot Buy and Sell signals for BTCDOM/USDT
+    ax.scatter(btcdom_df[btcdom_df['buy_signal'] == 1]['timestamp'], btcdom_df[btcdom_df['buy_signal'] == 1]['z_score'],
+               marker='^', color='green', label='BTCDOM Buy Signal')
+    ax.scatter(btcdom_df[btcdom_df['sell_signal'] == 1]['timestamp'], btcdom_df[btcdom_df['sell_signal'] == 1]['z_score'],
+               marker='v', color='red', label='BTCDOM Sell Signal')
+
+    # Plot signals for the other pair
+    ax.scatter(pair_df[pair_df['buy_signal'] == 1]['timestamp'], pair_df[pair_df['buy_signal'] == 1]['z_score'],
+               marker='^', color='green', alpha=0.5, label=f"{symbols} Buy Signal")
+    ax.scatter(pair_df[pair_df['sell_signal'] == 1]['timestamp'], pair_df[pair_df['sell_signal'] == 1]['z_score'],
+               marker='v', color='red', alpha=0.5, label=f"{symbols} Sell Signal")
+
+    # Format plot
+    ax.set_title(f"Z-Scores Signals {timeframe} for {symbols}/USDT Futures", fontsize=16)
+    ax.set_xlabel("Time (UTC)", fontsize=12)
+    ax.set_ylabel("Z-Score", fontsize=12)
+    ax.xaxis.set_major_formatter(mdates.DateFormatter("%Y-%m-%d %H:%M"))
+    ax.legend(loc="upper left")
+    ax.grid(True)
+    plt.xticks(rotation=45)
+    
+    plt.draw()  # Redraw the plot
+    plt.pause(0.1)  # Pause to allow plot to update
+
+# Function to run historical data processing
+def run_historical():
+    json_data = []
+    try:
+        with open('signals.json', 'r') as file:
+            json_data = json.load(file)
+    except FileNotFoundError:
+        pass
+
+    fig, ax = plt.subplots(figsize=(14, 7))
+
+    # Set start and end dates for the loop
+    start_date = datetime(2023, 1, 1)
+    end_date = datetime(2024, 1, 1)
+
+    # Loop through each month in the date range (or week, depending on your choice)
+    current_date = start_date
+    while current_date < end_date:
+        # Set 'since' to the start of each month or week (whichever you prefer)
+        since = binance.parse8601(current_date.strftime('%Y-%m-%dT%H:%M:%SZ'))
+
+        btcdom_symbol = 'BTCDOM/USDT'
+        pair_symbol = f'{symbols}/USDT'
+        btc_symbol = 'BTC/USDT'
+
+        # Fetch and process data
+        btcdom_df = fetch_and_calculate_zscore(btcdom_symbol, timeframe, since)
+        pair_df = fetch_and_calculate_zscore(pair_symbol, timeframe, since)
+        btc_df = fetch_and_calculate_zscore(btc_symbol, timeframe, since)
+
+        # Update signals and append to JSON
+        json_data = update_signal_json(pair_symbol, pair_df, json_data)
+        json_data = update_signal_json(btc_symbol, btc_df, json_data)
+        json_data = update_signal_json(btcdom_symbol, btcdom_df, json_data)
+
+        # Save updated signals to JSON
+        with open('signals.json', 'w') as file:
+            json.dump(json_data, file, indent=4)
+
+        # Plot the data
+        plot_data(btcdom_df, pair_df, btc_df, ax)
+
+        # Display the plot after each loop
+        plt.show()  # Show the plot for the current iteration
+
+        # Move to the next chunk (next month/week)
+        current_date += timedelta(weeks=4)
+
+# Run the historical data processing
+run_historical()

main_with_plot.py

@@ -0,0 +1,193 @@
+import pandas as pd
+import numpy as np
+import ccxt
+import matplotlib.pyplot as plt
+import matplotlib.dates as mdates
+import time
+import json
+from datetime import datetime
+import pytz
+
+# Prompt for the symbol
+symbols = input('Please input Symbol: ')
+timeframe = input("please input time frame: ")
+# Initialize Binance Futures API
+binance = ccxt.binance({
+    'options': {'defaultType': 'future'},  # Specify futures
+})
+def fetch_and_calculate_zscore(symbol, timeframe=timeframe, limit=200, rolling_window=30):
+    # Fetch OHLCV data
+    data = binance.fetch_ohlcv(symbol, timeframe=timeframe, limit=limit)
+    df = pd.DataFrame(data, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
+    # Convert timestamp to UTC datetime format
+    df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms', utc=True)
+    
+    # Calculate rolling mean, std, and Z-Score
+    df['mean'] = df['close'].rolling(window=rolling_window).mean()
+    df['std'] = df['close'].rolling(window=rolling_window).std()
+    df['z_score'] = (df['close'] - df['mean']) / df['std']
+    
+    # Initialize signal columns
+    df['buy_signal'] = 0
+    df['sell_signal'] = 0
+    
+    # Variables to track thresholds
+    in_sell_signal = False
+    in_buy_signal = False
+    signal_triggered = False  # Track if any signal was triggered
+
+    # Iterate through the dataframe to track signals
+    for i in range(1, len(df)):
+        current_z = df.loc[i, 'z_score']
+        previous_z = df.loc[i - 1, 'z_score']
+        
+        # Handle Z-score crossing extreme thresholds for sell signal
+        if not in_sell_signal:
+            # Z-score crosses above 1.85 (potential sell signal)
+            if current_z > 1.85 and previous_z <= 1.85:
+                #print(f"Sell signal candidate at index {i}, Z-score = {current_z}")
+                in_sell_signal = True
+        
+        # Handle Z-score crossing extreme thresholds for buy signal
+        if not in_buy_signal:
+            # Z-score crosses below -1.85 (potential buy signal)
+            if current_z < -1.85 and previous_z >= -1.85:
+                #print(f"Buy signal candidate at index {i}, Z-score = {current_z}")
+                in_buy_signal = True
+        
+        # Keep the signal active if the Z-score remains within the range
+        if in_sell_signal:
+            # Sell signal is triggered between 1.85 and 1
+            if 1 <= current_z <= 1.85:
+                df.loc[i, 'sell_signal'] = 1  # Sell signal active
+                #print(f"Sell signal active at index {i}, Z-score = {current_z}")
+                signal_triggered = True
+            # Exit sell signal if Z-score falls below 1
+            elif current_z < 1:
+                in_sell_signal = False
+                #print(f"Sell signal exited at index {i}, Z-score = {current_z}")
+        
+        if in_buy_signal:
+            # Buy signal is triggered between -1.85 and -1
+            if -1.85 <= current_z <= -1:
+                df.loc[i, 'buy_signal'] = 1  # Buy signal active
+                #print(f"Buy signal active at index {i}, Z-score = {current_z}")
+                signal_triggered = True
+            # Exit buy signal if Z-score rises above -1
+            elif current_z > -1:
+                in_buy_signal = False
+                #print(f"Buy signal exited at index {i}, Z-score = {current_z}")
+    
+    return df
+
+
+
+utc_time = datetime.utcnow()
+
+philippine_tz = pytz.timezone('Asia/Manila')
+philippine_time = pytz.utc.localize(utc_time).astimezone(philippine_tz)
+
+# Format the time in your preferred format
+formatted_ph_time = philippine_time.strftime("%Y-%m-%d %H:%M:%S")
+# Function to update signals in JSON
+# Function to update signals in JSON with real-time Z-Score
+def update_signal_json(symbol, df, json_data):
+    # Extract latest data point
+    latest_data = df.iloc[-1]
+
+    # Prepare new entry with real-time Z-Score
+    signal_entry = {
+        "symbol": symbol,
+        "time_frame": timeframe,
+        "date_and_time": latest_data['timestamp'].strftime("%Y-%m-%d %H:%M:%S"),
+        "realtime_ph_time": formatted_ph_time,  # Add the local Philippine time (UTC+8)
+        "current_price": latest_data['close'],
+        "zscore": latest_data['z_score']
+    }
+
+    # Remove previous entries for this symbol
+    json_data = [entry for entry in json_data if entry['symbol'] != symbol]
+
+    # Add the latest entry
+    json_data.append(signal_entry)
+
+    return json_data
+
+
+# Function to plot data
+def plot_data(btcdom_df, pair_df, btc_df, ax):
+    ax.clear()  # Clear previous plotspython /home/gjin/Documents/zscore/main_with_plot.py
+
+    # Plot Z-Scores for all pairs
+    ax.plot(btcdom_df['timestamp'], btcdom_df['z_score'], label="BTCDOM/USDT Z-Score", color='blue', linestyle='-')
+    ax.plot(pair_df['timestamp'], pair_df['z_score'], label=f"{symbols}/USDT Z-Score", color='orange', linestyle='-')
+    ax.plot(btc_df['timestamp'], btc_df['z_score'], label="BTC/USDT Z-Score", color='gray', linestyle='-')
+    
+    # Add thresholds
+    ax.axhline(y=2, color='red', linestyle='--', label='Overbought Threshold')
+    ax.axhline(y=-2, color='green', linestyle='--', label='Oversold Threshold')
+
+    # Plot Buy and Sell signals for BTCDOM/USDT
+    ax.scatter(btcdom_df[btcdom_df['buy_signal'] == 1]['timestamp'], btcdom_df[btcdom_df['buy_signal'] == 1]['z_score'],
+               marker='^', color='green', label='BTCDOM Buy Signal')
+    ax.scatter(btcdom_df[btcdom_df['sell_signal'] == 1]['timestamp'], btcdom_df[btcdom_df['sell_signal'] == 1]['z_score'],
+               marker='v', color='red', label='BTCDOM Sell Signal')
+
+    # Plot signals for the other pair
+    ax.scatter(pair_df[pair_df['buy_signal'] == 1]['timestamp'], pair_df[pair_df['buy_signal'] == 1]['z_score'],
+               marker='^', color='green', alpha=0.5, label=f"{symbols} Buy Signal")
+    ax.scatter(pair_df[pair_df['sell_signal'] == 1]['timestamp'], pair_df[pair_df['sell_signal'] == 1]['z_score'],
+               marker='v', color='red', alpha=0.5, label=f"{symbols} Sell Signal")
+
+    # Format plot
+    ax.set_title(f"Z-Scores Signals {timeframe} for {symbols}/USDT Futures", fontsize=16)
+    ax.set_xlabel("Time (UTC)", fontsize=12)
+    ax.set_ylabel("Z-Score", fontsize=12)
+    ax.xaxis.set_major_formatter(mdates.DateFormatter("%Y-%m-%d %H:%M"))
+    ax.legend(loc="upper left")
+    ax.grid(True)
+    plt.xticks(rotation=45)
+
+# Real-time monitoring
+# Real-time monitoring
+def run_real_time():
+    json_data = []
+    try:
+        with open('signals.json', 'r') as file:
+            json_data = json.load(file)
+    except FileNotFoundError:
+        pass
+
+    fig, ax = plt.subplots(figsize=(14, 7))
+    plt.ion()  # Interactive plotting
+
+    while True:
+        btcdom_symbol = 'BTCDOM/USDT'
+        pair_symbol = f'{symbols}/USDT'
+        btc_symbol = 'BTC/USDT'
+
+        btcdom_df = fetch_and_calculate_zscore(btcdom_symbol)
+        pair_df = fetch_and_calculate_zscore(pair_symbol)
+        btc_df = fetch_and_calculate_zscore(btc_symbol)
+
+        # Update JSON for BTCDOM
+        json_data = update_signal_json(btcdom_symbol, btcdom_df, json_data)
+
+        # Update JSON for selected pair
+        json_data = update_signal_json(pair_symbol, pair_df, json_data)
+
+        # Update JSON for BTC/USDT
+        json_data = update_signal_json(btc_symbol, btc_df, json_data)
+
+        # Save updated JSON
+        with open('signals.json', 'w') as file:
+            json.dump(json_data, file, indent=4)
+
+        # Update plot
+        plot_data(btcdom_df, pair_df, btc_df, ax)
+        plt.draw()
+        plt.pause(60)  # Update every 60 seconds
+        time.sleep(60)
+
+# Run the real-time system
+run_real_time()

main_with_plot_image_send.py

@@ -0,0 +1,196 @@
+import pandas as pd
+import numpy as np
+import ccxt
+import matplotlib.pyplot as plt
+import matplotlib.dates as mdates
+import time
+import json
+from datetime import datetime
+import pytz
+import telepot
+import os
+
+# Constants
+BOT_TOKEN = '6787349532:AAGSwuiEJeykI2rQgsoB8C_iXZYKYuJyoOM'  # Replace with your bot token
+CHAT_ID = '-4284060853'  # Replace with your chat ID
+
+bot = telepot.Bot(BOT_TOKEN)
+
+# Prompt for the symbol
+symbols = ['ADA/USDT', 'ATOM/USDT', 'XRP/USDT']
+timeframes = ['1h', '4h']
+
+# Directories to save images
+base_directory = '../zscore'
+image_directories = {
+    '1h': os.path.join(base_directory, 'images_1h'),
+    '4h': os.path.join(base_directory, 'images_4h')
+}
+for directory in image_directories.values():
+    os.makedirs(directory, exist_ok=True)
+
+# Initialize Binance Futures API
+binance = ccxt.binance({
+    'options': {'defaultType': 'future'},  # Specify futures
+})
+
+def fetch_and_calculate_zscore(symbol, timeframe, limit=200, rolling_window=30):
+    # Fetch OHLCV data
+    data = binance.fetch_ohlcv(symbol, timeframe=timeframe, limit=limit)
+    df = pd.DataFrame(data, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
+    # Convert timestamp to UTC datetime format
+    df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms', utc=True)
+    
+    # Calculate rolling mean, std, and Z-Score
+    df['mean'] = df['close'].rolling(window=rolling_window).mean()
+    df['std'] = df['close'].rolling(window=rolling_window).std()
+    df['z_score'] = (df['close'] - df['mean']) / df['std']
+    
+    # Initialize signal columns
+    df['buy_signal'] = 0
+    df['sell_signal'] = 0
+    
+    # Variables to track thresholds
+    in_sell_signal = False
+    in_buy_signal = False
+    signal_triggered = False  # Track if any signal was triggered
+
+    # Iterate through the dataframe to track signals
+    for i in range(1, len(df)):
+        current_z = df.loc[i, 'z_score']
+        previous_z = df.loc[i - 1, 'z_score']
+        
+        # Handle Z-score crossing extreme thresholds for sell signal
+        if not in_sell_signal:
+            if current_z > 1.85 and previous_z <= 1.85:
+                in_sell_signal = True
+        
+        # Handle Z-score crossing extreme thresholds for buy signal
+        if not in_buy_signal:
+            if current_z < -1.85 and previous_z >= -1.85:
+                in_buy_signal = True
+        
+        # Keep the signal active if the Z-score remains within the range
+        if in_sell_signal:
+            if 1 <= current_z <= 1.85:
+                df.loc[i, 'sell_signal'] = 1
+                signal_triggered = True
+            elif current_z < 1:
+                in_sell_signal = False
+        
+        if in_buy_signal:
+            if -1.85 <= current_z <= -1:
+                df.loc[i, 'buy_signal'] = 1
+                signal_triggered = True
+            elif current_z > -1:
+                in_buy_signal = False
+    
+    return df
+
+utc_time = datetime.utcnow()
+philippine_tz = pytz.timezone('Asia/Manila')
+philippine_time = pytz.utc.localize(utc_time).astimezone(philippine_tz)
+formatted_ph_time = philippine_time.strftime("%Y-%m-%d %H:%M:%S")
+
+# Function to update signals in JSON with real-time Z-Score
+def update_signal_json(symbol, df, timeframe, json_data):
+    latest_data = df.iloc[-1]
+    signal_entry = {
+        "symbol": symbol,
+        "time_frame": timeframe,
+        "date_and_time": latest_data['timestamp'].strftime("%Y-%m-%d %H:%M:%S"),
+        "realtime_ph_time": formatted_ph_time,
+        "current_price": latest_data['close'],
+        "zscore": latest_data['z_score']
+    }
+    json_data = [entry for entry in json_data if not (entry['symbol'] == symbol and entry['time_frame'] == timeframe)]
+    json_data.append(signal_entry)
+    return json_data
+
+# Function to plot data for a single symbol including BTCDOM and BTC
+def plot_data(pair_df, btcdom_df, btc_df, symbol, timeframe, ax):
+    ax.clear()
+
+    # Plot Z-Scores for all pairs
+    ax.plot(btcdom_df['timestamp'], btcdom_df['z_score'], label="BTCDOM/USDT Z-Score", color='blue', linestyle='-')
+    ax.plot(pair_df['timestamp'], pair_df['z_score'], label=f"{symbol} Z-Score", color='orange', linestyle='-')
+    ax.plot(btc_df['timestamp'], btc_df['z_score'], label="BTC/USDT Z-Score", color='gray', linestyle='-')
+    
+    # Add thresholds
+    ax.axhline(y=2, color='red', linestyle='--', label='Overbought Threshold')
+    ax.axhline(y=-2, color='green', linestyle='--', label='Oversold Threshold')
+
+    # Plot Buy and Sell signals for the pair
+    ax.scatter(pair_df[pair_df['buy_signal'] == 1]['timestamp'], pair_df[pair_df['buy_signal'] == 1]['z_score'],
+               marker='^', color='green', label=f"{symbol} Buy Signal")
+    ax.scatter(pair_df[pair_df['sell_signal'] == 1]['timestamp'], pair_df[pair_df['sell_signal'] == 1]['z_score'],
+               marker='v', color='red', label=f"{symbol} Sell Signal")
+
+    # Format plot
+    ax.set_title(f"Z-Scores Signals {timeframe} for {symbol}", fontsize=16)
+    ax.set_xlabel("Time (UTC)", fontsize=12)
+    ax.set_ylabel("Z-Score", fontsize=12)
+    ax.xaxis.set_major_formatter(mdates.DateFormatter("%Y-%m-%d %H:%M"))
+    ax.legend(loc="upper left")
+    ax.grid(True)
+    plt.xticks(rotation=45)
+
+# Real-time monitoring
+def run_real_time():
+    json_data = []
+    try:
+        with open('signals.json', 'r') as file:
+            json_data = json.load(file)
+    except FileNotFoundError:
+        pass
+
+    while True:
+        for timeframe in timeframes:
+            btcdom_symbol = 'BTCDOM/USDT'
+            btc_symbol = 'BTC/USDT'
+            btcdom_df = fetch_and_calculate_zscore(btcdom_symbol, timeframe)
+            btc_df = fetch_and_calculate_zscore(btc_symbol, timeframe)
+
+            # Send announcement message for the timeframe
+            message = f"{timeframe} time frame for {', '.join(symbols)}"
+            bot.sendMessage(chat_id=CHAT_ID, text=message)
+
+            media_group = []
+            for symbol in symbols:
+                pair_df = fetch_and_calculate_zscore(symbol, timeframe)
+
+                # Update JSON for the pair, BTCDOM, and BTC
+                json_data = update_signal_json(symbol, pair_df, timeframe, json_data)
+                json_data = update_signal_json(btcdom_symbol, btcdom_df, timeframe, json_data)
+                json_data = update_signal_json(btc_symbol, btc_df, timeframe, json_data)
+
+                # Create a new figure for each symbol and timeframe
+                fig, ax = plt.subplots(figsize=(14, 7))
+                plot_data(pair_df, btcdom_df, btc_df, symbol, timeframe, ax)
+                plt.tight_layout()
+                # Save image to the specified directory based on the timeframe
+                image_path = os.path.join(image_directories[timeframe], f"{symbol.lower().replace('/', '_')}_{timeframe}.png")
+                plt.savefig(image_path)
+                plt.close(fig)  # Close the figure to free memory
+
+                # Add image to media group
+                media_group.append({'media': open(image_path, 'rb'), 'type': 'photo'})
+
+            # Send the media group to Telegram
+            try:
+                bot.sendMediaGroup(
+                    chat_id=CHAT_ID,
+                    media=media_group,
+                    disable_notification=True
+                )
+            except Exception as e:
+                print(f"Failed to send media group for {timeframe} to Telegram: {e}")
+
+            # Save updated JSON for both timeframes
+            with open('signals.json', 'w') as file:
+                json.dump(json_data, file, indent=4)
+
+        time.sleep(60)  # Wait for 60 seconds before next update
+
+# Run the real-time system
+run_real_time()

signals.json

@@ -0,0 +1,134 @@
+[
+    {
+        "symbol": "1000SHIB/USDT",
+        "time_frame": "1h",
+        "date_and_time": "2025-02-17 16:00:00",
+        "realtime_ph_time": "2025-02-18 00:54:17",
+        "current_price": 0.015581,
+        "zscore": -2.970455641927065
+    },
+    {
+        "symbol": "1000PEPE/USDT",
+        "time_frame": "1h",
+        "date_and_time": "2025-02-18 23:00:00",
+        "realtime_ph_time": "2025-02-19 00:31:52",
+        "current_price": 0.0092516,
+        "zscore": -0.848579839750643
+    },
+    {
+        "symbol": "ETH/USDT",
+        "time_frame": "1h",
+        "date_and_time": "2025-02-19 04:00:00",
+        "current_price": 2674.99,
+        "zscore": -0.09842164703262933,
+        "buy_signal": 0,
+        "sell_signal": 0
+    },
+    {
+        "symbol": "ETH/USDT",
+        "time_frame": "4h",
+        "date_and_time": "2025-02-19 04:00:00",
+        "current_price": 2675.0,
+        "zscore": -0.7886916975900665,
+        "buy_signal": 0,
+        "sell_signal": 0
+    },
+    {
+        "symbol": "DOGE/USDT",
+        "time_frame": "1h",
+        "date_and_time": "2025-02-19 04:00:00",
+        "current_price": 0.25039,
+        "zscore": -0.23689684021453575,
+        "buy_signal": 0,
+        "sell_signal": 0
+    },
+    {
+        "symbol": "DOGE/USDT",
+        "time_frame": "4h",
+        "date_and_time": "2025-02-19 04:00:00",
+        "current_price": 0.25038,
+        "zscore": -1.38866466036044,
+        "buy_signal": 1,
+        "sell_signal": 0
+    },
+    {
+        "symbol": "ADA/USDT",
+        "time_frame": "1h",
+        "date_and_time": "2025-02-19 05:00:00",
+        "realtime_ph_time": "2025-02-19 13:24:07",
+        "current_price": 0.736,
+        "zscore": -1.3425889423872113
+    },
+    {
+        "symbol": "ATOM/USDT",
+        "time_frame": "1h",
+        "date_and_time": "2025-02-19 05:00:00",
+        "realtime_ph_time": "2025-02-19 13:24:07",
+        "current_price": 4.508,
+        "zscore": -0.9086170027253152
+    },
+    {
+        "symbol": "XRP/USDT",
+        "time_frame": "1h",
+        "date_and_time": "2025-02-19 05:00:00",
+        "realtime_ph_time": "2025-02-19 13:24:07",
+        "current_price": 2.5169,
+        "zscore": -1.001519813480331
+    },
+    {
+        "symbol": "BTCDOM/USDT",
+        "time_frame": "1h",
+        "date_and_time": "2025-02-19 05:00:00",
+        "realtime_ph_time": "2025-02-19 13:24:07",
+        "current_price": 3746.0,
+        "zscore": 0.5070158300134885
+    },
+    {
+        "symbol": "BTC/USDT",
+        "time_frame": "1h",
+        "date_and_time": "2025-02-19 05:00:00",
+        "realtime_ph_time": "2025-02-19 13:24:07",
+        "current_price": 95045.5,
+        "zscore": -0.4977546948967619
+    },
+    {
+        "symbol": "ADA/USDT",
+        "time_frame": "4h",
+        "date_and_time": "2025-02-19 04:00:00",
+        "realtime_ph_time": "2025-02-19 13:24:07",
+        "current_price": 0.7357,
+        "zscore": -2.297588101404301
+    },
+    {
+        "symbol": "ATOM/USDT",
+        "time_frame": "4h",
+        "date_and_time": "2025-02-19 04:00:00",
+        "realtime_ph_time": "2025-02-19 13:24:07",
+        "current_price": 4.507,
+        "zscore": -1.8724272039451528
+    },
+    {
+        "symbol": "XRP/USDT",
+        "time_frame": "4h",
+        "date_and_time": "2025-02-19 04:00:00",
+        "realtime_ph_time": "2025-02-19 13:24:07",
+        "current_price": 2.5161,
+        "zscore": -1.8578167868901203
+    },
+    {
+        "symbol": "BTCDOM/USDT",
+        "time_frame": "4h",
+        "date_and_time": "2025-02-19 04:00:00",
+        "realtime_ph_time": "2025-02-19 13:24:07",
+        "current_price": 3747.3,
+        "zscore": 1.7310390668012654
+    },
+    {
+        "symbol": "BTC/USDT",
+        "time_frame": "4h",
+        "date_and_time": "2025-02-19 04:00:00",
+        "realtime_ph_time": "2025-02-19 13:24:07",
+        "current_price": 95040.0,
+        "zscore": -1.4683861167984986
+    }
+]

yolo11n.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0ebbc80d4a7680d14987a577cd21342b65ecfd94632bd9a8da63ae6417644ee1
+size 5613764

zscore_backtest.py

@@ -0,0 +1,213 @@
+import pandas as pd
+import ccxt
+import matplotlib.pyplot as plt
+import matplotlib.dates as mdates
+import json
+from datetime import datetime, timedelta
+import pytz
+import os
+images_folder = '/home/gjin/Documents/zscore/images'
+os.makedirs(images_folder, exist_ok=True)
+
+
+# Prompt for the symbol and time frame
+symbols = input('Please input Symbol: ')
+timeframe = input("Please input time frame: ")
+
+# Initialize Binance Futures API
+binance = ccxt.binance({
+    'options': {'defaultType': 'future'},  # Specify futures
+})
+
+
+
+from tqdm import tqdm
+import pandas as pd
+
+def fetch_and_calculate_zscore(symbol, timeframe, since, limit=200, rolling_window=30):
+    data = binance.fetch_ohlcv(symbol, timeframe=timeframe, since=since, limit=limit)
+    df = pd.DataFrame(data, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
+    
+    # Convert timestamp to UTC datetime format
+    df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms', utc=True)
+    
+    # Calculate rolling mean, std, and Z-Score
+    df['mean'] = df['close'].rolling(window=rolling_window).mean()
+    df['std'] = df['close'].rolling(window=rolling_window).std()
+    df['z_score'] = (df['close'] - df['mean']) / df['std']
+    
+    # Initialize signal columns
+    df['buy_signal'] = 0
+    df['sell_signal'] = 0
+    
+    # Variables to track thresholds and state
+    in_sell_signal = False
+    in_buy_signal = False
+    crossed_threshold = False  # Track if the extreme threshold has been crossed (2 or -2)
+    
+    # Iterate through the dataframe to track signals with tqdm progress bar
+    for i in tqdm(range(1, len(df)), desc="Processing Z-score signals"):
+        current_z = df.loc[i, 'z_score']
+        
+        # Track when Z-score crosses the thresholds (2 and -2)
+        if current_z > 2 and not crossed_threshold:  # If Z-score exceeds 2
+            crossed_threshold = True
+            in_sell_signal = True  # Trigger sell signal
+        
+        elif current_z < -2 and not crossed_threshold:  # If Z-score falls below -2
+            crossed_threshold = True
+            in_buy_signal = True  # Trigger buy signal
+        
+        # Maintain sell signal between 1 and 2
+        if in_sell_signal:
+            if 1 <= current_z <= 2:
+                df.loc[i, 'sell_signal'] = 1  # Sell signal active
+            # Exit sell signal if Z-score falls below 1
+            elif current_z < 1:
+                in_sell_signal = False
+                crossed_threshold = False  # Reset threshold crossing
+        
+        # Maintain buy signal between -2 and -1
+        if in_buy_signal:
+            if -2 <= current_z <= -1:
+                df.loc[i, 'buy_signal'] = 1  # Buy signal active
+            # Exit buy signal if Z-score rises above -1
+            elif current_z > -1:
+                in_buy_signal = False
+                crossed_threshold = False  # Reset threshold crossing
+    
+    return df
+
+
+
+
+
+
+# Convert time to local timezone (Philippine Time)
+utc_time = datetime.utcnow()
+philippine_tz = pytz.timezone('Asia/Manila')
+philippine_time = pytz.utc.localize(utc_time).astimezone(philippine_tz)
+
+# Format the time in your preferred format
+formatted_ph_time = philippine_time.strftime("%Y-%m-%d %H:%M:%S")
+
+
+
+
+latest_data  = []
+def update_signal_json(symbol, df, json_data):
+    # Extract the latest data point from the DataFrame
+    global latest_data
+    latest_data = df.iloc[-1]  # Update to get the last row
+
+    # Get the timestamp from the latest data and format it
+    timestamp = latest_data['timestamp'].strftime("%Y-%m-%d %H:%M:%S") if isinstance(latest_data['timestamp'], pd.Timestamp) else str(latest_data['timestamp'])
+
+    # Check if the latest Z-score has a signal
+    signal_status = "True" if latest_data['buy_signal'] == 1 or latest_data['sell_signal'] == 1 else "False"
+
+    # Prepare new entry with real-time Z-Score
+    signal_entry = {
+        "symbol": symbol,
+        "time_frame": timeframe,  # Make sure `timeframe` is defined or passed to this function
+        "date_and_time": timestamp,  # Correct timestamp for the entry
+        "realtime_ph_time": formatted_ph_time,  # Add the local Philippine time (UTC+8)
+        "current_price": latest_data['close'],  # Closing price for the most recent entry
+        "zscore": latest_data['z_score'],  # Z-Score value
+        "detection": signal_status  # Add signal status
+    }
+
+    # Append the new data to the json_data list
+    json_data.append(signal_entry)
+
+    return json_data
+
+def plot_data(btcdom_df, pair_df, btc_df):
+    fig, ax = plt.subplots(figsize=(14, 7))
+
+    # Clear previous plots
+    ax.clear()
+
+    # Plot Z-Scores for all pairs
+    ax.plot(btcdom_df['timestamp'], btcdom_df['z_score'], label="BTCDOM/USDT Z-Score", color='blue', linestyle='-')
+    ax.plot(pair_df['timestamp'], pair_df['z_score'], label=f"{symbols}/USDT Z-Score", color='orange', linestyle='-')
+    ax.plot(btc_df['timestamp'], btc_df['z_score'], label="BTC/USDT Z-Score", color='gray', linestyle='-')
+    
+    # Add thresholds
+    ax.axhline(y=2, color='red', linestyle='--', label='Overbought Threshold')
+    ax.axhline(y=-2, color='green', linestyle='--', label='Oversold Threshold')
+
+    # Plot Buy and Sell signals for BTCDOM/USDT
+    ax.scatter(btcdom_df[btcdom_df['buy_signal'] == 1]['timestamp'], btcdom_df[btcdom_df['buy_signal'] == 1]['z_score'],
+               marker='^', color='green', label='BTCDOM Buy Signal')
+    ax.scatter(btcdom_df[btcdom_df['sell_signal'] == 1]['timestamp'], btcdom_df[btcdom_df['sell_signal'] == 1]['z_score'],
+               marker='v', color='red', label='BTCDOM Sell Signal')
+
+    # Plot signals for the other pair
+    ax.scatter(pair_df[pair_df['buy_signal'] == 1]['timestamp'], pair_df[pair_df['buy_signal'] == 1]['z_score'],
+               marker='^', color='green', alpha=0.5, label=f"{symbols} Buy Signal")
+    ax.scatter(pair_df[pair_df['sell_signal'] == 1]['timestamp'], pair_df[pair_df['sell_signal'] == 1]['z_score'],
+               marker='v', color='red', alpha=0.5, label=f"{symbols} Sell Signal")
+
+    # Format plot
+    ax.set_title(f"Z-Scores Signals {timeframe} for {symbols}/USDT Futures", fontsize=16)
+    ax.set_xlabel("Time (UTC)", fontsize=12)
+    ax.set_ylabel("Z-Score", fontsize=12)
+    ax.xaxis.set_major_formatter(mdates.DateFormatter("%Y-%m-%d %H:%M"))
+    ax.legend(loc="upper left")
+    ax.grid(True)
+    plt.xticks(rotation=45)
+
+    # Save each plot with unique filename
+    global latest_data
+    plot_filename = f"/home/gjin/Documents/zscore/images/zscore_plot_{symbols}_{latest_data['timestamp'].strftime('%Y%m%d_%H%M%S')}.png"
+    plt.savefig(plot_filename)
+    plt.close(fig)  # Close the figure to prevent memory issues
+
+    # plt.close(fig)  # Close the figure to prevent memory issues
+
+# Function to run historical data processing
+def run_historical():
+    json_data = []
+    try:
+        with open(f'signals_{symbols}.json', 'r') as file:
+            json_data = json.load(file)
+    except FileNotFoundError:
+        pass
+
+    # Set start and end dates for the loop
+    start_date = datetime(2024, 9, 1)
+    end_date = datetime(2024, 11, 27)
+
+    # Loop through each month in the date range (or week, depending on your choice)
+    current_date = start_date
+    while current_date < end_date:
+        # Set 'since' to the start of each month or week (whichever you prefer)
+        since = binance.parse8601(current_date.strftime('%Y-%m-%dT%H:%M:%SZ'))
+
+        btcdom_symbol = 'BTCDOM/USDT'
+        pair_symbol = f'{symbols}/USDT'
+        btc_symbol = 'BTC/USDT'
+
+        # Fetch and process data
+        btcdom_df = fetch_and_calculate_zscore(btcdom_symbol, timeframe, since)
+        pair_df = fetch_and_calculate_zscore(pair_symbol, timeframe, since)
+        btc_df = fetch_and_calculate_zscore(btc_symbol, timeframe, since)
+
+        # Update signals and append to JSON
+        json_data = update_signal_json(pair_symbol, pair_df, json_data)
+        json_data = update_signal_json(btc_symbol, btc_df, json_data)
+        json_data = update_signal_json(btcdom_symbol, btcdom_df, json_data)
+
+        # Save updated signals to JSON
+        with open(f'signals{symbols}.json', 'w') as file:
+            json.dump(json_data, file, indent=4)
+
+        # Plot the data and save each plot separately
+        plot_data(btcdom_df, pair_df, btc_df)
+
+        # Move to the next chunk (next month/week)
+        current_date += timedelta(hours=4)
+
+# Start historical data processing
+run_historical()