Update LLM.py

LLM.py

@@ -1,3 +1,4 @@
+# LLM.py
 import os, traceback, asyncio, json
 from datetime import datetime
 from functools import wraps
@@ -5,7 +6,7 @@ from backoff import on_exception, expo
 from openai import OpenAI, RateLimitError, APITimeoutError
 import numpy as np
 from sentiment_news import NewsFetcher
-from helpers import parse_json_from_response, validate_required_fields, format_technical_indicators, format_strategy_scores, local_analyze_opportunity, local_re_analyze_trade
+from helpers import parse_json_from_response, validate_required_fields, format_technical_indicators, format_strategy_scores
 
 NVIDIA_API_KEY = os.getenv("NVIDIA_API_KEY")
 PRIMARY_MODEL = "nvidia/llama-3.1-nemotron-ultra-253b-v1"
@@ -15,7 +16,8 @@ class PatternAnalysisEngine:
         self.llm = llm_service
 
     def _format_chart_data_for_llm(self, ohlcv_data):
-        if not ohlcv_data or len(ohlcv_data) < 20: return "Insufficient chart data for pattern analysis"
+        if not ohlcv_data or len(ohlcv_data) < 20: 
+            return "Insufficient chart data for pattern analysis"
         try:
             candles_to_analyze = ohlcv_data[-50:] if len(ohlcv_data) > 50 else ohlcv_data
             chart_description = ["CANDLE DATA FOR PATTERN ANALYSIS:", f"Total candles available: {len(ohlcv_data)}", f"Candles used for analysis: {len(candles_to_analyze)}", ""]
@@ -49,7 +51,8 @@ class PatternAnalysisEngine:
                 chart_description.extend(["", "VOLUME ANALYSIS:", f"Current Volume: {current_volume:,.0f}", f"Volume Ratio: {volume_ratio:.2f}x average", f"Volume Signal: {volume_signal}"])
             
             return "\n".join(chart_description)
-        except Exception as e: return f"Error formatting chart data: {str(e)}"
+        except Exception as e: 
+            return f"Error formatting chart data: {str(e)}"
     
     async def analyze_chart_patterns(self, symbol, ohlcv_data):
         try:
@@ -68,11 +71,13 @@ class PatternAnalysisEngine:
     def _parse_pattern_response(self, response_text):
         try:
             json_str = parse_json_from_response(response_text)
-            if not json_str: return {"pattern_detected": "parse_error", "pattern_confidence": 0.1, "pattern_analysis": "Could not parse pattern analysis response"}
+            if not json_str: 
+                return {"pattern_detected": "parse_error", "pattern_confidence": 0.1, "pattern_analysis": "Could not parse pattern analysis response"}
             
             pattern_data = json.loads(json_str)
             required = ['pattern_detected', 'pattern_confidence', 'predicted_direction']
-            if not validate_required_fields(pattern_data, required): return {"pattern_detected": "incomplete_data", "pattern_confidence": 0.1, "pattern_analysis": "Incomplete pattern analysis data"}
+            if not validate_required_fields(pattern_data, required): 
+                return {"pattern_detected": "incomplete_data", "pattern_confidence": 0.1, "pattern_analysis": "Incomplete pattern analysis data"}
             
             return pattern_data
         except Exception as e:
@@ -88,11 +93,13 @@ class LLMService:
         self.news_fetcher = NewsFetcher()
         self.pattern_engine = PatternAnalysisEngine(self)
         self.semaphore = asyncio.Semaphore(5)
+        self.r2_service = None  # سيتم تعيينه من app.py
 
     def _rate_limit_nvidia_api(func):
         @wraps(func)
         @on_exception(expo, RateLimitError, max_tries=5)
-        async def wrapper(*args, **kwargs): return await func(*args, **kwargs)
+        async def wrapper(*args, **kwargs): 
+            return await func(*args, **kwargs)
         return wrapper
 
     async def get_trading_decision(self, data_payload: dict):
