Update learning_engine.py

learning_engine.py

@@ -1,11 +1,6 @@
-import os
-import json
-import asyncio
-import pandas as pd
-import numpy as np
-from datetime import datetime, timedelta
-from typing import Dict, List, Any
-import hashlib
+import os, json, asyncio
+from datetime import datetime
+from helpers import normalize_weights, calculate_market_volatility, should_update_weights
 
 class LearningEngine:
     def __init__(self, r2_service, data_manager):
@@ -20,58 +15,42 @@ class LearningEngine:
         self.initialization_lock = asyncio.Lock()
         
     async def initialize(self):
-        """تهيئة نظام التعلم من R2"""
         async with self.initialization_lock:
-            if self.initialized:
-                return
-                
-            print("🧠 تهيئة نظام التعلم الذاتي...")
+            if self.initialized: return
+            print("Initializing learning system...")
             try:
                 await self.load_weights_from_r2()
                 await self.load_performance_history()
                 self.initialized = True
-                print("✅ نظام التعلم جاهز - الأوزان محملة بنجاح")
+                print("Learning system ready")
             except Exception as e:
-                print(f"⚠️ لم يتم تحميل الأوزان السابقة: {e} - سيتم البدء بأوزان افتراضية")
+                print(f"Weights loading failed: {e}")
                 await self.initialize_default_weights()
                 self.initialized = True
 
     async def initialize_enhanced(self):
-        """تهيئة محسنة لنظام التعلم"""
         async with self.initialization_lock:
-            if self.initialized:
-                return
-                
-            print("🧠 تهيئة نظام التعلم الذاتي المحسّن...")
+            if self.initialized: return
+            print("Enhanced learning system initialization...")
             try:
                 await self.load_weights_from_r2()
                 await self.load_performance_history()
-                
-                # إصلاح هيكل الأوزان إذا لزم الأمر
                 await self.fix_weights_structure()
-                
-                # إذا لم تكن هناك بيانات كافية، بدء التعلم من الصفر
                 if not self.performance_history:
-                    print("🔰 بدء التعلم من الصفر - لا توجد بيانات تاريخية")
+                    print("Starting learning from scratch")
                     await self.initialize_default_weights()
-                
                 self.initialized = True
-                print("✅ نظام التعلم المحسّن جاهز")
-                
             except Exception as e:
-                print(f"⚠️ فشل التهيئة المحسنة: {e}")
+                print(f"Enhanced initialization failed: {e}")
                 await self.initialize_default_weights()
                 self.initialized = True
     
     async def fix_weights_structure(self):
-        """إصلاح هيكل الأوزان ليتوافق مع الكود"""
         try:
-            # تحميل البيانات الحالية
             key = "learning_engine_weights.json"
             response = self.r2_service.s3_client.get_object(Bucket="trading", Key=key)
             current_data = json.loads(response['Body'].read())
             
-            # إذا كان الهيكل قديماً، قم بتحديثه
             if 'strategy_weights' in current_data and 'last_updated' not in current_data:
                 fixed_data = {
                     "weights": current_data,
@@ -79,89 +58,56 @@ class LearningEngine:
                     "version": "2.0",
                     "performance_metrics": await self.calculate_performance_metrics()
                 }
-                
                 data_json = json.dumps(fixed_data, indent=2, ensure_ascii=False).encode('utf-8')
                 self.r2_service.s3_client.put_object(
                     Bucket="trading", Key=key, Body=data_json, ContentType="application/json"
                 )
-                print("✅ تم إصلاح هيكل الأوزان بنجاح")
-                
+                print("Weights structure fixed")
         except Exception as e:
-            print(f"⚠️ لم يتم إصلاح هيكل الأوزان: {e}")
+            print(f"Weights structure fix failed: {e}")
     
     async def initialize_default_weights(self):
