Qubx 0.7.8__tar.gz → 0.7.25__tar.gz

{qubx-0.7.8 → qubx-0.7.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Qubx
-Version: 0.7.8
+Version: 0.7.25
 Summary: Qubx - Quantitative Trading Framework
 License-File: LICENSE
 Author: Dmitry Marienko
@@ -58,6 +58,7 @@ Requires-Dist: textual-serve (>=1.0.0,<2.0.0)
 Requires-Dist: textual[syntax] (>=6.0.0,<7.0.0)
 Requires-Dist: toml (>=0.10.2,<0.11.0)
 Requires-Dist: tqdm
+Requires-Dist: uvloop (>=0.22.1,<0.23.0)
 Requires-Dist: websockets (==15.0.1)
 Project-URL: Repository, https://github.com/xLydianSoftware/Qubx
 Description-Content-Type: text/markdown

{qubx-0.7.8 → qubx-0.7.25}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "Qubx"
-version = "0.7.8"
+version = "0.7.25"
 description = "Qubx - Quantitative Trading Framework"
 authors = [ "Dmitry Marienko <dmitry.marienko@xlydian.com>", "Yuriy Arabskyy <yuriy.arabskyy@xlydian.com>",]
 readme = "README.md"
@@ -79,6 +79,7 @@ textual-serve = "^1.0.0"
 rich = "^13.9.4"
 jinja2 = "^3.1.0"
 qubx-lighter-api = "^0.1.4"
+uvloop = "^0.22.1"
 
 [tool.ruff.lint]
 extend-select = [ "I",]

{qubx-0.7.8 → qubx-0.7.25}/src/qubx/backtester/account.py

@@ -8,6 +8,7 @@ from qubx.core.basics import (
     Timestamped,
     dt_64,
 )
+from qubx.core.interfaces import IHealthMonitor
 from qubx.core.series import OrderBook, Quote, Trade, TradeArray
 from qubx.restorers import RestoredState
 
@@ -21,7 +22,9 @@ class SimulatedAccountProcessor(BasicAccountProcessor):
         account_id: str,
         exchange: ISimulatedExchange,
         channel: CtrlChannel,
+        health_monitor: IHealthMonitor,
         base_currency: str,
+        exchange_name: str,
         initial_capital: float,
         restored_state: RestoredState | None = None,
     ) -> None:
@@ -29,6 +32,8 @@ class SimulatedAccountProcessor(BasicAccountProcessor):
             account_id=account_id,
             time_provider=exchange.get_time_provider(),
             base_currency=base_currency,
+            health_monitor=health_monitor,
+            exchange=exchange_name,
             tcc=exchange.get_transaction_costs_calculator(),
             initial_capital=initial_capital,
         )
@@ -37,7 +42,9 @@ class SimulatedAccountProcessor(BasicAccountProcessor):
         self._channel = channel
 
         if restored_state is not None:
-            self._balances.update(restored_state.balances)
+            # Convert list of AssetBalance to dict for internal storage
+            for balance in restored_state.balances:
+                self._balances[balance.currency] = balance
             for instrument, position in restored_state.positions.items():
                 _pos = self.get_position(instrument)
                 _pos.reset_by_position(position)

{qubx-0.7.8 → qubx-0.7.25}/src/qubx/backtester/broker.py

@@ -5,6 +5,7 @@ from qubx.core.basics import (
     CtrlChannel,
     Instrument,
     Order,
+    OrderRequest,
 )
 from qubx.core.exceptions import BadRequest, OrderNotFound
 from qubx.core.interfaces import IBroker
@@ -32,18 +33,17 @@ class SimulatedBroker(IBroker):
     def is_simulated_trading(self) -> bool:
         return True
 
