Qubx 0.6.50__tar.gz → 0.6.53__tar.gz

{qubx-0.6.50 → qubx-0.6.53}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: Qubx
-Version: 0.6.50
+Version: 0.6.53
 Summary: Qubx - Quantitative Trading Framework
 Author: Dmitry Marienko
 Author-email: dmitry.marienko@xlydian.com

{qubx-0.6.50 → qubx-0.6.53}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "Qubx"
-version = "0.6.50"
+version = "0.6.53"
 description = "Qubx - Quantitative Trading Framework"
 authors = [ "Dmitry Marienko <dmitry.marienko@xlydian.com>", "Yuriy Arabskyy <yuriy.arabskyy@xlydian.com>",]
 readme = "README.md"

{qubx-0.6.50 → qubx-0.6.53}/src/qubx/core/mixins/processing.py

@@ -383,7 +383,7 @@ class ProcessingManager(IProcessingManager):
                     missing_symbols = [inst.symbol for inst in missing_instruments]
                     logger.info(
                         f"Phase 1: Waiting for all instruments ({ready_instruments}/{total_instruments} ready). "
-                        f"Missing: {missing_symbols}. Timeout in {self.DATA_READY_TIMEOUT_SECONDS - elapsed_time_seconds:.1f}s"
+                        f"Missing: {missing_symbols}. Timeout in {self.DATA_READY_TIMEOUT_SECONDS - elapsed_time_seconds}s"
                     )
                 return False
         else:

{qubx-0.6.50 → qubx-0.6.53}/src/qubx/core/mixins/universe.py

@@ -114,11 +114,12 @@ class UniverseManager(IUniverseManager):
                 self._removal_queue.pop(instr)
 
     def add_instruments(self, instruments: list[Instrument]):
-        self.__do_add_instruments(instruments)
+        to_add = list(set([instr for instr in instruments if instr not in self._instruments]))
+        self.__do_add_instruments(to_add)
         self.__cleanup_removal_queue(instruments)
-        self._strategy.on_universe_change(self._context, instruments, [])
+        self._strategy.on_universe_change(self._context, to_add, [])
         self._subscription_manager.commit()
