Update app.py

app.py

@@ -1,34 +1,22 @@
-import os
-import traceback
-import signal
-import sys
-import uvicorn
-import asyncio
+import os, traceback, signal, sys, uvicorn, asyncio, json
 from contextlib import asynccontextmanager
-from fastapi import FastAPI, BackgroundTasks, HTTPException
-from datetime import datetime, timedelta
+from fastapi import FastAPI, HTTPException
+from datetime import datetime
 from r2 import R2Service
 from LLM import LLMService, local_analyze_opportunity, local_re_analyze_trade
 from data_manager import DataManager
 from ML import MLProcessor as FeatureProcessor
 from learning_engine import LearningEngine
-import time
-import json
+from sentiment_news import SentimentAnalyzer
 import state
-import re
-
-from whale_news_data import whale_monitor_global
 from helpers import safe_float_conversion, _apply_patience_logic
 
-TOP_N_SYMBOLS = 100
-OPPORTUNITY_COUNT = 10
-CHUNK_SIZE = 5
-
 r2_service_global = None
 data_manager_global = None
 llm_service_global = None
 learning_engine_global = None
 realtime_monitor = None
+sentiment_analyzer_global = None
 
 class RealTimeTradeMonitor:
     def __init__(self):
@@ -37,7 +25,6 @@ class RealTimeTradeMonitor:
         
     async def start_monitoring(self):
         self.is_running = True
-        print("🔍 Starting real-time trade monitoring...")
         
         while self.is_running:
             try:
@@ -57,13 +44,11 @@ class RealTimeTradeMonitor:
                 await asyncio.sleep(10)
                 
             except Exception as error:
-                print(f"❌ Real-time monitor error: {error}")
+                print(f"Real-time monitor error: {error}")
                 await asyncio.sleep(30)
     
     async def _monitor_single_trade(self, trade):
         symbol = trade['symbol']
-        strategy = trade.get('strategy', 'GENERIC')
-        print(f"📊 Starting real-time monitoring for {symbol} (Strategy: {strategy})")
         
         while symbol in self.monitoring_tasks and self.is_running:
             try:
@@ -90,15 +75,11 @@ class RealTimeTradeMonitor:
                     dynamic_stop = current_price * 0.98
                     if dynamic_stop > (stop_loss or 0):
                         trade['stop_loss'] = dynamic_stop
-                        print(f"🔒 Updated trailing stop for {symbol}: {dynamic_stop:.4f}")
                 
                 if should_close:
-                    print(f"🚨 IMMEDIATE CLOSE: {symbol} - {close_reason} - Strategy: {strategy}")
-                    
                     if r2_service_global.acquire_lock():
                         try:
                             await r2_service_global.close_trade_async(trade, current_price)
-                            print(f"✅ Trade {symbol} closed immediately at {current_price}. Strategy: {strategy}")
                             
                             if learning_engine_global and learning_engine_global.initialized:
                                 await learning_engine_global.analyze_trade_outcome(trade, 'CLOSED_BY_MONITOR')
@@ -115,56 +96,35 @@ class RealTimeTradeMonitor:
                 await asyncio.sleep(15)
                 
             except Exception as error:
-                print(f"❌ Real-time monitoring error for {symbol}: {error}")
+                print(f"Real-time monitoring error for {symbol}: {error}")
                 await asyncio.sleep(30)
     
     def stop_monitoring(self):
         self.is_running = False
         self.monitoring_tasks.clear()
-        print("🛑 Real-time trade monitoring stopped")
 
 async def monitor_market_async():
-    global data_manager_global
+    global data_manager_global, sentiment_analyzer_global
     
     init_attempts = 0
     while data_manager_global is None and init_attempts < 10:
-        print(f"⏳ Waiting for data manager initialization... (attempt {init_attempts + 1}/10)")
         await asyncio.sleep(3)
         init_attempts += 1
     
     if data_manager_global is None:
-        print("❌ Data manager failed to initialize after 10 attempts")
         return
     
     while True:
         try:
-            print("👁️ Monitoring market sentiment...")
-            
-            try:
-                market_context = await data_manager_global.get_market_context_async()
-            except Exception as error:
-                print(f"⚠️ Failed to get market context: {error}")
-                market_context = await get_fallback_market_context()
+            market_context = await sentiment_analyzer_global.get_market_sentiment()
             
             if not market_context:
-                print("❌ Failed to get market context. Assuming neutral state.")
                 state.MARKET_STATE_OK = True
                 await asyncio.sleep(60)
                 continue
 
             whale_analysis = market_context.get('general_whale_activity', {})
-            whale_sentiment = whale_analysis.get('sentiment', 'NEUTRAL')
             is_critical = whale_analysis.get('critical_alert', False)