-        """تهيئة الأوزان الافتراضية - موزعة بشكل أفضل"""
         self.weights = {
             "strategy_weights": {
-                "trend_following": 0.18,
-                "mean_reversion": 0.15,  
-                "breakout_momentum": 0.22,
-                "volume_spike": 0.12,
-                "whale_tracking": 0.15,
-                "pattern_recognition": 0.10,
+                "trend_following": 0.18, "mean_reversion": 0.15, "breakout_momentum": 0.22,
+                "volume_spike": 0.12, "whale_tracking": 0.15, "pattern_recognition": 0.10,
                 "hybrid_ai": 0.08
             },
             "technical_weights": {
-                "rsi": 0.15,
-                "macd": 0.18,
-                "ema_cross": 0.12,
-                "bollinger_bands": 0.10,
-                "volume_analysis": 0.15,
-                "support_resistance": 0.12,
-                "market_sentiment": 0.18
+                "rsi": 0.15, "macd": 0.18, "ema_cross": 0.12, "bollinger_bands": 0.10,
+                "volume_analysis": 0.15, "support_resistance": 0.12, "market_sentiment": 0.18
             },
             "risk_parameters": {
-                "max_position_size": 0.1,
-                "max_daily_loss": 0.02,
-                "stop_loss_base": 0.02,
-                "risk_reward_ratio": 2.0,
-                "volatility_adjustment": 1.0
+                "max_position_size": 0.1, "max_daily_loss": 0.02, "stop_loss_base": 0.02,
+                "risk_reward_ratio": 2.0, "volatility_adjustment": 1.0
             },
             "market_condition_weights": {
-                "bull_market": {
-                    "trend_following": 0.25,
-                    "breakout_momentum": 0.20,
-                    "whale_tracking": 0.15
-                },
-                "bear_market": {
-                    "mean_reversion": 0.25,
-                    "pattern_recognition": 0.20,
-                    "hybrid_ai": 0.15
-                },
-                "sideways_market": {
-                    "mean_reversion": 0.30,
-                    "volume_spike": 0.20,
-                    "pattern_recognition": 0.15
-                }
+                "bull_market": {"trend_following": 0.25, "breakout_momentum": 0.20, "whale_tracking": 0.15},
+                "bear_market": {"mean_reversion": 0.25, "pattern_recognition": 0.20, "hybrid_ai": 0.15},
+                "sideways_market": {"mean_reversion": 0.30, "volume_spike": 0.20, "pattern_recognition": 0.15}
             }
         }
     
     async def load_weights_from_r2(self):
-        """تحميل الأوزان من R2"""
         try:
             key = "learning_engine_weights.json"
-            response = self.r2_service.s3_client.get_object(
-                Bucket="trading", Key=key
-            )
+            response = self.r2_service.s3_client.get_object(Bucket="trading", Key=key)
             weights_data = json.loads(response['Body'].read())
             
-            # التعامل مع الهيكل الجديد والقديم
             if isinstance(weights_data, dict):
                 if 'weights' in weights_data:
                     self.weights = weights_data['weights']
                 else:
                     self.weights = weights_data
-                print(f"✅ تم تحميل الأوزان من R2 بنجاح. إصدار الهيكل: {'جديد' if 'weights' in weights_data else 'قديم'}")
+                print(f"Weights loaded from R2")
             else:
-                raise ValueError("هيكل الأوزان غير صحيح")
-                
+                raise ValueError("Invalid weights structure")
         except Exception as e:
-            print(f"❌ فشل تحميل الأوزان: {e}")
+            print(f"Weights loading failed: {e}")
             await self.initialize_default_weights()
             await self.save_weights_to_r2()
     
     async def save_weights_to_r2(self):
-        """حفظ الأوزان إلى R2"""
         try:
             key = "learning_engine_weights.json"
             weights_data = {
@@ -170,64 +116,47 @@ class LearningEngine:
                 "version": "2.0",
                 "performance_metrics": await self.calculate_performance_metrics()
             }
-            
             data_json = json.dumps(weights_data, indent=2, ensure_ascii=False).encode('utf-8')
             self.r2_service.s3_client.put_object(
-                Bucket="trading",
-                Key=key, 
-                Body=data_json, 
-                ContentType="application/json"
+                Bucket="trading", Key=key, Body=data_json, ContentType="application/json"
             )
-            print("✅ تم حفظ الأوزان إلى R2 بنجاح")
+            print("Weights saved to R2")
         except Exception as e:
-            print(f"❌ فشل حفظ الأوزان: {e}")
+            print(f"Weights saving failed: {e}")
     
     async def load_performance_history(self):
-        """تحميل سجل الأداء"""
         try:
             key = "learning_performance_history.json"
-            response = self.r2_service.s3_client.get_object(
-                Bucket="trading", Key=key
-            )
+            response = self.r2_service.s3_client.get_object(Bucket="trading", Key=key)
             history_data = json.loads(response['Body'].read())
             self.performance_history = history_data.get("history", [])
-            print(f"✅ تم تحميل سجل الأداء - {len(self.performance_history)} تسجيل")
+            print(f"Performance history loaded - {len(self.performance_history)} records")
         except Exception as e:
-            print(f"⚠️ لم يتم تحميل سجل الأداء: {e}")
+            print(f"Performance history loading failed: {e}")
             self.performance_history = []
     
     async def save_performance_history(self):
-        """حفظ سجل الأداء"""
         try:
             key = "learning_performance_history.json"
             history_data = {
                 "history": self.performance_history[-1000:],
                 "last_updated": datetime.now().isoformat()
             }
-            
             data_json = json.dumps(history_data, indent=2, ensure_ascii=False).encode('utf-8')
             self.r2_service.s3_client.put_object(
-                Bucket="trading",
-                Key=key, 
-                Body=data_json, 
-                ContentType="application/json"
+                Bucket="trading", Key=key, Body=data_json, ContentType="application/json"
             )
         except Exception as e:
-            print(f"❌ فشل حفظ سجل الأداء: {e}")
+            print(f"Performance history saving failed: {e}")
     
     async def analyze_trade_outcome(self, trade_data, outcome):
-        """تحليل نتيجة الصفقة وتحديث الأوزان - الإصدار المحسّن"""
-        if not self.initialized:
-            await self.initialize()
-            
+        if not self.initialized: await self.initialize()
         try:
-            # استخراج الاستراتيجية من بيانات الصفقة
             strategy = trade_data.get('strategy', 'unknown')
             if strategy == 'unknown':
                 decision_data = trade_data.get('decision_data', {})
                 strategy = decision_data.get('strategy', 'unknown')
             
-            # الحصول على سياق السوق الحقيقي
             market_context = await self.get_current_market_conditions()
             
             analysis_entry = {
@@ -242,29 +171,19 @@ class LearningEngine:
             }
             
             self.performance_history.append(analysis_entry)
-            
             await self.update_strategy_effectiveness(analysis_entry)
             await self.update_market_patterns(analysis_entry)
             
-            # ✅ التحديث الهام: تحديث الأوزان بعد كل صفقة في البداية
-            if len(self.performance_history) <= 10:  # أول 10 صفقات
+            if should_update_weights(len(self.performance_history)):
                 await self.adapt_weights_based_on_performance()
                 await self.save_weights_to_r2()
                 await self.save_performance_history()
-            else:
-                # بعد ذلك، تحديث كل 3 صفقات
-                if len(self.performance_history) % 3 == 0:
-                    await self.adapt_weights_based_on_performance()
-                    await self.save_weights_to_r2()
-                    await self.save_performance_history()
-            
-            print(f"📊 تم تحليل صفقة {trade_data.get('symbol')} - الاستراتيجية: {strategy} - النتيجة: {outcome} - PnL: {trade_data.get('pnl_percent', 0):.2f}%")
             
+            print(f"Trade analyzed {trade_data.get('symbol')} - Strategy: {strategy} - Outcome: {outcome}")
         except Exception as e:
-            print(f"❌ فشل تحليل نتيجة الصفقة: {e}")
+            print(f"Trade outcome analysis failed: {e}")
     
     async def update_strategy_effectiveness(self, analysis_entry):
-        """تحديث فعالية الاستراتيجيات"""
         strategy = analysis_entry['strategy_used']
         outcome = analysis_entry['outcome']
         market_condition = analysis_entry['market_conditions']['current_trend']
