Merge pull request #23 from folg-code/tests/strategy

Tests/strategy

Author: folg-code

Strategies/Samplestrategy.py

@@ -1,12 +1,11 @@
 import pandas as pd
 import talib.abstract as ta
 
-from Strategies.utils.decorators import informative
 from core.backtesting.reporting.core.context import ContextSpec
 from core.backtesting.reporting.core.metrics import ExpectancyMetric, MaxDrawdownMetric
-from core.strategy.BaseStrategy import BaseStrategy
 from FeatureEngineering.MarketStructure.engine import MarketStructureEngine
-
+from core.strategy.base import BaseStrategy
+from core.strategy.informatives import informative
 
 class Samplestrategy(BaseStrategy):
 
@@ -15,13 +14,11 @@ def __init__(
             df,
             symbol,
             startup_candle_count,
-            provider,
     ):
         super().__init__(
             df=df,
             symbol=symbol,
             startup_candle_count=startup_candle_count,
-            provider=provider,
         )
 
     @informative("M30")
@@ -100,85 +97,31 @@ def populate_entry_trend(self):
         # LONG MEAN REVERSION SETUP
         # =====================
 
-        mr_env = True
-
-        setup_mr_long = (
-                mr_env
-                & ((df['close'] < df["bos_bull_level"]) | (df['close'] < df["mss_bull_level"]) )
-        )
 
-        trigger_mr_long = (
-                setup_mr_long
-                & (df["close"] > df["open"])
-        )
 
         # =====================
         # SHORT CONTINUATION SETUP
         # =====================
-        setup_continuation_short = (
-                #df["bias_short_M30"]
-                 (df["trend_regime"] == "trend_down")
-                & df["bos_bear_event"]
-                & df["bos_bear_ft_valid"]
-               # & (df["bos_bear_struct_vol"] == "high")
-        )
 
-        trigger_continuation_short = (
-            setup_continuation_short
-            & (df["close"] < df["open"])
-        )
-
-        # =====================
-        # SHORT MEAN REVERSION SETUP
-        # =====================
-        setup_mr_short = (
-                mr_env
-                & ((df['close'] > df["bos_bull_level"]) | (df['close'] > df["mss_bull_level"]) )
-        )
-
-        trigger_mr_short = (
-                setup_mr_short
-                & (df["close"] < df["open"])
-        )
-
-        # =====================
-        # SIGNALS (PRIORITY)
-        # =====================
-
-        # =====================
-        # SIGNALS (PRIORITY)
-        # =====================
+        setup_mr_long = df["close"] > df["open"]
+        setup_continuation_short = df["close"] < df["open"]
 
         df["signal_entry"] = None
 
-        # --- CONTINUATION FIRST ---
-        df.loc[trigger_continuation_long, "signal_entry"] = pd.Series(
-            [{"direction": "long", "tag": "bos_continuation_long"}]
-            * trigger_continuation_long.sum(),
-            index=df.index[trigger_continuation_long],
-        )
+        idx = df.index[setup_mr_long]
 