-            total_volume = whale_analysis.get('total_volume_usd', 0)
-
-            netflow_analysis = whale_analysis.get('netflow_analysis', {})
-            net_flow = netflow_analysis.get('net_flow', 0)
-            flow_direction = netflow_analysis.get('flow_direction', 'BALANCED')
-            market_impact = netflow_analysis.get('market_impact', 'UNKNOWN')
-
-            print(f"🐋 Whale Analysis: {whale_sentiment} | Critical: {is_critical} | Volume: ${total_volume:,.0f}")
-            print(f"📈 Net Flow: ${net_flow:,.0f} ({flow_direction}) | Market Impact: {market_impact}")
-            print(f"📊 Whale Description: {whale_analysis.get('description', 'No data')}")
 
             bitcoin_sentiment = market_context.get('btc_sentiment')
             fear_greed_index = market_context.get('fear_and_greed_index')
@@ -174,60 +134,28 @@ async def monitor_market_async():
             
             if is_critical:
                 should_halt_trading = True
-                halt_reason = f"CRITICAL whale activity detected: {whale_analysis.get('description')}"
+                halt_reason = f"CRITICAL whale activity detected"
             elif bitcoin_sentiment == 'BEARISH' and (fear_greed_index is not None and fear_greed_index < 30):
                 should_halt_trading = True
-                halt_reason = f"Bearish market conditions (BTC: {bitcoin_sentiment}, F&G: {fear_greed_index})"
-            elif netflow_analysis and net_flow < -1000000 and market_impact == 'HIGH':
-                should_halt_trading = True
-                halt_reason = f"Strong sell pressure detected: ${abs(net_flow):,.0f} net outflow to exchanges"
+                halt_reason = f"Bearish market conditions"
 
             if should_halt_trading:
-                print(f"🚨🚨🚨 MARKET HALT: {halt_reason} 🚨🚨🚨")
                 state.MARKET_STATE_OK = False
-                
-                try:
-                    await r2_service_global.save_system_logs_async({
-                        "market_halt": True,
-                        "reason": halt_reason,
-                        "whale_sentiment": whale_sentiment,
-                        "is_critical": is_critical,
-                        "net_flow": net_flow,
-                        "flow_direction": flow_direction
-                    })
-                except Exception as log_error:
-                    print(f"⚠️ Failed to save market halt log: {log_error}")
+                await r2_service_global.save_system_logs_async({
+                    "market_halt": True,
+                    "reason": halt_reason
+                })
             else:
                 if not state.MARKET_STATE_OK:
-                    print("🟢 Market conditions improved. Resuming normal operations.")
+                    print("Market conditions improved. Resuming normal operations.")
                 state.MARKET_STATE_OK = True
                 
             await asyncio.sleep(60)
         except Exception as error:
-            print(f"❌ An error occurred during COMPREHENSIVE market monitoring: {error}")
-            traceback.print_exc()
+            print(f"Error during market monitoring: {error}")
             state.MARKET_STATE_OK = True
             await asyncio.sleep(60)
 
-async def get_fallback_market_context():
-    return {
-        'timestamp': datetime.now().isoformat(),
-        'general_whale_activity': {
-            'sentiment': 'NEUTRAL', 
-            'description': 'Fallback mode - system initializing',
-            'critical_alert': False,
-            'transaction_count': 0,
-            'total_volume_usd': 0,
-            'netflow_analysis': {
-                'net_flow': 0,
-                'flow_direction': 'BALANCED',
-                'market_impact': 'LOW'
-            }
-        },
-        'btc_sentiment': 'NEUTRAL',
-        'fear_and_greed_index': 50
-    }
-
 async def validate_candidate_data_enhanced(candidate):
     try:
         required_fields = ['symbol', 'current_price', 'final_score', 'enhanced_final_score']
@@ -240,10 +168,10 @@ async def validate_candidate_data_enhanced(candidate):
         candidate['final_score'] = safe_float_conversion(candidate.get('final_score'), 0.5)
         candidate['enhanced_final_score'] = safe_float_conversion(candidate.get('enhanced_final_score'), candidate['final_score'])
         
-        if 'reasons_for_candidacy' not in candidate or not candidate['reasons_for_candidacy']:
+        if 'reasons_for_candidacy' not in candidate:
             candidate['reasons_for_candidacy'] = ['unknown_reason']
             
