Update app.py

app.py

@@ -8,119 +8,59 @@ from data_manager import DataManager
 from ML import MLProcessor as FeatureProcessor
 from learning_engine import LearningEngine
 from sentiment_news import SentimentAnalyzer
+from trade_manager import TradeManager
 import state
-from helpers import safe_float_conversion, _apply_patience_logic, local_analyze_opportunity, local_re_analyze_trade
+from helpers import safe_float_conversion, _apply_patience_logic, local_analyze_opportunity, local_re_analyze_trade, validate_candidate_data_enhanced
 
 r2_service_global = None
 data_manager_global = None
 llm_service_global = None
 learning_engine_global = None
-realtime_monitor = None
+trade_manager_global = None
 sentiment_analyzer_global = None
 
-class RealTimeTradeMonitor:
-    def __init__(self):
-        self.monitoring_tasks = {}
-        self.is_running = False
-        
-    async def start_monitoring(self):
-        self.is_running = True
-        while self.is_running:
-            try:
-                open_trades = await r2_service_global.get_open_trades_async()
-                for trade in open_trades:
-                    symbol = trade['symbol']
-                    if symbol not in self.monitoring_tasks:
-                        asyncio.create_task(self._monitor_single_trade(trade))
-                        self.monitoring_tasks[symbol] = trade
-                current_symbols = {trade['symbol'] for trade in open_trades}
-                for symbol in list(self.monitoring_tasks.keys()):
-                    if symbol not in current_symbols: del self.monitoring_tasks[symbol]
-                await asyncio.sleep(10)
-            except Exception as error:
-                print(f"Real-time monitor error: {error}")
-                await asyncio.sleep(30)
-    
-    async def _monitor_single_trade(self, trade):
-        symbol = trade['symbol']
-        while symbol in self.monitoring_tasks and self.is_running:
-            try:
-                current_price = await data_manager_global.get_latest_price_async(symbol)
-                if not current_price: await asyncio.sleep(15); continue
-                entry_price = trade['entry_price']
-                stop_loss = trade.get('stop_loss')
-                take_profit = trade.get('take_profit')
-                should_close, close_reason = False, ""
-                if stop_loss and current_price <= stop_loss: should_close, close_reason = True, f"Stop loss hit: {current_price} <= {stop_loss}"
-                elif take_profit and current_price >= take_profit: should_close, close_reason = True, f"Take profit hit: {current_price} >= {take_profit}"
-                if not should_close and current_price > entry_price:
-                    dynamic_stop = current_price * 0.98
-                    if dynamic_stop > (stop_loss or 0): trade['stop_loss'] = dynamic_stop
-                if should_close:
-                    if r2_service_global.acquire_lock():
-                        try:
-                            await r2_service_global.close_trade_async(trade, current_price)
-                            if learning_engine_global and learning_engine_global.initialized:
-                                await learning_engine_global.analyze_trade_outcome(trade, 'CLOSED_BY_MONITOR')
-                            asyncio.create_task(run_bot_cycle_async())
-                        finally: r2_service_global.release_lock()
-                    if symbol in self.monitoring_tasks: del self.monitoring_tasks[symbol]
-                    break
-                await asyncio.sleep(15)
-            except Exception as 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()
-
 async def monitor_market_async():
     global data_manager_global, sentiment_analyzer_global
     init_attempts = 0
-    while data_manager_global is None and init_attempts < 10: await asyncio.sleep(3); init_attempts += 1
-    if data_manager_global is None: return
+    while data_manager_global is None and init_attempts < 10: 
+        await asyncio.sleep(3)
+        init_attempts += 1
+    if data_manager_global is None: 
+        return
+        
     while True:
         try:
             market_context = await sentiment_analyzer_global.get_market_sentiment()
-            if not market_context: state.MARKET_STATE_OK = True; await asyncio.sleep(60); continue
+            if not market_context: 
+                state.MARKET_STATE_OK = True
+                await asyncio.sleep(60)
+                continue
+                
             whale_analysis = market_context.get('general_whale_activity', {})
             is_critical = whale_analysis.get('critical_alert', False)
             bitcoin_sentiment = market_context.get('btc_sentiment')
             fear_greed_index = market_context.get('fear_and_greed_index')
