Update app.py

app.py

@@ -1,13 +1,14 @@
-import time
-import json
 import requests
+import json
+import time
 import re
 import logging
+from datetime import datetime, timedelta
 from flask import Flask, jsonify
 from apscheduler.schedulers.background import BackgroundScheduler
-from datetime import datetime, timedelta
-from db import deeper, signals
-from ai import analyze_forex_pairs
+from apscheduler.triggers.cron import CronTrigger
+from db.signals import fetch_json_from_github, update_user_json_file, fetch_authenticity_token_and_commit_oid
+from ai import analyze_forex_pairs  # Import the updated analyze_forex_pairs function
 
 # Configure logging
 logging.basicConfig(
@@ -24,284 +25,271 @@ TELEGRAM_TOKEN = "7750258010:AAEfEn1Hc1h0n6uRc1KcPdZf7ozBEkehnEY"
 TELEGRAM_CHAT_ID = "6859142642"
 TELEGRAM_CHAT_ID2 = "5666511049"
 
-def send_telegram_message(message):
-    """Send message to Telegram user"""
+def send_telegram_message(text):
+    """Send a message to Telegram."""
     url = f"https://api.telegram.org/bot{TELEGRAM_TOKEN}/sendMessage"
     data = {
         "chat_id": TELEGRAM_CHAT_ID,
-        "text": message,
+        "text": text,
         "parse_mode": "HTML"
     }
     data2 = {
         "chat_id": TELEGRAM_CHAT_ID2,
-        "text": message,
+        "text": text,
         "parse_mode": "HTML"
     }
     try:
-        logger.info(f"Sending Telegram message to chat ID: {TELEGRAM_CHAT_ID}")
         response = requests.post(url, data=data)
         response2 = requests.post(url, data=data2)
-        response_json = response.json()
-
-        if response_json.get("ok"):
-            logger.info("Telegram message sent successfully")
-            return response_json
-        else:
-            logger.error(f"Telegram API error: {response_json.get('description', 'Unknown error')}")
-            return None
+        return response.json()
     except Exception as e:
-        logger.error(f"Error sending Telegram message: {e}", exc_info=True)
-        return None
-
-def get_active_signals():
-    """Get all active signals from the signals database"""
-    signals_response = signals.fetch_json_from_github()
-
-    if not signals_response["success"]:
-        logger.error(f"Error fetching signals data: {signals_response['message']}")
-        return "لا توجد صفقات نشطة حالياً."
+        logger.error(f"Error sending Telegram message: {e}")
+        return {"ok": False, "error": str(e)}
 
-    signals_data = signals_response["data"]
-
-    # Defensive check - ensure signals_data is a list
-    if not isinstance(signals_data, list) or len(signals_data) == 0:
-        logger.warning("No active signals found in database")
-        return "لا توجد صفقات نشطة حالياً."
-
-    deals_string = []
-    for signal in signals_data:
-        deal = f"الزوج: {signal.get('pair', '')}, "
-        deal += f"النوع: {signal.get('type', '')}, "
-        deal += f"سعر الدخول: {signal.get('entry', '')}, "
-        deal += f"وقف الخسارة: {signal.get('stop_loss', '')}, "
-        deal += f"الهدف: {signal.get('take_profit', '')}"
-        deals_string.append(deal)
-
-    if not deals_string:
-        return "لا توجد صفقات نشطة حالياً."
-
-    return "\n".join(deals_string)
-
-def extract_signal_from_ai_response(response):
-    """Extract signal data from AI response if present"""
-    signal_pattern = r'<signal>(.*?)</signal>'
-    match = re.search(signal_pattern, response, re.DOTALL)
-
-    if not match:
-        return None
-
-    signal_text = match.group(1)
-
-    # Extract individual fields from signal - full format
-    pair_match = re.search(r'<pair>(.*?)</pair>', signal_text, re.DOTALL)
-    type_match = re.search(r'<type>(.*?)</type>', signal_text, re.DOTALL)
-    entry_match = re.search(r'<entry>(.*?)</entry>', signal_text, re.DOTALL)
-    stop_loss_match = re.search(r'<stop_loss>(.*?)</stop_loss>', signal_text, re.DOTALL)
-    take_profit_match = re.search(r'<take_profit>(.*?)</take_profit>', signal_text, re.DOTALL)
-    duration_match = re.search(r'<duration>(.*?)</duration>', signal_text, re.DOTALL)
-    reason_match = re.search(r'<reason>(.*?)</reason>', signal_text, re.DOTALL)
-
-    # Create signal dictionary
-    signal_data = {
-        "pair": pair_match.group(1).strip() if pair_match else "",
-        "timeframe": "15min",  # Default timeframe
-        "type": type_match.group(1).strip() if type_match else "",
-        "entry": entry_match.group(1).strip() if entry_match else "",
-        "stop_loss": stop_loss_match.group(1).strip() if stop_loss_match else "",
-        "take_profit": take_profit_match.group(1).strip() if take_profit_match else "",
-        "duration": duration_match.group(1).strip() if duration_match else "1-3 ساعات",
-        "reason": reason_match.group(1).strip() if reason_match else "تم التحليل بواسطة النظام الآلي",
-        "status": "starting"
+def send_to_api(pair_name, message):
+    """Send the message to the external API."""
+    url = "https://forextrade-app.hf.space/api/message"  # Replace with your actual API URL
+    data = {
+        "pair_name": pair_name,
+        "message": message
     }
 
-    return signal_data
-
-def check_if_pairs_exist_in_signals(pairs_list):
-    """Check if a list of pairs already exists in the signals database"""
-    signals_response = signals.fetch_json_from_github()
-
-    if not signals_response["success"]:
-        logger.error(f"Error fetching signals data: {signals_response['message']}")
-        return False
-
-    signals_data = signals_response["data"]
-
-    # Defensive check - ensure signals_data is a list
-    if not isinstance(signals_data, list):
-        logger.warning(f"signals_data is not a list (type: {type(signals_data)}), converting to empty list")
-        signals_data = []
-
-    # Convert pairs_list to a sorted JSON string for consistent comparison
-    pairs_json = json.dumps(sorted(pairs_list), ensure_ascii=False)
-
-    # Check if pairs list exists
-    for signal in signals_data:
-        if "pairs" in signal and json.dumps(sorted(signal.get("pairs", [])), ensure_ascii=False) == pairs_json:
-            return True
-
-    return False
-
-def update_signals_file(signal_data, pairs_list):
-    """Update signals JSON file with new signal data including pairs list"""
-    # Fetch current signals data
-    signals_response = signals.fetch_json_from_github()
-
-    if not signals_response["success"]:
-        logger.error(f"Error fetching signals data: {signals_response['message']}")
-        return False
-
-    signals_data = signals_response["data"]
-
-    # Defensive check - ensure signals_data is a list
-    if not isinstance(signals_data, list):
-        logger.warning(f"signals_data is not a list (type: {type(signals_data)}), converting to empty list")
-        signals_data = []
-
-    # Add pairs list to the signal data
-    signal_data["pairs"] = pairs_list
-
-    # Add new signal
-    signals_data.append(signal_data)
-
-    # Get authenticity token and commit OID for signals file
-    auth_token, commit_oid = signals.fetch_authenticity_token_and_commit_oid()
-    if not auth_token or not commit_oid:
-        logger.error("Failed to get authenticity token or commit OID for signals file")
-        return False
-
-    # Update the signals file - using json.dumps with separators to ensure a single line
-    update_response = signals.update_user_json_file(
-        auth_token,
-        commit_oid,
-        json.dumps(signals_data, ensure_ascii=False, separators=(',', ':'))
-    )
-
-    return update_response["success"]
-
-def remove_group_from_deeper(group_key):
-    """Remove analyzed group from deeper.json file"""
-    # Fetch current deeper data
-    deeper_response = deeper.fetch_json_from_github()
-
-    if not deeper_response["success"]:
-        logger.error(f"Error fetching deeper data: {deeper_response['message']}")
-        return False
-
-    deeper_data = deeper_response["data"]
+    headers = {
+        "Content-Type": "application/json"
+    }
 
-    # Remove the group from forwards if it exists
-    if group_key in deeper_data.get("forwards", {}):
-        del deeper_data["forwards"][group_key]
+    try:
+        response = requests.post(url, json=data, headers=headers, timeout=30)
+        response.raise_for_status()
+        return {"success": True, "response": response.json()}
+    except requests.exceptions.RequestException as e:
+        logger.error(f"API request error: {e}")
+        return {"success": False, "error": str(e)}
+    except Exception as e:
+        logger.error(f"Unexpected error sending to API: {e}")
+        return {"success": False, "error": str(e)}
 
-    # Get authenticity token and commit OID for deeper file
-    auth_token, commit_oid = deeper.fetch_authenticity_token_and_commit_oid()
-    if not auth_token or not commit_oid:
-        logger.error("Failed to get authenticity token or commit OID for deeper file")
-        return False
+def extract_message_content(analysis_text, pair_name):
+    """Extract message, reason, prediction, and advice from the analysis text."""
+    try:
+        # Check for regular message
+        message_match = re.search(r'<send_message>\s*<message>(.*?)</message>\s*<reason>(.*?)</reason>\s*<Prediction>(.*?)</Prediction>\s*<Advice>(.*?)</Advice>\s*</send_message>',
+                                analysis_text, re.DOTALL)
+
+        if message_match:
+            message = message_match.group(1).strip()
+            reason = message_match.group(2).strip()
+            prediction = message_match.group(3).strip()
+            advice = message_match.group(4).strip()
+
+            return {
+                "type": "regular",
+                "message": message,
+                "reason": reason,
+                "prediction": prediction,
+                "advice": advice,
+                "full_message": f"🔹 {pair_name} 🔹\n\n💬 الرسالة: {message}\n\n📝 النصيحة: {advice}"
+            }
+
+        # Check for close deal message
+        close_match = re.search(r'<close_deal>(.*?)</close_deal>', analysis_text, re.DOTALL)
+        if close_match:
+            close_reason = close_match.group(1).strip()
+            return {
+                "type": "close",
+                "reason": close_reason,
+                "full_message": f"🔴 إغلاق صفقة 🔴\n\n🔹 {pair_name} 🔹\n\n⛔️ تم إغلاق الصفقة\n\n🧠 السبب: {close_reason}"
+            }
 
-    # Update the deeper file - using json.dumps with separators to ensure a single line
-    update_response = deeper.update_user_json_file(
-        auth_token,
-        commit_oid,
-        json.dumps(deeper_data, ensure_ascii=False, separators=(',', ':'))
-    )
+        return None
+    except Exception as e:
+        logger.error(f"Error extracting message content: {e}")
+        return None
 
-    return update_response["success"]
+def extract_all_messages(analysis_text):
+    """Extract all messages for different pairs from the analysis text."""
+    try:
+        # First check if there are any pair-specific sections
+        pair_sections = re.findall(r'🔹 ([A-Z]+) 🔹(.*?)(?=🔹 [A-Z]+ 🔹|$)', analysis_text, re.DOTALL)
+
+        if pair_sections:
+            results = {}
+            for pair, content in pair_sections:
+                # Check for regular message
+                message_match = re.search(r'💬 الرسالة: (.*?)(?=🧠 السبب:|$)', content, re.DOTALL)
+                reason_match = re.search(r'🧠 السبب: (.*?)(?=🔮 التوقع:|$)', content, re.DOTALL)
+                prediction_match = re.search(r'🔮 التوقع: (.*?)(?=📝 النصيحة:|$)', content, re.DOTALL)
+                advice_match = re.search(r'📝 النصيحة: (.*?)$', content, re.DOTALL)
+
+                close_match = re.search(r'⛔️ تم إغلاق الصفقة\s*🧠 السبب: (.*?)$', content, re.DOTALL)
+
+                if message_match and reason_match and prediction_match and advice_match:
+                    message = message_match.group(1).strip()
+                    reason = reason_match.group(1).strip()
+                    prediction = prediction_match.group(1).strip()
+                    advice = advice_match.group(1).strip()
+
+                    results[pair] = {
+                        "type": "regular",
+                        "message": message,
+                        "reason": reason,
+                        "prediction": prediction,
+                        "advice": advice,
+                        "full_message": f"🔹 {pair} 🔹\n\n💬 الرسالة: {message}\n\n📝 النصيحة: {advice}"
+                    }
+                elif close_match:
+                    close_reason = close_match.group(1).strip()
+                    results[pair] = {
+                        "type": "close",
+                        "reason": close_reason,
+                        "full_message": f"🔴 إغلاق صفقة 🔴\n\n🔹 {pair} 🔹\n\n⛔️ تم إغلاق الصفقة\n\n🧠 السبب: {close_reason}"
+                    }
+
+            return results
+        else:
+            # Fall back to the old extraction method if no pair-specific sections are found
+            return None
+    except Exception as e:
+        logger.error(f"Error extracting all messages: {e}")
+        return None
 
-def format_telegram_message(signal_data):
-    """تنسيق إشارة الفوركس للإرسال عبر تيليجرام - بصيغة احترافية"""
-    message = "🔔 <b>إشارة فوركس جديدة</b> 🔔\n\n"
-    message += f"<b>🔹 الزوج:</b> {signal_data['pair']}\n"
-    message += f"<b>📊 النوع:</b> {signal_data['type']}\n"
-    message += f"<b>🎯 الدخول:</b> {signal_data['entry']}\n"
-    message += f"<b>🛡️ وقف الخسارة:</b> {signal_data['stop_loss']}\n"
-    message += f"<b>✨ الهدف:</b> {signal_data['take_profit']}\n"
+def format_deal_details(signal):
+    """Format the signal details for the AI analysis."""
+    details = f"زوج: {signal.get('pair')}, "
+    details += f"نوع: {signal.get('type')}, "
+    details += f"سعر الدخول: {signal.get('entry')}, "
+    details += f"وقف الخسارة: {signal.get('stop_loss')}, "
+    details += f"هدف الربح: {signal.get('take_profit')}, "
+    details += f"المدة: {signal.get('duration')}, "
+    details += f"السبب: {signal.get('reason')}"
 
-    return message
+    return details
 
-def analyze_forex_groups():
-    """Function to analyze forex groups from the deeper.json file"""
-    logger.info("Starting forex group analysis cycle")
+def check_and_process_signals():
+    """Check for signals and process them."""
+    current_time = datetime.now()
+    logger.info(f"Processing signals at candle close: {current_time.strftime('%Y-%m-%d %H:%M:%S')}")
 
     try:
-        # Fetch data from deeper.json
-        deeper_response = deeper.fetch_json_from_github()
-
-        if not deeper_response["success"]:
-            logger.error(f"Error fetching deeper data: {deeper_response['message']}")
-            return
+        # Fetch the signals from GitHub
+        result = fetch_json_from_github()
 
-        deeper_data = deeper_response["data"]
-
-        # Check if system is enabled
-        if not deeper_data.get("status", False):
-            logger.info("System is currently turned OFF. Please turn it ON to continue.")
+        if not result["success"]:
+            logger.error(f"Error fetching signals: {result['message']}")
             return
 
-        # Get active signals to pass to AI
-        active_deals = get_active_signals()
-        logger.info(f"Active deals: {active_deals}")
-
-        # Process each forex group in the forwards section
-        for group_key, group_data in deeper_data.get("forwards", {}).items():
-            pairs = group_data.get("pairs", [])
-            message = group_data.get("message", "")
-
-            if not pairs:
-                logger.warning(f"Group {group_key} has no pairs. Skipping.")
-                continue
-
-            logger.info(f"Analyzing group {group_key} with pairs: {', '.join(pairs)}")
-
-            # Check if this group already exists in signals database
-            if check_if_pairs_exist_in_signals(pairs):
-                logger.info(f"Signal for group {group_key} already exists in database. Skipping analysis.")
-
-                # Remove the group from deeper.json since we're not processing it
-                if remove_group_from_deeper(group_key):
-                    logger.info(f"Group {group_key} removed from deeper.json successfully")
-                else:
-                    logger.error(f"Failed to remove group {group_key} from deeper.json")
-
-                continue
-
-            # Call AI to analyze the forex pairs with active deals
-            ai_response = analyze_forex_pairs(pairs, message, active_deals)
-
-            # Check if the AI response contains a signal
-            signal_data = extract_signal_from_ai_response(ai_response)
-
-            if signal_data:
-                logger.info(f"Signal detected for group {group_key}")
-
-                # Update signals file with the new signal, including pairs list
-                if update_signals_file(signal_data, pairs):
-                    logger.info(f"Signal for group {group_key} saved successfully")
-
-                    # Format and send Telegram message AFTER successfully saving to database
-                    telegram_message = format_telegram_message(signal_data)
-                    logger.info("Attempting to send Telegram message...")
-                    telegram_response = send_telegram_message(telegram_message)
-
-                    if telegram_response and telegram_response.get("ok"):
-                        logger.info(f"Telegram message for group {group_key} sent successfully")
+        signals = result["data"]
+        updated = False
+        signals_to_remove = []
+
+        for i, signal in enumerate(signals):
+            # Check if the signal is in "starting" status
+            if signal.get("status") == "starting":
+                pairs = signal.get("pairs", [signal.get("pair")])
+                main_pair = signal.get("pair")
+                logger.info(f"Processing signal for main pair {main_pair} with group: {pairs}")
+
+                try:
+                    # Format the deal details for AI
+                    deal_details = format_deal_details(signal)
+
+                    # Analyze the forex pairs using the updated function
+                    analysis = analyze_forex_pairs(pairs, deal_details)
+
+                    # First try to extract all messages
+                    all_messages = extract_all_messages(analysis)
+
+                    if all_messages:
+                        # Process each pair's message
+                        close_signal = False
+
+                        for pair, message_data in all_messages.items():
+                            # Send to Telegram
+                            telegram_result = send_telegram_message(message_data["full_message"])
+                            if telegram_result.get("ok"):
+                                logger.info(f"Telegram message sent for {pair}")
+                            else:
+                                logger.error(f"Failed to send Telegram message: {telegram_result}")
+
+                            # Handle based on message type
+                            if message_data["type"] == "regular":
+                                # Send to API
+                                api_result = send_to_api(pair, message_data["message"])
+                                if api_result["success"]:
+                                    logger.info(f"API message sent for {pair}")
+                                else:
+                                    logger.error(f"Failed to send to API: {api_result['error']}")
+                            elif message_data["type"] == "close" and pair == main_pair:
+                                # Only mark for removal if the main pair has a close signal
+                                close_signal = True
+
+                        if close_signal:
+                            signals_to_remove.append(i)
+                            updated = True
+                            logger.info(f"Signal for {main_pair} marked for removal due to close deal")
                     else:
-                        logger.error(f"Failed to send Telegram message for group {group_key}. Response: {telegram_response}")
-
-                    # Remove the group from deeper.json
-                    if remove_group_from_deeper(group_key):
-                        logger.info(f"Group {group_key} removed from deeper.json successfully")
+                        # Fall back to old extraction method for backward compatibility
+                        if "<send_message>" in analysis or "<close_deal>" in analysis:
+                            message_data = extract_message_content(analysis, main_pair)
+
+                            if message_data:
+                                # Send to Telegram
+                                telegram_result = send_telegram_message(message_data["full_message"])
+                                if telegram_result.get("ok"):
+                                    logger.info(f"Telegram message sent for {main_pair}")
+                                else:
+                                    logger.error(f"Failed to send Telegram message: {telegram_result}")
+
+                                # Handle based on message type
+                                if message_data["type"] == "regular":
+                                    # Send to API
+                                    api_result = send_to_api(main_pair, message_data["message"])
+                                    if api_result["success"]:
+                                        logger.info(f"API message sent for {main_pair}")
+                                    else:
+                                        logger.error(f"Failed to send to API: {api_result['error']}")
+                                elif message_data["type"] == "close":
+                                    # Mark the signal for removal
+                                    signals_to_remove.append(i)
+                                    updated = True
+                                    logger.info(f"Signal for {main_pair} marked for removal due to close deal")
+                            else:
+                                logger.warning(f"Could not extract message content for {main_pair}")
+                        else:
+                            logger.info(f"No message to send for {main_pair}")
+                except Exception as e:
+                    logger.error(f"Error processing signal for {main_pair}: {e}", exc_info=True)
+                    # Continue with other signals instead of breaking
+
+        # Remove signals marked for deletion (in reverse order to avoid index issues)
+        for index in sorted(signals_to_remove, reverse=True):
+            signals.pop(index)
+
+        # If any signals were updated, update the GitHub file
+        if updated:
+            try:
+                # Convert the updated signals to JSON
+                updated_content = json.dumps(signals, separators=(',', ':'))
+
+                # Fetch the authenticity token and commit OID
+                authenticity_token, commit_oid = fetch_authenticity_token_and_commit_oid()
+
+                if authenticity_token and commit_oid:
+                    # Update the GitHub file
+                    update_result = update_user_json_file(authenticity_token, commit_oid, updated_content)
+                    if update_result["success"]:
+                        logger.info("GitHub signals file updated successfully")
                     else:
-                        logger.error(f"Failed to remove group {group_key} from deeper.json")
+                        logger.error(f"Failed to update GitHub file: {update_result['message']}")
                 else:
-                    logger.error(f"Failed to save signal for group {group_key}")
-            else:
-                logger.info(f"No signal detected in AI response for group {group_key}")
-
-        logger.info("Analysis cycle completed successfully")
+                    logger.error("Failed to get authenticity token and commit OID")
+            except Exception as e:
+                logger.error(f"Error updating GitHub file: {e}", exc_info=True)
+        else:
+            logger.info("No signals needed updating")
 
     except Exception as e:
-        logger.error(f"Error in analyze_forex_groups: {e}", exc_info=True)
+        logger.error(f"Unexpected error in check_and_process_signals: {e}", exc_info=True)
 
 # Flask routes
 @app.route('/')
@@ -309,102 +297,74 @@ def health_check():
     """Health check endpoint to verify the service is running"""
     return jsonify({
         "status": "running",
-        "message": "Forex Analysis System is active"
+        "message": "Forex Signal Processing System is active",
+        "time": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
     })
 
-@app.route('/analyze/now')
-def trigger_analysis():
-    """Endpoint to manually trigger analysis"""
+@app.route('/process/now')
+def trigger_processing():
+    """Endpoint to manually trigger signal processing"""
     try:
-        analyze_forex_groups()
+        check_and_process_signals()
         return jsonify({
             "status": "success",
-            "message": "Analysis triggered successfully"
+            "message": "Signal processing triggered successfully",
+            "time": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
         })
     except Exception as e:
-        logger.error(f"Error triggering analysis: {e}", exc_info=True)
+        logger.error(f"Error triggering signal processing: {e}", exc_info=True)
         return jsonify({
             "status": "error",
-            "message": f"Error triggering analysis: {str(e)}"
+            "message": f"Error triggering signal processing: {str(e)}"
         }), 500
 
-@app.route('/status')
-def get_status():
-    """Endpoint to get system status"""
-    try:
-        deeper_response = deeper.fetch_json_from_github()
-        if deeper_response["success"]:
-            system_status = deeper_response["data"].get("status", False)
-            return jsonify({
-                "system_enabled": system_status,
-                "service_status": "running"
-            })
-        else:
-            return jsonify({
-                "service_status": "running",
-                "error": deeper_response["message"]
-            })
-    except Exception as e:
-        logger.error(f"Error getting status: {e}", exc_info=True)
-        return jsonify({
-            "service_status": "running",
-            "error": str(e)
-        })
+# Initialize scheduler
+scheduler = BackgroundScheduler(daemon=True)
+
+def add_candle_close_jobs():
+    """Add jobs to run at 5-minute candle closes"""
+    logger.info("Setting up scheduler jobs for candle closes")
+
+    # Schedule jobs to run at each 5-minute mark (00:00, 00:05, 00:10, etc.)
+    scheduler.add_job(
+        check_and_process_signals,
+        CronTrigger(minute='0,5,10,15,20,25,30,35,40,45,50,55'),
+        id='candle_close_processing',
+        replace_existing=True,
+    )
 
-def schedule_candle_analysis():
-    """Schedule analysis at candle close times (00, 15, 30, 45)"""
+    # Calculate time to next candle close
     now = datetime.now()
+    # Get the minutes and find the next 5-minute mark
     current_minute = now.minute
+    next_5min = ((current_minute // 5) + 1) * 5
+    if next_5min >= 60:
+        next_5min = 0
 
-    # Calculate the next 15-minute mark
-    if current_minute < 17:
-        next_minute = 17
-    elif current_minute < 32:
-        next_minute = 32
-    elif current_minute < 47:
-        next_minute = 47
-    else:
-        next_minute = 0  # Next hour
-
-    # Calculate the target time
-    if next_minute == 0:
-        target_time = datetime(now.year, now.month, now.day, now.hour, 0, 0) + timedelta(hours=1)
-    else:
-        target_time = datetime(now.year, now.month, now.day, now.hour, next_minute, 0)
+    next_run = now.replace(minute=next_5min, second=5, microsecond=0)  # 5 seconds after the minute mark
+    if next_run <= now:
+        next_run = next_run + timedelta(hours=1)
 
-    # Calculate seconds until next run
-    time_diff = (target_time - now).total_seconds()
+    time_to_next = (next_run - now).total_seconds()
 
-    logger.info(f"Scheduling analysis to run at {target_time.strftime('%H:%M:%S')} (in {time_diff:.1f} seconds)")
+    logger.info(f"Next candle close processing scheduled for: {next_run.strftime('%Y-%m-%d %H:%M:%S')} "
+                f"(in {time_to_next:.2f} seconds)")
 
-    # Schedule the job
+    # Also add a one-time job that runs at the start
     scheduler.add_job(
-        run_analysis_and_reschedule,
+        check_and_process_signals,
         'date',
-        run_date=target_time,
-        id='candle_analysis'
+        run_date=datetime.now() + timedelta(seconds=10),  # Run 10 seconds after startup
+        id='initial_check',
+        replace_existing=True
     )
 
-def run_analysis_and_reschedule():
-    """Run the analysis and schedule the next run"""
-    logger.info("Running scheduled analysis at candle close")
-    try:
-        analyze_forex_groups()
-    except Exception as e:
-        logger.error(f"Error in scheduled analysis: {e}", exc_info=True)
-    finally:
-        # Always reschedule the next run
-        schedule_candle_analysis()
-
-# Initialize scheduler
-scheduler = BackgroundScheduler()
-
 def start_scheduler():
-    """Start the scheduler with the analysis job at candle close times"""
-    logger.info("Starting scheduler for forex analysis at candle close times (00, 15, 30, 45)")
+    """Start the scheduler with the candle close processing jobs"""
+    logger.info("Starting scheduler for candle close signal processing")
 
-    # Schedule the first analysis
-    schedule_candle_analysis()
+    # Add the candle close jobs
+    add_candle_close_jobs()
 
     # Start the scheduler if it's not already running
     if not scheduler.running:
@@ -412,7 +372,7 @@ def start_scheduler():
         logger.info("Scheduler started successfully")
 
 if __name__ == "__main__":
-    logger.info("Starting Forex Analysis System...")
+    logger.info("Starting Forex Signal Processing System...")
 
     # Start the scheduler
     start_scheduler()