investing-algorithm-framework 8.0.0__tar.gz → 8.1.1__tar.gz

{investing_algorithm_framework-8.0.0 → investing_algorithm_framework-8.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: investing-algorithm-framework
-Version: 8.0.0
+Version: 8.1.1
 Summary: A framework for creating trading bots
 Author: MDUYN
 Requires-Python: >=3.10

{investing_algorithm_framework-8.0.0 → investing_algorithm_framework-8.1.1}/investing_algorithm_framework/app/context.py

@@ -161,7 +161,8 @@ class Context:
         market=None,
         execute=True,
         validate=True,
-        sync=True
+        sync=True,
+        metadata=None
     ) -> Order:
         """
         Function to create a limit order. This function will create a limit
@@ -257,6 +258,9 @@ class Context:
             "trading_symbol": portfolio.trading_symbol,
         }
 
+        if metadata is not None:
+            order_data["metadata"] = metadata
+
         if BACKTESTING_FLAG in self.configuration_service.config \
                 and self.configuration_service.config[BACKTESTING_FLAG]:
             order_data["created_at"] = \

{investing_algorithm_framework-8.0.0 → investing_algorithm_framework-8.1.1}/investing_algorithm_framework/app/reporting/backtest_report.py

@@ -10,7 +10,7 @@ from datetime import datetime, timedelta
 from jinja2 import Environment, FileSystemLoader
 
 from investing_algorithm_framework.domain import (
-    Backtest, OperationalException
+    Backtest, OperationalException, tqdm
 )
 
 logger = logging.getLogger("investing_algorithm_framework")
@@ -88,6 +88,70 @@ def _is_na(val):
     return False
 
 
+def _downsample(series, max_points=300):
+    """Downsample a time-series list to at most *max_points* entries.
+
+    Uses the Largest-Triangle-Three-Buckets (LTTB) algorithm to
+    preserve visual fidelity while drastically reducing data size
+    for the browser.  Always keeps the first and last points.
+    """
+    if not series or len(series) <= max_points:
+        return series
+
+    n = len(series)
+    # Each element is [value, date_str]
+    sampled = [series[0]]
+    bucket_size = (n - 2) / (max_points - 2)
+
+    a_idx = 0
+    for i in range(1, max_points - 1):
+        # Calculate bucket boundaries
+        avg_start = int((i) * bucket_size) + 1
+        avg_end = int((i + 1) * bucket_size) + 1
+        if avg_end > n - 1:
+            avg_end = n - 1
+
+        # Average point of next bucket
+        avg_x = 0
+        avg_y = 0
+        count = avg_end - avg_start
+        if count <= 0:
+            count = 1
+            avg_end = avg_start + 1
+        for j in range(avg_start, avg_end):
+            avg_x += j
+            avg_y += series[j][0]
+        avg_x /= count
+        avg_y /= count
+
+        # Current bucket boundaries
+        range_start = int((i - 1) * bucket_size) + 1
+        range_end = int(i * bucket_size) + 1
+        if range_end > n - 1:
+            range_end = n - 1
+
+        # Pick the point with the largest triangle area
+        a_x = a_idx
+        a_y = series[a_idx][0]
+        max_area = -1
+        best_idx = range_start
+
+        for j in range(range_start, range_end):
+            area = abs(
+                (a_x - avg_x) * (series[j][0] - a_y)
+                - (a_x - j) * (avg_y - a_y)
+            ) * 0.5
+            if area > max_area:
+                max_area = area
+                best_idx = j
+
+        sampled.append(series[best_idx])
+        a_idx = best_idx
+
+    sampled.append(series[-1])
+    return sampled
+
+
 @dataclass
 class BacktestReport:
     backtests: List[Backtest] = field(default_factory=list)
@@ -125,14 +189,17 @@ class BacktestReport:
         with open(path, "w") as f:
             f.write(self.html_report)
 
+        if browser:
+            webbrowser.open(f"file://{path}")
+            return
+
         try:
             from IPython import get_ipython
             shell = get_ipython().__class__.__name__
             if shell == 'ZMQInteractiveShell':
                 from IPython.display import display, HTML
                 display(HTML(self.html_report))
-                if not browser:
-                    return
+                return
         except (NameError, ImportError):
             pass
 
@@ -159,6 +226,7 @@ class BacktestReport:
     def open(
         backtests: List[Backtest] = None,
         directory_path: Union[str, List[str], None] = None,
+        show_progress: bool = False,
     ) -> "BacktestReport":
         loaded = []
         source_tags = []
@@ -175,11 +243,12 @@ class BacktestReport:
         else:
             dir_paths = []
 
+        # Collect all backtest paths first for progress tracking
+        backtest_paths = []
         for dp in dir_paths:
             tag = os.path.basename(os.path.normpath(dp))
             if BacktestReport._is_backtest(dp):
-                loaded.append(Backtest.open(dp))
-                source_tags.append(tag)
+                backtest_paths.append((dp, tag))
             else:
                 for root, dirs, _ in os.walk(dp):
                     for dir_name in dirs:
@@ -189,10 +258,20 @@ class BacktestReport:
                         if BacktestReport._is_backtest(
                             subdir
                         ):
-                            loaded.append(
-                                Backtest.open(subdir)
+                            backtest_paths.append(
+                                (subdir, tag)
                             )
-                            source_tags.append(tag)
+
+        iterator = backtest_paths
+        if show_progress:
+            iterator = tqdm(
+                backtest_paths,
+                desc="Loading backtests",
+            )
+
+        for path, tag in iterator:
+            loaded.append(Backtest.open(path))
+            source_tags.append(tag)
 
         for bt in backtests:
             if not isinstance(bt, Backtest):
@@ -336,10 +415,10 @@ class BacktestReport:
                     initial = ec[0][0] if ec else 1
                     if initial == 0:
                         initial = 1
-                    rep_eq = [
+                    rep_eq = _downsample([
                         [(v / initial - 1) * 100, _fmt_date(d)]
                         for v, d in ec
-                    ]
+                    ])
 
             # Run IDs / mappings / labels
             run_ids, run_name_map, run_labels_list = [], {}, []
@@ -463,6 +542,29 @@ class BacktestReport:
                         op_dt = t.opened_at
                         cl_dt = t.closed_at
                         total_fees = getattr(t, 'total_fees', 0) or 0
+                        # Stop-loss / take-profit status
+                        t_sls = getattr(t, 'stop_losses', None)
+                        t_tps = getattr(t, 'take_profits', None)
+                        sl_triggered = any(
+                            getattr(sl, 'triggered', False)
+                            for sl in (t_sls or [])
+                        )
+                        tp_triggered = any(
+                            getattr(tp, 'triggered', False)
+                            for tp in (t_tps or [])
+                        )
+                        has_sl = bool(t_sls and len(t_sls) > 0)
+                        has_tp = bool(t_tps and len(t_tps) > 0)
+                        # Collect unique order reasons
+                        t_reasons = set()
+                        for t_o in (getattr(t, 'orders', None)
+                                    or []):
+                            t_o_meta = getattr(
+                                t_o, 'metadata', None
+                            ) or {}
+                            r = t_o_meta.get('order_reason')
+                            if r:
+                                t_reasons.add(r)
                         trades_list.append({
                             'id': idx_t,
                             'sym': sym,
@@ -476,6 +578,17 @@ class BacktestReport:
                             'total_fees': round(total_fees, 4),
                             'net_gain': round(ng, 2),
                             'pct': round(pct, 2),
+                            'stop_loss': (
+                                'Triggered' if sl_triggered
+                                else ('Set' if has_sl else '')
+                            ),
+                            'take_profit': (
+                                'Triggered' if tp_triggered
+                                else ('Set' if has_tp else '')
+                            ),
+                            'reasons': ', '.join(
+                                sorted(t_reasons)
+                            ),
                         })
                         sym_stats.setdefault(sym, {'count': 0, 'gain': 0})
                         sym_stats[sym]['count'] += 1
@@ -588,6 +701,11 @@ class BacktestReport:
                         o_slippage = getattr(o, 'slippage', None)
                         if o_slippage is None:
                             o_slippage = 0
+                        o_meta = getattr(o, 'metadata', None)
+                        o_meta = o_meta if o_meta else {}
+                        o_reason = o_meta.get(
+                            'order_reason', ''
+                        )
                         orders_list.append({
                             'sym': getattr(o, 'target_symbol', '')
                             or '',
@@ -617,6 +735,7 @@ class BacktestReport:
                             'slippage': round(
                                 float(o_slippage), 4
                             ),
+                            'reason': o_reason,
                             'created': _fmt_date(o_dt)
                             if o_dt else '',
                             'updated': _fmt_date(u_dt)
@@ -637,6 +756,11 @@ class BacktestReport:
                             ),
                         })
 
+                # Downsample heavy time series for browser perf
+                eq = _downsample(eq)
+                dd = _downsample(dd)
+                rs = _downsample(rs)
+
                 run_data[rid] = {
                     'label': label,
                     'EQ': eq,