+            
             should_halt_trading, halt_reason = False, ""
-            if is_critical: should_halt_trading, halt_reason = True, f"CRITICAL whale activity detected"
-            elif bitcoin_sentiment == 'BEARISH' and (fear_greed_index is not None and fear_greed_index < 30): should_halt_trading, halt_reason = True, f"Bearish market conditions"
+            if is_critical: 
+                should_halt_trading, halt_reason = True, "نشاط حيتان حرج"
+            elif bitcoin_sentiment == 'BEARISH' and (fear_greed_index is not None and fear_greed_index < 30): 
+                should_halt_trading, halt_reason = True, "ظروف سوق هابطة"
+                
             if should_halt_trading:
                 state.MARKET_STATE_OK = False
                 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.")
+                if not state.MARKET_STATE_OK: 
+                    print("تحسنت ظروف السوق. استئناف العمليات العادية.")
                 state.MARKET_STATE_OK = True
+                
             await asyncio.sleep(60)
         except Exception as error:
-            print(f"Error during market monitoring: {error}")
+            print(f"خطأ أثناء مراقبة السوق: {error}")
             state.MARKET_STATE_OK = True
             await asyncio.sleep(60)
 
-async def validate_candidate_data_enhanced(candidate):
-    try:
-        required_fields = ['symbol', 'current_price', 'final_score', 'enhanced_final_score']
-        for field in required_fields:
-            if field not in candidate: candidate[field] = 0.0 if field.endswith('_score') or field == 'current_price' else 'UNKNOWN'
-        candidate['current_price'] = safe_float_conversion(candidate.get('current_price'), 0.0)
-        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: candidate['reasons_for_candidacy'] = ['unknown_reason']
-        if 'sentiment_data' not in candidate: candidate['sentiment_data'] = {'btc_sentiment': 'NEUTRAL','fear_and_greed_index': 50,'general_whale_activity': {'sentiment': 'NEUTRAL', 'critical_alert': False}}
-        if 'advanced_indicators' not in candidate: candidate['advanced_indicators'] = {}
-        if 'strategy_scores' not in candidate: candidate['strategy_scores'] = {}
-        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}")
-        return False
-
 async def analyze_market_strategy(market_context):
     try:
         whale_analysis = market_context.get('general_whale_activity', {})
@@ -133,33 +73,57 @@ async def analyze_market_strategy(market_context):
             strategy_data = json.loads(json_str)
         except:
             net_flow = netflow_analysis.get('net_flow', 0)
-            if net_flow > 1000000: fallback_strategy = "AGGRESSIVE_GROWTH"
-            elif net_flow < -1000000: fallback_strategy = "CONSERVATIVE" 
-            elif whale_analysis.get('critical_alert'): fallback_strategy = "CONSERVATIVE"
-            else: fallback_strategy = "GENERIC"
-            strategy_data = {"primary_strategy": fallback_strategy,"reasoning": "Fallback strategy","risk_tolerance": 5,"optimal_scan_count": 100}
+            if net_flow > 1000000: 
+                fallback_strategy = "AGGRESSIVE_GROWTH"
+            elif net_flow < -1000000: 
+                fallback_strategy = "CONSERVATIVE" 
+            elif whale_analysis.get('critical_alert'): 
+                fallback_strategy = "CONSERVATIVE"
+            else: 
+                fallback_strategy = "GENERIC"
+            strategy_data = {
+                "primary_strategy": fallback_strategy,
+                "reasoning": "Fallback strategy",
+                "risk_tolerance": 5,
+                "optimal_scan_count": 100
+            }
         return strategy_data
     except Exception as error:
