Qubx 0.2.61__tar.gz → 0.2.62__tar.gz

{qubx-0.2.61 → qubx-0.2.62}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: Qubx
-Version: 0.2.61
+Version: 0.2.62
 Summary: Qubx - quantitative trading framework
 Home-page: https://github.com/dmarienko/Qubx
 Author: Dmitry Marienko

{qubx-0.2.61 → qubx-0.2.62}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "Qubx"
-version = "0.2.61"
+version = "0.2.62"
 description = "Qubx - quantitative trading framework"
 authors = ["Dmitry Marienko <dmitry@gmail.com>", "Yuriy Arabskyy <yuriy.arabskyy@gmail.com>"]
 readme = "README.md"

{qubx-0.2.61 → qubx-0.2.62}/src/qubx/backtester/simulator.py

@@ -2,7 +2,7 @@ import numpy as np
 import pandas as pd
 from collections import defaultdict
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Tuple, TypeAlias, Callable
+from typing import Any, Dict, List, Optional, Tuple, TypeAlias, Callable, Literal
 from enum import Enum
 from tqdm.auto import tqdm
 from itertools import chain
@@ -187,7 +187,7 @@ class SimulatedTrading(ITradingServiceProvider):
         price: float | None = None,
         client_id: str | None = None,
         time_in_force: str = "gtc",
-        **optional,
+        **options,
     ) -> Order:
         ome = self._ome.get(instrument.symbol)
         if ome is None:
@@ -201,7 +201,7 @@ class SimulatedTrading(ITradingServiceProvider):
             price,
             client_id,
             time_in_force,
-            fill_at_price=optional.get("fill_at_price", False),
+            fill_at_price=options.get("fill_at_price", False),
         )
         order = report.order
         self._order_to_symbol[order.id] = instrument.symbol
@@ -685,7 +685,12 @@ def simulate(
     n_jobs: int = 1,
     silent: bool = False,
     enable_event_batching: bool = True,
+    debug: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] | None = "WARNING",
 ) -> list[TradingSessionResult]:
+
+    # - setup logging
+    QubxLogConfig.set_log_level(debug.upper() if debug else "WARNING")
+
     # - recognize provided data
     if isinstance(data, dict):
         data_reader = InMemoryDataFrameReader(data)
@@ -707,13 +712,13 @@ def simulate(
             f"No exchange iformation provided - you can specify it by exchange parameter or use <yellow>EXCHANGE:SYMBOL</yellow> format for symbols"
         )
         # - TODO: probably we need to raise exceptions here ?
-        return None
+        return []
 
     # - check exchanges
     if len(set(_exchanges)) > 1:
         logger.error(f"Multiple exchanges found: {', '.join(_exchanges)} - this mode is not supported yet in Qubx !")
         # - TODO: probably we need to raise exceptions here ?
-        return None
+        return []
 
     exchange = list(set(_exchanges))[0]
 
@@ -724,7 +729,7 @@ def simulate(
             f"Can't recognize setup - it should be a strategy, a set of signals or list of signals/strategies + tracker !"
         )
         # - TODO: probably we need to raise exceptions here ?
-        return None
+        return []
 
     # - check stop time : here we try to backtest till now (may be we need to get max available time from data reader ?)
     if stop is None:

{qubx-0.2.61 → qubx-0.2.62}/src/qubx/core/basics.py

@@ -4,11 +4,11 @@ import numpy as np
 import pandas as pd
 from dataclasses import dataclass, field
 
-from threading import Thread, Event, Lock, Condition
+from threading import Event, Lock
 from queue import Queue
 
 from qubx.core.series import Quote, Trade, time_as_nsec
-from qubx.core.utils import time_to_str, time_delta_to_str, recognize_timeframe
+from qubx.core.utils import prec_ceil, prec_floor
 
 
 dt_64 = np.datetime64
@@ -138,6 +138,42 @@ class Instrument:
             self._size_precision = int(abs(np.log10(self.min_size_step)))
         return self._size_precision
 
