Qubx 0.2.73__tar.gz → 0.2.75__tar.gz

{qubx-0.2.73 → qubx-0.2.75}/PKG-INFO

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

{qubx-0.2.73 → qubx-0.2.75}/pyproject.toml

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

{qubx-0.2.73 → qubx-0.2.75}/src/qubx/backtester/optimization.py

@@ -90,7 +90,41 @@ def permutate_params(
     return _wrap_single_list(result) if wrap_as_list else result
 
 
-def variate(clz: Type[Any] | List[Type[Any]], *args, conditions=None, **kwargs) -> Dict[str, Any]:
+def dicts_product(d1: dict, d2: dict) -> dict:
+    """
+    Product of two dictionaries.
+
+    Example:
+    -------
+
+    dicts_product({
+        'A': 1,
+        'B': 2,
+    }, {
+        'C': 3,
+        'D': 4,
+    })
+
+    Output:
+    ------
+    {
+        'A + C': [1, 3],
+        'A + D': [1, 4],
+        'B + C': [2, 3],
+        'B + D': [2, 4]
+    }
+
+    """
+    flatten = lambda l: [item for sublist in l for item in (sublist if isinstance(sublist, list) else [sublist])]
+    return {(a + " + " + b): flatten([d1[a], d2[b]]) for a, b in product(d1.keys(), d2.keys())}
+
+
+class _dict(dict):
+    def __add__(self, other: dict) -> dict:
+        return _dict(dicts_product(self, other))
+
+
+def variate(clz: Type[Any] | List[Type[Any]], *args, conditions=None, **kwargs) -> _dict:
     """
     Make variations of parameters for simulations (micro optimizer)
 
@@ -149,7 +183,9 @@ def variate(clz: Type[Any] | List[Type[Any]], *args, conditions=None, **kwargs)
     to_excl = [s for s, v in kwargs.items() if not isinstance(v, (list, set, tuple, range))]
     dic2str = lambda ds: [_cmprss(k) + "=" + str(v) for k, v in ds.items() if k not in to_excl]
 
-    return {
-        f"{sfx}_({ ','.join(dic2str(z)) })": _mk(clz, *args, **z)
-        for z in permutate_params(kwargs, conditions=conditions)
-    }
+    return _dict(
+        {
+            f"{sfx}_({ ','.join(dic2str(z)) })": _mk(clz, *args, **z)
+            for z in permutate_params(kwargs, conditions=conditions)
+        }
+    )

{qubx-0.2.73 → qubx-0.2.75}/src/qubx/backtester/simulator.py

@@ -556,7 +556,7 @@ class SimulatedExchange(IBrokerServiceProvider):
             # we have to schedule possible crons before sending the data event itself
             if self._scheduler.check_and_run_tasks():
                 # - push nothing - it will force to process last event
-                cc.send((None, "time", None))
+                cc.send((None, "service_time", None))
 
         cc.send((symbol, data_type, data))
 

{qubx-0.2.73 → qubx-0.2.75}/src/qubx/core/helpers.py

@@ -300,9 +300,9 @@ class BasicScheduler:
         next_time = iter.get_next(start_time=start_time)
         if next_time:
             self._scdlr.enterabs(next_time, 1, self._trigger, (event, prev_time, next_time))
-            logger.debug(
-                f"Now is <red>{_SEC2TS(self.time_sec())}</red> next ({event}) at <cyan>{_SEC2TS(next_time)}</cyan>"
-            )
+            # logger.debug(
+            #     f"Now is <red>{_SEC2TS(self.time_sec())}</red> next ({event}) at <cyan>{_SEC2TS(next_time)}</cyan>"
+            # )
             return True
         logger.debug(f"({event}) task is not scheduled")
         return False

{qubx-0.2.73 → qubx-0.2.75}/src/qubx/data/readers.py

@@ -945,6 +945,23 @@ class QuestDBConnector(DataReader):
             return pd.Series()
         return vol_stats.set_index("symbol")["quote_volume"]
 
+    def get_fundamental_data(
+        self, exchange: str, start: str | pd.Timestamp | None = None, stop: str | pd.Timestamp | None = None
+    ) -> pd.DataFrame:
+        table_name = {"BINANCE.UM": "binance.umfutures.fundamental"}[exchange]
+        query = f"select * from {table_name}"
+        if start or stop:
+            conditions = []
+            if start:
+                conditions.append(f"timestamp >= '{start}'")
+            if stop:
+                conditions.append(f"timestamp < '{stop}'")
+            query += " where " + " and ".join(conditions)
+        df = self.execute(query)
+        if df.empty:
+            return pd.DataFrame()
+        return df.set_index(["timestamp", "symbol", "metric"]).value.unstack("metric")
+
     def get_names(self) -> List[str]:
         return self._get_names(self._builder)
 
@@ -1027,7 +1044,6 @@ class QuestDBSqlOrderBookBuilder(QuestDBSqlCandlesBuilder):
     Sql builder for snapshot data
     """
 
-    MAX_TIME_DELTA = pd.Timedelta("5h")
     SNAPSHOT_DELTA = pd.Timedelta("1h")
     MIN_DELTA = pd.Timedelta("1s")
 
@@ -1043,8 +1059,6 @@ class QuestDBSqlOrderBookBuilder(QuestDBSqlCandlesBuilder):
             raise ValueError("Start and end dates must be provided for orderbook data!")
         start_dt, end_dt = pd.Timestamp(start), pd.Timestamp(end)
         delta = end_dt - start_dt
-        if delta > self.MAX_TIME_DELTA:
-            raise ValueError(f"Time range is too big for orderbook data: {delta}, max allowed: {self.MAX_TIME_DELTA}")
 
         raw_start_dt = start_dt.floor(self.SNAPSHOT_DELTA) - self.MIN_DELTA
 

{qubx-0.2.73 → qubx-0.2.75}/src/qubx/trackers/riskctrl.py

@@ -5,7 +5,7 @@ from typing import Dict, List, Literal
 import numpy as np
 
 from qubx import logger
-from qubx.core.basics import Deal, Instrument, Signal, TargetPosition
+from qubx.core.basics import Deal, Instrument, OrderStatus, Signal, TargetPosition
 from qubx.core.series import Bar, Quote, Trade
 from qubx.core.strategy import IPositionSizer, PositionsTracker, StrategyContext
 from qubx.trackers.sizers import FixedRiskSizer, FixedSizer
@@ -270,6 +270,15 @@ class BrokerSideRiskController(RiskController):
                         )
                         order = ctx.trade(instrument, -pos, c_w.target.take)
                         c_w.take_order_id = order.id
+
+                        # - if order was executed immediately we don't need to send stop order
+                        if order.status == "CLOSED":
+                            c_w.status = State.RISK_TRIGGERED
+                            logger.debug(
+                                f"<yellow>{self.__class__.__name__}</yellow> <g>TAKE PROFIT</g> was exected immediately for <green>{instrument.symbol}</green> at {c_w.target.take}"
+                            )
+                            return
+
                     except Exception as e:
                         logger.error(
                             f"<yellow>{self.__class__.__name__}</yellow> couldn't send take limit order for <green>{instrument.symbol}</green>: {str(e)}"

{qubx-0.2.73 → qubx-0.2.75}/src/qubx/utils/time.py

@@ -113,7 +113,7 @@ def infer_series_frequency(series: Union[List, pd.DataFrame, pd.Series, pd.Datet
             [
                 (
                     x
-                    if isinstance(x, (np.timedelta64, int))
+                    if isinstance(x, (np.timedelta64, int, np.int64))
                     else int(x) if isinstance(x, float) else int(1e9 * x.total_seconds())
                 )
                 for x in np.abs(np.diff(times_index))