Qubx 1.1.2.dev1__tar.gz → 1.1.2.dev3__tar.gz

{qubx-1.1.2.dev1 → qubx-1.1.2.dev3}/PKG-INFO

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

qubx-1.1.2.dev3/src/qubx/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '1.1.2.dev3'
+__version_tuple__ = version_tuple = (1, 1, 2, 'dev3')
+
+__commit_id__ = commit_id = None

{qubx-1.1.2.dev1 → qubx-1.1.2.dev3}/src/qubx/backtester/management.py

@@ -573,7 +573,7 @@ class BacktestStorage:
         if self._is_cloud:
             self._setup_cloud_duckdb()
 
-    def get_log(self, backtest_id: str, config_name: str | None = None) -> str | None:
+    def get_log(self, backtest_id: str, config_name: str | None = None, max_lines: int = 1000) -> tuple[str, bool] | None:
         """
         Read the log file for a backtest run.
 
@@ -581,14 +581,29 @@ class BacktestStorage:
             backtest_id: Relative path within base_path.
             config_name: Config name (used for log filename).
                         If None, searches for any .log file.
+            max_lines: Maximum number of lines to return (from the end). 0 = unlimited.
 
         Returns:
-            Log file content as string, or None if not found.
+            (log_content, truncated) tuple, or None if not found.
         """
         run_dir = f"{self.base_path}{backtest_id.strip('/')}/"
 
         if config_name:
             log_path = f"{run_dir}{config_name}.log"
+        elif self._is_cloud:
+            try:
+                from pyarrow.fs import FileSelector, FileType
+
+                from qubx.utils.s3 import strip_scheme
+
+                client = S3Client(storage_options=self._storage_options)
+                entries = client.fs.get_file_info(FileSelector(strip_scheme(run_dir)))
+                log_files = [e.path for e in entries if e.type == FileType.File and e.path.endswith(".log")]
+                if not log_files:
+                    return None
+                log_path = f"s3://{log_files[0]}"
+            except Exception:
+                return None
         else:
             try:
                 files_df = self._conn.execute(f"SELECT file FROM glob('{run_dir}*.log')").df()
@@ -598,20 +613,30 @@ class BacktestStorage:
             except Exception:
                 return None
 
+        def _tail(content: str) -> tuple[str, bool]:
+            if not max_lines:
+                return content, False
+            lines = content.splitlines()
+            if len(lines) <= max_lines:
+                return content, False
+            return "\n".join(lines[-max_lines:]), True
+
         if self._is_cloud:
             try:
                 from qubx.utils.s3 import strip_scheme
 
                 client = S3Client(storage_options=self._storage_options)
                 with client.fs.open_input_stream(strip_scheme(log_path)) as f:
-                    return f.read().decode("utf-8")
+                    return _tail(f.read().decode("utf-8"))
             except Exception:
                 return None
         else:
             from pathlib import Path
 
             p = Path(log_path)
-            return p.read_text(encoding="utf-8", errors="replace") if p.is_file() else None
+            if not p.is_file():
+                return None
+            return _tail(p.read_text(encoding="utf-8", errors="replace"))
 
     def export_backtests_to_markdown(self, backtest_id: str, path: str, tags: tuple[str] | None = None):
         if tsr := self.load(backtest_id):

{qubx-1.1.2.dev1 → qubx-1.1.2.dev3}/src/qubx/cli/tui.py

@@ -844,6 +844,8 @@ class DetailScreen(Screen):
         self._result_info = result_info
         self._storage = storage
         self._load_id = result_info.get("load_id", "")
+        self._pending_copy: bool = False
+        self._pending_copy_timer: Timer | None = None
 
     def compose(self) -> ComposeResult:
         name = self._result_info.get("name", self._load_id)
@@ -854,7 +856,7 @@ class DetailScreen(Screen):
                 with VerticalScroll(id="detail-scroll"):
                     yield Markdown("*Loading…*", id="detail-report")
             with TabPane("Logs", id="tab-logs"):
-                yield RichLog(id="detail-log", wrap=True, highlight=True)
+                yield RichLog(id="detail-log", wrap=True, highlight=True, markup=True)
         yield Footer()
 
     def on_mount(self) -> None:
@@ -875,16 +877,19 @@ class DetailScreen(Screen):
 
         # - load log file
         config_name = self._result_info.get("config_name")
-        log_content = self._storage.get_log(self._load_id, config_name)
+        log_result = self._storage.get_log(self._load_id, config_name)
 
-        self.app.call_from_thread(self._populate, report, log_content)
+        self.app.call_from_thread(self._populate, report, log_result)
 
-    def _populate(self, report: str, log_content: str | None) -> None:
+    def _populate(self, report: str, log_result: tuple[str, bool] | None) -> None:
         """UI-thread callback: fill in the tabs."""
         self.query_one("#detail-report", Markdown).update(report)
 
         log_widget = self.query_one("#detail-log", RichLog)
-        if log_content:
+        if log_result:
+            log_content, truncated = log_result
+            if truncated:
+                log_widget.write("[bold yellow]Log truncated — showing last 1000 lines[/]\n")
             for line in log_content.splitlines():
                 log_widget.write(line)
         else:
@@ -910,6 +915,31 @@ class DetailScreen(Screen):
     def action_go_back(self) -> None:
         self.app.pop_screen()
 
+    def on_key(self, event) -> None:
+        if event.key == "c":
+            if self._pending_copy:
+                self._pending_copy = False
+                if self._pending_copy_timer:
+                    self._pending_copy_timer.stop()
+                    self._pending_copy_timer = None
+                self.app.copy_to_clipboard(str(self._load_id))
+                self.app.notify(f"Copied: {self._load_id}", timeout=3)
+            else:
+                self._pending_copy = True
+                self._pending_copy_timer = self.set_timer(
+                    0.5, self._cancel_pending_copy, name="cc_timeout"
+                )
+            event.prevent_default()
+            event.stop()
+        elif self._pending_copy:
+            self._cancel_pending_copy()
+
+    def _cancel_pending_copy(self) -> None:
+        self._pending_copy = False
+        if self._pending_copy_timer:
+            self._pending_copy_timer.stop()
+            self._pending_copy_timer = None
+
 
 class BacktestBrowserApp(App):
     """Main TUI application for browsing backtest results"""

{qubx-1.1.2.dev1 → qubx-1.1.2.dev3}/src/qubx/connectors/ccxt/exchanges/okx/account.py

@@ -7,7 +7,7 @@ from qubx.connectors.ccxt.utils import (
     ccxt_extract_deals_from_exec,
     ccxt_find_instrument,
 )
-from qubx.core.basics import CtrlChannel, Instrument
+from qubx.core.basics import AssetBalance, CtrlChannel, Instrument
 
 
 class OkxAccountProcessor(CcxtAccountProcessor):
@@ -57,6 +57,56 @@ class OkxAccountProcessor(CcxtAccountProcessor):
             ),
         )
 
+    async def _update_balance(self) -> None:
+        """OKX balance override: use cashBal instead of eq (equity) to avoid double-counting unrealized PnL.
+
+        CCXT maps OKX's `eq` (equity = cashBal + unrealizedPnL) to balance `total`.
+        Since get_total_capital() adds position market values (= unrealized PnL) on top,
+        using `eq` would double-count unrealized PnL. We use `cashBal` instead.
+        """
+        balances_raw = await self.exchange_manager.exchange.fetch_balance()
+
+        # Extract cashBal from raw OKX response instead of CCXT-parsed eq
+        balances: list[AssetBalance] = []
+        raw_details = balances_raw.get("info", {}).get("data", [{}])[0].get("details", [])
+        for detail in raw_details:
+            cash_bal = float(detail.get("cashBal", 0) or 0)
+            if not cash_bal:
+                continue
+            frozen_bal = float(detail.get("frozenBal", 0) or 0)
+            currency = detail["ccy"]
+            balances.append(
+                AssetBalance(
+                    exchange=self.exchange,
+                    currency=currency,
+                    free=cash_bal - frozen_bal,
+                    locked=frozen_bal,
+                    total=cash_bal,
+                )
+            )
+
+        current_balances = self.get_balances()
+
+        # remove balances that are not there anymore
+        current_currencies = {b.currency for b in current_balances}
+        new_currencies = {b.currency for b in balances}
+        for currency in current_currencies - new_currencies:
+            self.update_balance(currency, 0, 0)
+
+        # update current balances
+        for balance in balances:
+            self.update_balance(currency=balance.currency, total=balance.total, locked=balance.locked)
+
+        # update required instruments that we need to subscribe to
+        currencies = [b.currency for b in self.get_balances()]
+        instruments = [
+            self._get_instrument_for_currency(c) for c in currencies if c.upper() != self.base_currency.upper()
+        ]
+        self._required_instruments.update(instruments)
+
+        # fetch tickers for instruments that don't have recent price updates
+        await self._fetch_missing_tickers(instruments)
+
     async def _subscribe_instruments(self, instruments: list) -> None:
         """Skip SPOT instruments on OKX.F - futures connector only handles swap contracts."""
         await super()._subscribe_instruments([i for i in instruments if i.is_futures()])