@@ -272,35 +191,26 @@ class LearningEngine:
         
         if strategy not in self.strategy_effectiveness:
             self.strategy_effectiveness[strategy] = {
-                "total_trades": 0,
-                "successful_trades": 0,
-                "total_profit": 0,
-                "total_pnl_percent": 0,
-                "market_conditions": {}
+                "total_trades": 0, "successful_trades": 0, "total_profit": 0,
+                "total_pnl_percent": 0, "market_conditions": {}
             }
         
         self.strategy_effectiveness[strategy]["total_trades"] += 1
         self.strategy_effectiveness[strategy]["total_pnl_percent"] += pnl_percent
         
-        # تحديد النجاح بناءً على النتيجة والأداء
         is_success = outcome in ["SUCCESS", "CLOSED_BY_REANALYSIS", "CLOSED_BY_MONITOR"] and pnl_percent > 0
-        if is_success:
-            self.strategy_effectiveness[strategy]["successful_trades"] += 1
+        if is_success: self.strategy_effectiveness[strategy]["successful_trades"] += 1
         
         if market_condition not in self.strategy_effectiveness[strategy]["market_conditions"]:
             self.strategy_effectiveness[strategy]["market_conditions"][market_condition] = {
-                "trades": 0,
-                "successes": 0,
-                "total_pnl": 0
+                "trades": 0, "successes": 0, "total_pnl": 0
             }
         
         self.strategy_effectiveness[strategy]["market_conditions"][market_condition]["trades"] += 1
         self.strategy_effectiveness[strategy]["market_conditions"][market_condition]["total_pnl"] += pnl_percent
-        if is_success:
-            self.strategy_effectiveness[strategy]["market_conditions"][market_condition]["successes"] += 1
+        if is_success: self.strategy_effectiveness[strategy]["market_conditions"][market_condition]["successes"] += 1
     
     async def update_market_patterns(self, analysis_entry):
-        """تحديث أنماط السوق"""
         market_condition = analysis_entry['market_conditions']['current_trend']
         symbol = analysis_entry['symbol']
         outcome = analysis_entry['outcome']
@@ -308,25 +218,20 @@ class LearningEngine:
         
         if market_condition not in self.market_patterns:
             self.market_patterns[market_condition] = {
-                "total_trades": 0,
-                "successful_trades": 0,
-                "total_pnl_percent": 0,
-                "best_performing_strategies": {},
-                "best_performing_symbols": {}
+                "total_trades": 0, "successful_trades": 0, "total_pnl_percent": 0,
+                "best_performing_strategies": {}, "best_performing_symbols": {}
             }
         
         self.market_patterns[market_condition]["total_trades"] += 1
         self.market_patterns[market_condition]["total_pnl_percent"] += pnl_percent
         
         is_success = outcome in ["SUCCESS", "CLOSED_BY_REANALYSIS", "CLOSED_BY_MONITOR"] and pnl_percent > 0
-        if is_success:
-            self.market_patterns[market_condition]["successful_trades"] += 1
+        if is_success: self.market_patterns[market_condition]["successful_trades"] += 1
         
         strategy = analysis_entry['strategy_used']
         if strategy not in self.market_patterns[market_condition]["best_performing_strategies"]:
             self.market_patterns[market_condition]["best_performing_strategies"][strategy] = {
-                "count": 0,
-                "total_pnl": 0
+                "count": 0, "total_pnl": 0
             }
         
         self.market_patterns[market_condition]["best_performing_strategies"][strategy]["count"] += 1
@@ -334,25 +239,20 @@ class LearningEngine:
         
         if symbol not in self.market_patterns[market_condition]["best_performing_symbols"]:
             self.market_patterns[market_condition]["best_performing_symbols"][symbol] = {
-                "count": 0,
-                "total_pnl": 0
+                "count": 0, "total_pnl": 0
             }
         
         self.market_patterns[market_condition]["best_performing_symbols"][symbol]["count"] += 1
         self.market_patterns[market_condition]["best_performing_symbols"][symbol]["total_pnl"] += pnl_percent
     
     async def adapt_weights_based_on_performance(self):
-        """تعديل الأوزان بناءً على الأداء - الإصدار المحسّن"""
-        print("🔄 تحديث الأوزان بناءً على الأداء...")
-        
+        print("Updating weights based on performance...")
         try:
-            # إذا لم تكن هناك بيانات كافية، استخدم تحديثاً تدريجياً
             if not self.strategy_effectiveness:
-                print("⚠️ لا توجد بيانات أداء كافية، استخدام تحديث تدريجي")
+                print("Insufficient performance data, using gradual adjustment")
                 await self.gradual_weights_adjustment()
                 return
 
-            # تحديث أوزان الاستراتيجيات بناءً على الأداء الحقيقي
             total_performance = 0
             strategy_performance = {}
             
@@ -360,35 +260,26 @@ class LearningEngine:
                 if data["total_trades"] > 0:
                     success_rate = data["successful_trades"] / data["total_trades"]
                     avg_pnl = data["total_pnl_percent"] / data["total_trades"]
-                    
-                    # حساب الأداء المركب
                     composite_performance = (success_rate * 0.7) + (min(avg_pnl, 10) / 10 * 0.3)
                     strategy_performance[strategy] = composite_performance
                     total_performance += composite_performance
             
-            # إذا كان هناك أداء كافٍ، قم بالتحديث
             if total_performance > 0 and strategy_performance:
                 for strategy, performance in strategy_performance.items():
                     current_weight = self.weights["strategy_weights"].get(strategy, 0.1)
-                    # تحديث تدريجي لتجنب التغيرات المفاجئة
                     new_weight = current_weight * 0.7 + (performance * 0.3)
                     self.weights["strategy_weights"][strategy] = new_weight
                 
-                # تطبيع الأوزان
-                self.normalize_weights()
-                print("✅ تم تحديث الأوزان بناءً على الأداء الحقيقي")
+                normalize_weights(self.weights["strategy_weights"])
+                print("Weights updated based on real performance")
             else:
                 await self.gradual_weights_adjustment()
-                
         except Exception as e:
-            print(f"❌ فشل تحديث الأوزان: {e}")
+            print(f"Weights update failed: {e}")
             await self.gradual_weights_adjustment()
 
     async def gradual_weights_adjustment(self):
-        """تعديل تدريجي للأوزان لتحسين الأداء"""
-        print("📈 إجراء تعديل تدريجي على الأوزان...")
-        
-        # زيادة وزن الاستراتيجيات التي تعتمد على البيانات المتاحة
+        print("Gradual weights adjustment...")
         if self.market_patterns:
             for market_condition, data in self.market_patterns.items():
                 if data.get("total_trades", 0) > 0:
@@ -398,87 +289,35 @@ class LearningEngine:
                         current_weight = self.weights["strategy_weights"].get(best_strategy, 0.1)
                         self.weights["strategy_weights"][best_strategy] = min(current_weight * 1.1, 0.3)
         
-        self.normalize_weights()
-        print("✅ تم التعديل التدريجي للأوزان")
-
-    def normalize_weights(self):
-        """تطبيع الأوزان للتأكد من أن مجموعها 1"""
-        total = sum(self.weights["strategy_weights"].values())
-        if total > 0:
-            for strategy in self.weights["strategy_weights"]:
-                self.weights["strategy_weights"][strategy] /= total
+        normalize_weights(self.weights["strategy_weights"])
+        print("Gradual weights adjustment completed")
 
     async def get_current_market_conditions(self):
-        """الحصول على ظروف السوق الحالية - بيانات حقيقية"""
         try:
-            if not self.data_manager:
-                raise ValueError("DataManager غير متوفر")
-                
+            if not self.data_manager: raise ValueError("DataManager unavailable")
             market_context = await self.data_manager.get_market_context_async()
-            if not market_context:
-                raise ValueError("فشل جلب سياق السوق")
-            
+            if not market_context: raise ValueError("Market context fetch failed")
             return {
                 "current_trend": market_context.get('market_trend', 'sideways_market'),
-                "volatility": self._calculate_market_volatility(market_context),
+                "volatility": calculate_market_volatility(market_context),
                 "market_sentiment": market_context.get('btc_sentiment', 'NEUTRAL'),
                 "whale_activity": market_context.get('general_whale_activity', {}).get('sentiment', 'NEUTRAL'),
                 "fear_greed_index": market_context.get('fear_and_greed_index', 50)
             }
         except Exception as e:
-            print(f"⚠️ فشل الحصول على ظروف السوق: {e}")
+            print(f"Market conditions fetch failed: {e}")
             return {
-                "current_trend": "sideways_market",
-                "volatility": "medium",
-                "market_sentiment": "neutral",
-                "whale_activity": "low",
-                "fear_greed_index": 50
+                "current_trend": "sideways_market", "volatility": "medium",
+                "market_sentiment": "neutral", "whale_activity": "low", "fear_greed_index": 50
             }
     
-    def _calculate_market_volatility(self, market_context):
-        """حساب تقلبية السوق بناءً على البيانات الحقيقية"""
-        try:
-            btc_price = market_context.get('bitcoin_price_usd', 0)
-            fear_greed = market_context.get('fear_and_greed_index', 50)
-            whale_sentiment = market_context.get('general_whale_activity', {}).get('sentiment', 'NEUTRAL')
-            
-            volatility_score = 0
-            
-            # تحليل سعر البيتكوين (تغيرات كبيرة = تقلبية عالية)
-            if btc_price > 0:
-                # هذا مؤشر مبسط - في التطبيق الحقيقي نحتاج بيانات تاريخية
-                if abs(fear_greed - 50) > 20:
-                    volatility_score += 1
-            
-            # تحليل نشاط الحيتان
-            if whale_sentiment in ['BULLISH', 'BEARISH']:
-                volatility_score += 1
-            elif whale_sentiment == 'SLIGHTLY_BULLISH':
-                volatility_score += 0.5
-            
-            if volatility_score >= 1.5:
-                return "high"
-            elif volatility_score >= 0.5:
-                return "medium"
-            else:
-                return "low"
-                
-        except Exception as e:
-            print(f"⚠️ خطأ في حساب التقلبية: {e}")
-            return "medium"
-    
     async def calculate_performance_metrics(self):
-        """حساب مقاييس الأداء"""
-        if not self.performance_history:
-            return {"status": "لا توجد بيانات أداء بعد"}
-        
-        recent_trades = self.performance_history[-50:]  # آخر 50 صفقة فقط
-        
+        if not self.performance_history: return {"status": "No performance data yet"}
+        recent_trades = self.performance_history[-50:]
         total_trades = len(recent_trades)
         successful_trades = sum(1 for trade in recent_trades 
                               if trade['outcome'] in ["SUCCESS", "CLOSED_BY_REANALYSIS", "CLOSED_BY_MONITOR"] and trade.get('pnl_percent', 0) > 0)
         success_rate = successful_trades / total_trades if total_trades > 0 else 0
-        
         total_pnl = sum(trade.get('pnl_percent', 0) for trade in recent_trades)
         avg_pnl = total_pnl / total_trades if total_trades > 0 else 0
         
@@ -488,10 +327,8 @@ class LearningEngine:
                 strategy_success_rate = data["successful_trades"] / data["total_trades"]
                 strategy_avg_pnl = data["total_pnl_percent"] / data["total_trades"]
                 strategy_performance[strategy] = {
-                    "success_rate": strategy_success_rate,
-                    "avg_pnl_percent": strategy_avg_pnl,
-                    "total_trades": data["total_trades"],
-                    "successful_trades": data["successful_trades"]
+                    "success_rate": strategy_success_rate, "avg_pnl_percent": strategy_avg_pnl,
+                    "total_trades": data["total_trades"], "successful_trades": data["successful_trades"]
                 }
         
         market_performance = {}
@@ -500,111 +337,75 @@ class LearningEngine:
                 market_success_rate = data["successful_trades"] / data["total_trades"]
                 market_avg_pnl = data["total_pnl_percent"] / data["total_trades"]
                 market_performance[condition] = {
-                    "success_rate": market_success_rate,
-                    "avg_pnl_percent": market_avg_pnl,
+                    "success_rate": market_success_rate, "avg_pnl_percent": market_avg_pnl,
                     "total_trades": data["total_trades"]
                 }
         
         return {
-            "overall_success_rate": success_rate,
-            "overall_avg_pnl_percent": avg_pnl,
-            "total_analyzed_trades": len(self.performance_history),
-            "recent_trades_analyzed": total_trades,
-            "strategy_performance": strategy_performance,
-            "market_performance": market_performance,
+            "overall_success_rate": success_rate, "overall_avg_pnl_percent": avg_pnl,
+            "total_analyzed_trades": len(self.performance_history), "recent_trades_analyzed": total_trades,
+            "strategy_performance": strategy_performance, "market_performance": market_performance,
             "last_updated": datetime.now().isoformat()
         }
     
     async def get_optimized_strategy_weights(self, market_condition):