-        self._instruments.update(instruments)
+        self._instruments.update(to_add)
 
     def remove_instruments(
         self,

{qubx-0.6.50 → qubx-0.6.53}/src/qubx/data/composite.py

@@ -128,6 +128,12 @@ class IteratedDataStreamsSlicer(Iterator[SlicerOutData]):
                 data.extend(self._load_next_chunk_to_buffer(key))  # - get next chunk of data
             except StopIteration:
                 self._remove_iterator(key)
+                # Return empty list if no data is available
+                return values
+
+        # Check if data is still empty after attempting to load
+        if not data:
+            return values
 
         # pull most past elements
         v = data[-1]
@@ -139,6 +145,9 @@ class IteratedDataStreamsSlicer(Iterator[SlicerOutData]):
                 except StopIteration:
                     self._remove_iterator(key)
                     break
+                # Check if data is still empty after loading attempt
+                if not data:
+                    break
             v = data[-1]
 
         return values

{qubx-0.6.50 → qubx-0.6.53}/src/qubx/notifications/slack.py

@@ -5,6 +5,7 @@ This module provides a Slack implementation of IStrategyLifecycleNotifier.
 """
 
 import datetime
+import threading
 from concurrent.futures import ThreadPoolExecutor
 from typing import Any
 
@@ -52,6 +53,9 @@ class SlackLifecycleNotifier(IStrategyLifecycleNotifier):
         self._emoji_error = emoji_error
         self._throttler = throttler if throttler is not None else NoThrottling()
 
+        # Add a lock for thread-safe throttling operations
+        self._throttler_lock = threading.Lock()
+
         self._executor = ThreadPoolExecutor(max_workers=max_workers, thread_name_prefix="slack_notifier")
 
         logger.info(f"[SlackLifecycleNotifier] Initialized for environment '{environment}'")
@@ -75,10 +79,16 @@ class SlackLifecycleNotifier(IStrategyLifecycleNotifier):
             throttle_key: Optional key for throttling (if None, no throttling is applied)
         """
         try:
-            # Check if the message should be throttled
-            if throttle_key is not None and not self._throttler.should_send(throttle_key):
-                logger.debug(f"[SlackLifecycleNotifier] Throttled message with key '{throttle_key}': {message}")
-                return
+            # Thread-safe throttling check and registration
+            if throttle_key is not None:
+                with self._throttler_lock:
+                    if not self._throttler.should_send(throttle_key):
+                        logger.debug(f"[SlackLifecycleNotifier] Throttled message with key '{throttle_key}': {message}")
+                        return
+                    # Immediately register that we're about to send this message
+                    # This prevents race conditions where multiple threads check should_send
+                    # before any of them call register_sent
+                    self._throttler.register_sent(throttle_key)
 
             # Submit the task to the executor
             self._executor.submit(self._post_to_slack_impl, message, emoji, color, metadata, throttle_key)
@@ -132,10 +142,6 @@ class SlackLifecycleNotifier(IStrategyLifecycleNotifier):
             response = requests.post(self._webhook_url, json=data)
             response.raise_for_status()
 
-            # Register that we sent the message (for throttling)
-            if throttle_key is not None:
-                self._throttler.register_sent(throttle_key)
-
             logger.debug(f"[SlackLifecycleNotifier] Successfully posted message: {message}")
             return True
         except requests.RequestException as e:

{qubx-0.6.50 → qubx-0.6.53}/src/qubx/restarts/state_resolvers.py

@@ -55,7 +55,7 @@ class StateResolver:
                 elif abs(live_qty) > abs(sim_qty) and abs(live_qty) > instrument.lot_size:
                     qty_diff = sim_qty - live_qty
                     logger.info(
-                        f"Reducing position for {instrument.symbol}: {live_qty} -> {sim_qty} (diff: {qty_diff})"
+                        f"Reducing position for {instrument.symbol}: {live_qty} -> {sim_qty} (diff: {qty_diff:.4f})"
                     )
                     ctx.trade(instrument, qty_diff)
 
@@ -123,7 +123,7 @@ class StateResolver:
             # Only trade if there's a difference
             if abs(qty_diff) > instrument.lot_size:
                 logger.info(
-                    f"Syncing position for {instrument.symbol}: {live_qty} -> {sim_pos.quantity} (diff: {qty_diff})"
+                    f"Syncing position for {instrument.symbol}: {live_qty} -> {sim_pos.quantity} (diff: {qty_diff:.4f})"
                 )
                 ctx.trade(instrument, qty_diff)
 

{qubx-0.6.50 → qubx-0.6.53}/src/qubx/utils/runner/factory.py

@@ -298,7 +298,9 @@ def create_lifecycle_notifiers(
                 params[key] = resolve_env_vars(value)
 
             # Create throttler if configured or use default TimeWindowThrottler
-            if "SlackLifecycleNotifier" in notifier_class_name and "throttler" not in params:
+            if "SlackLifecycleNotifier" in notifier_class_name and (
+                "throttle" not in params or params["throttle"] is None
+            ):
                 # Import here to avoid circular imports
                 from qubx.notifications.throttler import TimeWindowThrottler
 

{qubx-0.6.50 → qubx-0.6.53}/src/qubx/utils/runner/runner.py

@@ -28,6 +28,7 @@ from qubx.core.basics import (
     CtrlChannel,
     Instrument,
     LiveTimeProvider,
+    Position,
     RestoredState,
     TransactionCostsCalculator,
 )
@@ -688,13 +689,21 @@ def _run_warmup(
     # - get the instruments from the warmup runner context
     _instruments = warmup_runner.ctx.instruments
     _positions = warmup_account.get_positions()
-    _positions = {k: v for k, v in _positions.items() if k in _instruments}
+    _positions = {k: v for k, v in _positions.items() if k in _instruments and v is not None and v.quantity is not None}
     _orders = warmup_account.get_orders()
     instrument_to_orders = defaultdict(list)
     for o in _orders.values():
         if o.instrument in _instruments:
             instrument_to_orders[o.instrument].append(o)
 
+    # - find instruments with nonzero positions from restored state and add them to the context
+    if restored_state is not None:
+        restored_positions = {k: p for k, p in restored_state.positions.items() if p.is_open()}
+        # - if there is no warmup position for a restored position, then create a new zero position
+        for pos in restored_positions.values():
+            if pos.instrument not in _positions:
+                _positions[pos.instrument] = Position(pos.instrument)
+
     # - set the warmup positions and orders
     ctx.set_warmup_positions(_positions)
     ctx.set_warmup_orders(instrument_to_orders)
@@ -766,6 +775,11 @@ def simulate_strategy(
             for a, c in cond.items():
                 conditions.append(dict2lambda(a, c))
 
+        # - if a parameter is of type list, then transform it to list of lists to avoid invalid variation
+        for k, v in cfg.parameters.items():
+            if isinstance(v, list):
+                cfg.parameters[k] = [v]
+
         experiments = variate(stg_cls, **(cfg.parameters | cfg.simulation.variate), conditions=conditions)
         experiments = {f"{simulation_name}.{_v_id}.[{k}]": v for k, v in experiments.items()}
         print(f"Parameters variation is configured. There are {len(experiments)} simulations to run.")