{qubx-1.1.2.dev1 → qubx-1.1.2.dev3}/src/qubx/core/basics.py

@@ -936,7 +936,8 @@ class Position:
 
         if not np.isnan(price):
             u_pnl = self.unrealized_pnl()
-            self.pnl = u_pnl + self.r_pnl + self.cumulative_funding
+            # r_pnl already includes cumulative funding
+            self.pnl = u_pnl + self.r_pnl
             if self.instrument.is_futures():
                 # for derivatives market value of the position is the current unrealized PnL
                 self.market_value = u_pnl
@@ -955,7 +956,12 @@ class Position:
 
     def unrealized_pnl(self) -> float:
         if not np.isnan(self.last_update_price):
-            return self.quantity * self._qty_multiplier * (self.last_update_price - self.position_avg_price) / self.last_update_conversion_rate  # type: ignore
+            return (
+                self.quantity
+                * self._qty_multiplier
+                * (self.last_update_price - self.position_avg_price)
+                / self.last_update_conversion_rate
+            )  # type: ignore
         return 0.0
 
     def apply_funding_payment(self, funding_payment: FundingPayment, mark_price: float) -> float:
@@ -1021,7 +1027,9 @@ class Position:
         funds_release = self.market_value_funds
         if to_remain != 0 and self.quantity != 0 and np.sign(to_remain) == d:
             qty_to_release = max(self.quantity - to_remain, 0) if d > 0 else min(self.quantity - to_remain, 0)
-            funds_release = qty_to_release * self._qty_multiplier * self.last_update_price / self.last_update_conversion_rate
+            funds_release = (
+                qty_to_release * self._qty_multiplier * self.last_update_price / self.last_update_conversion_rate
+            )
         return abs(funds_release)
 
     @staticmethod

{qubx-1.1.2.dev1 → qubx-1.1.2.dev3}/src/qubx/core/metrics.py

@@ -685,6 +685,18 @@ class TradingSessionResult:
                 return df
             return df.loc[start:stop]
 
+        def _rebase_cumulative_columns(pfl: pd.DataFrame) -> pd.DataFrame:
+            """Rebase cumulative counter columns (_Funding, _Commissions) so the slice starts from zero.
+            Note: _PnL is NOT rebased because it includes unrealized PnL which depends on current positions."""
+            if pfl is None or pfl.empty:
+                return pfl
+            pfl = pfl.copy()
+            for pattern in ["_Funding", "_Commissions"]:
+                cols = [c for c in pfl.columns if c.endswith(pattern)]
+                if cols:
+                    pfl[cols] = pfl[cols] - pfl[cols].iloc[0]
+            return pfl
+
         start = pd.Timestamp(key.start) if key.start is not None else None
         stop = pd.Timestamp(key.stop) if key.stop is not None else None
 
@@ -696,6 +708,10 @@ class TradingSessionResult:
         else:
             capital = self.capital
 