-        print(f"Failed to analyze market strategy: {error}")
-        return {"primary_strategy": "GENERIC","reasoning": "Fallback due to analysis error","risk_tolerance": 5,"optimal_scan_count": 100}
+        print(f"فشل تحليل استراتيجية السوق: {error}")
+        return {
+            "primary_strategy": "GENERIC",
+            "reasoning": "Fallback due to analysis error",
+            "risk_tolerance": 5,
+            "optimal_scan_count": 100
+        }
 
 async def find_strategy_specific_candidates(strategy, scan_count):
     try:
         all_candidates = await data_manager_global.find_high_potential_candidates(scan_count * 2)
-        if not all_candidates: return []
+        if not all_candidates: 
+            return []
+            
         market_context = await data_manager_global.get_market_context_async()
-        if not market_context: return []
+        if not market_context: 
+            return []
+            
         feature_processor = FeatureProcessor(market_context, data_manager_global, learning_engine_global)
         processed_candidates = []
+        
         for candidate in all_candidates[:30]:
             try:
                 symbol_with_reasons = [{'symbol': candidate['symbol'], 'reasons': candidate.get('reasons', [])}]
                 ohlcv_data = await data_manager_global.get_fast_pass_data_async(symbol_with_reasons)
                 if ohlcv_data and ohlcv_data[0]:
                     processed = await feature_processor.process_and_score_symbol_enhanced(ohlcv_data[0])
-                    if processed: processed_candidates.append(processed)
-            except Exception as e: print(f"Failed to process {candidate.get('symbol')}: {e}")
-        if not processed_candidates: return []
+                    if processed: 
+                        processed_candidates.append(processed)
+            except Exception as e: 
+                print(f"Failed to process {candidate.get('symbol')}: {e}")
+                
+        if not processed_candidates: 
+            return []
+            
         if strategy != 'GENERIC':
             strategy_candidates = []
             for candidate in processed_candidates:
@@ -173,6 +137,7 @@ async def find_strategy_specific_candidates(strategy, scan_count):
         else:
             sorted_candidates = sorted(processed_candidates, key=lambda x: x.get('enhanced_final_score', 0), reverse=True)
             top_candidates = sorted_candidates[:15]
+            
         return top_candidates
     except Exception as error:
         print(f"Advanced filtering failed: {error}")
@@ -182,50 +147,104 @@ async def find_new_opportunities_async():
     try:
         await r2_service_global.save_system_logs_async({"opportunity_scan_started": True})
         market_context = await data_manager_global.get_market_context_async()
-        if not market_context: return
+        if not market_context: 
+            return
+            
         strategy_decision = await analyze_market_strategy(market_context)
-        high_potential_candidates = await find_strategy_specific_candidates(strategy_decision['primary_strategy'], strategy_decision.get('optimal_scan_count', 100))
+        high_potential_candidates = await find_strategy_specific_candidates(
+            strategy_decision['primary_strategy'], 
+            strategy_decision.get('optimal_scan_count', 100)
+        )
+        
         if not high_potential_candidates:
             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'
-            else: return
+                for candidate in high_potential_candidates: 
+                    candidate['target_strategy'] = 'GENERIC'
+            else: 
+                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)
             updated_market_context = await data_manager_global.get_market_context_async()
-            if not updated_market_context: updated_market_context = market_context
+            if not updated_market_context: 
+                updated_market_context = market_context
+                
             feature_processor = FeatureProcessor(updated_market_context, data_manager_global, learning_engine_global)
-            processed_chunk = await asyncio.gather(*[feature_processor.process_and_score_symbol_enhanced(data) for data in chunk_data])
+            processed_chunk = await asyncio.gather(*[
+                feature_processor.process_and_score_symbol_enhanced(data) for data in chunk_data
+            ])
             all_processed_candidates.extend([c for c in processed_chunk if c is not None])
             await asyncio.sleep(1)
-        if not all_processed_candidates: return
+            
+        if not all_processed_candidates: 
+            return
+            
         updated_market_context = await data_manager_global.get_market_context_async()
