Qubx 0.6.11__tar.gz → 0.6.13__tar.gz

{qubx-0.6.11 → qubx-0.6.13}/PKG-INFO

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

{qubx-0.6.11 → qubx-0.6.13}/pyproject.toml

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

{qubx-0.6.11 → qubx-0.6.13}/src/qubx/core/account.py

@@ -175,8 +175,9 @@ class BasicAccountProcessor(IAccountProcessor):
                 self._lock_limit_order_value(order)
 
         if _closed or _cancel:
-            if order.id in self._processed_trades:
-                self._processed_trades.pop(order.id)
+            # TODO: (LIVE) WE NEED TO THINK HOW TO CLEANUP THIS COLLECTION !!!! -> @DM
+            # if order.id in self._processed_trades:
+            # self._processed_trades.pop(order.id)
 
             if order.id in self._active_orders:
                 self._active_orders.pop(order.id)

{qubx-0.6.11 → qubx-0.6.13}/src/qubx/core/basics.py

@@ -8,7 +8,6 @@ from typing import Any, Literal, Optional, TypeAlias, Union
 import numpy as np
 import pandas as pd
 
-from qubx import logger
 from qubx.core.exceptions import QueueTimeout
 from qubx.core.series import Bar, OrderBook, Quote, Trade, time_as_nsec
 from qubx.core.utils import prec_ceil, prec_floor, time_delta_to_str
@@ -476,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:
         """
@@ -540,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
@@ -558,6 +559,10 @@ class Position:
                 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
@@ -567,16 +572,14 @@ class Position:
             # - if it has something to add to position let's update price and cost
             if not np.isclose(qty_opening, 0.0):
                 _abs_qty_open = abs(qty_opening)
-                try:
-                    pos_avg_price_raw = (_abs_qty_open * exec_price + self.__pos_incr_qty * self.position_avg_price) / (
-                        self.__pos_incr_qty + _abs_qty_open
-                    )
-                except ZeroDivisionError:
-                    logger.warning(
-                        "Zero division error in position update: "
-                        f"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 = self.position_avg_price
+
+                # 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)
@@ -676,7 +679,9 @@ class Position:
                 f"qty={self.quantity:.{self.instrument.size_precision}f}",
                 f"entryPrice={self.position_avg_price:.{self.instrument.price_precision}f}",
                 f"price={self.last_update_price:.{self.instrument.price_precision}f}",
-                f"pnl={self.unrealized_pnl():.2f}",
+                f"PNL: (unrealized={self.unrealized_pnl():.2f}",
+                f"realized={self.r_pnl:.2f}",
+                f"pnl={self.pnl:.2f})",
                 f"value={self.market_value_funds:.2f}",
             ]
         )

{qubx-0.6.11 → qubx-0.6.13}/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.11 → qubx-0.6.13}/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.11 → qubx-0.6.13}/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 {}

{qubx-0.6.11 → qubx-0.6.13}/src/qubx/utils/runner/_jupyter_runner.pyt

@@ -181,7 +181,7 @@ def portfolio(all=True):
     d = dict()
     for s, p in ctx.get_positions().items():
         mv = round(p.market_value_funds, 3)
-        if mv != 0.0 or all:
+        if p.quantity != 0.0 or all:
             d[dequotify(s.symbol)] = _pos_to_dict(p)
 
     d = pd.DataFrame.from_dict(d, orient='index')
@@ -232,14 +232,14 @@ class IntMagics(Magics):
 
     @line_cell_magic
     def lp(self, line: str):
-        portfolio('true' in line)
+        portfolio(any(x in line.lower() for x in ['true', 'all']))
 
     @line_cell_magic
     def add(self, line: str):
         ctx + line.strip()
 
     @line_cell_magic
-    def rm(self, line: str):
+    def remove(self, line: str):
         ctx - line.strip()
 
     @line_cell_magic