+        sliced_portfolio = _slice_df(self.portfolio_log)
+        if start is not None and sliced_portfolio is not None and not sliced_portfolio.empty:
+            sliced_portfolio = _rebase_cumulative_columns(sliced_portfolio)
+
         tsr = TradingSessionResult(
             id=self.id,
             name=self.name,
@@ -706,7 +722,7 @@ class TradingSessionResult:
             capital=capital,
             base_currency=self.base_currency,
             commissions=self.commissions,
-            portfolio_log=_slice_df(self.portfolio_log),
+            portfolio_log=sliced_portfolio,
             executions_log=_slice_df(self.executions_log),
             signals_log=_slice_df(self.signals_log),
             targets_log=_slice_df(self.targets_log),
@@ -719,9 +735,7 @@ class TradingSessionResult:
             emitter_data=_slice_df(self.emitter_data.set_index("timestamp")).reset_index()
             if self.emitter_data is not None
             else None,
-            transfers_log=_slice_df(self.transfers_log.set_index("timestamp")).reset_index()
-            if self.transfers_log is not None
-            else None,
+            transfers_log=_slice_df(self.transfers_log) if self.transfers_log is not None else None,
         )
         tsr.qubx_version = self.qubx_version
         tsr.description = self.description
@@ -904,10 +918,75 @@ class TradingSessionResult:
             return pd.DataFrame(dtype=float)
         return calculate_funding_per_symbol(self.portfolio_log, start, stop)
 
-    def get_funding_per_asset(self, start: OptTimestamp = None, stop: OptTimestamp = None) -> pd.DataFrame:
+    def get_funding_per_asset(
+        self, start: OptTimestamp = None, stop: OptTimestamp = None, filter_zero: bool = True
+    ) -> pd.DataFrame:
         if self.portfolio_log.empty:
             return pd.DataFrame(dtype=float)
-        return calculate_funding_per_asset(self.portfolio_log, start, stop)
+        return calculate_funding_per_asset(self.portfolio_log, start, stop, filter_zero)
+
+    def get_funding_total(self, start: OptTimestamp = None, stop: OptTimestamp = None) -> pd.Series:
+        return self.get_funding_per_asset(start, stop).sum(axis=1).rename("funding_total")
+
+    def get_funding_pnl(self, start: OptTimestamp = None, stop: OptTimestamp = None) -> pd.Series:
+        return self.get_funding_per_asset(start, stop).iloc[-1].sort_values(ascending=False).rename("funding_pnl")
+
+    def get_asset_pnl(
+        self,
+        asset: str,
+        start: OptTimestamp = None,
+        stop: OptTimestamp = None,
+        commission_factor: float = 1.0,
+        pct_from_initial_capital: bool = False,
+        include_funding: bool = False,
+    ) -> pd.Series:
+        portfolio = self.portfolio_log
+        start = start or self.start
+        stop = stop or self.stop
+        init_capital = self.get_total_capital()
+        pnl = portfolio.filter(regex=f".*:{asset}USD.*_PnL").loc[start:stop].sum(axis=1).cumsum()
+        if not include_funding:
+            funding = portfolio.filter(regex=f".*:{asset}USD.*_Funding").loc[start:stop].sum(axis=1)
+            if len(funding) > 0:
+                funding_delta = funding.diff().fillna(funding.iloc[0])
+                pnl -= funding_delta.cumsum()
+        if commission_factor:
+            comm = portfolio.filter(regex=f".*{asset}.*_Commissions").loc[start:stop].sum(axis=1).cumsum()
+            pnl -= comm * commission_factor
+        return pnl / init_capital * 100 if pct_from_initial_capital else pnl
+
+    def get_pnl_per_asset(
+        self,
+        start: OptTimestamp = None,
+        stop: OptTimestamp = None,
+        pct_from_initial_capital: bool = False,
+        drop_zero: bool = True,
+        include_funding: bool = False,
+    ) -> pd.Series:
+        start = start or self.start
+        stop = stop or self.stop
+        assets = set()
+        for symbol in self.symbols:
+            parts = symbol.split(":")
+            if len(parts) != 2:
+                continue
+            exchange, symbol = parts
+            instrument = lookup.find_symbol(exchange, symbol)
+            if instrument:
+                assets.add(instrument.asset)
+        asset_to_pnl = {}
+        for asset in assets:
+            pnl = self.get_asset_pnl(asset, start, stop, pct_from_initial_capital=pct_from_initial_capital, include_funding=include_funding)
+            if pnl is not None and not pnl.empty:
+                last_pnl = pnl.iloc[-1]
+                if drop_zero and last_pnl == 0:
+                    continue
+                asset_to_pnl[asset] = last_pnl
+        return pd.Series(asset_to_pnl).sort_values(ascending=False)
+
+    def get_position_asset(self, asset: str, start: OptTimestamp = None, stop: OptTimestamp = None) -> pd.DataFrame:
+        pos = self.portfolio_log.filter(regex=f".*{asset}.*_Pos")
+        return pos.rename(columns=lambda x: x.replace("_Pos", ""))
 
     def performance(self) -> dict[str, float]:
         """
@@ -2023,7 +2102,7 @@ def calculate_leverage_per_symbol(
         df.columns = [col.split(":")[-1] for col in df.columns]
 
     if drop_zero_leverage:
-        df = df.loc[:, df.gt(0).any(axis=0)]
+        df = df.loc[:, df.ne(0).any(axis=0)]
 
     return cast(pd.DataFrame, df)
 
@@ -2105,6 +2184,7 @@ def calculate_funding_per_asset(
     portfolio_log: pd.DataFrame,
     start: OptTimestamp = None,
     stop: OptTimestamp = None,
+    filter_zero: bool = True,
 ) -> pd.DataFrame:
     """
     Calculate funding for each asset in the trading session.