+    def round_size_down(self, size: float) -> float:
+        """
+        Round down size to specified precision
+
+        i.size_precision == 3
+        i.round_size_up(0.1234) -> 0.123
+        """
+        return prec_floor(size, self.size_precision)
+
+    def round_size_up(self, size: float) -> float:
+        """
+        Round up size to specified precision
+
+        i.size_precision == 3
+        i.round_size_up(0.1234) -> 0.124
+        """
+        return prec_ceil(size, self.size_precision)
+
+    def round_price_down(self, price: float) -> float:
+        """
+        Round down price to specified precision
+
+        i.price_precision == 3
+        i.round_price_down(1.234999, 3) -> 1.234
+        """
+        return prec_floor(price, self.price_precision)
+
+    def round_price_up(self, price: float) -> float:
+        """
+        Round up price to specified precision
+
+        i.price_precision == 3
+        i.round_price_up(1.234999) -> 1.235
+        """
+        return prec_ceil(price, self.price_precision)
+
     def signal(
         self,
         signal: float,
@@ -266,11 +302,6 @@ class Order:
         return f"[{self.id}] {self.type} {self.side} {self.quantity} of {self.symbol} {('@ ' + str(self.price)) if self.price > 0 else ''} ({self.time_in_force}) [{self.status}]"
 
 
-def round_down(x, n):
-    dvz = 10 ** (-n)
-    return (int(x / dvz)) * dvz
-
-
 class Position:
     instrument: Instrument  # instrument for this poisition
     quantity: float = 0.0  # quantity positive for long and negative for short
@@ -338,7 +369,11 @@ class Position:
         self, timestamp: dt_64, amount: float, exec_price: float, fee_amount: float = 0, conversion_rate: float = 1
     ) -> tuple[float, float]:
         return self.update_position(
-            timestamp, self.quantity + amount, exec_price, fee_amount, conversion_rate=conversion_rate
+            timestamp,
+            self.instrument.round_size_down(self.quantity + amount),
+            exec_price,
+            fee_amount,
+            conversion_rate=conversion_rate,
         )
 
     def update_position(
@@ -374,7 +409,7 @@ class Position:
                     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 = round_down(pos_avg_price_raw, self.instrument.price_precision)
+                self.position_avg_price = self.instrument.round_price_down(pos_avg_price_raw)
                 self.__pos_incr_qty += _abs_qty_open
 
             # - update position and position's price

{qubx-0.2.61 → qubx-0.2.62}/src/qubx/core/context.py

@@ -38,7 +38,7 @@ from qubx.core.strategy import (
 from qubx.core.series import Trade, Quote, Bar, OHLCV
 from qubx.gathering.simplest import SimplePositionGatherer
 from qubx.trackers.sizers import FixedSizer
-from qubx.utils.misc import Stopwatch, round_down_at_min_qty
+from qubx.utils.misc import Stopwatch
 from qubx.utils.time import convert_seconds_to_str
 
 
@@ -702,7 +702,7 @@ class StrategyContextImpl(StrategyContext):
         amount: float,
         price: float | None = None,
         time_in_force="gtc",
-        **optional,
+        **options,
     ) -> Order:
         instrument: Instrument | None = (
             self._symb_to_instr.get(instr_or_symbol) if isinstance(instr_or_symbol, str) else instr_or_symbol
@@ -711,7 +711,7 @@ class StrategyContextImpl(StrategyContext):
             raise ValueError(f"Can't find instrument for symbol {instr_or_symbol}")
 
         # - adjust size
-        size_adj = round_down_at_min_qty(abs(amount), instrument.min_size_step)
+        size_adj = instrument.round_size_down(abs(amount))
         if size_adj < instrument.min_size:
             raise ValueError(f"Attempt to trade size {abs(amount)} less than minimal allowed {instrument.min_size} !")
 
@@ -720,13 +720,13 @@ class StrategyContextImpl(StrategyContext):
         logger.debug(f"(StrategyContext) sending {type} {side} for {size_adj} of {instrument.symbol} ...")
         client_id = self._generate_order_client_id(instrument.symbol)
 
-        if self.broker_provider.is_simulated_trading and optional.get("fill_at_price", False):
+        if self.broker_provider.is_simulated_trading and options.get("fill_at_price", False):
             # assume worst case, if we force execution and certain price, assume it's via market
             # TODO: add an additional flag besides price to indicate order type
             type = "market"
 
         order = self.trading_service.send_order(
-            instrument, side, type, size_adj, price, time_in_force=time_in_force, client_id=client_id, **optional
+            instrument, side, type, size_adj, price, time_in_force=time_in_force, client_id=client_id, **options
         )
 
         return order

{qubx-0.2.61 → qubx-0.2.62}/src/qubx/core/utils.pyi

@@ -2,3 +2,5 @@ def recognize_time(time): ...
 def time_to_str(t: int, units: str = "ns") -> str: ...
 def time_delta_to_str(d: int) -> str: ...
 def recognize_timeframe(timeframe): ...
+def prec_ceil(a: float, precision: int) -> float: ...
+def prec_floor(a: float, precision: int) -> float: ...

{qubx-0.2.61 → qubx-0.2.62}/src/qubx/core/utils.pyx

@@ -51,4 +51,12 @@ cpdef recognize_timeframe(timeframe):
 
     else:
         raise ValueError(f'Unknown timeframe type: {timeframe} !')
-    return tf
+    return tf
+
+
+cpdef double prec_ceil(double a, int precision):
+    return np.sign(a) * np.true_divide(np.ceil(abs(a) * 10**precision), 10**precision)
+
+
+cpdef double prec_floor(double a, int precision):
+    return np.sign(a) * np.true_divide(np.floor(abs(a) * 10**precision), 10**precision)

{qubx-0.2.61 → qubx-0.2.62}/src/qubx/impl/ccxt_utils.py

@@ -101,9 +101,12 @@ def ccxt_restore_position_from_deals(
         else:
             for d in _last_deals:
                 pos.update_position_by_deal(d)
+                fees = 0.0
                 if d.fee_amount is not None:
                     if instr.base == d.fee_currency:
-                        pos.quantity -= d.fee_amount
+                        fees += d.fee_amount
+            # - we round fees up in case of fees in base currency
+            pos.quantity -= pos.instrument.round_size_up(fees)
     return pos
 
 

{qubx-0.2.61 → qubx-0.2.62}/src/qubx/trackers/sizers.py

@@ -4,7 +4,6 @@ import numpy as np
 from qubx import logger
 from qubx.core.basics import Position, Signal, TargetPosition
 from qubx.core.strategy import IPositionSizer, StrategyContext
-from qubx.utils.misc import round_down_at_min_qty
 
 
 class FixedSizer(IPositionSizer):
@@ -140,9 +139,7 @@ class WeightedPortfolioSizer(IPositionSizer):
                     TargetPosition(
                         ctx.time(),
                         signal,
-                        round_down_at_min_qty(
-                            cap * max(signal.signal, 0) / sw / _q.mid_price(), signal.instrument.min_size_step
-                        ),
+                        signal.instrument.round_size_down(cap * max(signal.signal, 0) / sw / _q.mid_price()),
                     )
                 )
             else:

{qubx-0.2.61 → qubx-0.2.62}/src/qubx/utils/misc.py

@@ -339,10 +339,6 @@ def dequotify(sx: Union[str, List[str]], quote="USDT"):
     raise ValueError("Can't process input data !")
 
 
-def round_down_at_min_qty(x: float, min_size: float) -> float:
-    return (int(x / min_size)) * min_size
-
-
 class ProgressParallel(joblib.Parallel):
     def __init__(self, *args, **kwargs):
         self.total = kwargs.pop("total", None)