-        if 'sentiment_data' not in candidate or not candidate['sentiment_data']:
+        if 'sentiment_data' not in candidate:
             candidate['sentiment_data'] = {
                 'btc_sentiment': 'NEUTRAL',
                 'fear_and_greed_index': 50,
@@ -256,61 +184,34 @@ async def validate_candidate_data_enhanced(candidate):
         if 'strategy_scores' not in candidate:
             candidate['strategy_scores'] = {}
             
-        if 'recommended_strategy' not in candidate:
-            candidate['recommended_strategy'] = 'unknown'
-        
-        if 'target_strategy' not in candidate or not candidate['target_strategy'] or candidate['target_strategy'] == 'unknown':
+        if 'target_strategy' not in candidate:
             candidate['target_strategy'] = 'GENERIC'
             
         return True
         
     except Exception as error:
-        print(f"❌ Failed to validate candidate data for {candidate.get('symbol')}: {error}")
+        print(f"Failed to validate candidate data for {candidate.get('symbol')}: {error}")
         return False
 
 async def analyze_market_strategy(market_context):
     try:
         whale_analysis = market_context.get('general_whale_activity', {})
         netflow_analysis = whale_analysis.get('netflow_analysis', {})
-        trading_signals = whale_analysis.get('trading_signals', [])
         
         prompt = f"""
-        You are a professional crypto portfolio manager. Analyze the current market conditions and determine the most suitable strategy.
+        Analyze current market conditions and determine trading strategy.
 
-        **Enhanced Market Data:**
-        - BTC Price: {market_context.get('bitcoin_price_usd')}
+        Market Data:
         - BTC Sentiment: {market_context.get('btc_sentiment')}
         - Fear & Greed Index: {market_context.get('fear_and_greed_index')}
         - Whale Analysis: {whale_analysis.get('sentiment')}
-        - Critical Whale Alert: {whale_analysis.get('critical_alert')}
-        - Net Flow Analysis: ${netflow_analysis.get('net_flow', 0):,.0f} ({netflow_analysis.get('flow_direction', 'BALANCED')})
-        - Market Impact: {netflow_analysis.get('market_impact', 'UNKNOWN')}
-        - Active Trading Signals: {len(trading_signals)}
-
-        **Available Strategies:**
-        1. AGGRESSIVE_GROWTH - For strong bull markets with positive net flow.
-        2. DEFENSIVE_GROWTH - For volatile or uncertain markets.
-        3. CONSERVATIVE - For bearish or high-risk markets with negative net flow.
-        4. HIGH_FREQUENCY - For sideways markets with balanced flow.
-        5. WHALE_FOLLOWING - When whale activity is high and clear signals present.
-        6. GENERIC - Balanced approach for normal conditions.
-
-        **Enhanced Decision Factors:**
-        - Net Flow > $1M positive: Consider AGGRESSIVE_GROWTH
-        - Net Flow < $1M negative: Consider CONSERVATIVE  
-        - Strong whale signals: Consider WHALE_FOLLOWING
-        - Critical alerts: Use CONSERVATIVE regardless of other factors
-
-        **Required:**
-        - Choose one primary strategy.
-        - Explain why in a single sentence.
-        - Set an acceptable risk tolerance (1 to 10).
-        - Determine the optimal number of coins to scan (50 to 200).
-
-        **Output (JSON only):**
+        - Critical Alert: {whale_analysis.get('critical_alert')}
+        - Net Flow: ${netflow_analysis.get('net_flow', 0):,.0f}
+
+        Output JSON:
         {{
             "primary_strategy": "STRATEGY_NAME",
-            "reasoning": "Brief reasoning including net flow analysis.",
+            "reasoning": "Brief reasoning",
             "risk_tolerance": 5,
             "optimal_scan_count": 100
         }}
@@ -319,26 +220,23 @@ async def analyze_market_strategy(market_context):
         response = await llm_service_global._call_llm(prompt)
         
         try:
-            json_match = re.search(r'\{.*\}', response, re.DOTALL)
-            strategy_data = json.loads(json_match.group())
+            from helpers import parse_json_from_response
+            json_str = parse_json_from_response(response)
+            strategy_data = json.loads(json_str)
         except:
             net_flow = netflow_analysis.get('net_flow', 0)
             if net_flow > 1000000:
                 fallback_strategy = "AGGRESSIVE_GROWTH"
-                reasoning = "Strong positive net flow detected"
             elif net_flow < -1000000:
                 fallback_strategy = "CONSERVATIVE" 
-                reasoning = "Strong negative net flow detected"
             elif whale_analysis.get('critical_alert'):
                 fallback_strategy = "CONSERVATIVE"
-                reasoning = "Critical whale alert active"
             else:
                 fallback_strategy = "GENERIC"
-                reasoning = "Balanced market conditions"
                 
             strategy_data = {
                 "primary_strategy": fallback_strategy,
-                "reasoning": f"Fallback: {reasoning}",
+                "reasoning": "Fallback strategy",
                 "risk_tolerance": 5,
                 "optimal_scan_count": 100,
             }
@@ -346,7 +244,7 @@ async def analyze_market_strategy(market_context):
         return strategy_data
         
     except Exception as error:
-        print(f"❌ Failed to analyze market strategy: {error}")
+        print(f"Failed to analyze market strategy: {error}")
         return {
             "primary_strategy": "GENERIC",
             "reasoning": "Fallback due to analysis error",
@@ -359,12 +257,10 @@ async def find_strategy_specific_candidates(strategy, scan_count):
         all_candidates = await data_manager_global.find_high_potential_candidates(scan_count * 2)
         
         if not all_candidates:
-            print(f"⚠️ الماسح العام لم يجد أي مرشحين أوليين.")
             return []
 
         market_context = await data_manager_global.get_market_context_async()
         if not market_context:
-            print("❌ Failed to get market context for strategy analysis")
             return []
             
         feature_processor = FeatureProcessor(market_context, data_manager_global, learning_engine_global)
@@ -376,21 +272,13 @@ async def find_strategy_specific_candidates(strategy, scan_count):
                 ohlcv_data = await data_manager_global.get_fast_pass_data_async(symbol_with_reasons)
                 
                 if ohlcv_data and ohlcv_data[0]:
-                    try:
-                        updated_market_context = await data_manager_global.get_market_context_async()
-                        if updated_market_context:
-                            feature_processor.market_context = updated_market_context
-                    except Exception as e:
-                        print(f"⚠️ Failed to update market context for {candidate['symbol']}: {e}")
-                    
                     processed = await feature_processor.process_and_score_symbol_enhanced(ohlcv_data[0])
                     if processed:
                         processed_candidates.append(processed)
             except Exception as e:
-                print(f"⚠️ فشل معالجة {candidate.get('symbol')}: {e}")
+                print(f"Failed to process {candidate.get('symbol')}: {e}")
         
         if not processed_candidates:
-            print("⚠️ لم يتم معالجة أي مرشح بنجاح")
             return []
         
         if strategy != 'GENERIC':
@@ -402,76 +290,55 @@ async def find_strategy_specific_candidates(strategy, scan_count):
                 if strategy_score > 0.2:
                     candidate['strategy_match_score'] = strategy_score
                     strategy_candidates.append(candidate)
-                    print(f"✅ {candidate['symbol']} مناسب لـ {strategy} (درجة: {strategy_score:.3f})")
             
             sorted_candidates = sorted(strategy_candidates, 
                                     key=lambda x: x.get('strategy_match_score', 0), 
                                     reverse=True)
             top_candidates = sorted_candidates[:15]
-            
-            print(f"✅ تم اختيار {len(top_candidates)} مرشحًا لاستراتيجية {strategy}")
         else:
             sorted_candidates = sorted(processed_candidates, 
                                     key=lambda x: x.get('enhanced_final_score', 0), 
                                     reverse=True)
             top_candidates = sorted_candidates[:15]
-            print(f"✅ تم اختيار {len(top_candidates)} مرشحًا للاستراتيجية العامة")
 
         return top_candidates
 
     except Exception as error:
-        print(f"❌ فشل في نظام الفلترة المتقدم: {error}")
-        traceback.print_exc()
+        print(f"Advanced filtering failed: {error}")
         return []
 
 async def find_new_opportunities_async():
-    print("🔍 Scanning for new opportunities with enhanced data analysis...")
     try:
         await r2_service_global.save_system_logs_async({
-            "opportunity_scan_started": True, "timestamp": datetime.now().isoformat()
+            "opportunity_scan_started": True
         })
 
-        print("🧠 Determining trading strategy with enhanced market analysis...")
         market_context = await data_manager_global.get_market_context_async()
         if not market_context:
-            print("❌ Failed to fetch market context. Cannot determine strategy.")
             return
 
         strategy_decision = await analyze_market_strategy(market_context)
         
-        print(f"🎯 Selected Strategy: {strategy_decision['primary_strategy']}")
-        print(f"📝 Reasoning: {strategy_decision['reasoning']}")
-        print(f"⚡ Risk Tolerance: {strategy_decision.get('risk_tolerance', 5)}/10")
-        print(f"🔍 Optimal Scan Count: {strategy_decision.get('optimal_scan_count', 100)}")
-
-        print(f"🔍 Finding top candidates using enhanced dynamic ranking...")
         high_potential_candidates = await find_strategy_specific_candidates(
             strategy_decision['primary_strategy'], 
             strategy_decision.get('optimal_scan_count', 100)
         )
         
         if not high_potential_candidates:
-            print("🔄 لا توجد مرشحين متخصصين، جلب مرشحين عامين...")
             high_potential_candidates = await data_manager_global.find_high_potential_candidates(20)
             if high_potential_candidates:
                 for candidate in high_potential_candidates:
                     candidate['target_strategy'] = 'GENERIC'
-                print(f"✅ تم تحميل {len(high_potential_candidates)} مر��ح عام")
             else:
-                print("✅ No new candidates found after dynamic ranking.")
-                await r2_service_global.save_system_logs_async({
-                    "no_candidates_found": True, "strategy": strategy_decision['primary_strategy'],
-                    "reason": "Scanner did not return any initial candidates."
-                })
                 return
 
         all_processed_candidates = []
+        CHUNK_SIZE = 5
+        
         for index in range(0, len(high_potential_candidates), CHUNK_SIZE):
             chunk = high_potential_candidates[index:index+CHUNK_SIZE]
-            
             chunk_data = await data_manager_global.get_fast_pass_data_async(chunk)
             
-            print(f"⏳ Processing and scoring chunk {index//CHUNK_SIZE + 1}...")
             updated_market_context = await data_manager_global.get_market_context_async()
             if not updated_market_context:
                 updated_market_context = market_context
@@ -486,7 +353,6 @@ async def find_new_opportunities_async():
             await asyncio.sleep(1)
 
         if not all_processed_candidates:
-            print("❌ No candidates were processed successfully.")
             return
 
         updated_market_context = await data_manager_global.get_market_context_async()
@@ -494,74 +360,46 @@ async def find_new_opportunities_async():
             updated_market_context = market_context
             
         feature_processor = FeatureProcessor(updated_market_context, data_manager_global, learning_engine_global)
+        OPPORTUNITY_COUNT = 10
         top_candidates = feature_processor.filter_top_candidates(all_processed_candidates, OPPORTUNITY_COUNT)
         
-        print(f"✅ Identified {len(top_candidates)} top candidates after final scoring.")
-        
         await r2_service_global.save_candidates_data_async(
             candidates_data=top_candidates,
             reanalysis_data={
                 "strategy_used": strategy_decision, 
-                "market_conditions": market_context,
-                "enhanced_analysis": True
+                "market_conditions": market_context
             }
         )
         
         if not top_candidates:
-            print("❌ No strong candidates left after final filtering.")
-            await r2_service_global.save_system_logs_async({
-                "no_strong_candidates": True, 
-                "strategy": strategy_decision['primary_strategy'],
-                "initial_candidates_count": len(high_potential_candidates),
-                "enhanced_analysis": True
-            })
             return
             
-        print("🧠 Getting LLM analysis for top candidates with enhanced data...")
-        
         for candidate in top_candidates:
             try:
                 if not await validate_candidate_data_enhanced(candidate):
-                    print(f"⚠️ Skipping {candidate.get('symbol')} due to quality issues")
                     continue
                 
                 llm_analysis_data = await llm_service_global.get_trading_decision(candidate)
                 
                 if not llm_analysis_data:
-                    print(f"⚠️ LLM analysis failed for {candidate['symbol']}. Moving to next.")
                     continue
 
                 if llm_analysis_data.get('action') == "HOLD":
-                    print(f"🧠 LLM decided to HOLD on {candidate['symbol']}. Moving to next.")
                     continue
                 
                 if llm_analysis_data.get('action') in ["BUY", "SELL"]:
                     final_strategy = llm_analysis_data.get('strategy')
                     candidate_strategy = candidate.get('target_strategy', 'GENERIC')
                     
-                    if not final_strategy or final_strategy == 'unknown' or final_strategy == 'GENERIC':
+                    if not final_strategy or final_strategy == 'unknown':
                         final_strategy = candidate_strategy
                         llm_analysis_data['strategy'] = final_strategy
-                        print(f"🔧 تصحيح استراتيجية LLM لـ {candidate['symbol']}: {final_strategy}")
-                    
-                    print(f"🎯 الاستراتيجية النهائية: {final_strategy}")
-                    
-                    print("\n========================================================")
-                    print(f"💎💎💎 New Trading Opportunity Identified! 💎💎💎")
-                    print(f"   Symbol: {candidate['symbol']}")
-                    print(f"   Action: {llm_analysis_data.get('action')}")
-                    print(f"   Strategy: {final_strategy}")
-                    print(f"   Reasoning: {llm_analysis_data.get('reasoning')}")
-                    print(f"   Confidence: {llm_analysis_data.get('confidence_level')}")
-                    print("========================================================\n")
                     
                     await r2_service_global.save_system_logs_async({
                         "new_opportunity_found": True, 
                         "symbol": candidate['symbol'],
                         "action": llm_analysis_data.get('action'), 
-                        "strategy": final_strategy,
-                        "confidence": llm_analysis_data.get('confidence_level', 0),
-                        "enhanced_analysis": True
+                        "strategy": final_strategy
                     })
                     
                     return {
@@ -572,19 +410,15 @@ async def find_new_opportunities_async():
                     }
                     
             except Exception as error:
-                print(f"❌ LLM/Fallback error for {candidate.get('symbol', 'unknown')}: {error}")
-                traceback.print_exc()
+                print(f"LLM error for {candidate.get('symbol', 'unknown')}: {error}")
         
-        print("✅ Cycle finished. No actionable BUY/SELL opportunities found by LLM.")
         return None
         
     except Exception as error:
-        print(f"❌ An error occurred while scanning for opportunities: {error}")
-        traceback.print_exc()
+        print(f"Error while scanning for opportunities: {error}")
         await r2_service_global.save_system_logs_async({
             "opportunity_scan_error": True, 
-            "error": str(error),
-            "enhanced_analysis": True
+            "error": str(error)
         })
         return None
 
@@ -596,34 +430,18 @@ async def re_analyze_open_trade_async(trade_data):
         current_time = datetime.now()
         hold_minutes = (current_time - entry_time).total_seconds() / 60
         
-        print(f"⏳ Re-analyzing trade: {symbol} (held for {hold_minutes:.1f} minutes)")
-        
         original_strategy = trade_data.get('strategy')
         if not original_strategy or original_strategy == 'unknown':
             original_strategy = trade_data.get('decision_data', {}).get('strategy', 'GENERIC')
-            print(f"🔧 Fixed original strategy for {symbol}: {original_strategy}")
-        
-        reanalysis_context = {
-            'trade_data': {
-                'symbol': trade_data.get('symbol'),
-                'entry_price': trade_data.get('entry_price'),
-                'entry_time': trade_data.get('entry_timestamp'),
-                'hold_minutes': hold_minutes,
-                'strategy': original_strategy
-            }
-        }
-        
+
         try:
             market_context = await data_manager_global.get_market_context_async()
-        except Exception as error:
-            print(f"⚠️ Failed to get market context: {error}. Using basic market data...")
+        except Exception:
             market_context = {'btc_sentiment': 'NEUTRAL'}
 
         symbol_with_reasons = [{'symbol': symbol, 'reasons': ['re-analysis']}]
-        
         ohlcv_data_list = await data_manager_global.get_fast_pass_data_async(symbol_with_reasons)
         if not ohlcv_data_list:
-            print(f"❌ Failed to fetch latest data for {symbol}.")
             return None
         
         raw_data = ohlcv_data_list[0]
@@ -631,50 +449,39 @@ async def re_analyze_open_trade_async(trade_data):
             updated_market_context = await data_manager_global.get_market_context_async()
             if updated_market_context:
                 market_context = updated_market_context
-        except Exception as e:
-            print(f"⚠️ Failed to update market context for re-analysis: {e}")
+        except Exception:
+            pass
             
         feature_processor = FeatureProcessor(market_context, data_manager_global, learning_engine_global)
         processed_data = await feature_processor.process_and_score_symbol(raw_data)
         
         if not processed_data:
-            print(f"❌ Failed to process latest data for {symbol}.")
             return None
 
         await r2_service_global.save_candidates_data_async(
             candidates_data=None,
             reanalysis_data={
                 'market_context': market_context, 
-                'processed_data': processed_data,
-                'enhanced_analysis': True
+                'processed_data': processed_data
             }
         )
 
-        print(f"🧠 Getting LLM re-analysis for {symbol} with enhanced data...")
         try:
             re_analysis_decision = await llm_service_global.re_analyze_trade_async(trade_data, processed_data)
-            source = re_analysis_decision.get('model_source', 'LLM')
-        except Exception as error:
-            print(f"❌ LLM re-analysis error: {error}. Falling back to local.")
+        except Exception:
             re_analysis_decision = local_re_analyze_trade(trade_data, processed_data)
-            source = 'local_fallback'
         
         final_decision = _apply_patience_logic(re_analysis_decision, hold_minutes, trade_data, processed_data)
         
-        if not final_decision.get('strategy') or final_decision['strategy'] == 'unknown':
+        if not final_decision.get('strategy'):
             final_decision['strategy'] = original_strategy
-            print(f"🔧 Final re-analysis strategy fix for {symbol}: {original_strategy}")
-        
-        print(f"✅ Re-analysis decision for {symbol}: {final_decision.get('action')}. Strategy: {final_decision.get('strategy')}. Source: {source}")
         
         await r2_service_global.save_system_logs_async({
             "trade_reanalyzed": True, 
             "symbol": symbol, 
             "action": final_decision.get('action'),
-            "hold_minutes": hold_minutes, 
-            "source": source, 
-            "strategy": final_decision.get('strategy'),
-            "enhanced_analysis": True
+            "hold_minutes": hold_minutes,
+            "strategy": final_decision.get('strategy')
         })
         
         return {
@@ -685,35 +492,26 @@ async def re_analyze_open_trade_async(trade_data):
         }
         
     except Exception as error:
-        print(f"❌ An error occurred during trade re-analysis: {error}")
-        traceback.print_exc()
+        print(f"Error during trade re-analysis: {error}")
         await r2_service_global.save_system_logs_async({
             "reanalysis_error": True, 
             "symbol": symbol, 
-            "error": str(error),
-            "enhanced_analysis": True
+            "error": str(error)
         })
         return None
 
 async def run_bot_cycle_async():
-    print(f"\n{'='*70}")
-    print(f"⏳ New cycle initiated at: {datetime.now().isoformat()}")
-    print(f"{'='*70}")
-    
     try:
         await r2_service_global.save_system_logs_async({
-            "cycle_started": True,
-            "enhanced_analysis": True
+            "cycle_started": True
         })
 
         if not r2_service_global.acquire_lock():
-            print("❌ Failed to acquire lock. Skipping cycle.")
             return
 
         open_trades = []
         try:
             open_trades = await r2_service_global.get_open_trades_async()
-            print(f"✅ Found {len(open_trades)} open trade(s).")
             
             trades_fixed = 0
             for trade in open_trades:
@@ -721,10 +519,8 @@ async def run_bot_cycle_async():
                     original_strategy = trade.get('decision_data', {}).get('strategy', 'GENERIC')
                     trade['strategy'] = original_strategy
                     trades_fixed += 1
-                    print(f"🔧 Fixed missing strategy for {trade['symbol']}: {trade['strategy']}")
             
             if trades_fixed > 0:
-                print(f"✅ Fixed strategies for {trades_fixed} trades.")
                 await r2_service_global.save_open_trades_async(open_trades)
             
             should_look_for_new_trade = not open_trades
@@ -737,12 +533,10 @@ async def run_bot_cycle_async():
                 ]
 
                 if trades_to_reanalyze:
-                    print(f"🔍 Re-analyzing {len(trades_to_reanalyze)} trade(s)...")
                     for trade in trades_to_reanalyze:
                         result = await re_analyze_open_trade_async(trade)
                         if result and result['decision'].get('action') == "CLOSE_TRADE":
                             await r2_service_global.close_trade_async(trade, result['current_price'])
-                            print(f"✅ Trade for {trade['symbol']} CLOSED. Strategy: {trade.get('strategy', 'unknown')}")
                             if learning_engine_global and learning_engine_global.initialized:
                                 trade_with_strategy = trade.copy()
                                 strategy = result['decision'].get('strategy', trade.get('strategy', 'GENERIC'))
@@ -751,42 +545,25 @@ async def run_bot_cycle_async():
                             should_look_for_new_trade = True
                         elif result and result['decision'].get('action') == "UPDATE_TRADE":
                             await r2_service_global.update_trade_async(trade, result['decision'])
-                            print(f"✅ Trade for {trade['symbol']} UPDATED. Strategy: {trade.get('strategy', 'unknown')}")
-                        else:
-                            print(f"✅ Trade for {trade['symbol']} is on HOLD. Strategy: {trade.get('strategy', 'unknown')}")
-                else:
-                    print("✅ No trades due for re-analysis yet.")
 
             if should_look_for_new_trade:
                 portfolio_state = await r2_service_global.get_portfolio_state_async()
                 current_capital = portfolio_state.get("current_capital_usd", 0)
                 
-                print(f"💰 Current available capital: ${current_capital:.2f}")
-                
                 if current_capital <= 0:
-                    print("⚠️ Current capital is 0. Checking for potential calculation errors...")
-                    
                     if len(open_trades) == 0:
-                        print("🔄 No open trades but capital is 0. This might be an error.")
-                        print("💡 Attempting to recover capital state...")
-                        
                         initial_capital = portfolio_state.get("initial_capital_usd", 10.0)
                         if initial_capital > 0:
                             portfolio_state["current_capital_usd"] = initial_capital
                             portfolio_state["invested_capital_usd"] = 0.0
                             await r2_service_global.save_portfolio_state_async(portfolio_state)
-                            print(f"✅ Reset capital to initial amount: ${initial_capital:.2f}")
                             current_capital = initial_capital
                 
                 if current_capital > 1:
-                    print(f"✅ Capital available (${current_capital:.2f}). Scanning for new opportunities...")
                     new_opportunity = await find_new_opportunities_async()
                     if new_opportunity:
-                        print(f"✅ Opportunity for {new_opportunity['symbol']} confirmed! Saving trade. Strategy: {new_opportunity.get('strategy')}")
-                        
                         if not new_opportunity['decision'].get('strategy'):
                             new_opportunity['decision']['strategy'] = new_opportunity.get('strategy', 'GENERIC')
-                            print(f"🔧 Final pre-save strategy fix: {new_opportunity['decision']['strategy']}")
                         
                         await r2_service_global.save_new_trade_async(
                             new_opportunity['symbol'], 
@@ -798,35 +575,26 @@ async def run_bot_cycle_async():
                             if trade['symbol'] == new_opportunity['symbol']:
                                 asyncio.create_task(realtime_monitor._monitor_single_trade(trade))
                                 break
-                    else:
-                        print("✅ Scan complete. No actionable opportunities identified.")
-                else:
-                    print(f"😴 No available capital (${current_capital:.2f}). Waiting for current trade to close.")
             
         finally:
-            print("✅ Cycle finished. Releasing lock.")
             r2_service_global.release_lock()
             await r2_service_global.save_system_logs_async({
                 "cycle_completed": True, 
-                "open_trades": len(open_trades),
-                "enhanced_analysis": True
+                "open_trades": len(open_trades)
             })
 
     except Exception as error:
-        print(f"❌ Unhandled error in main cycle: {error}")
-        traceback.print_exc()
+        print(f"Unhandled error in main cycle: {error}")
         await r2_service_global.save_system_logs_async({
             "cycle_error": True, 
-            "error": str(error),
-            "enhanced_analysis": True
+            "error": str(error)
         })
         if r2_service_global.lock_acquired:
             r2_service_global.release_lock()
 
 @asynccontextmanager
 async def lifespan(application: FastAPI):
-    global r2_service_global, data_manager_global, llm_service_global, learning_engine_global, realtime_monitor
-    print("===== Application Startup =====")
+    global r2_service_global, data_manager_global, llm_service_global, learning_engine_global, realtime_monitor, sentiment_analyzer_global
     
     try:
         r2_service_global = R2Service()
@@ -836,36 +604,30 @@ async def lifespan(application: FastAPI):
         data_manager_global = DataManager(contracts_database)
         await data_manager_global.initialize()
 
+        sentiment_analyzer_global = SentimentAnalyzer(data_manager_global)
+        
         learning_engine_global = LearningEngine(r2_service_global, data_manager_global)
         await learning_engine_global.initialize_enhanced()
         
         await learning_engine_global.force_strategy_learning()
         
-        if learning_engine_global.initialized:
-            weights = await learning_engine_global.get_optimized_strategy_weights("bull_market")
-            print(f"🎯 الأوزان المحملة: {weights}")
-        
         realtime_monitor = RealTimeTradeMonitor()
         
         asyncio.create_task(monitor_market_async())
         asyncio.create_task(realtime_monitor.start_monitoring())
         
         await r2_service_global.save_system_logs_async({
-            "application_started": True,
-            "enhanced_analysis": True
+            "application_started": True
         })
         
-        print("\n✅ All services initialized. Application is ready.\n")
         yield
         
     except Exception as error:
-        print(f"❌ Application startup failed: {error}")
-        traceback.print_exc()
+        print(f"Application startup failed: {error}")
         if r2_service_global:
             await r2_service_global.save_system_logs_async({
                 "application_startup_failed": True, 
-                "error": str(error),
-                "enhanced_analysis": True
+                "error": str(error)
             })
         raise
     finally:
@@ -876,7 +638,7 @@ application = FastAPI(lifespan=lifespan)
 @application.get("/run-cycle")
 async def run_cycle_api():
     asyncio.create_task(run_bot_cycle_async())
-    return {"message": "Bot cycle initiated in the background."}
+    return {"message": "Bot cycle initiated"}
 
 @application.get("/health")
 async def health_check():
@@ -899,8 +661,7 @@ async def health_check():
             "realtime_monitor": "running" if realtime_monitor and realtime_monitor.is_running else "stopped"
         },
         "market_state_ok": state.MARKET_STATE_OK,
-        "learning_engine": learning_metrics,
-        "api_usage_stats": api_stats.get('api_usage', {})
+        "learning_engine": learning_metrics
     }
 
 @application.get("/stats")
@@ -909,10 +670,8 @@ async def get_performance_stats():
         market_context = await data_manager_global.get_market_context_async() if data_manager_global else {}
         
         learning_stats = {}
-        improvement_suggestions = []
         if learning_engine_global and learning_engine_global.initialized:
             learning_stats = await learning_engine_global.calculate_performance_metrics()
-            improvement_suggestions = await learning_engine_global.suggest_improvements()
         
         api_stats = {}
         if data_manager_global:
@@ -923,20 +682,13 @@ async def get_performance_stats():
             "data_manager": api_stats,
             "market_state": {
                 "is_healthy": state.MARKET_STATE_OK,
-                "description": "Market is healthy for trading" if state.MARKET_STATE_OK else "Market conditions are unfavorable",
                 "context": market_context
             },
             "realtime_monitoring": {
                 "active_trades": len(realtime_monitor.monitoring_tasks) if realtime_monitor else 0,
                 "is_running": realtime_monitor.is_running if realtime_monitor else False
             },
-            "learning_engine": learning_stats,
-            "improvement_suggestions": improvement_suggestions,
-            "enhanced_features": {
-                "netflow_analysis": True,
-                "enhanced_whale_tracking": True,
-                "dynamic_strategy_selection": True
-            }
+            "learning_engine": learning_stats
         }
         return stats
     except Exception as error:
@@ -953,45 +705,39 @@ async def get_logs_status():
             "open_trades_count": len(open_trades),
             "current_capital": portfolio_state.get("current_capital_usd", 0),
             "total_trades": portfolio_state.get("total_trades", 0),
-            "timestamp": datetime.now().isoformat(),
-            "enhanced_analysis": True
+            "timestamp": datetime.now().isoformat()
         }
     except Exception as error:
         raise HTTPException(status_code=500, detail=f"Failed to get logs status: {str(error)}")
 
 async def cleanup_on_shutdown():
     global r2_service_global, data_manager_global, realtime_monitor, learning_engine_global
-    print("\n🛑 Shutdown signal received. Cleaning up...")
+    print("Shutdown signal received. Cleaning up...")
     
     if r2_service_global:
         try:
             await r2_service_global.save_system_logs_async({
-                "application_shutdown": True,
-                "enhanced_analysis": True
+                "application_shutdown": True
             })
-        except Exception as log_error:
-            print(f"⚠️ Failed to save shutdown log: {log_error}")
+        except Exception:
+            pass
     
     if learning_engine_global and learning_engine_global.initialized:
         try:
             await learning_engine_global.save_weights_to_r2()
             await learning_engine_global.save_performance_history()
-            print("✅ Learning engine data saved.")
-        except Exception as e:
-            print(f"⚠️ Failed to save learning engine data: {e}")
+        except Exception:
+            pass
     
     if realtime_monitor:
         realtime_monitor.stop_monitoring()
     
     if r2_service_global and r2_service_global.lock_acquired:
         r2_service_global.release_lock()
-        print("✅ Lock released.")
     if data_manager_global:
         await data_manager_global.close()
-    print("✅ Cleanup completed.")
 
 def signal_handler(signum, frame):
-    print(f"\n⚠️ Received signal {signum}")
     asyncio.create_task(cleanup_on_shutdown())
     sys.exit(0)