@@ -2120,7 +2200,10 @@ def calculate_funding_per_asset(
         col_to_asset[col] = instr.asset if instr else col
 
     # Group by asset and sum
-    return df.rename(columns=col_to_asset).T.groupby(level=0).sum().T
+    df = df.rename(columns=col_to_asset).T.groupby(level=0).sum().T
+    if filter_zero:
+        df = df.loc[:, df.ne(0).any(axis=0)]
+    return df
 
 
 def calculate_turnover(

{qubx-1.1.2.dev1 → qubx-1.1.2.dev3}/src/qubx/data/cache.py

@@ -270,16 +270,18 @@ def _merge_batches(existing: pa.RecordBatch, incoming: pa.RecordBatch, time_col_
         [
             pa.Table.from_batches([existing]),
             pa.Table.from_batches([incoming]),
-        ]
+        ],
+        promote_options="permissive",
     )
     time_col_name = tbl.schema.field(time_col_idx).name
     tbl = tbl.sort_by(time_col_name)
 
+    merged_schema = tbl.schema
     pdf = tbl.to_pandas()
     dedup_cols = [time_col_name] + [f.name for f in existing.schema if pa.types.is_string(f.type) or pa.types.is_large_string(f.type)]
     pdf = pdf.drop_duplicates(subset=dedup_cols, keep="last")
 
-    batch = pa.RecordBatch.from_pandas(pdf, schema=existing.schema, preserve_index=False)
+    batch = pa.RecordBatch.from_pandas(pdf, schema=merged_schema, preserve_index=False)
     return batch
 
 

{qubx-1.1.2.dev1 → qubx-1.1.2.dev3}/src/qubx/data/storages/questdb.py

@@ -318,6 +318,10 @@ class xLTableMetaInfo:
         ("binance", "cmfutures"): ("binance.cm", "future"),
         ("binance", "margin"): ("binance.pm", "swap"),
         ("gateio", "swap"): ("gateio.f", "swap"),
+        ("kraken", "swap"): ("kraken.f", "swap"),
+        ("hyperliquid", "swap"): ("hyperliquid.f", "swap"),
+        ("bybit", "swap"): ("bybit.f", "swap"),
+        ("okx", "swap"): ("okx.f", "swap"),
     }
 
     _DTYPE_FIX = {

{qubx-1.1.2.dev1 → qubx-1.1.2.dev3}/src/qubx/data/transformers.py

@@ -119,7 +119,7 @@ class PandasFrame(IDataTransformer):
                 tbl = tbl.append_column(pa.field("symbol", pa.large_string()), sym_col)
             tables.append(tbl)
 
-        tbl = pa.concat_tables(tables)
+        tbl = pa.concat_tables(tables, promote_options="permissive")
         df = tbl.to_pandas()
         df[t_name] = pd.to_datetime(df[t_name])
         return df.set_index([t_name, "symbol"]).sort_index()

{qubx-1.1.2.dev1 → qubx-1.1.2.dev3}/src/qubx/utils/runner/textual/app.py

@@ -7,6 +7,7 @@ import concurrent.futures
 import sys
 from pathlib import Path
 
+import yaml
 from rich.text import Text
 from textual.app import App, ComposeResult, ScreenStackError
 from textual.binding import Binding
@@ -20,7 +21,7 @@ from qubx.cli.theme import QUBX_DARK
 from .handlers import KernelEventHandler
 from .init_code import generate_init_code, generate_mock_init_code
 from .kernel import IPyKernel
-from .widgets import CommandInput, DebugLog, OrdersTable, PositionsTable, QuotesTable, ReplOutput
+from .widgets import AccountSummary, CommandInput, DebugLog, OrdersTable, PositionsTable, QuotesTable, ReplOutput
 
 
 class TextualStrategyApp(App[None]):
@@ -80,8 +81,13 @@ class TextualStrategyApp(App[None]):
         self.no_notifiers = no_notifiers
         self.no_exporters = no_exporters
         self.kernel = kernel if kernel is not None else IPyKernel()
+
+        # Derive app title from config name or strategy class
+        self.title = self._resolve_title(config_file)
+
         self.output: ReplOutput
         self.input: CommandInput
+        self.account_summary: AccountSummary
         self.positions_panel: Vertical
         self.positions_table: PositionsTable
         self.orders_panel: Vertical
@@ -102,13 +108,29 @@ class TextualStrategyApp(App[None]):
         self._original_stderr = None
         self._executor = concurrent.futures.ThreadPoolExecutor(max_workers=1)
 
+    @staticmethod
+    def _resolve_title(config_file: Path) -> str:
+        """Derive window title from config 'name' field, falling back to strategy class name."""
+        try:
+            with open(config_file) as f:
+                cfg = yaml.safe_load(f) or {}
+            if name := cfg.get("name"):
+                return str(name)
+            if strategy := cfg.get("strategy"):
+                return str(strategy).rsplit(".", 1)[-1]
+        except Exception:
+            pass
+        return config_file.stem
+
     async def on_mount(self) -> None:
         """Initialize the app when mounted."""
         self.register_theme(QUBX_DARK)
         self.theme = QUBX_DARK.name
 
         # Setup event handler
-        self.event_handler = KernelEventHandler(self.output, self.positions_table, self.orders_table, self.quotes_table)
+        self.event_handler = KernelEventHandler(
+            self.output, self.positions_table, self.orders_table, self.quotes_table, self.account_summary
+        )
 
         # Add welcome message
         self.output.write(Text("Qubx Strategy Runner", style="bold cyan"))
@@ -239,6 +261,8 @@ class TextualStrategyApp(App[None]):
     def compose(self) -> ComposeResult:
         """Compose the TUI layout."""
         yield Header(show_clock=True)
+        self.account_summary = AccountSummary(id="account-summary")
+        yield self.account_summary
         with Vertical(id="content-wrapper"):
             with Horizontal(id="main-container"):
                 # Output on the left

{qubx-1.1.2.dev1 → qubx-1.1.2.dev3}/src/qubx/utils/runner/textual/handlers.py

@@ -9,7 +9,7 @@ from rich.text import Text
 
 from qubx import logger
 
-from .widgets import OrdersTable, PositionsTable, QuotesTable, ReplOutput
+from .widgets import AccountSummary, OrdersTable, PositionsTable, QuotesTable, ReplOutput
 
 
 class KernelEventHandler:
@@ -21,6 +21,7 @@ class KernelEventHandler:
         positions_table: PositionsTable,
         orders_table: OrdersTable,
         quotes_table: QuotesTable,
+        account_summary: AccountSummary,
     ):
         """
         Initialize the event handler.
@@ -28,13 +29,15 @@ class KernelEventHandler:
         Args:
             output: REPL output widget for displaying text
             positions_table: Positions table widget for displaying positions data
-            orders_table: Orders table widget for displaying orders data (optional)
-            quotes_table: Quotes table widget for displaying market quotes (optional)
+            orders_table: Orders table widget for displaying orders data
+            quotes_table: Quotes table widget for displaying market quotes
+            account_summary: Account summary bar widget
         """
         self.output = output
         self.positions_table = positions_table
         self.orders_table = orders_table
         self.quotes_table = quotes_table
