Qubx 1.0.0.dev4__tar.gz → 1.0.0.dev6__tar.gz

{qubx-1.0.0.dev4 → qubx-1.0.0.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Qubx
-Version: 1.0.0.dev4
+Version: 1.0.0.dev6
 Summary: Qubx - Quantitative Trading Framework
 Project-URL: homepage, https://xlydian.com
 Project-URL: repository, https://github.com/xLydianSoftware/Qubx

{qubx-1.0.0.dev4 → qubx-1.0.0.dev6}/pyproject.toml

@@ -180,5 +180,5 @@ dev = [
     "mongomock>=4.3.0,<5",
     "pytest-textual-snapshot>=1.1.0,<2",
     "git-cliff>=2.0.0",
-    "duckdb>=1.0.0"
+    "duckdb>=1.0.0",
 ]

{qubx-1.0.0.dev4 → qubx-1.0.0.dev6}/src/qubx/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.0.0.dev4'
-__version_tuple__ = version_tuple = (1, 0, 0, 'dev4')
+__version__ = version = '1.0.0.dev6'
+__version_tuple__ = version_tuple = (1, 0, 0, 'dev6')
 
 __commit_id__ = commit_id = None

{qubx-1.0.0.dev4 → qubx-1.0.0.dev6}/src/qubx/backtester/runner.py

@@ -229,7 +229,7 @@ class SimulationRunner:
         assert isinstance(_data_provider, SimulatedDataProvider)
 
         if not is_hist:
-            if t >= (_next_exp_time := self.scheduler.next_expected_event_time()):
+            while t >= (_next_exp_time := self.scheduler.next_expected_event_time()):
                 # - we use exact event's time
                 self.time_provider.set_time(_next_exp_time)
                 self.scheduler.check_and_run_tasks()

{qubx-1.0.0.dev4 → qubx-1.0.0.dev6}/src/qubx/cli/tui.py

@@ -1,10 +1,12 @@
 import json
+import re
 from typing import Any
 
 import pandas as pd
 from rich.console import RenderableType
 from rich.table import Table
-from textual import on
+from rich.text import Text as RichText
+from textual import on, work
 from textual.app import App, ComposeResult
 from textual.binding import Binding
 from textual.containers import Horizontal, Vertical
@@ -23,6 +25,56 @@ from qubx import logger
 from qubx.backtester import BacktestStorage
 from qubx.cli.theme import QUBX_DARK
 from qubx.core.metrics import TradingSessionResult, get_cum_pnl
+from qubx.utils.results import SimulationResultsSaver
+
+# - matches YYYYMMDD_HHMMSS timestamp directory names produced by SimulationResultsSaver
+_TS_DIR_RE = re.compile(r"^\d{8}_\d{6}$")
+
+
+def _fv(v: Any, default: float = 0.0) -> float:
+    """
+    Safely coerce a metadata value to float, substituting ``default`` for
+    ``None``, ``NaN``, and anything that cannot be parsed as a number.
+
+    ``float(nan) or 0`` does NOT work — NaN is truthy in Python, so the
+    ``or 0`` fallback is never reached.  This helper handles that correctly.
+    """
+    import math
+
+    try:
+        f = float(v)
+        return default if math.isnan(f) else f
+    except (TypeError, ValueError):
+        return default
+
+
+def _fmt_variation_params(result: dict[str, Any]) -> str:
+    """
+    Format variation parameters for compact table display.
+
+    Resolution order:
+    1. ``variation_params`` JSON field  →  ``fp=6, sp=34``
+    2. ``[bracketed]`` content inside ``name``  →  ``xxx_(fp=6,sp=34)``
+    3. ``variation_id`` as last resort  →  ``var_003``
+    """
+    raw = str(result.get("variation_params") or "").strip()
+    if raw:
+        try:
+            params = json.loads(raw)
+            if isinstance(params, dict) and params:
+                return _e(", ".join(f"{k}={v}" for k, v in params.items()))
+        except Exception:
+            pass
+
+    # - fallback: extract the [bracketed] part from the name field
+    # - e.g. "strat_fff_ggg.[xxx_(fp=6,sp=34)]"  →  "xxx_(fp=6,sp=34)"
+    name = str(result.get("name") or "")
+    m = re.search(r"\[([^\]]+)\]", name)
+    if m:
+        return _e(m.group(1))
+
+    # - last resort: raw variation_id
+    return _e(str(result.get("variation_id") or ""))
 
 
 def _e(text: object) -> str:
@@ -375,6 +427,8 @@ class BacktestTreeNode:
         self.children: list[BacktestTreeNode] = []
         self.backtest_results: list[dict[str, Any]] = []
         self.is_leaf = False
+        # - backtest_ids pending lazy metadata load (populated at tree build, cleared after first load)
+        self.pending_ids: list[str] = []
 
     def add_child(self, child: "BacktestTreeNode"):
         self.children.append(child)
@@ -390,59 +444,119 @@ class BacktestResultsTree(Tree[BacktestTreeNode]):
     def __init__(self, root_path: str):
         self.root_path = root_path
         self.storage = BacktestStorage(root_path)
+        self._root_data = BacktestTreeNode("Backtest Results", root_path, self.storage)
+        super().__init__(self._root_data.name, data=self._root_data)
 
-        root_node = BacktestTreeNode("Backtest Results", root_path, self.storage)
-        self._build_tree_structure(root_node)
-
-        super().__init__(root_node.name, data=root_node)
-        self._populate_tree(self.root, root_node)
+    def on_mount(self) -> None:
+        # - show placeholder immediately so user sees the tree is loading
+        self.root.add_leaf("⏳ Loading…")
+        self._load_data()
+
+    @work(thread=True)
+    def _load_data(self) -> None:
+        # - runs in background thread — does the expensive storage.search()
+        self._build_tree_structure(self._root_data)
+        # - marshal back to the UI thread to update the widget
+        self.app.call_from_thread(self._finish_loading)
+
+    def _finish_loading(self) -> None:
+        # - called on the UI thread once background load completes
+        self.root.remove_children()
+        self._populate_tree(self.root, self._root_data)
+        self.root.expand()
 
     def _build_tree_structure(self, root_node: BacktestTreeNode):
-        """Build tree structure from BacktestStorage search results."""
-        df = self.storage.search()
-        if df.empty:
+        """
+        Build 2-level tree structure by listing file paths only — zero parquet reads.
+
+        Uses DuckDB glob() TABLE function to enumerate filesystem/S3 entries
+        without reading any parquet data.  Metadata loads lazily on first leaf node
+        selection (see BacktestBrowserApp._load_node_metadata).
+
+        Path layout (new format)::
+
+            {base}/{ShortClass}/{config-name}/{YYYYMMDD_HHMMSS}/_metadata.parquet
+            {base}/{ShortClass}/{config-name}/{YYYYMMDD_HHMMSS}/var_XXX/_metadata.parquet  (old var)
+            {base}/{ShortClass}/{config-name}/{YYYYMMDD_HHMMSS}/_metadata.parquet  (new var, N rows)
+
+        Tree structure produced::
+
+            Root
+            ├── ShortClass  (parent node, expandable)
+            │   ├── config-name-A (N runs)   ← leaf, lazy-loads on click
+            │   └── config-name-B (M runs)   ← leaf, lazy-loads on click
+            └── AnotherClass
+                └── another-config (K runs)
+
+        Variation sets are deduplicated to a single timestamp-level entry.
+        Falls back to flat display when paths have fewer than 2 components
+        before the timestamp (e.g. old-format backtests).
+        """
+        glob_pat = self.storage._glob(SimulationResultsSaver.METADATA_FILE)
+        try:
+            # - glob() is a DuckDB TABLE function: zero parquet I/O, just path listing
+            paths_df = self.storage._conn.execute(f"SELECT file FROM glob('{glob_pat}')").df()
+        except Exception as e:
+            logger.warning(f"Failed to list backtest paths: {e}")
+            return
+
+        if paths_df.empty:
             return
 
-        # - deduplicate: glob may match _metadata.parquet at both the set level and
-        #   inside each var_XXX/ subdir, producing duplicate rows per backtest_id
-        df = df.drop_duplicates(subset=["backtest_id"])
-
-        # - separate regular runs and variations
-        is_var = df["is_variation"].fillna(False)
-        regular = df[~is_var]
-        variations = df[is_var]
-
-        # - group regular results by short strategy class name
-        strategy_groups: dict[str, list[dict]] = {}
-        for _, row in regular.iterrows():
-            row_dict = row.to_dict()
-            # - for regular runs load_id == backtest_id
-            row_dict["load_id"] = row_dict["backtest_id"]
-            cls = str(row_dict.get("strategy_class", "Unknown")).split(".")[-1]
-            strategy_groups.setdefault(cls, []).append(row_dict)
-
-        for strategy_name, results in strategy_groups.items():
-            strategy_node = BacktestTreeNode(f"{strategy_name} ({len(results)} results)", strategy_name, self.storage)
-            root_node.add_child(strategy_node)
-            for result in results:
-                strategy_node.add_backtest(result)
-
-        # - group variations by variation_name (the parent run dir, e.g. "strat/Cls/20240301_120000")
-        # - NOTE: backtest_id for variation rows already contains the var_XXX suffix,
-        #   so load_id == backtest_id directly (no extra appending needed)
-        var_groups: dict[str, list[dict]] = {}
-        for _, row in variations.iterrows():
-            row_dict = row.to_dict()
-            row_dict["load_id"] = row_dict["backtest_id"]
-            parent_key = str(row_dict.get("variation_name", row_dict.get("backtest_id", "")))
-            var_groups.setdefault(parent_key, []).append(row_dict)
-
-        for parent_key, var_list in var_groups.items():
-            name = var_list[0].get("name", parent_key).split(".")[0]
-            var_node = BacktestTreeNode(f"📊 {name} ({len(var_list)} variations)", name, self.storage)
-            root_node.add_child(var_node)
-            for variation in var_list:
-                var_node.add_backtest(variation)
+        base = self.storage.base_path  # - always ends with /
+
+        # - 2-level grouping: class_key → {config_name → set[run_id]}
+        groups: dict[str, dict[str, set[str]]] = {}
+
+        for file_path in paths_df["file"]:
+            rel = str(file_path).removeprefix(base).strip("/")
+            parts = rel.split("/")
+
+            # - find the rightmost YYYYMMDD_HHMMSS component — this is the run root
+            ts_idx = next(
+                (i for i in range(len(parts) - 1, -1, -1) if _TS_DIR_RE.match(parts[i])),
+                None,
+            )
+            if ts_idx is None:
+                continue
+
+            # - run_id = up to and including the timestamp dir (deduplicates var_XXX entries)
+            run_id = "/".join(parts[: ts_idx + 1])
+
+            if ts_idx >= 2:
+                # - new format: ...prefix/ShortClass/config-name/timestamp
+                # - config_name is immediately before the timestamp dir
+                config_name = parts[ts_idx - 1]
+                # - class_key is everything before config_name (may include extra path prefix)
+                class_key = "/".join(parts[: ts_idx - 1])
+            elif ts_idx == 1:
+                # - only one component before timestamp — treat as flat (no class prefix)
+                config_name = parts[0]
+                class_key = ""
+            else:
+                # - timestamp at root level — shouldn't happen, skip
+                continue
+
+            groups.setdefault(class_key, {}).setdefault(config_name, set()).add(run_id)
+
+        for class_key, config_groups in sorted(groups.items()):
+            # - display name for the class node = last component of class_key (the ShortClass)
+            class_display = class_key.split("/")[-1] if class_key else "root"
+            total_runs = sum(len(run_ids) for run_ids in config_groups.values())
+
+            class_node = BacktestTreeNode(f"{class_display} ({total_runs})", class_key, self.storage)
+            # - class nodes are not leaves — they expand to show config names
+            class_node.is_leaf = False
+
+            for config_name, run_ids in sorted(config_groups.items()):
+                leaf_path = f"{class_key}/{config_name}" if class_key else config_name
+                leaf = BacktestTreeNode(f"{config_name} ({len(run_ids)})", leaf_path, self.storage)
+                leaf.is_leaf = True
+                # - newest-first; timestamp dirs are zero-padded so lexicographic sort works
+                leaf.pending_ids = sorted(run_ids, reverse=True)
+                class_node.add_child(leaf)
+
+            root_node.add_child(class_node)
 
     def _populate_tree(self, tree_node, data_node: BacktestTreeNode):
         """Populate the textual tree with data nodes"""
@@ -468,11 +582,12 @@ class MetricsTable(DataTable):
 
         self.clear(columns=True)
 
-        columns = [
-            "Name",
-            "Strategy",
-            "Created",
-            "Author",
+        # - detect whether this result set contains variation rows;
+        # - if so, prepend a Params column instead of Name/Strategy
+        # - (Name and Strategy are already visible in the left tree)
+        has_variations = any(r.get("is_variation") for r in results_data)
+
+        columns: list[str] = [
             "Gain",
             "CAGR",
             "Sharpe",
@@ -481,29 +596,38 @@ class MetricsTable(DataTable):
             "MDD USD",
             "Fees",
             "Executions",
+            "Created",
+            "Author",
         ]
+        if has_variations:
+            columns.append("Params")
 
         for col in columns:
             self.add_column(col, key=col.lower().replace(" ", "_"))
 
         for result in results_data:
-            # - metrics are flat columns in BacktestStorage rows (not nested under 'performance')
-            # - user-data fields (name, strategy_class, author) must be _e()'d:
-            #   variation names contain [...] which Textual parses as markup tags
-            row_data = [
-                _e(str(result.get("name", result.get("backtest_id", "Unknown")))),
-                _e(str(result.get("strategy_class", "")).split(".")[-1]),
-                pd.Timestamp(result.get("creation_time", "")).strftime("%Y-%m-%d %H:%M"),
-                _e(str(result.get("author", ""))),
-                f"{float(result.get('gain') or 0):.3f}",
-                f"{float(result.get('cagr') or 0):.3f}",
-                f"{float(result.get('sharpe') or 0):.3f}",
-                f"{float(result.get('qr') or 0):.3f}",
-                f"{float(result.get('mdd_pct') or 0):.3f}",
-                f"{float(result.get('mdd_usd') or 0):.3f}",
-                f"{float(result.get('fees') or 0):.3f}",
-                f"{float(result.get('execs') or 0):.0f}",
+            gain_val = _fv(result.get("gain"))
+            # - negative gain → dim red row; positive → default style
+            row_style = "red" if gain_val < 0 else ""
+
+            def _c(s: str) -> RichText:
+                # - RichText doesn't parse markup so no _e() escaping needed
+                return RichText(s, style=row_style)
+
+            row_data: list[RichText] = [
+                _c(f"{gain_val:.3f}"),
+                _c(f"{_fv(result.get('cagr')):.3f}"),
+                _c(f"{_fv(result.get('sharpe')):.3f}"),
+                _c(f"{_fv(result.get('qr')):.3f}"),
+                _c(f"{_fv(result.get('mdd_pct')):.3f}"),
+                _c(f"{_fv(result.get('mdd_usd')):.3f}"),
+                _c(f"{_fv(result.get('fees')):.3f}"),
+                _c(f"{_fv(result.get('execs')):.0f}"),
+                _c(pd.Timestamp(result.get("creation_time", "")).strftime("%Y-%m-%d %H:%M")),
+                _c(str(result.get("author", ""))),
             ]
+            if has_variations:
+                row_data.append(_c(_fmt_variation_params(result)))
             # - row key is load_id so tearsheet loading doesn't need a lookup by name
             self.add_row(*row_data, key=result.get("load_id", result.get("backtest_id", "")))
 
@@ -577,10 +701,12 @@ class BacktestBrowserApp(App):
     BINDINGS = [
         Binding("j", "vim_down", "Down", show=False),
         Binding("k", "vim_up", "Up", show=False),
-        Binding("h", "vim_left", "Collapse/Left", show=False),
-        Binding("l", "vim_right", "Expand/Right", show=False),
-        Binding("G", "vim_end", "End", show=False),
-        Binding("g", "vim_home", "Home", show=False),
+        Binding("g", "vim_home", "Top", show=False),
+        Binding("h", "vim_left", "◀ Tree", show=True),
+        Binding("l", "vim_right", "▶ Table", show=True),
+        Binding("S", "sort_by_key_sharpe", "Sort Sharpe", show=True),
+        Binding("C", "sort_by_key_cagr", "Sort CAGR", show=True),
+        Binding("G", "vim_end", "Sort Gain", show=True),  # - Tree: scroll end; Table: sort gain
     ]
 
     CSS = """
@@ -737,6 +863,8 @@ class BacktestBrowserApp(App):
         self.current_results: list[dict[str, Any]] = []
         self.current_storage: BacktestStorage | None = None
         self._selected_result: dict[str, Any] | None = None
+        # - tracks which node is currently being loaded to discard stale callbacks
+        self._loading_node: BacktestTreeNode | None = None
 
     def compose(self) -> ComposeResult:
         """Compose the TUI layout"""
@@ -772,16 +900,26 @@ class BacktestBrowserApp(App):
 
     @on(Tree.NodeSelected)
     def handle_tree_selection(self, event: Tree.NodeSelected) -> None:
-        """Handle tree node selection"""
-        if event.node.data:
-            node_data = event.node.data
+        """Handle tree node selection — show cached results or trigger lazy metadata load."""
+        if not event.node.data:
+            return
+
+        node_data: BacktestTreeNode = event.node.data
+        self.current_storage = node_data.storage
+
+        if node_data.backtest_results:
+            # - already loaded: show immediately (cached after first click)
             self.current_results = node_data.backtest_results
-            self.current_storage = node_data.storage
+            self._update_table()
+            self.query_one("#metrics-table", MetricsTable).focus()
 
-            if self.current_results:
-                self._update_table()
-                # - move focus to the table so arrow keys / vim keys work immediately
-                self.query_one("#metrics-table", MetricsTable).focus()
+        elif node_data.pending_ids:
+            # - first selection: show spinner on the table then kick off background load
+            self._loading_node = node_data
+            table = self.query_one("#metrics-table", MetricsTable)
+            table.clear(columns=True)
+            table.loading = True  # - built-in Textual spinner overlay on the table widget
+            self._load_node_metadata(node_data)
 
     @on(DataTable.RowSelected)
     async def handle_row_selection(self, event: DataTable.RowSelected) -> None:
@@ -821,6 +959,66 @@ class BacktestBrowserApp(App):
             logger.error(f"Failed to build preview: {e}")
             await preview.update(f"*Preview error: {e}*")
 
+    @work(thread=True)
+    def _load_node_metadata(self, node_data: BacktestTreeNode) -> None:
+        """
+        Background worker: read parquet metadata for this group only.
+
+        Uses a group-scoped glob  (ShortClass/name/**/_metadata.parquet) so DuckDB
+        scans only this config's files — never the full storage tree.
+
+        Handles both layouts transparently:
+        - Regular run:   timestamp/_metadata.parquet          (1 row each)
+        - Old variation: timestamp/var_XXX/_metadata.parquet  (1 row per var)
+        - New variation: timestamp/_metadata.parquet          (N rows)
+        """
+        storage = node_data.storage
+        if not storage:
+            return
+
+        # - targeted glob scoped to this group's subdirectory only
+        group_glob = f"{storage.base_path}{node_data.path}/**/{SimulationResultsSaver.METADATA_FILE}"
+
+        try:
+            df = storage._conn.execute(
+                f"SELECT * FROM read_parquet('{group_glob}', union_by_name=true) ORDER BY creation_time DESC"
+            ).df()
+        except Exception as e:
+            logger.warning(f"Failed to load metadata for '{node_data.path}': {e}")
+            df = pd.DataFrame()
+
+        results: list[dict[str, Any]] = []
+        if not df.empty and "backtest_id" in df.columns:
+            df = df.drop_duplicates(subset=["backtest_id"])
+            for _, row in df.iterrows():
+                row_dict: dict[str, Any] = {str(k): v for k, v in row.items()}
+                row_dict["load_id"] = row_dict["backtest_id"]
+                results.append(row_dict)
+
+        node_data.backtest_results = results
+        node_data.pending_ids = []  # - free memory; signals "already loaded"
+        self.app.call_from_thread(self._on_node_metadata_loaded, node_data)
+
+    def _on_node_metadata_loaded(self, node_data: BacktestTreeNode) -> None:
+        """UI-thread callback: update table after metadata load completes."""
+        # - discard if user already navigated to a different node
+        if node_data is not self._loading_node:
+            return
+        self._loading_node = None
+
+        table = self.query_one("#metrics-table", MetricsTable)
+        table.loading = False  # - dismiss spinner regardless of outcome
+
+        self.current_results = node_data.backtest_results
+        if self.current_results:
+            self._update_table()
+            table.focus()
+        else:
+            self.call_later(
+                self.query_one("#preview-pane", Markdown).update,
+                "*No completed results found for this group.*",
+            )
+
     @on(Button.Pressed, "#sort-sharpe")
     def sort_by_sharpe(self) -> None:
         """Sort results by Sharpe ratio"""
@@ -864,16 +1062,17 @@ class BacktestBrowserApp(App):
             logger.error(f"Failed to refresh data: {e}")
 
     def _sort_table(self, metric: str) -> None:
-        """Sort table by specified metric"""
+        """
+        Sort current results by metric (descending) and repopulate the table.
+
+        Always sorts the underlying dict list rather than using Textual's
+        built-in DataTable.sort() — table cells are formatted strings so the
+        built-in sort would compare lexicographically and cannot handle NaN.
+        ``_fv`` substitutes 0.0 for NaN / None so those rows sink to the bottom.
+        """
         if self.current_results:
-            table = self.query_one("#metrics-table", MetricsTable)
-            try:
-                table.sort(metric, reverse=True)
-            except Exception as e:
-                logger.warning(f"Failed to sort by {metric}: {e}")
-                # - fallback: sort results dict and repopulate
-                self.current_results.sort(key=lambda x: float(x.get(metric) or 0), reverse=True)
-                self._update_table()
+            self.current_results.sort(key=lambda x: _fv(x.get(metric)), reverse=True)
+            self._update_table()
 
     def _update_table(self) -> None:
         """Update the metrics table"""
@@ -901,36 +1100,42 @@ class BacktestBrowserApp(App):
             focused.scroll_up(animate=False)
 
     def action_vim_left(self) -> None:
-        """Collapse tree node / move to parent; scroll left elsewhere."""
+        """In tree: collapse / go to parent.  In right pane: move focus back to tree."""
         focused = self.focused
         if focused is None:
             return
         if isinstance(focused, Tree):
-            focused.action_cursor_parent()  # - move to parent node (vim: h = go up/left)
-        elif isinstance(focused, DataTable):
-            focused.action_cursor_left()
+            focused.action_cursor_parent()
         else:
-            focused.scroll_left(animate=False)
+            # - h from DataTable, Markdown preview, or any other right-pane widget
+            self.query_one(BacktestResultsTree).focus()
 
     def action_vim_right(self) -> None:
-        """Expand/toggle tree node; scroll right elsewhere."""
+        """Tree: expand node (l).  Right pane: cursor right / scroll right."""
         focused = self.focused
         if focused is None:
             return
         if isinstance(focused, Tree):
-            focused.action_toggle_node()  # - expand/collapse node (vim: l = go into)
+            # - if the node is a leaf (has results / pending), move focus to the table;
+            # - otherwise expand/collapse the class-level parent node
+            node = focused.cursor_node
+            if node and node.data and (node.data.pending_ids or node.data.backtest_results):
+                self.query_one("#metrics-table", MetricsTable).focus()
+            else:
+                focused.action_toggle_node()
         elif isinstance(focused, DataTable):
             focused.action_cursor_right()
         else:
             focused.scroll_right(animate=False)
 
     def action_vim_end(self) -> None:
-        """Jump to last row / scroll to end (G)."""
+        """Tree: scroll to end (G).  Table: sort by gain (G = Shift+G)."""
         focused = self.focused
         if focused is None:
             return
         if isinstance(focused, DataTable):
-            focused.action_scroll_bottom()
+            # - G in right pane → sort by gain (more useful than scroll-to-bottom)
+            self._sort_table("gain")
         elif isinstance(focused, Tree):
             focused.action_scroll_end()
         else:
@@ -948,6 +1153,16 @@ class BacktestBrowserApp(App):
         else:
             focused.scroll_home(animate=False)
 
+    def action_sort_by_key_sharpe(self) -> None:
+        """Sort table by Sharpe ratio (S — right pane only)."""
+        if not isinstance(self.focused, Tree):
+            self._sort_table("sharpe")
+
+    def action_sort_by_key_cagr(self) -> None:
+        """Sort table by CAGR (C — right pane only)."""
+        if not isinstance(self.focused, Tree):
+            self._sort_table("cagr")
+
     # ── tearsheet ────────────────────────────────────────────────────────────
 
     def _generate_html_tearsheet(self, result_info: dict[str, Any]) -> None:

{qubx-1.0.0.dev4 → qubx-1.0.0.dev6}/src/qubx/connectors/ccxt/connection_manager.py

@@ -12,7 +12,7 @@ from asyncio.exceptions import CancelledError
 from collections import defaultdict
 from typing import Awaitable, Callable
 
-from ccxt import ExchangeClosedByUser, ExchangeError, ExchangeNotAvailable, NetworkError
+from ccxt import BadSymbol, ExchangeClosedByUser, ExchangeError, ExchangeNotAvailable, NetworkError
 from ccxt.async_support.base.ws.client import Client as _WsClient
 from ccxt.pro import Exchange
 
@@ -133,6 +133,12 @@ class ConnectionManager:
                 # Connection closed by us, stop gracefully
                 logger.info(f"<yellow>{self._exchange_id}</yellow> {stream_name} listening has been stopped")
                 break
+            except BadSymbol as e:
+                # Bad symbol is a permanent error - retrying will never succeed
+                logger.error(
+                    f"<yellow>{self._exchange_id}</yellow> BadSymbol :: {stream_name} : {e} - stopping stream"
+                )
+                break
             except (NetworkError, ExchangeError, ExchangeNotAvailable) as e:
                 # Network/exchange errors - retry after short delay
                 logger.error(

{qubx-1.0.0.dev4 → qubx-1.0.0.dev6}/src/qubx/connectors/ccxt/handlers/ohlc.py

@@ -8,6 +8,7 @@ import asyncio
 from typing import Set
 
 import pandas as pd
+from ccxt import BadSymbol
 
 from qubx import logger
 from qubx.core.basics import CtrlChannel, DataType, Instrument
@@ -274,6 +275,8 @@ class OhlcDataHandler(BaseDataTypeHandler):
                                     # Use private processing method to avoid duplication
                                     self._process_ohlcv_bar(oh, inst, sub_type, channel, timeframe, ohlcv_data)
 
+                        except BadSymbol:
+                            raise  # Permanent error, let ConnectionManager handle it
                         except Exception as e:
                             logger.error(
                                 f"<yellow>{exchange_id}</yellow> Error in individual OHLCV subscription for {inst.symbol}: {e}"

{qubx-1.0.0.dev4 → qubx-1.0.0.dev6}/src/qubx/core/basics.py

@@ -1455,3 +1455,8 @@ class InstrumentsLookup:
 
 class FeesLookup:
     def find_fees(self, exchange: str, spec: str | None) -> TransactionCostsCalculator: ...
+
+
+class AccountsLookup:
+    def get_credentials(self, exchange: str): ...
+    def get_settings(self, exchange: str): ...

{qubx-1.0.0.dev4 → qubx-1.0.0.dev6}/src/qubx/core/interfaces.py

@@ -148,7 +148,8 @@ class ITradeDataExport:
         pass
 
     def export_position_changes(
-        self, time: dt_64, instrument: Instrument, price: float, account: "IAccountViewer"
+        self, time: dt_64, instrument: Instrument, price: float, account: "IAccountViewer",
+        metadata: dict[str, Any] | None = None,
     ) -> None:
         """
         Export position changes to an external system.