Update simulation_engine/virtual_exchange.py

simulation_engine/virtual_exchange.py

@@ -1,24 +1,70 @@
 # simulation_engine/virtual_exchange.py
-# (V1.2 - include numeric 'score' in trade_record)
+# Single concurrent position allowed (configurable), zero cooldown supported, fast time-stop
 
 from datetime import datetime
 import uuid
 
 class VirtualExchange:
-    def __init__(self, initial_balance=10.0, fee_rate=0.001):
-        self.initial_balance = initial_balance
-        self.balance = initial_balance
-        self.fee_rate = fee_rate
-        self.positions = {}
+    def __init__(
+        self,
+        initial_balance=10.0,
+        fee_rate=0.001,
+        tp_pct=1.0,
+        sl_pct=1.0,
+        time_stop_bars=6,
+        bar_ms=300_000,
+        cooldown_bars=0,
+        min_trade_usd=0.10,
+        position_fraction=0.95,
+        max_concurrent=1,
+    ):
+        self.initial_balance = float(initial_balance)
+        self.balance = float(initial_balance)
+        self.fee_rate = float(fee_rate)
+
+        self.tp_pct = float(tp_pct) / 100.0
+        self.sl_pct = float(sl_pct) / 100.0
+        self.time_stop_bars = int(time_stop_bars) if time_stop_bars is not None else None
+        self.bar_ms = int(bar_ms) if bar_ms is not None else None
+        self.cooldown_bars = int(cooldown_bars) if cooldown_bars is not None else 0
+        self.min_trade_usd = float(min_trade_usd)
+        self.position_fraction = float(position_fraction)
+        self.max_concurrent = int(max_concurrent)
+
+        self.positions = {}          # symbol -> position dict
         self.trade_history = []
+        self.cooldowns = {}          # symbol -> cooldown_until_ts
+
         self.metrics = {
             "wins": 0, "losses": 0, "total_pnl_usd": 0.0,
-            "max_drawdown": 0.0, "peak_balance": initial_balance
+            "max_drawdown": 0.0, "peak_balance": self.balance
         }
 
+    # ------- Helpers -------
+    def open_positions_count(self):
+        return len(self.positions)
+
     def get_balance(self):
         return self.balance
 
+    def can_enter(self, symbol, current_ts):
+        # cooldown per symbol
+        cd_until = self.cooldowns.get(symbol)
+        if cd_until is not None and current_ts < cd_until:
+            return False
+        # single-position constraint or configured max
+        if self.open_positions_count() >= self.max_concurrent:
+            return False
+        # avoid duplicate position on same symbol
+        if symbol in self.positions:
+            return False
+        # check min trade size
+        planned = self.balance * self.position_fraction
+        if planned < self.min_trade_usd:
+            return False
+        return True
+
+    # ------- Lifecycle -------
     def update_positions(self, current_prices, timestamp):
         closed_trades = []
         for symbol in list(self.positions.keys()):
@@ -29,40 +75,61 @@ class VirtualExchange:
 
             pos["highest_price"] = max(pos.get("highest_price", 0), current_price)
 
-            tp_price = pos["entry_price"] * 1.015
-            sl_price = pos["entry_price"] * 0.9925
+            tp_price = pos["entry_price"] * (1.0 + self.tp_pct)
+            sl_price = pos["entry_price"] * (1.0 - self.sl_pct)
 
             closed_trade = None
             if current_price >= tp_price:
-                closed_trade = self.execute_sell(symbol, tp_price, timestamp, "TAKE_PROFIT")
+                closed_trade = self._close(symbol, tp_price, timestamp, "TAKE_PROFIT")
             elif current_price <= sl_price:
-                closed_trade = self.execute_sell(symbol, sl_price, timestamp, "STOP_LOSS")
+                closed_trade = self._close(symbol, sl_price, timestamp, "STOP_LOSS")
+            else:
+                # time stop
+                if self.time_stop_bars and self.bar_ms:
+                    age_ms = timestamp - pos["entry_time"]
+                    if age_ms >= self.time_stop_bars * self.bar_ms:
+                        closed_trade = self._close(symbol, current_price, timestamp, "TIME_STOP")
 
             if closed_trade:
                 closed_trades.append(closed_trade)
         return closed_trades
 
-    def execute_buy(self, symbol, price, amount_usd, timestamp, score_data=None):
-        if price <= 0 or self.balance < amount_usd:
+    def execute_buy(self, symbol, price, timestamp, score_data=None):
+        if price <= 0:
+            return False
+        if self.open_positions_count() >= self.max_concurrent:
+            return False
+        if symbol in self.positions:
+            return False
+
+        amount_usd = self.balance * self.position_fraction
+        if amount_usd < self.min_trade_usd or amount_usd > self.balance:
             return False
 
         fee = amount_usd * self.fee_rate
-        self.balance -= amount_usd
         net_invested = amount_usd - fee
+        if net_invested <= 0:
+            return False
+
         quantity = net_invested / price
+        self.balance -= amount_usd
 
         self.positions[symbol] = {
             "entry_price": price,
             "quantity": quantity,
             "invested_usd": amount_usd,
             "entry_time": timestamp,
-            "scores": score_data or {},  # يجب أن تحتوي الآن على final_score
+            "scores": score_data or {},
             "highest_price": price,
-            "trade_id": f"sim_{uuid.uuid4().hex[:8]}"
+            "trade_id": f"sim_{uuid.uuid4().hex[:8]}",
         }
         return True
 
     def execute_sell(self, symbol, price, timestamp, reason):
+        return self._close(symbol, price, timestamp, reason)
+
+    # ------- Internal close -------
+    def _close(self, symbol, price, timestamp, reason):
         pos = self.positions.get(symbol)
         if not pos:
             return None
@@ -73,12 +140,11 @@ class VirtualExchange:
         self.balance += net_revenue
 
         pnl_usd = net_revenue - pos["invested_usd"]
-        pnl_pct = (pnl_usd / pos["invested_usd"]) * 100
+        pnl_pct = (pnl_usd / pos["invested_usd"]) * 100.0
 
-        # حاول استخراج درجة الدخول النهائية إن وُجدت
-        entry_score = pos.get("scores", {}).get("final_score")
+        entry_score = None
         try:
-            entry_score = float(entry_score) if entry_score is not None else None
+            entry_score = float((pos.get("scores") or {}).get("final_score"))
         except Exception:
             entry_score = None
 
@@ -94,9 +160,9 @@ class VirtualExchange:
             "pnl_percent": pnl_pct,
             "close_reason": reason,
             "strategy": "HYBRID_TITAN",
-            "score": entry_score,  # ✅ يقرأه Reflector كعدد
+            "score": entry_score,
             "decision_data": {
-                "components": pos["scores"],
+                "components": pos.get("scores") or {},
                 "hybrid_weights_at_entry": {"titan": 0.5, "patterns": 0.4, "monte_carlo": 0.1}
             }
         }
@@ -108,8 +174,14 @@ class VirtualExchange:
         else:
             self.metrics["losses"] += 1
         self.metrics["peak_balance"] = max(self.metrics["peak_balance"], self.balance)
-        current_drawdown = (self.metrics["peak_balance"] - self.balance) / self.metrics["peak_balance"]
+        current_drawdown = (self.metrics["peak_balance"] - self.balance) / max(self.metrics["peak_balance"], 1e-9)
         self.metrics["max_drawdown"] = max(self.metrics["max_drawdown"], current_drawdown)
 
+        # apply per-symbol cooldown if configured (>0)
+        if self.cooldown_bars and self.bar_ms:
+            self.cooldowns[symbol] = timestamp + self.cooldown_bars * self.bar_ms
+        else:
+            self.cooldowns[symbol] = None  # zero cooldown => immediate eligibility
+
         del self.positions[symbol]
         return trade_record