+        self.account_summary = account_summary
         self._dashboard_busy = False
         self._on_dashboard_update: Callable[[], None] | None = None
 
@@ -60,9 +63,11 @@ class KernelEventHandler:
                 positions = payload.get("positions", [])
                 orders = payload.get("orders", [])
                 quotes = payload.get("quotes", {})
+                account_summary = payload.get("account_summary", [])
                 self.positions_table.update_positions(positions)
                 self.orders_table.update_orders(orders)
                 self.quotes_table.update_quotes(quotes)
+                self.account_summary.update_summary(account_summary)
             except Exception as e:
                 logger.error(f"Dashboard update error: {e}")
                 self.output.write(f"Dashboard update failed: {e}")

{qubx-1.1.2.dev1 → qubx-1.1.2.dev3}/src/qubx/utils/runner/textual/init_code.py

@@ -210,6 +210,21 @@ def _quotes_as_records():
         pass  # Context not ready yet
     return quotes
 
+def _account_summary():
+    \"\"\"Collect per-exchange account summary (total capital, leverage).\"\"\"
+    summary = []
+    try:
+        for exch in ctx.exchanges:
+            summary.append({{
+                "exchange": exch,
+                "total_capital": _sanitize_number(round(ctx.get_total_capital(exch), 2)),
+                "net_leverage": _sanitize_number(round(ctx.get_net_leverage(exch), 4)),
+                "gross_leverage": _sanitize_number(round(ctx.get_gross_leverage(exch), 4)),
+            }})
+    except Exception:
+        pass
+    return summary
+
 def emit_dashboard(all=True, debug=False):
     \"\"\"Publish unified dashboard data via custom MIME for Textual to capture.\"\"\"
     try:
@@ -217,6 +232,7 @@ def emit_dashboard(all=True, debug=False):
             "positions": _positions_as_records(all=all),
             "orders": _orders_as_records(),
             "quotes": _quotes_as_records(),
+            "account_summary": _account_summary(),
         }}
 
         # Let strategy inject custom data

{qubx-1.1.2.dev1 → qubx-1.1.2.dev3}/src/qubx/utils/runner/textual/styles.tcss

@@ -19,6 +19,21 @@ Header {
     text-style: bold;
 }
 
+#account-summary {
+    height: auto;
+    background: $panel;
+    padding: 0 2;
+}
+
+#account-summary-bar {
+    height: auto;
+}
+
+#account-summary-content {
+    height: auto;
+    color: $foreground;
+}
+
 Footer {
     dock: bottom;
     height: 1;

{qubx-1.1.2.dev1 → qubx-1.1.2.dev3}/src/qubx/utils/runner/textual/widgets/__init__.py

@@ -1,5 +1,6 @@
 """Textual UI widgets for strategy runner."""
 
+from .account_summary import AccountSummary
 from .command_input import CommandInput
 from .debug_log import DebugLog, TextualLogHandler
 from .orders_table import OrdersTable
@@ -7,4 +8,4 @@ from .positions_table import PositionsTable
 from .quotes_table import QuotesTable
 from .repl_output import ReplOutput
 
-__all__ = ["ReplOutput", "PositionsTable", "OrdersTable", "QuotesTable", "CommandInput", "DebugLog", "TextualLogHandler"]
+__all__ = ["AccountSummary", "ReplOutput", "PositionsTable", "OrdersTable", "QuotesTable", "CommandInput", "DebugLog", "TextualLogHandler"]