-        if not updated_market_context: updated_market_context = market_context
+        if not updated_market_context: 
+            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)
-        await r2_service_global.save_candidates_data_async(candidates_data=top_candidates, reanalysis_data={"strategy_used": strategy_decision, "market_conditions": market_context})
-        if not top_candidates: return
+        
+        await r2_service_global.save_candidates_data_async(
+            candidates_data=top_candidates, 
+            reanalysis_data={
+                "strategy_used": strategy_decision, 
+                "market_conditions": market_context
+            }
+        )
+        
+        if not top_candidates: 
+            return
+            
         for candidate in top_candidates:
             try:
-                if not await validate_candidate_data_enhanced(candidate): continue
+                if not await validate_candidate_data_enhanced(candidate): 
+                    continue
+                    
                 llm_analysis_data = await llm_service_global.get_trading_decision(candidate)
-                if not llm_analysis_data: continue
-                if llm_analysis_data.get('action') == "HOLD": continue
+                if not llm_analysis_data: 
+                    continue
+                    
+                if llm_analysis_data.get('action') == "HOLD": 
+                    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': final_strategy = candidate_strategy; llm_analysis_data['strategy'] = final_strategy
-                    await r2_service_global.save_system_logs_async({"new_opportunity_found": True, "symbol": candidate['symbol'],"action": llm_analysis_data.get('action'), "strategy": final_strategy})
-                    return {"symbol": candidate['symbol'],"decision": llm_analysis_data,"current_price": candidate['current_price'],"strategy": final_strategy}
-            except Exception as error: print(f"LLM error for {candidate.get('symbol', 'unknown')}: {error}")
+                    if not final_strategy or final_strategy == 'unknown': 
+                        final_strategy = candidate_strategy
+                        llm_analysis_data['strategy'] = final_strategy
+                        
+                    await r2_service_global.save_system_logs_async({
+                        "new_opportunity_found": True, 
+                        "symbol": candidate['symbol'],
+                        "action": llm_analysis_data.get('action'), 
+                        "strategy": final_strategy
+                    })
+                    
+                    return {
+                        "symbol": candidate['symbol'],
+                        "decision": llm_analysis_data,
+                        "current_price": candidate['current_price'],
+                        "strategy": final_strategy
+                    }
+            except Exception as error: 
+                print(f"LLM error for {candidate.get('symbol', 'unknown')}: {error}")
+                
         return None
     except Exception as error:
         print(f"Error while scanning for opportunities: {error}")
-        await r2_service_global.save_system_logs_async({"opportunity_scan_error": True, "error": str(error)})
+        await r2_service_global.save_system_logs_async({
+            "opportunity_scan_error": True, 
+            "error": str(error)
+        })
         return None
 
 async def re_analyze_open_trade_async(trade_data):
@@ -234,63 +253,109 @@ async def re_analyze_open_trade_async(trade_data):
         entry_time = datetime.fromisoformat(trade_data['entry_timestamp'])
         current_time = datetime.now()
         hold_minutes = (current_time - entry_time).total_seconds() / 60
+        
         original_strategy = trade_data.get('strategy')
-        if not original_strategy or original_strategy == 'unknown': original_strategy = trade_data.get('decision_data', {}).get('strategy', 'GENERIC')
-        try: market_context = await data_manager_global.get_market_context_async()
-        except Exception: market_context = {'btc_sentiment': 'NEUTRAL'}
+        if not original_strategy or original_strategy == 'unknown': 
+            original_strategy = trade_data.get('decision_data', {}).get('strategy', 'GENERIC')
+            
+        try: 
+            market_context = await data_manager_global.get_market_context_async()
+        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: return None
+        if not ohlcv_data_list: 
+            return None
+            
         raw_data = ohlcv_data_list[0]
         try:
             updated_market_context = await data_manager_global.get_market_context_async()
