Qubx 0.6.14__cp312-cp312-manylinux_2_39_x86_64.whl → 0.6.17__cp312-cp312-manylinux_2_39_x86_64.whl

qubx/backtester/broker.py

@@ -57,6 +57,19 @@ class SimulatedBroker(IBroker):
         self._send_exec_report(instrument, report)
         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 cancel_order(self, order_id: str) -> Order | None:
         instrument = self._account.order_to_instrument.get(order_id)
         if instrument is None:

qubx/backtester/runner.py

@@ -248,6 +248,9 @@ class SimulationRunner:
             initializer=self.initializer,
         )
 
+        if self.emitter is not None:
+            self.emitter.set_time_provider(simulated_clock)
+
         # - setup base subscription from spec
         if ctx.get_base_subscription() == DataType.NONE:
             logger.debug(

qubx/backtester/simulator.py

@@ -8,6 +8,8 @@ from qubx.core.exceptions import SimulationError
 from qubx.core.metrics import TradingSessionResult
 from qubx.data.readers import DataReader
 from qubx.utils.misc import ProgressParallel, Stopwatch, get_current_user
+from qubx.utils.runner.configs import EmissionConfig
+from qubx.utils.runner.factory import create_metric_emitters
 from qubx.utils.time import handle_start_stop
 
 from .runner import SimulationRunner
@@ -45,6 +47,7 @@ def simulate(
     show_latency_report: bool = False,
     portfolio_log_freq: str = "5Min",
     parallel_backend: Literal["loky", "multiprocessing"] = "multiprocessing",
+    emission: EmissionConfig | None = None,
 ) -> list[TradingSessionResult]:
     """
     Backtest utility for trading strategies or signals using historical data.
@@ -67,6 +70,9 @@ def simulate(
         - open_close_time_indent_secs (int): Time indent in seconds for open/close times, default is 1.
         - debug (Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] | None): Logging level for debugging.
         - show_latency_report: If True, shows simulator's latency report.
+        - portfolio_log_freq (str): Frequency for portfolio logging, default is "5Min".
+        - parallel_backend (Literal["loky", "multiprocessing"]): Backend for parallel processing, default is "multiprocessing".
+        - emission (EmissionConfig | None): Configuration for metric emitters, default is None.
 
     Returns:
         - list[TradingSessionResult]: A list of TradingSessionResult objects containing the results of each simulation setup.
@@ -139,6 +145,7 @@ def simulate(
         show_latency_report=show_latency_report,
         portfolio_log_freq=portfolio_log_freq,
         parallel_backend=parallel_backend,
+        emission=emission,
     )
 
 
@@ -152,6 +159,7 @@ def _run_setups(
     show_latency_report: bool = False,
     portfolio_log_freq: str = "5Min",
     parallel_backend: Literal["loky", "multiprocessing"] = "multiprocessing",
+    emission: EmissionConfig | None = None,
 ) -> list[TradingSessionResult]:
     # loggers don't work well with joblib and multiprocessing in general because they contain
     # open file handlers that cannot be pickled. I found a solution which requires the usage of enqueue=True
@@ -165,7 +173,16 @@ def _run_setups(
         n_jobs=n_jobs, total=len(strategies_setups), silent=_main_loop_silent, backend=parallel_backend
     )(
         delayed(_run_setup)(
-            id, f"Simulated-{id}", setup, data_setup, start, stop, silent, show_latency_report, portfolio_log_freq
+            id,
+            f"Simulated-{id}",
+            setup,
+            data_setup,
+            start,
+            stop,
+            silent,
+            show_latency_report,
+            portfolio_log_freq,
+            emission,
         )
         for id, setup in enumerate(strategies_setups)
     )
@@ -182,7 +199,13 @@ def _run_setup(
     silent: bool,
     show_latency_report: bool,
     portfolio_log_freq: str,
+    emission: EmissionConfig | None = None,
 ) -> TradingSessionResult:
+    # Create metric emitter if configured
+    emitter = None
+    if emission is not None:
+        emitter = create_metric_emitters(emission, setup.name)
+
     runner = SimulationRunner(
         setup=setup,
         data_config=data_setup,
@@ -190,6 +213,7 @@ def _run_setup(
         stop=stop,
         account_id=account_id,
         portfolio_log_freq=portfolio_log_freq,
+        emitter=emitter,
     )
 
     # - we want to see simulate time in log messages

qubx/cli/commands.py

@@ -140,16 +140,16 @@ def ls(directory: str):
     callback=lambda ctx, param, value: os.path.abspath(os.path.expanduser(value)),
 )
 @click.option(
-    "--strategy",
-    "-s",
-    type=click.STRING,
-    help="Strategy name to release (should match the strategy class name) or path to a config YAML file",
+    "--config",
+    "-c",
+    type=click.Path(exists=True, resolve_path=True),
+    help="Path to a config YAML file",
     required=True,
 )
 @click.option(
     "--output-dir",
     "-o",
-    type=click.STRING,
+    type=click.Path(exists=False),
     help="Output directory to put zip file.",
     default=".releases",
     show_default=True,
@@ -172,7 +172,6 @@ def ls(directory: str):
 )
 @click.option(
     "--commit",
-    "-c",
     is_flag=True,
     default=False,
     help="Commit changes and create tag in repo (default: False)",
@@ -180,7 +179,7 @@ def ls(directory: str):
 )
 def release(
     directory: str,
-    strategy: str,
+    config: str,
     tag: str | None,
     message: str | None,
     commit: bool,
@@ -189,16 +188,9 @@ def release(
     """
     Releases the strategy to a zip file.
 
-    The strategy can be specified in two ways:
-    1. As a strategy name (class name) - strategies are scanned in the given directory (NOT SUPPORTED ANYMORE !)
-    2. As a path to a config YAML file containing the strategy configuration in StrategyConfig format
-
-    If a strategy name is provided, a default configuration will be generated with:
-    - The strategy parameters from the strategy class
-    - Default exchange, connector, and instruments from the command options
-    - Standard logging configuration
+    The strategy is specified by a path to a config YAML file containing the strategy configuration in StrategyConfig format.
 
-    If a config file is provided, it must follow the StrategyConfig structure with:
+    The config file must follow the StrategyConfig structure with:
     - strategy: The strategy name or path
     - parameters: Dictionary of strategy parameters
     - exchanges: Dictionary of exchange configurations
@@ -211,7 +203,7 @@ def release(
 
     release_strategy(
         directory=directory,
-        strategy_name=strategy,
+        config_file=config,
         tag=tag,
         message=message,
         commit=commit,

qubx/cli/release.py

@@ -16,7 +16,6 @@ from qubx import logger
 from qubx.utils.misc import (
     cyan,
     generate_name,
-    get_local_qubx_folder,
     green,
     load_qubx_resources_as_text,
     magenta,
@@ -265,7 +264,7 @@ def load_strategy_from_config(config_path: Path, directory: str) -> StrategyInfo
 
 def release_strategy(
     directory: str,
-    strategy_name: str,
+    config_file: str,
     tag: str | None,
     message: str | None,
     commit: bool,
@@ -276,7 +275,7 @@ def release_strategy(
 
     Args:
         directory: str - directory to scan for strategies
-        strategy_name: str - strategy name to release or path to config file
+        config_file: str - path to config file
         tag: str - additional tag for this release
         message: str - release message
         commit: bool - commit changes and create tag in repo
@@ -288,29 +287,12 @@ def release_strategy(
 
     try:
         # - determine if strategy_name is a config file or a strategy name
-        if is_config_file(strategy_name):
-            # - load strategy from config file
-            logger.info(f"Loading strategy from config file: {strategy_name}")
-            stg_info = load_strategy_from_config(Path(strategy_name), directory)
-        else:
-            # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-            # TODO: generate default config from strategy class ? Do we really need it at all ?
-            # - find strategy by name
-            # logger.info(f"Looking for '{strategy_name}' strategy")
-
-            # strat_name = "_".join([x.split(".")[-1] for x in strategy_class_names])
-            # stg_info = StrategyInfo(name=strategy_name, classes=[find_class_by_name(directory, strategy_name)])
-
-            # stg_info = find_class_by_name(directory, strategy_name)
+        if not is_config_file(config_file):
+            raise ValueError("Try using yaml config file path")
 
-            # - generate default config
-            # strategy_config = generate_default_config(
-            # stg_info, default_exchange, default_connector, default_instruments
-            # )
-            # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-            raise ValueError(
-                "!!! Release of strategy by name is not supported anymore ! Try to use config file instead !!!"
-            )
+        # - load strategy from config file
+        logger.info(f"Loading strategy from config file: {config_file}")
+        stg_info = load_strategy_from_config(Path(config_file), directory)
 
         # - process git repo and pyproject.toml for each strategy component
         repos_paths = set()
@@ -413,9 +395,8 @@ def _save_strategy_config(stg_name: str, strategy_config: StrategyConfig, releas
 
 def _copy_strategy_file(strategy_path: str, pyproject_root: str, release_dir: str) -> None:
     """Copy the strategy file to the release directory."""
-    src_dir = os.path.basename(pyproject_root)
     rel_path = os.path.relpath(strategy_path, pyproject_root)
-    dest_file_path = os.path.join(release_dir, src_dir, rel_path)
+    dest_file_path = os.path.join(release_dir, rel_path)
 
     # Ensure the destination directory exists
     os.makedirs(os.path.dirname(dest_file_path), exist_ok=True)
@@ -428,11 +409,9 @@ def _copy_strategy_file(strategy_path: str, pyproject_root: str, release_dir: st
 def _try_copy_file(src_file: str, dest_dir: str, pyproject_root: str) -> None:
     """Try to copy the file to the release directory."""
     if os.path.exists(src_file):
-        _src_dir = os.path.basename(pyproject_root)
-
         # Get the relative path from pyproject_root
         _rel_import_path = os.path.relpath(src_file, pyproject_root)
-        _dest_import_path = os.path.join(dest_dir, _src_dir, _rel_import_path)
+        _dest_import_path = os.path.join(dest_dir, _rel_import_path)
 
         # Ensure the destination directory exists
         os.makedirs(os.path.dirname(_dest_import_path), exist_ok=True)
@@ -446,10 +425,22 @@ def _copy_dependencies(strategy_path: str, pyproject_root: str, release_dir: str
     """Copy all dependencies required by the strategy."""
     _src_dir = os.path.basename(pyproject_root)
     _imports = _get_imports(strategy_path, pyproject_root, [_src_dir])
+    # find inside of the pyproject_root a folder with the same name as the _src_dir
+    # for instance it could be like macd_crossover/src/macd_crossover
+    # or macd_crossover/macd_crossover
+    # and assign this folder to _src_root
+    _src_root = None
+    for root, dirs, files in os.walk(pyproject_root):
+        if _src_dir in dirs:
+            _src_root = os.path.join(root, _src_dir)
+            break
+
+    if _src_root is None:
+        raise ValueError(f"Could not find the source root for {_src_dir} in {pyproject_root}")
 
     for _imp in _imports:
         # Construct source path
-        _base = os.path.join(pyproject_root, *[s for s in _imp.module if s != _src_dir])
+        _base = os.path.join(_src_root, *[s for s in _imp.module if s != _src_dir])
 
         # - try to copy all available files for satisfying the import
         if os.path.isdir(_base):
@@ -521,7 +512,7 @@ def _modify_pyproject_toml(pyproject_path: str, package_name: str) -> None:
                         deps[d] = f">={version(d)}"
 
             # Replace the packages section with the new one
-            pyproject_data["tool"]["poetry"]["packages"] = [{"include": package_name}]
+            # pyproject_data["tool"]["poetry"]["packages"] = [{"include": package_name}]
 
             # Check if build section exists
             if "build" not in pyproject_data["tool"]["poetry"]:
@@ -632,7 +623,7 @@ def _handle_project_files(pyproject_root: str, release_dir: str) -> None:
     # Copy build.py if it exists
     build_src = os.path.join(pyproject_root, "build.py")
     if not os.path.exists(build_src):
-        logger.warning(f"build.py not found in {pyproject_root} using default one")
+        logger.info(f"build.py not found in {pyproject_root} using default one")
         build_src = load_qubx_resources_as_text("_build.py")
 
         # - setup project's name in default build.py

qubx/connectors/ccxt/account.py

@@ -77,6 +77,8 @@ class CcxtAccountProcessor(BasicAccountProcessor):
         balance_interval: str = "30Sec",
         position_interval: str = "30Sec",
         subscription_interval: str = "10Sec",
+        open_order_interval: str = "1Min",
+        open_order_backoff: str = "1Min",
         max_position_restore_days: int = 30,
         max_retries: int = 10,
     ):
@@ -93,6 +95,8 @@ class CcxtAccountProcessor(BasicAccountProcessor):
         self.balance_interval = balance_interval
         self.position_interval = position_interval
         self.subscription_interval = subscription_interval
+        self.open_order_interval = open_order_interval
+        self.open_order_backoff = open_order_backoff
         self.max_position_restore_days = max_position_restore_days
         self._loop = AsyncThreadLoop(exchange.asyncio_loop)
         self._is_running = False
@@ -140,11 +144,17 @@ class CcxtAccountProcessor(BasicAccountProcessor):
             logger.info("Account polling tasks have been initialized")
 
         # - start subscription polling task
-        self._polling_tasks["subscription"] = self._loop.submit(
-            self._poller("subscription", self._update_subscriptions, self.subscription_interval)
-        )
+        # self._polling_tasks["subscription"] = self._loop.submit(
+        #     self._poller("subscription", self._update_subscriptions, self.subscription_interval)
+        # )
         # - subscribe to order executions
         self._polling_tasks["executions"] = self._loop.submit(self._subscribe_executions("executions", channel))
+        # - sync open orders
+        self._polling_tasks["open_orders"] = self._loop.submit(
+            self._poller(
+                "open_orders", self._sync_open_orders, self.open_order_interval, backoff=self.open_order_backoff
+            )
+        )
 
     def stop(self):
         """Stop all polling tasks"""
@@ -188,10 +198,15 @@ class CcxtAccountProcessor(BasicAccountProcessor):
         name: str,
         coroutine: Callable[[], Awaitable],
         interval: str,
+        backoff: str | None = None,
     ):
         sleep_time = pd.Timedelta(interval).total_seconds()
         retries = 0
 
+        if backoff is not None:
+            sleep_time = pd.Timedelta(backoff).total_seconds()
+            await asyncio.sleep(sleep_time)
+
         while self.channel.control.is_set():
             try:
                 await coroutine()
@@ -276,7 +291,7 @@ class CcxtAccountProcessor(BasicAccountProcessor):
     async def _update_positions(self) -> None:
         # fetch and update positions from exchange
         ccxt_positions = await self.exchange.fetch_positions()
-        positions = ccxt_convert_positions(ccxt_positions, self.exchange.name, self.exchange.markets)
+        positions = ccxt_convert_positions(ccxt_positions, self.exchange.name, self.exchange.markets)  # type: ignore
         # update required instruments that we need to subscribe to
         self._required_instruments.update([p.instrument for p in positions])
         # update positions
@@ -388,7 +403,10 @@ class CcxtAccountProcessor(BasicAccountProcessor):
     async def _init_open_orders(self) -> None:
         # wait for balances and positions to be initialized
         await self._wait(lambda: all([self._polling_to_init[task] for task in ["balance", "position"]]))
-        logger.debug("Fetching open orders ...")
+        await self._sync_open_orders(initial_call=True)
+
+    async def _sync_open_orders(self, initial_call: bool = False) -> None:
+        logger.debug("[SYNC] Fetching open orders ...")
 
         # in order to minimize order requests we only fetch open orders for instruments that we have positions in
         _nonzero_balances = {
@@ -405,20 +423,50 @@ class CcxtAccountProcessor(BasicAccountProcessor):
                 _orders = await self._fetch_orders(instrument, is_open=True)
                 _open_orders.update(_orders)
             except Exception as e:
-                logger.warning(f"Error fetching open orders for {instrument}: {e}")
+                logger.warning(f"[SYNC] Error fetching open orders for {instrument}: {e}")
 
         await asyncio.gather(*[_add_open_orders(i) for i in _instruments])
 
-        self.add_active_orders(_open_orders)
-
-        logger.debug(f"Found {len(_open_orders)} open orders ->")
-        _instr_to_open_orders: dict[Instrument, list[Order]] = defaultdict(list)
-        for od in _open_orders.values():
-            _instr_to_open_orders[od.instrument].append(od)
-        for instr, orders in _instr_to_open_orders.items():
-            logger.debug(f"  ::  {instr} ->")
-            for order in orders:
-                logger.debug(f"    :: {order.side} {order.quantity} @ {order.price} ({order.status})")
+        if initial_call:
+            # - when it's the initial call, we add the open orders to the account
+            self.add_active_orders(_open_orders)
+            logger.debug(f"[SYNC] Found {len(_open_orders)} open orders ->")
+            _instr_to_open_orders: dict[Instrument, list[Order]] = defaultdict(list)
+            for od in _open_orders.values():
+                _instr_to_open_orders[od.instrument].append(od)
+            for instr, orders in _instr_to_open_orders.items():
+                logger.debug(f"  :: [SYNC] {instr} ->")
+                for order in orders:
+                    logger.debug(f"    :: [SYNC] {order.side} {order.quantity} @ {order.price} ({order.status})")
+        else:
+            # TODO: think if this should actually be here
+            # - we need to cancel the unexpected orders
+            await self._cancel_unexpected_orders(_open_orders)
+
+    async def _cancel_unexpected_orders(self, open_orders: dict[str, Order]) -> None:
+        _expected_orders = set(self._active_orders.keys())
+        _unexpected_orders = set(open_orders.keys()) - _expected_orders
+        if _unexpected_orders:
+            logger.info(f"[SYNC] Canceling {len(_unexpected_orders)} unexpected open orders ...")
+            _instr_to_orders = defaultdict(list)
+            for _id in _unexpected_orders:
+                _order = open_orders[_id]
+                _instr_to_orders[_order.instrument].append(_order)
+
+            async def _cancel_order(order: Order) -> None:
+                try:
+                    await self.exchange.cancel_order(order.id, symbol=instrument_to_ccxt_symbol(order.instrument))
+                    logger.debug(
+                        f"  :: [SYNC] Canceled {order.id} {order.instrument.symbol} {order.side} {order.quantity} @ {order.price} ({order.status})"
+                    )
+                except Exception as e:
+                    logger.warning(f"[SYNC] Error canceling order {order.id}: {e}")
+
+            for instr, orders in _instr_to_orders.items():
+                logger.debug(
+                    f"[SYNC] Canceling {len(orders)} (out of {len(open_orders)}) unexpected open orders for {instr}"
+                )
+                await asyncio.gather(*[_cancel_order(order) for order in orders])
 
     async def _fetch_orders(
         self, instrument: Instrument, days_before: int = 30, limit: int | None = None, is_open: bool = False