-        df.loc[trigger_continuation_short, "signal_entry"] = pd.Series(
-            [{"direction": "short", "tag": "bos_continuation_short"}]
-            * trigger_continuation_short.sum(),
-            index=df.index[trigger_continuation_short],
+        df.loc[idx, "signal_entry"] = pd.Series(
+            [{"direction": "long", "tag": "long"}] * len(idx),
+            index=idx
         )
 
-        free = df["signal_entry"].isna()
+        idx = df.index[setup_continuation_short]
 
-        df.loc[trigger_mr_long & free, "signal_entry"] = pd.Series(
-            [{"direction": "long", "tag": "mean_reversion_long"}]
-            * (trigger_mr_long & free).sum(),
-            index=df.index[trigger_mr_long & free],
+        df.loc[idx, "signal_entry"] = pd.Series(
+            [{"direction": "short", "tag": "short"}] * len(idx),
+            index=idx
         )
 
-        df.loc[trigger_mr_short & free, "signal_entry"] = pd.Series(
-            [{"direction": "short", "tag": "mean_reversion_short"}]
-            * (trigger_mr_short & free).sum(),
-            index=df.index[trigger_mr_short & free],
-        )
-
-
         df["levels"] = None
 
 
@@ -192,10 +135,13 @@ def populate_entry_trend(self):
             axis=1
         )
 
+        print(df["signal_entry"].notna().sum())
 
         self.df = df
 
 
+
+
         return df
 
     def build_report_config(self):
@@ -224,6 +170,7 @@ def populate_exit_trend(self):
         self.df["signal_exit"] = None
         self.df["custom_stop_loss"] = None
 
+
     def calculate_levels(self, signals, close, sl_long, sl_short):
 
         if not isinstance(signals, dict):

config/live.py

@@ -33,4 +33,10 @@
 STARTUP_CANDLE_COUNT = 600
 MAX_RISK_PER_TRADE = 0.005
 
-SERVER_TIMEZONE = "UTC"
+SERVER_TIMEZONE = "UTC"
+
+EXIT_EXECUTION = {
+    "TP1": "ENGINE",   # ENGINE | BROKER | DISABLED
+    "TP2": "BROKER",   # ENGINE | BROKER | DISABLED
+    "BE_ON_TP1": True, # move SL to BE when TP1 is reached
+}

core/backtesting/backtester.py

@@ -1,5 +1,5 @@
 import traceback
-from typing import  Optional
+from typing import Optional, Any
 import pandas as pd
 from concurrent.futures import ProcessPoolExecutor, as_completed
 import os
@@ -14,15 +14,16 @@
 from core.domain.cost.cost_engine import TradeCostEngine, InstrumentCtx
 from core.backtesting.trade_factory import TradeFactory
 from core.domain.risk.sizing import position_size
+from core.strategy.plan_builder import  PlanBuildContext
 
 
 class Backtester:
     def __init__(self,
-                 slippage: float = 0.0,
+                 strategy,
                  execution_policy: Optional[ExecutionPolicy] = None,
                  cost_engine: Optional[TradeCostEngine] = None
                  ):
-        self.slippage = slippage
+        self.strategy = strategy
         self.execution_policy = execution_policy or ExecutionPolicy()
         self.cost_engine = cost_engine or TradeCostEngine(self.execution_policy)
 
@@ -66,65 +67,70 @@ def _instrument_ctx(symbol: str) -> InstrumentCtx:
     def _backtest_single_symbol(self, df: pd.DataFrame, symbol: str) -> pd.DataFrame:
         trades = []
 
-        df = df.copy()
-        df["time"] = df["time"].dt.tz_localize(None)
-
+        time_arr = df["time"].dt.tz_localize(None).values
         high_arr = df["high"].values
         low_arr = df["low"].values
         close_arr = df["close"].values
-        time_arr = df["time"].values
 
-        signal_arr = df["signal_entry"].values
-        levels_arr = df["levels"].values
+        # instrument ctx do slippage itp.
+        ctx_inst = self._instrument_ctx(symbol)
+
+        # 1) Build vector-friendly plans once (shared logic)
+        ctx = PlanBuildContext(
+            symbol=symbol,
+            strategy_name=type(self.strategy).__name__,
+            strategy_config=self.strategy.strategy_config,
+        )
+        plans = self.strategy.build_trade_plans_backtest(df=df, ctx=ctx, allow_managed_in_backtest=False)
+
+        # 2) Precompute arrays used in the hot loop
+        plan_valid = plans["plan_valid"].values
+        plan_dir = plans["plan_direction"].values
+        plan_tag = plans["plan_entry_tag"].values
+        plan_sl = plans["plan_sl"].values.astype(float)
+        plan_tp1 = plans["plan_tp1"].values.astype(float)
+        plan_tp2 = plans["plan_tp2"].values.astype(float)
 
-        ctx = self._instrument_ctx(symbol)
-        point_size = ctx.point_size
-        pip_value = ctx.pip_value
+        plan_sl_tag = plans["plan_sl_tag"].values.astype(str)
+        plan_tp1_tag = plans["plan_tp1_tag"].values.astype(str)
+        plan_tp2_tag = plans["plan_tp2_tag"].values.astype(str)
 
         n = len(df)
 
         for direction in ("long", "short"):
             dir_flag = 1 if direction == "long" else -1
-            last_exit_by_tag = {}
+            last_exit_by_tag: dict[str, Any] = {}
 
             for entry_pos in range(n):
-                sig = signal_arr[entry_pos]
-                if not isinstance(sig, dict) or sig.get("direction") != direction:
+                if not plan_valid[entry_pos]:
+                    continue
+                if plan_dir[entry_pos] != direction:
                     continue
 
-                entry_tag = sig["tag"]
+                entry_tag = str(plan_tag[entry_pos])
                 entry_time = time_arr[entry_pos]
 
                 last_exit = last_exit_by_tag.get(entry_tag)
                 if last_exit is not None and last_exit > entry_time:
                     continue
 
-                levels = levels_arr[entry_pos]
-                if not isinstance(levels, dict):
-                    continue
-
-                sl = (levels.get("SL") or levels.get(0))["level"]
-                tp1 = (levels.get("TP1") or levels.get(1))["level"]
-                tp2 = (levels.get("TP2") or levels.get(2))["level"]
+                sl = float(plan_sl[entry_pos])
+                tp1 = float(plan_tp1[entry_pos])
+                tp2 = float(plan_tp2[entry_pos])
 
-                level_tags = {
-                    "SL": (levels.get("SL") or levels.get(0))["tag"],
-                    "TP1": (levels.get("TP1") or levels.get(1))["tag"],
-                    "TP2": (levels.get("TP2") or levels.get(2))["tag"],
-                }
+                level_tags = {"SL": plan_sl_tag[entry_pos], "TP1": plan_tp1_tag[entry_pos], "TP2": plan_tp2_tag[entry_pos]}
 
                 entry_price = float(close_arr[entry_pos])
 
-                # legacy behavior: entry slippage on exec price (kept as-is)
-                entry_price += ctx.slippage_abs if direction == "long" else -ctx.slippage_abs
+                entry_price += ctx_inst.slippage_abs if direction == "long" else -ctx_inst.slippage_abs
 
                 size = position_size(
                     entry_price=entry_price,
                     stop_price=sl,
                     max_risk=MAX_RISK_PER_TRADE,
-                    account_size=INITIAL_BALANCE,
-                    point_size=point_size,
-                    pip_value=pip_value,
+                    account_size=INITIAL_BALANCE,   # lub INITIAL_BALANCE
+                    point_size=ctx_inst.point_size,
+                    pip_value=ctx_inst.pip_value,
                 )
 
                 (
@@ -145,7 +151,7 @@ def _backtest_single_symbol(self, df: pd.DataFrame, symbol: str) -> pd.DataFrame
                     low_arr,
                     close_arr,
                     time_arr,
-                    ctx.slippage_abs,
+                    ctx_inst.slippage_abs,
                 )
 
                 exit_result = ExitProcessor.process(
@@ -161,10 +167,12 @@ def _backtest_single_symbol(self, df: pd.DataFrame, symbol: str) -> pd.DataFrame
                     tp1=tp1,
                     tp2=tp2,
                     position_size=size,
-                    point_size=point_size,
-                    pip_value=pip_value,
+                    point_size=ctx_inst.point_size,
+                    pip_value=ctx_inst.pip_value,
                 )
 
+
+
                 trade_dict = TradeFactory.create_trade(
                     symbol=symbol,
                     direction=direction,
@@ -175,22 +183,18 @@ def _backtest_single_symbol(self, df: pd.DataFrame, symbol: str) -> pd.DataFrame
                     sl=sl,
                     tp1=tp1,
                     tp2=tp2,
-                    point_size=point_size,
-                    pip_value=pip_value,
+                    point_size=ctx_inst.point_size,
+                    pip_value=ctx_inst.pip_value,
                     exit_result=exit_result,
                     level_tags=level_tags,
                 )
 
-                self.cost_engine.enrich(trade_dict, df=df, ctx=ctx)
+                self.cost_engine.enrich(trade_dict, df=df, ctx=ctx_inst)
 
                 trades.append(trade_dict)
                 last_exit_by_tag[entry_tag] = exit_time
 
         print(f"✅ Finished backtest for {symbol}, {len(trades)} trades.")
-
-        df = pd.DataFrame(trades)
-
-        print(df.loc[df['financing_usd_total'] > 0])
         return pd.DataFrame(trades)
 
     # -----------------------------

core/backtesting/reporting/runner.py

@@ -58,7 +58,6 @@ def run(self):
             strategy=self.strategy,
         )
 
-        print(ctx.trades.columns)
 
         # ==================================================
         # BUILD REPORT (SECTIONS)

core/backtesting/runner.py

@@ -15,8 +15,8 @@
 from core.backtesting.backtester import Backtester
 from core.backtesting.plotting.plot import TradePlotter
 
-from core.strategy.runner import run_strategy_single
-from core.strategy.strategy_loader import load_strategy_class
+from core.backtesting.strategy_runner import run_strategy_single
+from core.live_trading.strategy_loader import load_strategy_class
 
 
 class BacktestRunner:
@@ -31,7 +31,6 @@ class BacktestRunner:
 
     def __init__(self, cfg):
         self.config = cfg
-        self.provider = None
 
         # 🔑 STRATEGY CONTRACT
         self.strategy = None          # reference strategy (for reporting config)
@@ -167,7 +166,7 @@ def _run_backtest_window(self, start, end, label):
         if df_slice.empty:
             raise RuntimeError(f"No signals in window: {label}")
 
-        backtester = Backtester(slippage=self.config.SLIPPAGE)
+        backtester = Backtester(strategy=self.strategy)
         trades = backtester.run_backtest(df_slice)
         trades["window"] = label
         return trades