-            if updated_market_context: market_context = updated_market_context
-        except Exception: pass
+            if updated_market_context: 
+                market_context = updated_market_context
+        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: return None
-        await r2_service_global.save_candidates_data_async(candidates_data=None, reanalysis_data={'market_context': market_context, 'processed_data': processed_data})
-        try: re_analysis_decision = await llm_service_global.re_analyze_trade_async(trade_data, processed_data)
-        except Exception: re_analysis_decision = local_re_analyze_trade(trade_data, processed_data)
+        if not processed_data: 
+            return None
+            
+        await r2_service_global.save_candidates_data_async(
+            candidates_data=None, 
+            reanalysis_data={
+                'market_context': market_context, 
+                'processed_data': processed_data
+            }
+        )
+        
+        try: 
+            re_analysis_decision = await llm_service_global.re_analyze_trade_async(trade_data, processed_data)
+        except Exception: 
+            re_analysis_decision = local_re_analyze_trade(trade_data, processed_data)
+            
         final_decision = _apply_patience_logic(re_analysis_decision, hold_minutes, trade_data, processed_data)
-        if not final_decision.get('strategy'): final_decision['strategy'] = original_strategy
-        await r2_service_global.save_system_logs_async({"trade_reanalyzed": True, "symbol": symbol, "action": final_decision.get('action'),"hold_minutes": hold_minutes, "strategy": final_decision.get('strategy')})
-        return {"symbol": symbol, "decision": final_decision,"current_price": processed_data.get('current_price'), "hold_minutes": hold_minutes}
+        if not final_decision.get('strategy'): 
+            final_decision['strategy'] = original_strategy
+            
+        await r2_service_global.save_system_logs_async({
+            "trade_reanalyzed": True, 
+            "symbol": symbol, 
+            "action": final_decision.get('action'),
+            "hold_minutes": hold_minutes, 
+            "strategy": final_decision.get('strategy')
+        })
+        
+        return {
+            "symbol": symbol, 
+            "decision": final_decision,
+            "current_price": processed_data.get('current_price'), 
+            "hold_minutes": hold_minutes
+        }
     except Exception as error:
         print(f"Error during trade re-analysis: {error}")
-        await r2_service_global.save_system_logs_async({"reanalysis_error": True, "symbol": symbol, "error": str(error)})
+        await r2_service_global.save_system_logs_async({
+            "reanalysis_error": True, 
+            "symbol": symbol, 
+            "error": str(error)
+        })
         return None
 
 async def run_bot_cycle_async():
     try:
         await r2_service_global.save_system_logs_async({"cycle_started": True})
-        if not r2_service_global.acquire_lock(): return
+        if not r2_service_global.acquire_lock(): 
+            return
+            
         open_trades = []
         try:
-            open_trades = await r2_service_global.get_open_trades_async()
+            open_trades = await trade_manager_global.get_open_trades()
             trades_fixed = 0
             for trade in open_trades:
                 if not trade.get('strategy') or trade['strategy'] == 'unknown':
                     original_strategy = trade.get('decision_data', {}).get('strategy', 'GENERIC')
                     trade['strategy'] = original_strategy
                     trades_fixed += 1
-            if trades_fixed > 0: await r2_service_global.save_open_trades_async(open_trades)
+                    
+            if trades_fixed > 0: 
+                await r2_service_global.save_open_trades_async(open_trades)
+                
             should_look_for_new_trade = not open_trades
             if open_trades:
                 now = datetime.now()
-                trades_to_reanalyze = [trade for trade in open_trades if now >= datetime.fromisoformat(trade.get('expected_target_time', now.isoformat()))]
+                trades_to_reanalyze = [
+                    trade for trade in open_trades 
+                    if now >= datetime.fromisoformat(trade.get('expected_target_time', now.isoformat()))
+                ]
                 if trades_to_reanalyze:
                     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'])
-                            if learning_engine_global and learning_engine_global.initialized:
-                                trade_with_strategy = trade.copy()
-                                strategy = result['decision'].get('strategy', trade.get('strategy', 'GENERIC'))
-                                trade_with_strategy['strategy'] = strategy
-                                await learning_engine_global.analyze_trade_outcome(trade_with_strategy, 'CLOSED_BY_REANALYSIS')
+                            await trade_manager_global.close_trade(trade, result['current_price'], 'CLOSED_BY_REANALYSIS')
                             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'])
+                        elif result and result['decision'].get('action') == "UPDATE_TRADE": 
+                            await trade_manager_global.update_trade(trade, result['decision'])
+                            
             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)