-    def send_order(
-        self,
-        instrument: Instrument,
-        order_side: str,
-        order_type: str,
-        amount: float,
-        price: float | None = None,
-        client_id: str | None = None,
-        time_in_force: str = "gtc",
-        **options,
-    ) -> Order:
-        # - place order at exchange and send exec report to data channel
+    def send_order(self, request: OrderRequest) -> Order:
+        """Submit order synchronously in simulation."""
+        instrument = request.instrument
+        order_side = request.side
+        order_type = request.order_type
+        amount = request.quantity
+        price = request.price
+        client_id = request.client_id
+        time_in_force = request.time_in_force
+        options = request.options
+
         self._send_execution_report(
             report := self._exchange.place_order(
                 instrument, order_side, order_type, amount, price, client_id, time_in_force, **options
@@ -51,18 +51,9 @@ class SimulatedBroker(IBroker):
         )
         return report.order
 
-    def send_order_async(
-        self,
-        instrument: Instrument,
-        order_side: str,
-        order_type: str,
-        amount: float,
-        price: float | None = None,
-        client_id: str | None = None,
-        time_in_force: str = "gtc",
-        **optional,
-    ) -> None:
-        self.send_order(instrument, order_side, order_type, amount, price, client_id, time_in_force, **optional)
+    def send_order_async(self, request: OrderRequest) -> None:
+        """Submit order asynchronously (same as sync in simulation)."""
+        self.send_order(request)
 
     def cancel_order(self, order_id: str) -> bool:
         """Cancel an order synchronously and return success status."""
@@ -104,25 +95,25 @@ class SimulatedBroker(IBroker):
             raise OrderNotFound(f"Order {order_id} not found")
 
         # Validate that it's a limit order
-        if existing_order.type.lower() != "limit":
+        if existing_order.type != "LIMIT":
             raise BadRequest(
                 f"Order {order_id} is not a limit order (type: {existing_order.type}). Only limit orders can be updated."
             )
 
-        # Cancel the existing order first
         self.cancel_order(order_id)
 
-        # Create a new order with updated parameters, preserving original properties
-        updated_order = self.send_order(
+        request = OrderRequest(
             instrument=existing_order.instrument,
-            order_side=existing_order.side,
-            order_type="limit",
-            amount=abs(amount),
+            quantity=abs(amount),
             price=price,
-            client_id=existing_order.client_id,  # Preserve original client_id for tracking
+            order_type="LIMIT",
+            side=existing_order.side,
             time_in_force=existing_order.time_in_force or "gtc",
+            options={},
         )
 
+        updated_order = self.send_order(request)
+
         return updated_order
 
     def _send_execution_report(self, report: SimulatedExecutionReport | None):

{qubx-0.7.8 → qubx-0.7.25}/src/qubx/backtester/data.py

@@ -1,5 +1,5 @@
 from collections import defaultdict
-from typing import Any, TypeVar
+from typing import TypeVar
 
 import pandas as pd
 
@@ -74,16 +74,35 @@ class SimulatedDataProvider(IDataProvider):
     def is_simulation(self) -> bool:
         return True
 
+    def is_connected(self) -> bool:
+        """
+        Check if the data provider is currently connected to the exchange.
+
+        For simulated data provider, always returns True since data is loaded from files.
+
+        Returns:
+            bool: Always True for simulated data
+        """
+        return True
+
     def subscribe(self, subscription_type: str, instruments: set[Instrument], reset: bool) -> None:
         _new_instr = [i for i in instruments if not self.has_subscription(i, subscription_type)]
+
         self._data_source.add_instruments_for_subscription(subscription_type, list(instruments))
 
         # - provide historical data and last quote for subscribed instruments
         for i in _new_instr:
-            # Check if the instrument was actually subscribed (not filtered out)
+            # - check if the instrument was actually subscribed (not filtered out)
             if not self.has_subscription(i, subscription_type):
                 continue
 
+            # - notify simulating exchange that instrument is subscribed
+            self._account._exchange.on_subscribe(i)
+
+            # - we need to clear last quote as it can be staled
+            self._last_quotes.pop(i, None)
+
+            # - try to peek most recent market data
             h_data = self._data_source.peek_historical_data(i, subscription_type)
             if h_data:
                 # _s_type = DataType.from_str(subscription_type)[0]
@@ -103,9 +122,16 @@ class SimulatedDataProvider(IDataProvider):
     def unsubscribe(self, subscription_type: str, instruments: set[Instrument] | Instrument | None = None) -> None:
         # logger.debug(f" | unsubscribe: {subscription_type} -> {instruments}")
         if instruments is not None:
-            self._data_source.remove_instruments_from_subscription(
-                subscription_type, [instruments] if isinstance(instruments, Instrument) else list(instruments)
-            )
+            _instruments = [instruments] if isinstance(instruments, Instrument) else list(instruments)
+            self._data_source.remove_instruments_from_subscription(subscription_type, _instruments)
+
+            # - Clear last quotes for unsubscribed instruments
+            for instr in _instruments:
+                # - clear last quote
+                self._last_quotes.pop(instr, None)
+
+                # - Notify simulating exchange that instrument is unsubscribed
+                self._account._exchange.on_unsubscribe(instr)
 
     def has_subscription(self, instrument: Instrument, subscription_type: str) -> bool:
         return self._data_source.has_subscription(instrument, subscription_type)
@@ -174,11 +200,11 @@ class SimulatedDataProvider(IDataProvider):
             high_price = r.data["high"]
             low_price = r.data["low"]
             close_price = r.data["close"]
-            
+
             # Skip this record if any OHLC value is None
             if open_price is None or high_price is None or low_price is None or close_price is None:
                 continue
-            
+
             bars.append(
                 Bar(
                     _b_ts_0,

{qubx-0.7.8 → qubx-0.7.25}/src/qubx/backtester/management.py

@@ -382,7 +382,7 @@ class BacktestsResultsManager:
                     _mtrx[_nm] = v.get("performance", {})
 
                 _m_repr = pd.DataFrame.from_dict(_mtrx, orient="index")[
-                    ["gain", "cagr", "sharpe", "qr", "max_dd_pct", "mdd_usd", "fees", "execs"]
+                    ["gain", "cagr", "sharpe", "qr", "mdd_pct", "mdd_usd", "fees", "execs"]
                 ].astype(float)
                 _m_repr = _m_repr.round(3)
                 _m_repr = _m_repr.sort_values(by=sort_by, ascending=ascending) if sort_by else _m_repr

{qubx-0.7.8 → qubx-0.7.25}/src/qubx/backtester/ome.py

@@ -79,8 +79,11 @@ class OrdersManagementEngine:
         self.active_orders = dict()
         self.stop_orders = dict()
         self.bbo = None
-        self.__order_id = 100000
-        self.__trade_id = 100000
+        # - 2025-12-09: OME always started with fixed order_id / trade_id
+        #   executions stopped to be accounted in portfolio when OME re-created
+        _start_id = int(time_provider.time().view("i8")) + 1000
+        self.__order_id = _start_id
+        self.__trade_id = _start_id
         self._fill_stops_at_price = fill_stop_order_at_price
         self._tick_size = instrument.tick_size
         self._last_update_time = np.datetime64(0, "ns")

{qubx-0.7.8 → qubx-0.7.25}/src/qubx/backtester/runner.py

@@ -16,6 +16,7 @@ from qubx.core.initializer import BasicStrategyInitializer
 from qubx.core.interfaces import (
     CtrlChannel,
     IDataProvider,
+    IHealthMonitor,
     IMetricEmitter,
     IStrategy,
     IStrategyContext,
@@ -26,6 +27,7 @@ from qubx.core.interfaces import (
 from qubx.core.loggers import StrategyLogging
 from qubx.core.lookups import lookup
 from qubx.data.helpers import CachedPrefetchReader
+from qubx.health import DummyHealthMonitor
 from qubx.loggers.inmemory import InMemoryLogsWriter
 from qubx.pandaz.utils import _frame_to_str
 from qubx.utils.time import now_ns
@@ -140,18 +142,20 @@ class SimulationRunner:
 
         self._prefetch_aux_data()
 
-        # Start the context
+        # - Apply warmup periods before the start
+        # - merge default warmups with strategy warmups (strategy warmups take precedence)
+        _merged_warmups = {
+            **(self.data_config.default_warmups or {}),
+            **self.ctx.initializer.get_subscription_warmup(),
+        }
+        if _merged_warmups:
+            logger.debug(f"[<y>SimulationRunner</y>] :: Setting warmups: {_merged_warmups}")
+            self.ctx.set_warmup(_merged_warmups)
+
+        # - Start the context
         self.ctx.start()
 
-        # Apply default warmup periods if strategy didn't set them
-        for s in self.ctx.get_subscriptions():
-            if not self.ctx.get_warmup(s) and (_d_wt := self.data_config.default_warmups.get(s)):
-                logger.debug(
-                    f"[<y>SimulationRunner</y>] :: Strategy didn't set warmup period for <c>{s}</c> so default <c>{_d_wt}</c> will be used"
-                )
-                self.ctx.set_warmup({s: _d_wt})
-
-        # Subscribe to any custom data types if needed
+        # - Subscribe to any custom data types if needed
         def _is_known_type(t: str):
             try:
                 DataType(t)
@@ -387,9 +391,14 @@ class SimulationRunner:
 
         channel = SimulatedCtrlChannel("databus", sentinel=(None, None, None, None))
         simulated_clock = SimulatedTimeProvider(np.datetime64(self.start, "ns"))
+        health_monitor = DummyHealthMonitor()
 
         account = self._construct_account_processor(
-            self.setup.exchanges, self.setup.commissions, simulated_clock, channel
+            self.setup.exchanges,
+            self.setup.commissions,
+            simulated_clock,
+            channel,
+            health_monitor,
         )
 
         scheduler = SimulatedScheduler(channel, lambda: simulated_clock.time().item())
@@ -528,6 +537,7 @@ class SimulationRunner:
         commissions: str | dict[str, str | None] | None,
         time_provider: ITimeProvider,
         channel: CtrlChannel,
+        health_monitor: IHealthMonitor,
     ) -> CompositeAccountProcessor:
         _exchange_to_tcc = self._construct_tcc(exchanges, commissions)
         for tcc in _exchange_to_tcc.values():
@@ -555,7 +565,9 @@ class SimulationRunner:
                 account_id=self.account_id,
                 exchange=_exchange_to_simulated_exchange[exchange],
                 channel=channel,
+                health_monitor=health_monitor,
                 base_currency=self.setup.base_currency,
+                exchange_name=exchange,
                 initial_capital=_initial_capital,
             )
 

{qubx-0.7.8 → qubx-0.7.25}/src/qubx/backtester/simulated_exchange.py

@@ -47,6 +47,10 @@ class ISimulatedExchange:
 
     def get_open_orders(self, instrument: Instrument | None = None) -> dict[str, Order]: ...
 
+    def on_unsubscribe(self, instrument: Instrument) -> None: ...
+
+    def on_subscribe(self, instrument: Instrument) -> None: ...
+
     def process_market_data(
         self, instrument: Instrument, data: Quote | OrderBook | Trade | TradeArray
     ) -> Generator[SimulatedExecutionReport]: ...
@@ -93,6 +97,7 @@ class BasicSimulatedExchange(ISimulatedExchange):
     """
 
     _ome: dict[Instrument, OrdersManagementEngine]
+    _half_tick_size: dict[Instrument, float]
     _order_to_instrument: dict[str, Instrument]
     _fill_stop_order_at_price: bool
     _time_provider: ITimeProvider
@@ -112,6 +117,7 @@ class BasicSimulatedExchange(ISimulatedExchange):
         self._fill_stop_order_at_price = accurate_stop_orders_execution
         self._time_provider = time_provider
         self._tcc = tcc
+
         if self._fill_stop_order_at_price:
             logger.info(
                 f"[<y>{self.__class__.__name__}</y>] :: emulation of stop orders executions at exact price is ON"
@@ -193,6 +199,23 @@ class BasicSimulatedExchange(ISimulatedExchange):
 
         return {o.id: o for ome in self._ome.values() for o in ome.get_open_orders()}
 
+    def on_unsubscribe(self, instrument: Instrument) -> None:
+        """
+        Called when an instrument is unsubscribed.
+        """
+        # - clears the OME to remove stale BBO data.
+        self._ome.pop(instrument, None)
+        self._half_tick_size.pop(instrument, None)
+
+    def on_subscribe(self, instrument: Instrument) -> None:
+        """
+        Called when new instrument is subscribed.
+        """
+        # - just for sanity: remove OME for this instrument if it wasn't removed in on_unsubscribe call
+        if instrument in self._ome:
+            self._ome.pop(instrument, None)
+            self._half_tick_size.pop(instrument, None)
+
     def _get_ome(self, instrument: Instrument) -> OrdersManagementEngine:
         if (ome := self._ome.get(instrument)) is None:
             self._half_tick_size[instrument] = instrument.tick_size / 2  # type: ignore

{qubx-0.7.8 → qubx-0.7.25}/src/qubx/backtester/transfers.py

@@ -63,11 +63,13 @@ class SimulationTransferManager(ITransferManager):
             raise ValueError(f"Exchange not found: {e}")
 
         # Validate sufficient funds
-        from_balances = from_processor.get_balances()
-        if currency not in from_balances:
+        from_balances_list = from_processor.get_balances()
+        from_balance = next((b for b in from_balances_list if b.currency == currency), None)
+
+        if from_balance is None:
             raise ValueError(f"Currency '{currency}' not found in {from_exchange}")
 
-        available = from_balances[currency].free
+        available = from_balance.free
         if available < amount:
             raise ValueError(
                 f"Insufficient funds in {from_exchange}: "
@@ -75,12 +77,15 @@ class SimulationTransferManager(ITransferManager):
             )
 
         # Execute transfer (instant balance manipulation)
-        from_balances[currency].total -= amount
-        from_balances[currency].free -= amount
+        from_balance.total -= amount
+        from_balance.free -= amount
+
+        to_balances_list = to_processor.get_balances()
+        to_balance = next((b for b in to_balances_list if b.currency == currency), None)
 
-        to_balances = to_processor.get_balances()
-        to_balances[currency].total += amount
-        to_balances[currency].free += amount
+        total_amount = to_balance.total + amount if to_balance is not None else amount
+        locked_amount = to_balance.locked if to_balance is not None else 0
+        to_processor.update_balance(currency, total_amount, locked_amount, to_exchange)
 
         # Record transfer
         transfer_record = {

{qubx-0.7.8 → qubx-0.7.25}/src/qubx/backtester/utils.py

@@ -746,8 +746,15 @@ def _detect_defaults_from_subscriptions(
             _out_tf_tdelta, open_close_time_indent_secs
         )
 
-    # - default warmups
-    _warmups = {str(_base_subscr): time_delta_to_str(_get_default_warmup_period(_base_subscr, _in_base_tf).asm8.item())}
+    # - default warmups - populate for all subscription types in readers
+    _warmups = {}
+    for _sub_type in _t_readers.keys():
+        _sub_tf = _tf(_sub_type)  # - extract timeframe if exists (None for quote/trade/orderbook)
+        _warmups[str(_sub_type)] = time_delta_to_str(_get_default_warmup_period(str(_sub_type), _sub_tf).asm8.item())
+
+    # - ensure base subscription has warmup (in case it's not in readers)
+    if str(_base_subscr) not in _warmups:
+        _warmups[str(_base_subscr)] = time_delta_to_str(_get_default_warmup_period(_base_subscr, _in_base_tf).asm8.item())
 
     return SimulationDataConfig(
         _default_trigger_schedule,

{qubx-0.7.8 → qubx-0.7.25}/src/qubx/cli/commands.py

@@ -34,8 +34,9 @@ def main(debug: bool, debug_port: int, log_level: str):
     """
     # Suppress syntax warnings from AST parsing during import resolution
     import warnings
+
     warnings.filterwarnings("ignore", category=SyntaxWarning)
-    
+
     os.environ["PYDEVD_DISABLE_FILE_VALIDATION"] = "1"
     log_level = log_level.upper() if not debug else "DEBUG"
 
@@ -69,23 +70,29 @@ def main(debug: bool, debug_port: int, log_level: str):
 @click.option(
     "--jupyter", "-j", is_flag=True, default=False, help="Run strategy in jupyter console.", show_default=True
 )
+@click.option("--textual", "-t", is_flag=True, default=False, help="Run strategy in textual TUI.", show_default=True)
 @click.option(
-    "--textual", "-t", is_flag=True, default=False, help="Run strategy in textual TUI.", show_default=True
-)
-@click.option(
-    "--textual-dev", is_flag=True, default=False, help="Enable Textual dev mode (use with 'textual console').", show_default=True
-)
-@click.option(
-    "--textual-web", is_flag=True, default=False, help="Serve Textual app in web browser.", show_default=True
-)
-@click.option(
-    "--textual-port", type=int, default=None, help="Port for Textual (web server: 8000, devtools: 8081).", show_default=False
+    "--textual-dev",
+    is_flag=True,
+    default=False,
+    help="Enable Textual dev mode (use with 'textual console').",
+    show_default=True,
 )
+@click.option("--textual-web", is_flag=True, default=False, help="Serve Textual app in web browser.", show_default=True)
 @click.option(
-    "--textual-host", type=str, default="0.0.0.0", help="Host for Textual web server.", show_default=True
+    "--textual-port",
+    type=int,
+    default=None,
+    help="Port for Textual (web server: 8000, devtools: 8081).",
+    show_default=False,
 )
+@click.option("--textual-host", type=str, default="0.0.0.0", help="Host for Textual web server.", show_default=True)
 @click.option(
-    "--kernel-only", is_flag=True, default=False, help="Start kernel without UI (returns connection file).", show_default=True
+    "--kernel-only",
+    is_flag=True,
+    default=False,
+    help="Start kernel without UI (returns connection file).",
+    show_default=True,
 )
 @click.option(
     "--connect", type=Path, default=None, help="Connect to existing kernel via connection file.", show_default=False
@@ -94,7 +101,21 @@ def main(debug: bool, debug_port: int, log_level: str):
     "--restore", "-r", is_flag=True, default=False, help="Restore strategy state from previous run.", show_default=True
 )
 @click.option("--no-color", is_flag=True, default=False, help="Disable colored logging output.", show_default=True)
-def run(config_file: Path, account_file: Path | None, paper: bool, jupyter: bool, textual: bool, textual_dev: bool, textual_web: bool, textual_port: int | None, textual_host: str, kernel_only: bool, connect: Path | None, restore: bool, no_color: bool):
+def run(
+    config_file: Path,
+    account_file: Path | None,
+    paper: bool,
+    jupyter: bool,
+    textual: bool,
+    textual_dev: bool,
+    textual_web: bool,
+    textual_port: int | None,
+    textual_host: str,
+    kernel_only: bool,
+    connect: Path | None,
+    restore: bool,
+    no_color: bool,
+):
     """
     Starts the strategy with the given configuration file. If paper mode is enabled, account is not required.
 
@@ -138,6 +159,7 @@ def run(config_file: Path, account_file: Path | None, paper: bool, jupyter: bool
         # Keep the process alive until interrupted
         try:
             import signal
+
             signal.pause()
         except KeyboardInterrupt:
             click.echo("\nShutting down kernel...")
@@ -152,7 +174,9 @@ def run(config_file: Path, account_file: Path | None, paper: bool, jupyter: bool
     if jupyter:
         run_strategy_yaml_in_jupyter(config_file, account_file, paper, restore)
     elif textual:
-        run_strategy_yaml_in_textual(config_file, account_file, paper, restore, textual_dev, textual_web, textual_port, textual_host, connect)
+        run_strategy_yaml_in_textual(
+            config_file, account_file, paper, restore, textual_dev, textual_web, textual_port, textual_host, connect
+        )
     else:
         logo()
         run_strategy_yaml(config_file, account_file, paper=paper, restore=restore, blocking=True, no_color=no_color)
@@ -169,7 +193,10 @@ def run(config_file: Path, account_file: Path | None, paper: bool, jupyter: bool
 @click.option(
     "--output", "-o", default="results", type=str, help="Output directory for simulation results.", show_default=True
 )
-def simulate(config_file: Path, start: str | None, end: str | None, output: str | None):
+@click.option(
+    "--report", "-r", default=None, type=str, help="Output directory for simulation reports.", show_default=True
+)
+def simulate(config_file: Path, start: str | None, end: str | None, output: str | None, report: str | None):
     """
     Simulates the strategy with the given configuration file.
     """
@@ -179,7 +206,7 @@ def simulate(config_file: Path, start: str | None, end: str | None, output: str
     add_project_to_system_path()
     add_project_to_system_path(str(config_file.parent))
     logo()
-    simulate_strategy(config_file, output, start, end)
+    simulate_strategy(config_file, output, start, end, report)
 
 
 @main.command()
@@ -457,32 +484,32 @@ def init(
 ):
     """
     Create a new strategy from a template.
-    
+
     This command generates a complete strategy project structure with:
     - Strategy class implementing IStrategy interface
     - Configuration file for qubx run command
     - Package structure for proper imports
-    
+
     The generated strategy can be run immediately with:
     poetry run qubx run --config config.yml --paper
     """
     from qubx.templates import TemplateError, TemplateManager
-    
+
     try:
         manager = TemplateManager()
-        
+
         if list_templates:
             templates = manager.list_templates()
             if not templates:
                 click.echo("No templates available.")
                 return
-            
+
             click.echo("Available templates:")
             for template_name, metadata in templates.items():
                 description = metadata.get("description", "No description")
                 click.echo(f"  {template_name:<15} - {description}")
             return
-        
+
         # Generate strategy
         strategy_path = manager.generate_strategy(
             template_name=template if not template_path else None,
@@ -493,7 +520,7 @@ def init(
             symbols=symbols,
             timeframe=timeframe,
         )
-        
+
         click.echo(f"✅ Strategy '{name}' created successfully!")
         click.echo(f"📁 Location: {strategy_path}")
         click.echo()
@@ -503,7 +530,7 @@ def init(
         click.echo()
         click.echo("To run in Jupyter mode:")
         click.echo("  ./jpaper.sh")
-        
+
     except TemplateError as e:
         click.echo(f"❌ Template error: {e}", err=True)
         raise click.Abort()