-        """الحصول على أوزان استراتيجية محسنة - الإصدار المصحح"""
         try:
-            if not self.initialized:
-                print("⚠️ نظام التعلم غير مهيء، استخدام الأوزان الافتراضية")
+            if not self.initialized: return await self.get_default_strategy_weights()
+            if (not self.weights or "strategy_weights" not in self.weights or not self.weights["strategy_weights"]):
                 return await self.get_default_strategy_weights()
-            
-            # ✅ التحقق من وجود الأوزان وهيكلتها بشكل صحيح
-            if (not self.weights or 
-                "strategy_weights" not in self.weights or 
-                not self.weights["strategy_weights"]):
-                print("⚠️ الأوزان غير متوفرة أو فارغة، استخدام الأوزان الافتراضية")
-                return await self.get_default_strategy_weights()
-            
             base_weights = self.weights["strategy_weights"].copy()
-            
-            # ✅ التحقق من أن الأوزان تحتوي على استراتيجيات فعلية
             if not any(weight > 0 for weight in base_weights.values()):
-                print("⚠️ جميع الأوزان صفر، استخدام الأوزان الافتراضية")
                 return await self.get_default_strategy_weights()
-            
-            print(f"✅ استخدام الأوزان المتعلمة: {base_weights}")
+            print(f"Using learned weights: {base_weights}")
             return base_weights
-                
         except Exception as e:
-            print(f"❌ فشل في حساب الأوزان المحسنة: {e}")
+            print(f"Optimized weights calculation failed: {e}")
             return await self.get_default_strategy_weights()
     
     async def get_default_strategy_weights(self):
-        """إرجاع الأوزان الافتراضية"""
         return {
-            "trend_following": 0.18,
-            "mean_reversion": 0.15,  
-            "breakout_momentum": 0.22,
-            "volume_spike": 0.12,
-            "whale_tracking": 0.15,
-            "pattern_recognition": 0.10,
+            "trend_following": 0.18, "mean_reversion": 0.15, "breakout_momentum": 0.22,
+            "volume_spike": 0.12, "whale_tracking": 0.15, "pattern_recognition": 0.10,
             "hybrid_ai": 0.08
         }
     
     async def get_risk_parameters(self, symbol_volatility):
-        """الحصول على معايير المخاطرة المحسنة"""
-        if not self.weights or "risk_parameters" not in self.weights:
-            await self.initialize_default_weights()
-        
+        if not self.weights or "risk_parameters" not in self.weights: await self.initialize_default_weights()
         risk_params = self.weights.get("risk_parameters", {}).copy()
-        
-        # تعديل معايير المخاطرة بناءً على تقلبية الرمز
         if symbol_volatility == "HIGH":
             risk_params["stop_loss_base"] *= 1.5
             risk_params["max_position_size"] *= 0.7
-            risk_params["risk_reward_ratio"] = 1.5  # تخفيض نسبة المكافأة/المخاطرة للتقليل العالي
+            risk_params["risk_reward_ratio"] = 1.5
         elif symbol_volatility == "LOW":
             risk_params["stop_loss_base"] *= 0.7
             risk_params["max_position_size"] *= 1.2
-            risk_params["risk_reward_ratio"] = 2.5  # زيادة النسبة للتقليل المنخفض
-        
+            risk_params["risk_reward_ratio"] = 2.5
         return risk_params
     
     async def suggest_improvements(self):
-        """اقتراح تحسينات بناءً على تحليل الأداء"""
         improvements = []
-        
         if not self.performance_history:
-            improvements.append("📊 ابدأ بجمع بيانات الأداء من الصفقات الأولى")
+            improvements.append("Start collecting performance data from first trades")
             return improvements
         
-        # تحليل أداء الاستراتيجيات
         for strategy, data in self.strategy_effectiveness.items():
             if data["total_trades"] >= 3:
                 success_rate = data["successful_trades"] / data["total_trades"]
                 avg_pnl = data["total_pnl_percent"] / data["total_trades"]
-                
                 if success_rate < 0.3 and avg_pnl < 0:
-                    improvements.append(f"🚨 استراتيجية {strategy} ضعيفة الأداء ({success_rate:.1%} نجاح، {avg_pnl:+.1f}% متوسط) - يقترح تقليل استخدامها")
+                    improvements.append(f"Strategy {strategy} poor performance ({success_rate:.1%} success, {avg_pnl:+.1f}% average) - suggest reducing usage")
                 elif success_rate > 0.6 and avg_pnl > 2:
-                    improvements.append(f"✅ استراتيجية {strategy} ممتازة الأداء ({success_rate:.1%} نجاح، {avg_pnl:+.1f}% متوسط) - يقترح زيادة استخدامها")
+                    improvements.append(f"Strategy {strategy} excellent performance ({success_rate:.1%} success, {avg_pnl:+.1f}% average) - suggest increasing usage")
                 elif success_rate > 0.7:
-                    improvements.append(f"🎯 استراتيجية {strategy} عالية النجاح ({success_rate:.1%}) - التركيز على جودة الصفقات")
+                    improvements.append(f"Strategy {strategy} high success ({success_rate:.1%}) - focus on trade quality")
         
-        # تحليل أداء ظروف السوق
         for market_condition, data in self.market_patterns.items():
             if data["total_trades"] >= 5:
                 success_rate = data["successful_trades"] / data["total_trades"]
                 avg_pnl = data["total_pnl_percent"] / data["total_trades"]
-                
                 if success_rate < 0.4:
-                    improvements.append(f"⚠️ الأداء ضعيف في سوق {market_condition} ({success_rate:.1%} نجاح) - يحتاج مراجعة الاستراتيجيات")
+                    improvements.append(f"Poor performance in {market_condition} market ({success_rate:.1%} success) - needs strategy review")
                 
-                # العثور على أفضل استراتيجية لهذا السوق
                 best_strategy = None
                 best_performance = -100
                 for strategy, stats in data["best_performing_strategies"].items():
@@ -615,30 +416,21 @@ class LearningEngine:
                             best_strategy = strategy
                 
                 if best_strategy and best_performance > 1:
-                    improvements.append(f"📈 أفضل استراتيجية في {market_condition}: {best_strategy} ({best_performance:+.1f}% متوسط ربح)")
-        
-        if not improvements:
-            improvements.append("📊 لا توجد تحسينات مقترحة حالياً - استمر في جمع البيانات")
+                    improvements.append(f"Best strategy in {market_condition}: {best_strategy} ({best_performance:+.1f}% average profit)")
         
+        if not improvements: improvements.append("No suggested improvements currently - continue data collection")
         return improvements
 
     async def force_strategy_learning(self):
-        """إجبار النظام على التعلم من البيانات الحالية"""
-        print("🧠 إجبار تحديث الاستراتيجيات من البيانات الحالية...")
-        
+        print("Forcing strategy update from current data...")
         if not self.performance_history:
-            print("⚠️ لا توجد بيانات أداء للتعلم منها")
+            print("No performance data to learn from")
             return
-        
-        # تحديث فعالية الاستراتيجيات من البيانات التاريخية
         for entry in self.performance_history:
             await self.update_strategy_effectiveness(entry)
             await self.update_market_patterns(entry)
-        
-        # تحديث الأوزان فوراً
         await self.adapt_weights_based_on_performance()
         await self.save_weights_to_r2()
-        
-        print("✅ تم إجبار تحديث الاستراتيجيات بنجاح")
+        print("Strategy update forced successfully")
 
-print("✅ نظام التعلم الذاتي المحسن محمل - جاهز للتعلم والتكيف المستمر")
+print("Enhanced self-learning system loaded - ready for continuous learning and adaptation")