@@ -302,27 +367,36 @@ async def run_bot_cycle_async():
                             portfolio_state["invested_capital_usd"] = 0.0
                             await r2_service_global.save_portfolio_state_async(portfolio_state)
                             current_capital = initial_capital
+                            
                 if current_capital > 1:
                     new_opportunity = await find_new_opportunities_async()
                     if new_opportunity:
-                        if not new_opportunity['decision'].get('strategy'): new_opportunity['decision']['strategy'] = new_opportunity.get('strategy', 'GENERIC')
-                        await r2_service_global.save_new_trade_async(new_opportunity['symbol'], new_opportunity['decision'], new_opportunity['current_price'])
-                        newly_opened_trades = await r2_service_global.get_open_trades_async()
-                        for trade in newly_opened_trades:
-                            if trade['symbol'] == new_opportunity['symbol']:
-                                asyncio.create_task(realtime_monitor._monitor_single_trade(trade))
-                                break
+                        if not new_opportunity['decision'].get('strategy'): 
+                            new_opportunity['decision']['strategy'] = new_opportunity.get('strategy', 'GENERIC')
+                            
+                        await trade_manager_global.open_trade(
+                            new_opportunity['symbol'], 
+                            new_opportunity['decision'], 
+                            new_opportunity['current_price']
+                        )
         finally:
             r2_service_global.release_lock()
-            await r2_service_global.save_system_logs_async({"cycle_completed": True, "open_trades": len(open_trades)})
+            await r2_service_global.save_system_logs_async({
+                "cycle_completed": True, 
+                "open_trades": len(open_trades)
+            })
     except Exception as error:
         print(f"Unhandled error in main cycle: {error}")
-        await r2_service_global.save_system_logs_async({"cycle_error": True, "error": str(error)})
-        if r2_service_global.lock_acquired: r2_service_global.release_lock()
+        await r2_service_global.save_system_logs_async({
+            "cycle_error": 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, sentiment_analyzer_global
+    global r2_service_global, data_manager_global, llm_service_global, learning_engine_global, trade_manager_global, sentiment_analyzer_global
     try:
         r2_service_global = R2Service()
         llm_service_global = LLMService()
@@ -333,16 +407,21 @@ async def lifespan(application: FastAPI):
         learning_engine_global = LearningEngine(r2_service_global, data_manager_global)
         await learning_engine_global.initialize_enhanced()
         await learning_engine_global.force_strategy_learning()
-        realtime_monitor = RealTimeTradeMonitor()
+        trade_manager_global = TradeManager(r2_service_global, learning_engine_global, data_manager_global)
         asyncio.create_task(monitor_market_async())
-        asyncio.create_task(realtime_monitor.start_monitoring())
+        asyncio.create_task(trade_manager_global.start_trade_monitoring())
         await r2_service_global.save_system_logs_async({"application_started": True})
         yield
     except Exception as error:
         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)})
+        if r2_service_global: 
+            await r2_service_global.save_system_logs_async({
+                "application_startup_failed": True, 
+                "error": str(error)
+            })
         raise
-    finally: await cleanup_on_shutdown()
+    finally: 
+        await cleanup_on_shutdown()
 
 application = FastAPI(lifespan=lifespan)
 
@@ -354,17 +433,25 @@ async def run_cycle_api():
 @application.get("/health")
 async def health_check():
     learning_metrics = {}
-    if learning_engine_global and learning_engine_global.initialized: learning_metrics = await learning_engine_global.calculate_performance_metrics()
+    if learning_engine_global and learning_engine_global.initialized: 
+        learning_metrics = await learning_engine_global.calculate_performance_metrics()
+        
     api_stats = {}
