Qubx 0.6.10__tar.gz → 0.6.12__tar.gz

{qubx-0.6.10 → qubx-0.6.12}/PKG-INFO

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

{qubx-0.6.10 → qubx-0.6.12}/pyproject.toml

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

{qubx-0.6.10 → qubx-0.6.12}/src/qubx/core/basics.py

@@ -475,6 +475,7 @@ class Position:
             self.quantity = quantity
             self.position_avg_price = pos_average_price
             self.r_pnl = r_pnl
+            self.__pos_incr_qty = abs(quantity)
 
     def reset(self) -> None:
         """
@@ -539,6 +540,7 @@ class Position:
         deal_pnl = 0
         quantity = self.quantity
         comms = 0
+        # logger.info(f"{self.instrument.symbol} exec_price={exec_price} fee_amount={fee_amount} position={position}")
 
         if quantity != position:
             pos_change = position - quantity
@@ -550,13 +552,17 @@ class Position:
             qty_opening = pos_change if prev_direction == direction else pos_change - qty_closing
 
             # - extract realized part of PnL
-            if qty_closing != 0:
+            if not np.isclose(qty_closing, 0.0):
                 _abs_qty_close = abs(qty_closing)
                 deal_pnl = qty_closing * (self.position_avg_price - exec_price)
 
                 quantity += qty_closing
                 self.__pos_incr_qty -= _abs_qty_close
 
+                # logger.info(
+                #     f"{self.instrument.symbol} qty_closing={qty_closing} deal_pnl={deal_pnl} quantity={quantity} pos_incr_qty={self.__pos_incr_qty} position_avg_price={self.position_avg_price}"
+                # )
+
                 # - reset average price to 0 if smaller than minimal price change to avoid cumulative error
                 if abs(quantity) < self.instrument.lot_size:
                     quantity = 0.0
@@ -564,11 +570,17 @@ class Position:
                     self.__pos_incr_qty = 0
 
             # - if it has something to add to position let's update price and cost
-            if qty_opening != 0:
+            if not np.isclose(qty_opening, 0.0):
                 _abs_qty_open = abs(qty_opening)
+
+                # logger.info(
+                #     f"{self.instrument.symbol} qty_opening={qty_opening} exec_price={exec_price} pos_incr_qty={self.__pos_incr_qty} position_avg_price={self.position_avg_price}"
+                # )
+
                 pos_avg_price_raw = (_abs_qty_open * exec_price + self.__pos_incr_qty * self.position_avg_price) / (
                     self.__pos_incr_qty + _abs_qty_open
                 )
+
                 # - round position average price to be in line with how it's calculated by broker
                 self.position_avg_price = self.instrument.round_price_down(pos_avg_price_raw)
                 self.__pos_incr_qty += _abs_qty_open

{qubx-0.6.10 → qubx-0.6.12}/src/qubx/core/loggers.py

@@ -216,8 +216,10 @@ class _BaseIntervalDumper:
     def store(self, timestamp: np.datetime64):
         _t_ns = time_as_nsec(timestamp)
         if self._freq:
-            _interval_start_time = int(_t_ns - _t_ns % self._freq)
-            if _t_ns - self._last_log_time_ns >= self._freq:
+            # Convert freq to nanoseconds for calculation
+            _freq_ns = self._freq.astype("int64")
+            _interval_start_time = int(_t_ns - (_t_ns % _freq_ns))
+            if _t_ns - self._last_log_time_ns >= _freq_ns:
                 self.dump(np.datetime64(_interval_start_time, "ns"), timestamp)
                 self._last_log_time_ns = _interval_start_time
         else:
@@ -412,22 +414,29 @@ class SignalsLogger(_BaseIntervalDumper):
 
 class BalanceLogger(_BaseIntervalDumper):
     """
-    Balance logger - send balance on strategy start
+    Balance logger - save balance information at regular intervals similar to positions
     """
 
     _writer: LogsWriter
+    _balance: dict[str, AssetBalance]
 
-    def __init__(self, writer: LogsWriter) -> None:
-        super().__init__(None)  # no intervals
+    def __init__(self, writer: LogsWriter, interval: str) -> None:
+        super().__init__(interval)
         self._writer = writer
+        self._balance = {}
 
-    def record_balance(self, timestamp: np.datetime64, balance: Dict[str, AssetBalance]):
+    def record_balance(self, timestamp: np.datetime64, balance: dict[str, AssetBalance]):
         if balance:
+            self._balance = balance
+            self.dump(timestamp, timestamp)
+
+    def dump(self, interval_start_time: np.datetime64, actual_timestamp: np.datetime64):
+        if self._balance:
             data = []
-            for s, d in balance.items():
+            for s, d in self._balance.items():
                 data.append(
                     {
-                        "timestamp": timestamp,
+                        "timestamp": str(interval_start_time),
                         "currency": s,
                         "total": d.total,
                         "locked": d.locked,
@@ -435,9 +444,6 @@ class BalanceLogger(_BaseIntervalDumper):
                 )
             self._writer.write_data("balance", data)
 
-    def store(self, timestamp: np.datetime64):
-        pass
-
     def close(self):
         self._writer.flush_data()
 
@@ -484,7 +490,7 @@ class StrategyLogging:
                 self.signals_logger = SignalsLogger(logs_writer, num_signals_records_to_write)
 
             # - balance logger
-            self.balance_logger = BalanceLogger(logs_writer)
+            self.balance_logger = BalanceLogger(logs_writer, positions_log_freq)
         else:
             logger.warning("Log writer is not defined - strategy activity will not be saved !")
 
@@ -534,6 +540,10 @@ class StrategyLogging:
         if self.portfolio_logger:
             self.portfolio_logger.store(timestamp)
 
+        # - notify balance logger
+        if self.balance_logger:
+            self.balance_logger.store(timestamp)
+
         # - log heartbeat
         self._log_heartbeat(timestamp)
 

{qubx-0.6.10 → qubx-0.6.12}/src/qubx/restarts/state_resolvers.py

@@ -43,7 +43,7 @@ class StateResolver:
                     ctx.trade(instrument, -live_qty)
 
                 # If live position is larger than sim position (same direction), reduce it
-                elif abs(live_qty) > abs(sim_qty) and abs(sim_qty) > instrument.lot_size:
+                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})"

{qubx-0.6.10 → qubx-0.6.12}/src/qubx/restorers/signal.py

@@ -78,7 +78,12 @@ class CsvSignalRestorer(ISignalRestorer):
 
         try:
             # Read the CSV file
-            df = pd.read_csv(file_path)
+            try:
+                df = pd.read_csv(file_path)
+            except Exception as e:
+                logger.info(f"Could not read signal file {file_path}: {e}")
+                return {}
+
             if df.empty:
                 logger.info(f"No signals found in {file_path}")
                 return {}