Update simulation_engine/sim_runner.py

simulation_engine/sim_runner.py

@@ -1,5 +1,5 @@
 # simulation_engine/sim_runner.py
-# Close each trade at ~1h if >= breakeven, else force close by 2h. Single concurrent position.
+# V3.0 — Balanced-Fast: more trades, better expectancy, single-position, 1–2h time stops.
 
 import asyncio
 import os
@@ -15,33 +15,36 @@ try:
     from .mock_kucoin import MockKuCoin
     from .virtual_exchange import VirtualExchange
 except ImportError:
-    print("❌ [SimRunner] Missing mock components.", flush=True)
+    # إذا كانت البنية مختلفة، حدّث المسارات حسب مشروعك
+    from simulation_engine.mock_kucoin import MockKuCoin
+    from simulation_engine.virtual_exchange import VirtualExchange
 
 SIM_CONFIG = {
+    # نافذة الاختبار
     "START_DATE": "2025-09-10",
     "END_DATE":   "2025-11-09",
 
-    # Portfolio & execution
+    # المحفظة والتنفيذ
     "INITIAL_BALANCE": 10.0,
-    "FEE_RATE": 0.001,
+    "FEE_RATE": 0.001,          # 0.1%
 
-    # Entry cadence & quality
-    "STEP_TF": "5m",            # قرارات كل 5 دقائق
-    "ENTRY_THRESHOLD": 0.25,    # توازن مقبول لخفض الضوضاء
+    # سرعة القرار وجودته
+    "STEP_TF": "5m",            # قرار كل 5 دقائق
+    "ENTRY_THRESHOLD": 0.22,    # عتبة دخول متوازنة لرفع العدد دون ضوضاء مفرطة
 
-    # Position sizing & limits
-    "POSITION_FRACTION": 0.50,  # نصف الرصيد للصفقة الواحدة
-    "MAX_CONCURRENT_POSITIONS": 1,
+    # حجم الصفقة والقيود
+    "POSITION_FRACTION": 0.45,  # 45% من الرصيد لكل صفقة
+    "MAX_CONCURRENT_POSITIONS": 1,  # صفقة واحدة في نفس الوقت
     "MIN_TRADE_USD": 0.10,
 
-    # Exits
-    "TP_PCT": 1.2,              # 1.2% هدف
-    "SL_PCT": 0.8,              # 0.8% وقف
-    "SOFT_TIME_STOP_BARS": 12,  # ≈ 1 ساعة عند STEP_TF=5m
-    "HARD_TIME_STOP_BARS": 24,  # ≈ 2 ساعة كحد أقصى
-    "COOLDOWN_BARS": 3,         # تبريد بسيط لمنع إعادة الدخول الفوري
+    # الخروج: هدف/وقف + إيقاف زمني مرن
+    "TP_PCT": 1.6,              # 1.6%
+    "SL_PCT": 0.8,              # 0.8%
+    "SOFT_TIME_STOP_BARS": 12,  # ≈ 1 ساعة عند STEP_TF=5m: يغلق عند التعادل أو أفضل
+    "HARD_TIME_STOP_BARS": 24,  # ≈ 2 ساعة: إغلاق قسري
+    "COOLDOWN_BARS": 1,         # تبريد قصير لمنع إعادة الدخول الفوري
 
-    # Universe
+    # الكون
     "TEST_SYMBOLS": [
         "BTC/USDT","ETH/USDT","SOL/USDT","BNB/USDT","XRP/USDT",
         "DOGE/USDT","ADA/USDT","AVAX/USDT","LINK/USDT"
@@ -55,9 +58,10 @@ TF_MS = {'5m': 300_000, '15m': 900_000, '1h': 3_600_000, '4h': 14_400_000, '1d':
 REQUIRED_TFS = ['5m','15m','1h','4h','1d']
 FETCH_LIMIT = 500
 
+# الحد الأدنى للشموع المطلوبة لكل إطار
 MIN_CANDLES_BASE = {'5m':220,'15m':220,'1h':220,'4h':220,'1d':60}
 MIN_CANDLES_REQ  = dict(MIN_CANDLES_BASE)
-MIN_CANDLES_REQ['1d'] = 59
+MIN_CANDLES_REQ['1d'] = 59  # مرونة بسيطة لبدء المحاكاة
 
 async def run_realistic_simulation():
     SIM_STATUS["running"] = True
@@ -65,21 +69,23 @@ async def run_realistic_simulation():
         f"🚀 Sim {SIM_CONFIG['START_DATE']} -> {SIM_CONFIG['END_DATE']} | symbols={len(SIM_CONFIG['TEST_SYMBOLS'])}\n"
         f"STEP_TF={SIM_CONFIG['STEP_TF']} THR={SIM_CONFIG['ENTRY_THRESHOLD']} "
         f"TP/SL={SIM_CONFIG['TP_PCT']}/{SIM_CONFIG['SL_PCT']} "
-        f"SOFT/HARD={SIM_CONFIG['SOFT_TIME_STOP_BARS']}/{SIM_CONFIG['HARD_TIME_STOP_BARS']} bars",
+        f"SOFT/HARD={SIM_CONFIG['SOFT_TIME_STOP_BARS']}/{SIM_CONFIG['HARD_TIME_STOP_BARS']} bars "
+        f"| COOLDOWN={SIM_CONFIG['COOLDOWN_BARS']} | POS_FRAC={SIM_CONFIG['POSITION_FRACTION']}",
         flush=True
     )
 
     r2_service = R2Service()
-    if not os.path.exists(SIM_CONFIG["LOCAL_DATA_DIR"]):
-        print(f"❌ Missing data dir: {SIM_CONFIG['LOCAL_DATA_DIR']}", flush=True)
+    data_dir = SIM_CONFIG["LOCAL_DATA_DIR"]
+    if not os.path.exists(data_dir):
+        print(f"❌ Missing data dir: {data_dir}", flush=True)
         SIM_STATUS["running"] = False
         return
 
     print("🛠️ Bootstrapping...", flush=True)
-    mock_exchange = MockKuCoin(SIM_CONFIG["LOCAL_DATA_DIR"])
+    mock_exchange = MockKuCoin(data_dir)
     await mock_exchange.load_data(SIM_CONFIG["TEST_SYMBOLS"], REQUIRED_TFS)
 
-    # Wallet with 1–2h time-stop logic
+    # إنشاء المحفظة بمنطق الإيقاف الزمني المرن
     step_ms = TF_MS.get(SIM_CONFIG["STEP_TF"], TF_MS['5m'])
     virtual_wallet = VirtualExchange(
         initial_balance=SIM_CONFIG["INITIAL_BALANCE"],
@@ -95,7 +101,7 @@ async def run_realistic_simulation():
         hard_time_stop_bars=SIM_CONFIG["HARD_TIME_STOP_BARS"],
     )
 
-    # span detection
+    # تحديد مجال الزمن الآمن
     min_ts, max_ts = None, None
     for sym in SIM_CONFIG["TEST_SYMBOLS"]:
         for tf in REQUIRED_TFS:
@@ -106,7 +112,7 @@ async def run_realistic_simulation():
             min_ts = mn if min_ts is None else min(min_ts, mn)
             max_ts = mx if max_ts is None else max(max_ts, mx)
     if min_ts is None or max_ts is None:
-        print("❌ لا توجد بيانات صالحة في المخزن.", flush=True); SIM_STATUS["running"] = False; return
+        print("❌ لا توجد بيانات صالحة.", flush=True); SIM_STATUS["running"] = False; return
 
     boot_requirements_ms = []
     for tf in REQUIRED_TFS:
@@ -133,24 +139,26 @@ async def run_realistic_simulation():
 
     print("🧠 Initializing hybrid system...", flush=True)
     data_manager  = DataManager(None, None, r2_service=r2_service, mock_exchange=mock_exchange)
-    learning_hub  = LearningHubManager(r2_service, None, data_manager, disable_llm=True)
+    learning_hub  = LearningHubManager(r2_service, None, data_manager, disable_llm=True)  # NO_LLM
     await learning_hub.initialize()
     processor     = MLProcessor(None, data_manager, learning_hub)
     await processor.initialize()
 
+    # تمرير عتبة الدخول للنظام الهجين
     setattr(data_manager, 'HYBRID_ENTRY_THRESHOLD', float(SIM_CONFIG["ENTRY_THRESHOLD"]))
     print(f"✅ Ready. Threshold={getattr(data_manager, 'HYBRID_ENTRY_THRESHOLD', 'NA')}", flush=True)
 
+    # حلقة المحاكاة
     timeline = range(safe_start_ts, safe_end_ts, step_ms)
     total = len(timeline)
     bar = tqdm(timeline, desc="Simulating", unit="step")
 
-    def log(msg): 
+    def log(msg):
         try: bar.write(msg)
         except Exception: print(msg, flush=True)
 
-    # loop
     for i, ts in enumerate(bar):
+        # تحديث الوقت
         mock_exchange.set_time(ts)
 
         if i % 10 == 0:
@@ -158,17 +166,17 @@ async def run_realistic_simulation():
             SIM_STATUS["current_balance"] = virtual_wallet.get_balance()
             SIM_STATUS["trades_count"]    = len(virtual_wallet.trade_history)
 
-        # update open positions
+        # إغلاقات قائمة (TP/SL/Soft/Hard)
         prices = {s:(await mock_exchange.fetch_ticker(s))['last'] for s in SIM_CONFIG["TEST_SYMBOLS"]}
         closed = virtual_wallet.update_positions(prices, ts)
         for tr in closed:
             log(f"[CLOSE] {tr['symbol']} reason={tr['close_reason']} pnl={tr['pnl_percent']:.2f}%")
             await learning_hub.analyze_trade_and_learn(tr, tr['close_reason'])
 
-        # try entries (respect single concurrent position)
+        # فتح مركز جديد إن لم توجد صفقات مفتوحة
         if virtual_wallet.open_positions_count() < SIM_CONFIG["MAX_CONCURRENT_POSITIONS"]:
             for symbol in SIM_CONFIG["TEST_SYMBOLS"]:
-                # availability check
+                # تحقق توافر حزمة الفريمات
                 enough = True
                 for tf in REQUIRED_TFS:
                     candles = await mock_exchange.fetch_ohlcv(symbol, tf, limit=FETCH_LIMIT)
@@ -178,19 +186,24 @@ async def run_realistic_simulation():
                     continue
 
                 packet = {tf: await mock_exchange.fetch_ohlcv(symbol, tf, limit=FETCH_LIMIT) for tf in REQUIRED_TFS}
-                res = await processor.process_and_score_symbol_enhanced({'symbol':symbol,'ohlcv':packet,'current_price':prices.get(symbol,0.0)})
+                cur_price = prices.get(symbol, 0.0)
+                res = await processor.process_and_score_symbol_enhanced({
+                    'symbol': symbol, 'ohlcv': packet, 'current_price': cur_price
+                })
                 if not res:
                     continue
 
                 final_s = float(res['enhanced_final_score'])
                 thr = getattr(data_manager, 'HYBRID_ENTRY_THRESHOLD', 0.75)
-                log(f"[SCORE] {symbol} final={final_s:.3f} thr={thr:.3f} comps={dict(res.get('components',{}), final_score=final_s)}")
+                comps = dict(res.get('components', {})); comps['final_score'] = final_s
+                log(f"[SCORE] {symbol} final={final_s:.3f} thr={thr:.3f} comps={comps}")
+
                 if final_s >= thr and virtual_wallet.can_enter(symbol, ts):
-                    if virtual_wallet.execute_buy(symbol, res['current_price'], ts, {'final_score': final_s}):
-                        log(f"[BUY] {symbol} @ {res['current_price']} bal=${virtual_wallet.get_balance():.2f}")
+                    if virtual_wallet.execute_buy(symbol, cur_price, ts, comps):
+                        log(f"[BUY] {symbol} @ {cur_price} bal=${virtual_wallet.get_balance():.2f}")
                     break  # نحافظ على صفقة واحدة فقط
 
-    # flush
+    # إغلاق ما تبقى عند نهاية النافذة
     print("\n🏁 نهاية فترة المحاكاة. إغلاق الصفقات المتبقية...", flush=True)
     final_ts = safe_end_ts
     mock_exchange.set_time(final_ts)