Update app.py

app.py

@@ -3,13 +3,13 @@ from contextlib import asynccontextmanager
 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 LLM import LLMService
 from data_manager import DataManager
 from ML import MLProcessor as FeatureProcessor
 from learning_engine import LearningEngine
 from sentiment_news import SentimentAnalyzer
 import state
-from helpers import safe_float_conversion, _apply_patience_logic
+from helpers import safe_float_conversion, _apply_patience_logic, local_analyze_opportunity, local_re_analyze_trade
 
 r2_service_global = None
 data_manager_global = None
@@ -25,76 +25,48 @@ class RealTimeTradeMonitor:
         
     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]
-                
+                    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
-                
+                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 = False
-                close_reason = ""
-                
-                if stop_loss and current_price <= stop_loss:
-                    should_close = True
-                    close_reason = f"Stop loss hit: {current_price} <= {stop_loss}"
-                elif take_profit and current_price >= take_profit:
-                    should_close = True
-                    close_reason = f"Take profit hit: {current_price} >= {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 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]
+                        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)
@@ -105,51 +77,26 @@ class RealTimeTradeMonitor:
 
 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 = False
-            halt_reason = ""
-            
-            if is_critical:
-                should_halt_trading = True
-                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"
-
+            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 should_halt_trading:
                 state.MARKET_STATE_OK = False
-                await r2_service_global.save_system_logs_async({
-                    "market_halt": True,
-                    "reason": halt_reason
-                })
+                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("Market conditions improved. Resuming normal operations.")
                 state.MARKET_STATE_OK = True
-                
             await asyncio.sleep(60)
         except Exception as error:
             print(f"Error during market monitoring: {error}")
@@ -159,36 +106,17 @@ async def monitor_market_async():
 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'
-        
+            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'
-            
+        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
@@ -197,341 +125,160 @@ async def analyze_market_strategy(market_context):
     try:
         whale_analysis = market_context.get('general_whale_activity', {})
         netflow_analysis = whale_analysis.get('netflow_analysis', {})
-        
-        prompt = f"""
-        Analyze current market conditions and determine trading strategy.
-
-        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 Alert: {whale_analysis.get('critical_alert')}
-        - Net Flow: ${netflow_analysis.get('net_flow', 0):,.0f}
-
-        Output JSON:
-        {{
-            "primary_strategy": "STRATEGY_NAME",
-            "reasoning": "Brief reasoning",
-            "risk_tolerance": 5,
-            "optimal_scan_count": 100
-        }}
-        """
-        
+        prompt = f"Analyze current market conditions and determine trading strategy.\n\nMarket Data:\n- BTC Sentiment: {market_context.get('btc_sentiment')}\n- Fear & Greed Index: {market_context.get('fear_and_greed_index')}\n- Whale Analysis: {whale_analysis.get('sentiment')}\n- Critical Alert: {whale_analysis.get('critical_alert')}\n- Net Flow: ${netflow_analysis.get('net_flow', 0):,.0f}\n\nOutput JSON:\n{{\"primary_strategy\": \"STRATEGY_NAME\",\"reasoning\": \"Brief reasoning\",\"risk_tolerance\": 5,\"optimal_scan_count\": 100}}"
         response = await llm_service_global._call_llm(prompt)
-        
         try:
             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"
-            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,
-        }
+        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:
                 base_scores = candidate.get('base_strategy_scores', {})
                 strategy_score = base_scores.get(strategy, 0)
-                
                 if strategy_score > 0.2:
                     candidate['strategy_match_score'] = strategy_score
                     strategy_candidates.append(candidate)
-            
-            sorted_candidates = sorted(strategy_candidates, 
-                                    key=lambda x: x.get('strategy_match_score', 0), 
-                                    reverse=True)
+            sorted_candidates = sorted(strategy_candidates, key=lambda x: x.get('strategy_match_score', 0), reverse=True)
             top_candidates = sorted_candidates[:15]
         else:
-            sorted_candidates = sorted(processed_candidates, 
-                                    key=lambda x: x.get('enhanced_final_score', 0), 
-                                    reverse=True)
+            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}")
         return []
 
 async def find_new_opportunities_async():
     try:
-        await r2_service_global.save_system_logs_async({
-            "opportunity_scan_started": True
-        })
-
+        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):
     symbol = trade_data.get('symbol')
-    
     try:
         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
-
+        await r2_service_global.save_system_logs_async({"cycle_started": True})
+        if not r2_service_global.acquire_lock(): return
         open_trades = []
         try:
             open_trades = await r2_service_global.get_open_trades_async()
-            
             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)
@@ -543,13 +290,10 @@ async def run_bot_cycle_async():
                                 trade_with_strategy['strategy'] = strategy
                                 await learning_engine_global.analyze_trade_outcome(trade_with_strategy, '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 r2_service_global.update_trade_async(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)
-                
                 if current_capital <= 0:
                     if len(open_trades) == 0:
                         initial_capital = portfolio_state.get("initial_capital_usd", 10.0)
@@ -558,80 +302,47 @@ 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']
-                        )
+                        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
-            
         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
-    
     try:
         r2_service_global = R2Service()
         llm_service_global = LLMService()
         contracts_database = await r2_service_global.load_contracts_db_async()
-        
         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()
-        
         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
-        })
-        
+        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)
 
@@ -643,99 +354,65 @@ 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
+        }, "market_state_ok": state.MARKET_STATE_OK, "learning_engine": learning_metrics
     }
 
 @application.get("/stats")
 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": {
+            "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
+            }, "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():
     try:
         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
     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 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()
 
 def signal_handler(signum, frame):
     asyncio.create_task(cleanup_on_shutdown())
@@ -744,5 +421,4 @@ 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)