-    if data_manager_global: api_stats = data_manager_global.get_performance_stats()
+    if data_manager_global: 
+        api_stats = data_manager_global.get_performance_stats()
+        
     return {
-        "status": "healthy", "timestamp": datetime.now().isoformat(), "services": {
+        "status": "healthy", 
+        "timestamp": datetime.now().isoformat(), 
+        "services": {
             "r2_service": "initialized" if r2_service_global else "uninitialized",
             "llm_service": "initialized" if llm_service_global else "uninitialized",
             "data_manager": "initialized" if data_manager_global else "uninitialized",
             "learning_engine": "active" if learning_engine_global and learning_engine_global.initialized else "inactive",
-            "realtime_monitor": "running" if realtime_monitor and realtime_monitor.is_running else "stopped"
-        }, "market_state_ok": state.MARKET_STATE_OK, "learning_engine": learning_metrics
+            "trade_manager": "active" if trade_manager_global else "inactive"
+        }, 
+        "market_state_ok": state.MARKET_STATE_OK, 
+        "learning_engine": learning_metrics
     }
 
 @application.get("/stats")
@@ -372,19 +459,29 @@ async def get_performance_stats():
     try:
         market_context = await data_manager_global.get_market_context_async() if data_manager_global else {}
         learning_stats = {}
-        if learning_engine_global and learning_engine_global.initialized: learning_stats = await learning_engine_global.calculate_performance_metrics()
+        if learning_engine_global and learning_engine_global.initialized: 
+            learning_stats = await learning_engine_global.calculate_performance_metrics()
+            
         api_stats = {}
-        if data_manager_global: api_stats = data_manager_global.get_performance_stats()
+        if data_manager_global: 
+            api_stats = data_manager_global.get_performance_stats()
+            
         stats = {
-            "timestamp": datetime.now().isoformat(), "data_manager": api_stats, "market_state": {
-                "is_healthy": state.MARKET_STATE_OK, "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
+            "timestamp": datetime.now().isoformat(), 
+            "data_manager": api_stats, 
+            "market_state": {
+                "is_healthy": state.MARKET_STATE_OK, 
+                "context": market_context
+            }, 
+            "trade_monitoring": {
+                "active_trades": len(trade_manager_global.monitoring_tasks) if trade_manager_global else 0,
+                "is_running": trade_manager_global.is_running if trade_manager_global else False
+            }, 
+            "learning_engine": learning_stats
         }
         return stats
-    except Exception as error: raise HTTPException(status_code=500, detail=f"Failed to retrieve stats: {str(error)}")
+    except Exception as error: 
+        raise HTTPException(status_code=500, detail=f"Failed to retrieve stats: {str(error)}")
 
 @application.get("/logs/status")
 async def get_logs_status():
@@ -392,27 +489,39 @@ async def get_logs_status():
         open_trades = await r2_service_global.get_open_trades_async()
         portfolio_state = await r2_service_global.get_portfolio_state_async()
         return {
-            "logging_system": "active", "open_trades_count": len(open_trades),
+            "logging_system": "active", 
+            "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()
         }
-    except Exception as error: raise HTTPException(status_code=500, detail=f"Failed to get logs status: {str(error)}")
+    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
+    global r2_service_global, data_manager_global, trade_manager_global, learning_engine_global
     print("Shutdown signal received. Cleaning up...")
     if r2_service_global:
-        try: await r2_service_global.save_system_logs_async({"application_shutdown": True})
-        except Exception: pass
+        try: 
+            await r2_service_global.save_system_logs_async({"application_shutdown": True})
+        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()
-        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()
-    if data_manager_global: await data_manager_global.close()
+        except Exception: 
+            pass
+            
+    if trade_manager_global: 
+        trade_manager_global.stop_monitoring()
+        
+    if r2_service_global and r2_service_global.lock_acquired: 
+        r2_service_global.release_lock()
+        
+    if data_manager_global: 
+        await data_manager_global.close()
 
 def signal_handler(signum, frame):
     asyncio.create_task(cleanup_on_shutdown())
@@ -421,4 +530,5 @@ def signal_handler(signum, frame):
 signal.signal(signal.SIGINT, signal_handler)
 signal.signal(signal.SIGTERM, signal_handler)
 
-if __name__ == "__main__": uvicorn.run(application, host="0.0.0.0", port=7860)
+if __name__ == "__main__": 
+    uvicorn.run(application, host="0.0.0.0", port=7860)