@@ -104,29 +111,51 @@ class LLMService:
             pattern_analysis = await self._get_pattern_analysis(data_payload)
             prompt = self._create_enhanced_trading_prompt(data_payload, news_text, pattern_analysis)
             
-            async with self.semaphore: response = await self._call_llm(prompt)
+            # ✅ حفظ الـ Prompt في R2 قبل إرساله للنموذج
+            if self.r2_service:
+                analysis_data = {
+                    'current_price': data_payload.get('current_price'),
+                    'final_score': data_payload.get('final_score'),
+                    'enhanced_final_score': data_payload.get('enhanced_final_score'),
+                    'target_strategy': target_strategy,
+                    'pattern_analysis': pattern_analysis
+                }
+                await self.r2_service.save_llm_prompts_async(
+                    symbol, 'trading_decision', prompt, analysis_data
+                )
+            
+            async with self.semaphore: 
+                response = await self._call_llm(prompt)
             
             decision_dict = self._parse_llm_response_enhanced(response, target_strategy, symbol)
             if decision_dict:
                 decision_dict['model_source'] = self.model_name
                 decision_dict['pattern_analysis'] = pattern_analysis
                 return decision_dict
-            else: return local_analyze_opportunity(data_payload)
+            else:
+                # ❌ لا نستخدم أي محاكاة - نرجع None في حالة الفشل
+                print(f"❌ فشل تحليل النموذج الضخم لـ {symbol} - لا توجد قرارات بديلة")
+                return None
+                
         except Exception as e:
-            print(f"Error getting LLM decision for {data_payload.get('symbol', 'unknown')}: {e}")
-            return local_analyze_opportunity(data_payload)
+            print(f"❌ خطأ في قرار التداول لـ {data_payload.get('symbol', 'unknown')}: {e}")
+            # ❌ لا نستخدم أي محاكاة
+            return None
     
     def _parse_llm_response_enhanced(self, response_text: str, fallback_strategy: str, symbol: str) -> dict:
         try:
             json_str = parse_json_from_response(response_text)
-            if not json_str: return None
+            if not json_str: 
+                return None
 
             decision_data = json.loads(json_str)
             required_fields = ['action', 'reasoning', 'risk_assessment', 'trade_type', 'stop_loss', 'take_profit', 'expected_target_minutes', 'confidence_level']
-            if not validate_required_fields(decision_data, required_fields): return None
+            if not validate_required_fields(decision_data, required_fields): 
+                return None
 
             strategy_value = decision_data.get('strategy')
-            if not strategy_value or strategy_value == 'unknown': decision_data['strategy'] = fallback_strategy
+            if not strategy_value or strategy_value == 'unknown': 
+                decision_data['strategy'] = fallback_strategy
 
             return decision_data
         except Exception as e:
@@ -138,11 +167,13 @@ class LLMService:
             symbol = data_payload['symbol']
             if 'raw_ohlcv' in data_payload and '1h' in data_payload['raw_ohlcv']:
                 ohlcv_data = data_payload['raw_ohlcv']['1h']
-                if ohlcv_data and len(ohlcv_data) >= 20: return await self.pattern_engine.analyze_chart_patterns(symbol, ohlcv_data)
+                if ohlcv_data and len(ohlcv_data) >= 20: 
+                    return await self.pattern_engine.analyze_chart_patterns(symbol, ohlcv_data)
             
             if 'advanced_indicators' in data_payload and '1h' in data_payload['advanced_indicators']:
                 ohlcv_data = data_payload['advanced_indicators']['1h']
-                if ohlcv_data and len(ohlcv_data) >= 20: return await self.pattern_engine.analyze_chart_patterns(symbol, ohlcv_data)
+                if ohlcv_data and len(ohlcv_data) >= 20: 
+                    return await self.pattern_engine.analyze_chart_patterns(symbol, ohlcv_data)
             
             return None
         except Exception as e:
@@ -214,7 +245,8 @@ class LLMService:
         return prompt
 
     def _format_pattern_analysis(self, pattern_analysis):
-        if not pattern_analysis: return "No clear patterns detected"
+        if not pattern_analysis: 
+            return "No clear patterns detected"
         confidence = pattern_analysis.get('pattern_confidence', 0)
         pattern_name = pattern_analysis.get('pattern_detected', 'unknown')
         analysis_lines = [f"Pattern: {pattern_name}", f"Confidence: {confidence:.1%}", f"Predicted Move: {pattern_analysis.get('predicted_direction', 'N/A')}", f"Analysis: {pattern_analysis.get('pattern_analysis', 'No detailed analysis')}"]
@@ -234,25 +266,45 @@ class LLMService:
             pattern_analysis = await self._get_pattern_analysis(processed_data)
             prompt = self._create_re_analysis_prompt(trade_data, processed_data, news_text, pattern_analysis)
             
-            async with self.semaphore: response = await self._call_llm(prompt)
+            # ✅ حفظ الـ Prompt في R2 قبل إرساله للنموذج
+            if self.r2_service:
+                analysis_data = {
+                    'entry_price': trade_data.get('entry_price'),
+                    'current_price': processed_data.get('current_price'),
+                    'original_strategy': original_strategy,
+                    'pattern_analysis': pattern_analysis
+                }
+                await self.r2_service.save_llm_prompts_async(
+                    symbol, 'trade_reanalysis', prompt, analysis_data
+                )
+            
+            async with self.semaphore: 
+                response = await self._call_llm(prompt)
             
             re_analysis_dict = self._parse_re_analysis_response(response, original_strategy, symbol)
             if re_analysis_dict:
                 re_analysis_dict['model_source'] = self.model_name
                 return re_analysis_dict
-            else: return local_re_analyze_trade(trade_data, processed_data)
+            else:
+                # ❌ لا نستخدم أي محاكاة - نرجع None في حالة الفشل
+                print(f"❌ فشل إعادة تحليل ا��نموذج الضخم لـ {symbol} - لا توجد قرارات بديلة")
+                return None
+                
         except Exception as e:
-            print(f"Error in LLM re-analysis: {e}")
-            return local_re_analyze_trade(trade_data, processed_data)
+            print(f"❌ خطأ في إعادة تحليل LLM: {e}")
+            # ❌ لا نستخدم أي محاكاة
+            return None
 
     def _parse_re_analysis_response(self, response_text: str, fallback_strategy: str, symbol: str) -> dict:
         try:
             json_str = parse_json_from_response(response_text)
-            if not json_str: return None
+            if not json_str: 
+                return None
 
             decision_data = json.loads(json_str)
             strategy_value = decision_data.get('strategy')
-            if not strategy_value or strategy_value == 'unknown': decision_data['strategy'] = fallback_strategy
+            if not strategy_value or strategy_value == 'unknown': 
+                decision_data['strategy'] = fallback_strategy
 
             return decision_data
         except Exception as e:
@@ -265,8 +317,11 @@ class LLMService:
         current_price = processed_data.get('current_price', 'N/A')
         strategy = trade_data.get('strategy', 'GENERIC')
         
-        try: price_change = ((current_price - entry_price) / entry_price) * 100; price_change_display = f"{price_change:+.2f}%"
-        except (TypeError, ZeroDivisionError): price_change_display = "N/A"
+        try: 
+            price_change = ((current_price - entry_price) / entry_price) * 100
+            price_change_display = f"{price_change:+.2f}%"
+        except (TypeError, ZeroDivisionError): 
+            price_change_display = "N/A"
             
         indicators_summary = format_technical_indicators(processed_data.get('advanced_indicators', {}))
         pattern_summary = self._format_pattern_analysis(pattern_analysis)