Create trade_manger.py

trade_manger.py

@@ -0,0 +1,390 @@
+import asyncio
+from datetime import datetime, timedelta
+from helpers import safe_float_conversion, _apply_patience_logic
+
+class TradeManager:
+    def __init__(self, r2_service, learning_engine=None, data_manager=None):
+        self.r2_service = r2_service
+        self.learning_engine = learning_engine
+        self.data_manager = data_manager
+        self.monitoring_tasks = {}
+        self.is_running = False
+
+    async def open_trade(self, symbol, decision, current_price):
+        """فتح صفقة جديدة باستخدام رأس المال المتاح بالكامل"""
+        try:
+            portfolio_state = await self.r2_service.get_portfolio_state_async()
+            available_capital = portfolio_state.get("current_capital_usd", 0)
+
+            if available_capital < 1:
+                print(f"❌ رأس مال غير كافٍ (${available_capital:.2f}) لفتح صفقة جديدة.")
+                return None
+
+            expected_target_minutes = decision.get('expected_target_minutes', 15)
+            expected_target_minutes = max(5, min(expected_target_minutes, 45))
+            expected_target_time = (datetime.now() + timedelta(minutes=expected_target_minutes)).isoformat()
+
+            strategy = decision.get('strategy')
+            if not strategy or strategy == 'unknown':
+                strategy = 'GENERIC'
+                print(f"⚠️ الاستراتيجية مفقودة أو غير معروفة. تعيين إلى GENERIC لـ {symbol}")
+
+            trades = await self.r2_service.get_open_trades_async()
+            new_trade = {
+                "id": str(int(datetime.now().timestamp())),
+                "symbol": symbol,
+                "entry_price": current_price,
+                "entry_timestamp": datetime.now().isoformat(),
+                "decision_data": decision,
+                "status": "OPEN",
+                "stop_loss": decision.get("stop_loss"),
+                "take_profit": decision.get("take_profit"),
+                "trade_type": decision.get("trade_type"),
+                "position_size_usd": available_capital,
+                "expected_target_minutes": expected_target_minutes,
+                "expected_target_time": expected_target_time,
+                "is_monitored": True,
+                "strategy": strategy
+            }
+            
+            trades.append(new_trade)
+            await self.r2_service.save_open_trades_async(trades)
+            
+            original_expected = decision.get('expected_target_minutes', 15)
+            if original_expected > 45:
+                print(f"⚠️ النموذج طلب {original_expected} دقيقة، تم التحديد إلى 45 دقيقة لتناسق الاستراتيجية")
+                
+            print(f"✅ صفقة جديدة لـ {symbol} محفوظة بحجم ${available_capital:.2f}. الاستراتيجية: {strategy}. النتائج المتوقعة في {expected_target_minutes} دقيقة.")
+
+            portfolio_state["invested_capital_usd"] = available_capital
+            portfolio_state["current_capital_usd"] = 0.0
+            portfolio_state["total_trades"] = portfolio_state.get("total_trades", 0) + 1
+            await self.r2_service.save_portfolio_state_async(portfolio_state)
+
+            await self.r2_service.save_system_logs_async({
+                "new_trade_opened": True,
+                "symbol": symbol,
+                "position_size": available_capital,
+                "expected_minutes": expected_target_minutes,
+                "trade_type": decision.get("trade_type", "LONG"),
+                "strategy": strategy
+            })
+
+            return new_trade
+
+        except Exception as e:
+            print(f"❌ فشل فتح صفقة جديدة: {e}")
+            raise
+
+    async def close_trade(self, trade_to_close, close_price, reason="إغلاق بالنظام"):
+        """إغلاق صفقة وتحديث المحفظة وتحليل النتيجة"""
+        try:
+            trade_to_close['status'] = 'CLOSED'
+            trade_to_close['close_price'] = close_price
+            trade_to_close['close_timestamp'] = datetime.now().isoformat()
+            trade_to_close['is_monitored'] = False
+            
+            entry_price = trade_to_close['entry_price']
+            position_size = trade_to_close['position_size_usd']
+            trade_type = trade_to_close.get('trade_type', 'LONG')
+            strategy = trade_to_close.get('strategy', 'unknown')
+            
+            pnl = 0.0
+            pnl_percent = 0.0
+            
+            if entry_price and entry_price > 0 and close_price and close_price > 0:
+                try:
+                    if trade_type == 'LONG':
+                        pnl_percent = ((close_price - entry_price) / entry_price) * 100
+                        pnl = position_size * (pnl_percent / 100)
+                    elif trade_type == 'SHORT':
+                        pnl_percent = ((entry_price - close_price) / entry_price) * 100
+                        pnl = position_size * (pnl_percent / 100)
+                    
+                    print(f"💰 حساب PnL: الدخول=${entry_price:.6f}, الخروج=${close_price:.6f}, "
+                          f"الحجم=${position_size:.2f}, النوع={trade_type}, "
+                          f"PnL=${pnl:.4f} ({pnl_percent:+.4f}%)")
+                          
+                except (TypeError, ZeroDivisionError) as calc_error:
+                    print(f"⚠️ خطأ في حساب PnL: {calc_error}")
+                    pnl = 0.0
+                    pnl_percent = 0.0
+            else:
+                print(f"⚠️ أسعار غير صالحة لحساب PnL: الدخول={entry_price}, الخروج={close_price}")
+                    
+            trade_to_close['pnl_usd'] = pnl
+            trade_to_close['pnl_percent'] = pnl_percent
+
+            await self._archive_closed_trade(trade_to_close)
+            await self._update_trade_summary(trade_to_close)
+
+            portfolio_state = await self.r2_service.get_portfolio_state_async()
+            current_capital = portfolio_state.get("current_capital_usd", 0)
+            invested_capital = portfolio_state.get("invested_capital_usd", 0)
+            
+            new_capital = current_capital + position_size + pnl
+            
+            portfolio_state["current_capital_usd"] = new_capital
+            portfolio_state["invested_capital_usd"] = 0.0
+            
+            if pnl > 0:
+                portfolio_state["winning_trades"] = portfolio_state.get("winning_trades", 0) + 1
+                portfolio_state["total_profit_usd"] = portfolio_state.get("total_profit_usd", 0.0) + pnl
+            elif pnl < 0:
+                portfolio_state["total_loss_usd"] = portfolio_state.get("total_loss_usd", 0.0) + abs(pnl)
+            
+            await self.r2_service.save_portfolio_state_async(portfolio_state)
+            
+            print(f"📈 PnL الصفقة: ${pnl:.4f} ({pnl_percent:+.4f}%). "
+                  f"رأس المال الجديد المتاح: ${new_capital:.4f}. الاستراتيجية: {strategy}")
+
+            open_trades = await self.r2_service.get_open_trades_async()
+            trades_to_keep = [t for t in open_trades if t.get('id') != trade_to_close.get('id')]
+            await self.r2_service.save_open_trades_async(trades_to_keep)
+            
+            print(f"✅ تم إغلاق صفقة {trade_to_close.get('symbol')} وأرشفتها بنجاح. الاستراتيجية: {strategy}")
+
+            await self.r2_service.save_system_logs_async({
+                "trade_closed": True,
+                "symbol": trade_to_close.get('symbol'),
+                "entry_price": entry_price,
+                "close_price": close_price,
+                "pnl_usd": pnl,
+                "pnl_percent": pnl_percent,
+                "new_capital": new_capital,
+                "strategy": strategy,
+                "position_size": position_size,
+                "trade_type": trade_type,
+                "reason": reason
+            })
+
+            if self.learning_engine and self.learning_engine.initialized:
+                await self.learning_engine.analyze_trade_outcome(trade_to_close, reason)
+
+            return True
+
+        except Exception as e:
+            print(f"❌ فشل إغلاق الصفقة: {e}")
+            raise
+
+    async def update_trade(self, trade_to_update, re_analysis_decision):
+        """تحديث الصفقة بمعطيات جديدة من إعادة التحليل"""
+        try:
+            if re_analysis_decision.get('new_stop_loss'):
+                trade_to_update['stop_loss'] = re_analysis_decision['new_stop_loss']
+            if re_analysis_decision.get('new_take_profit'):
+                trade_to_update['take_profit'] = re_analysis_decision['new_take_profit']
+            
+            new_expected_minutes = re_analysis_decision.get('new_expected_minutes')
+            if new_expected_minutes:
+                new_expected_minutes = max(5, min(new_expected_minutes, 45))
+                trade_to_update['expected_target_minutes'] = new_expected_minutes
+                trade_to_update['expected_target_time'] = (datetime.now() + timedelta(minutes=new_expected_minutes)).isoformat()
+                print(f"⏰ تم تحديث وقت الصفقة المتوقع إلى {new_expected_minutes} دقيقة.")
+
+            original_strategy = trade_to_update.get('strategy')
+            if not original_strategy or original_strategy == 'unknown':
+                original_strategy = re_analysis_decision.get('strategy', 'GENERIC')
+            
+            trade_to_update['strategy'] = original_strategy
+            trade_to_update['decision_data'] = re_analysis_decision
+            trade_to_update['is_monitored'] = True
+
+            open_trades = await self.r2_service.get_open_trades_async()
+            for i, trade in enumerate(open_trades):
+                if trade.get('id') == trade_to_update.get('id'):
+                    open_trades[i] = trade_to_update
+                    break
+
+            await self.r2_service.save_open_trades_async(open_trades)
+            print(f"✅ تم تحديث صفقة {trade_to_update.get('symbol')} بنجاح. الاستراتيجية: {original_strategy}")
+
+            await self.r2_service.save_system_logs_async({
+                "trade_updated": True,
+                "symbol": trade_to_update.get('symbol'),
+                "new_expected_minutes": new_expected_minutes,
+                "action": "UPDATE_TRADE",
+                "strategy": original_strategy
+            })
+
+            return True
+
+        except Exception as e:
+            print(f"❌ فشل تحديث الصفقة: {e}")
+            raise
+
+    async def immediate_close_trade(self, symbol, close_price, reason="المراقبة الفورية"):
+        """إغلاق فوري لصفقة بدون إعادة تحليل كاملة"""
+        try:
+            open_trades = await self.r2_service.get_open_trades_async()
+            trade_to_close = None
+            
+            for trade in open_trades:
+                if trade['symbol'] == symbol and trade['status'] == 'OPEN':
+                    trade_to_close = trade
+                    break
+            
+            if not trade_to_close:
+                print(f"❌ لم يتم العثور على صفقة مفتوحة لـ {symbol}")
+                return False
+            
+            await self.close_trade(trade_to_close, close_price, reason)
+            print(f"🚨 إغلاق فوري: {symbol} عند {close_price} - {reason}")
+            
+            return True
+            
+        except Exception as e:
+            print(f"❌ فشل الإغلاق الفوري لصفقة {symbol}: {e}")
+            return False
+
+    async def start_trade_monitoring(self):
+        """بدء مراقبة الصفقات المفتوحة"""
+        self.is_running = True
+        while self.is_running:
+            try:
+                open_trades = await self.r2_service.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"خطأ في مراقبة الصفقات: {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:
+                if not self.data_manager:
+                    await asyncio.sleep(15)
+                    continue
+                    
+                current_price = await self.data_manager.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"وصول وقف الخسارة: {current_price} <= {stop_loss}"
+                elif take_profit and current_price >= take_profit:
+                    should_close, close_reason = True, f"وصول جني الأرباح: {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 self.r2_service.acquire_lock():
+                        try:
+                            await self.immediate_close_trade(symbol, current_price, close_reason)
+                        finally:
+                            self.r2_service.release_lock()
+                    
+                    if symbol in self.monitoring_tasks:
+                        del self.monitoring_tasks[symbol]
+                    break
+                    
+                await asyncio.sleep(15)
+            except Exception as error:
+                print(f"خطأ في مراقبة {symbol}: {error}")
+                await asyncio.sleep(30)
+
+    def stop_monitoring(self):
+        """إيقاف مراقبة الصفقات"""
+        self.is_running = False
+        self.monitoring_tasks.clear()
+
+    async def _archive_closed_trade(self, closed_trade):
+        """أرشفة الصفقة المغلقة"""
+        try:
+            key = "closed_trades_history.json"
+            try:
+                response = self.r2_service.s3_client.get_object(Bucket="trading", Key=key)
+                history = json.loads(response['Body'].read())
+            except Exception:
+                history = []
+            
+            history.append(closed_trade)
+            
+            data_json = json.dumps(history, indent=2).encode('utf-8')
+            self.r2_service.s3_client.put_object(
+                Bucket="trading", Key=key, Body=data_json, ContentType="application/json"
+            )
+            print(f"📚 تم أرشفة الصفقة. إجمالي الصفقات المؤرشفة: {len(history)}")
+        except Exception as e:
+            print(f"❌ فشل أرشفة الصفقة: {e}")
+
+    async def _update_trade_summary(self, closed_trade):
+        """تحديث إحصائيات التداول"""
+        try:
+            key = "trade_summary.json"
+            try:
+                response = self.r2_service.s3_client.get_object(Bucket="trading", Key=key)
+                summary = json.loads(response['Body'].read())
+            except Exception:
+                summary = {
+                    "total_trades": 0, "winning_trades": 0, "losing_trades": 0,
+                    "total_profit_usd": 0.0, "total_loss_usd": 0.0, "win_percentage": 0.0,
+                    "avg_profit_per_trade": 0.0, "avg_loss_per_trade": 0.0,
+                    "largest_win": 0.0, "largest_loss": 0.0
+                }
+            
+            pnl = closed_trade.get('pnl_usd', 0.0)
+            
+            summary['total_trades'] += 1
+            if pnl >= 0:
+                summary['winning_trades'] += 1
+                summary['total_profit_usd'] += pnl
+                if pnl > summary.get('largest_win', 0):
+                    summary['largest_win'] = pnl
+            else:
+                summary['losing_trades'] += 1
+                summary['total_loss_usd'] += abs(pnl)
+                if abs(pnl) > summary.get('largest_loss', 0):
+                    summary['largest_loss'] = abs(pnl)
+            
+            if summary['total_trades'] > 0:
+                summary['win_percentage'] = (summary['winning_trades'] / summary['total_trades']) * 100
+            
+            if summary['winning_trades'] > 0:
+                summary['avg_profit_per_trade'] = summary['total_profit_usd'] / summary['winning_trades']
+            if summary['losing_trades'] > 0:
+                summary['avg_loss_per_trade'] = summary['total_loss_usd'] / summary['losing_trades']
+            
+            data_json = json.dumps(summary, indent=2).encode('utf-8')
+            self.r2_service.s3_client.put_object(
+                Bucket="trading", Key=key, Body=data_json, ContentType="application/json"
+            )
+            print(f"📊 تم تحديث ملخص التداول. معدل الربح: {summary['win_percentage']:.2f}%")
+
+        except Exception as e:
+            print(f"❌ فشل تحديث ملخص التداول: {e}")
+
+    async def get_open_trades(self):
+        """الحصول على الصفقات المفتوحة"""
+        return await self.r2_service.get_open_trades_async()
+
+    async def get_trade_by_symbol(self, symbol):
+        """الحصول على صفقة بالرمز"""
+        open_trades = await self.get_open_trades()
+        for trade in open_trades:
+            if trade['symbol'] == symbol and trade['status'] == 'OPEN':
+                return trade
+        return None
+
+print("✅ Trade Manager محمل - إدارة موحدة للصفقات")