Qubx 0.6.42__tar.gz → 0.6.44__tar.gz

{qubx-0.6.42 → qubx-0.6.44}/PKG-INFO

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

{qubx-0.6.42 → qubx-0.6.44}/pyproject.toml

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

{qubx-0.6.42 → qubx-0.6.44}/src/qubx/backtester/utils.py

@@ -218,7 +218,7 @@ def find_instruments_and_exchanges(
     exchange: ExchangeName_t | None,
 ) -> tuple[list[Instrument], list[ExchangeName_t]]:
     _instrs: list[Instrument] = []
-    _exchanges = [] if exchange is None else [exchange.lower()]
+    _exchanges = [] if exchange is None else [exchange]
     for i in instruments:
         match i:
             case str():

{qubx-0.6.42 → qubx-0.6.44}/src/qubx/core/lookups.py

@@ -283,13 +283,14 @@ class InstrumentsLookup:
             query_exchanges=query_exchanges,
         )
 
+    #todo: temporaty disabled ccxt call to exchange, due to conectivity issues. Revert for bitfinex live usage
     def _update_bitfinex(self, path: str, query_exchanges: bool = False):
         self._ccxt_update(
             path,
             "bitfinex.f",
             {"bitfinex.f": "bitfinex"},
             keep_types=[MarketType.SWAP],
-            query_exchanges=query_exchanges,
+            query_exchanges=False,
         )
 
     def _update_bitmex(self, path: str, query_exchanges: bool = False):

{qubx-0.6.42 → qubx-0.6.44}/src/qubx/core/metrics.py

@@ -1406,8 +1406,8 @@ def chart_signals(
         if show_leverage:
             leverage = calculate_leverage(portfolio, result.capital, start, symbol)
             indicators["Leverage"] = ["area", "cyan", leverage]
-        symbol_count = len(portfolio.filter(like="_PnL").columns)
-        pnl = portfolio.filter(regex=f"{symbol}_PnL").cumsum() + result.capital / symbol_count
+        # symbol_count = len(portfolio.filter(like="_PnL").columns)
+        pnl = portfolio.filter(regex=f"{symbol}_PnL").cumsum() + result.capital  # / symbol_count
         pnl = pnl.loc[start:]
         if apply_commissions:
             comm = portfolio.filter(regex=f"{symbol}_Commissions").loc[start:].cumsum()

{qubx-0.6.42 → qubx-0.6.44}/src/qubx/core/mixins/universe.py

@@ -109,6 +109,8 @@ class UniverseManager(IUniverseManager):
                 if self._has_position(instr):
                     self._removal_queue[instr] = (if_has_position_then, skip_callback)
                     to_keep.append(instr)
+                else: 
+                    to_remove.append(instr)
         return to_remove, to_keep
 
     def __cleanup_removal_queue(self, instruments: list[Instrument]):

{qubx-0.6.42 → qubx-0.6.44}/src/qubx/pandaz/ta.py

@@ -633,6 +633,17 @@ def rolling_std_with_mean(x: pd.Series, mean: float | pd.Series, window: int):
     return np.sqrt((((x - mean) ** 2).rolling(window=window).sum() / (window - 1)))
 
 
+def rolling_zscore(x: pd.Series, window: int):
+    """
+    Calculates rolling z-score for data from x
+    :param x: series data
+    :param window: window
+    :return: rolling z-score
+    """
+    r = x.rolling(window=window)
+    return (x - r.mean()) / r.std(ddof=0)
+
+
 def bollinger(x: pd.Series, window=14, nstd=2, mean="sma") -> pd.DataFrame:
     """
     Bollinger Bands indicator
@@ -1326,11 +1337,11 @@ def rolling_rank(x, period, pctls=(25, 50, 75)):
         raise ValueError(f"Period {period} exceeds number of data records {len(x)} ")
 
     if isinstance(x, pd.DataFrame):
-        z = pd.DataFrame.from_dict({c: rolling_rank(s, period, pctls) for c, s in x.iteritems()})
+        z = pd.DataFrame.from_dict({c: rolling_rank(s, period, pctls) for c, s in x.items()})
     elif isinstance(x, pd.Series):
-        z = pd.Series(_rolling_rank(x.values, period, pctls), x.index, name=x.name)
+        z = pd.Series(_rolling_rank(np.ascontiguousarray(x.values), period, pctls), x.index, name=x.name)
     else:
-        z = _rolling_rank(x.values, period, pctls)
+        z = _rolling_rank(np.ascontiguousarray(x), period, pctls)
     return z
 
 
@@ -1532,6 +1543,7 @@ def choppiness(
     volatility_estimator="t",
     volume_adjusting=False,
     identification="strong",
+    with_raw_indicator=False,
 ) -> pd.Series:
     """
     Calculate market choppiness index using volatility-based formula.
@@ -1566,7 +1578,8 @@ def choppiness(
                     0 when exiting trending regime (crossing above lower threshold)
         - 'weak': Binary classification focused on choppiness - returns 1 when entering choppy regime (crossing above upper threshold),
                  0 when entering trending regime (crossing below lower threshold)
-
+    with_raw_indicator : bool, default False
+        If True, returns the raw indicator value instead of the classification
     Returns
     -------
     pd.Series
@@ -1619,7 +1632,7 @@ def choppiness(
     # f0[(ci < lower) & (ci.shift(1) >= lower)] = 0
     # return f0.ffill().fillna(0)
 
-    return f0.ffill().fillna(0)
+    return f0.ffill().fillna(0) if not with_raw_indicator else ci
 
 
 @njit

{qubx-0.6.42 → qubx-0.6.44}/src/qubx/pandaz/utils.py

@@ -590,9 +590,11 @@ class OhlcDict(dict):
         print(str(d))
     """
 
+    _orig: dict[str, pd.DataFrame | pd.Series | OHLCV]
     _fields: Set[str]
 
     def __init__(self, orig: dict[str, pd.DataFrame | pd.Series | OHLCV]):
+        self._orig = orig
         _o_copy = {}
         _lst = []
         if isinstance(orig, dict):
@@ -639,3 +641,16 @@ class OhlcDict(dict):
 
     def __repr__(self) -> str:
         return self.display(3, 3)
+
+    def __reduce__(self):
+        """
+        For joblib Parallel compatibility - defines how to pickle the object
+        """
+        # Return the class, constructor arguments, and additional state
+        data = {k: v for k, v in self.items()}
+        return (self.__class__, (data,), {"_orig": self._orig})
+
+    def __setstate__(self, state):
+        """Restore object from pickle state"""
+        # Recreate the object using the constructor
+        self.__init__(state["_orig"])

{qubx-0.6.42 → qubx-0.6.44}/src/qubx/restorers/balance.py

@@ -8,6 +8,7 @@ from various sources.
 import os
 from pathlib import Path
 from pymongo import MongoClient
+from datetime import datetime, timedelta
 
 import pandas as pd
 
@@ -152,13 +153,16 @@ class MongoDBBalanceRestorer(IBalanceRestorer):
             Example: {'USDT': AssetBalance(total=100000.0, locked=0.0)}
         """
         try:
-            match_query = {
+            now = datetime.utcnow()
+            lookup_range = now - timedelta(days=7)
+            base_match = {
                 "log_type": "balance",
                 "strategy_name": self.strategy_name,
+                "timestamp": {"$gte": lookup_range}
             }
 
             latest_run_doc = (
-                self.collection.find(match_query, {"run_id": 1, "timestamp": 1})
+                self.collection.find(base_match, {"run_id": 1, "timestamp": 1})
                 .sort("timestamp", -1)
                 .limit(1)
             )
@@ -172,23 +176,34 @@ class MongoDBBalanceRestorer(IBalanceRestorer):
 
             logger.info(f"Restoring balances from MongoDB for run_id: {latest_run_id}")
 
-            query = {**match_query, "run_id": latest_run_id}
-            logs = self.collection.find(query).sort("timestamp", 1)
-
-            balances = {}
-
-            for log in logs:
+            pipeline = [
+                {"$match": {**base_match, "run_id": latest_run_id}},
+                {"$sort": {"timestamp": -1}},
+                {
+                    "$group": {
+                        "_id": "$currency",
+                        "doc": {"$first": "$$ROOT"}
+                    }
+                }
+            ]
+
+            cursor = self.collection.aggregate(pipeline)
+            balances: dict[str, AssetBalance] = {}
+
+            for entry in cursor:
+                log = entry["doc"]
                 currency = log.get("currency")
-                if currency:
-                    total = log.get("total", 0.0)
-                    locked = log.get("locked", 0.0)
-
-                    balance = AssetBalance(
-                        total=total,
-                        locked=locked,
-                    )
-                    balance.free = total - locked
-                    balances[currency] = balance
+                if not currency:
+                    continue
+                total = log.get("total", 0.0)
+                locked = log.get("locked", 0.0)
+
+                balance = AssetBalance(
+                    total=total,
+                    locked=locked,
+                )
+                balance.free = total - locked
+                balances[currency] = balance
 
             return balances
         except Exception as e:

{qubx-0.6.42 → qubx-0.6.44}/src/qubx/restorers/position.py

@@ -8,6 +8,7 @@ for restoring positions from various sources.
 import os
 from pathlib import Path
 from pymongo import MongoClient
+from datetime import datetime, timedelta
 
 import pandas as pd
 
@@ -168,13 +169,17 @@ class MongoDBPositionRestorer(IPositionRestorer):
             A dictionary mapping instruments to positions.
         """
         try:
-            match_query = {
+            now = datetime.utcnow()
+            lookup_range = now - timedelta(days=7)
+
+            base_match = {
                 "log_type": "positions",
                 "strategy_name": self.strategy_name,
+                "timestamp": {"$gte": lookup_range}
             }
 
             latest_run_doc = (
-                self.collection.find(match_query, {"run_id": 1, "timestamp": 1})
+                self.collection.find(base_match, {"run_id": 1, "timestamp": 1})
                 .sort("timestamp", -1)
                 .limit(1)
             )
@@ -188,20 +193,34 @@ class MongoDBPositionRestorer(IPositionRestorer):
 
             logger.info(f"Restoring positions from MongoDB for run_id: {latest_run_id}")
 
-            query = {**match_query, "run_id": latest_run_id}
-            logs = self.collection.find(query).sort("timestamp", 1)
-
-            positions = {}
-            seen_keys = set()
-
-            for log in logs:
-                key = (log.get("symbol"), log.get("exchange"), log.get("market_type"))
-                if None in key or key in seen_keys:
+            pipeline = [
+                {"$match": {**base_match, "run_id": latest_run_id}},
+                {"$sort": {"timestamp": -1}},
+                {
+                    "$group": {
+                        "_id": {
+                            "symbol":   "$symbol",
+                            "exchange": "$exchange",
+                            "market_type": "$market_type"
+                        },
+                        "doc": {"$first": "$$ROOT"}
+                    }
+                }
+            ]
+
+            cursor = self.collection.aggregate(pipeline)
+
+            positions: dict[Instrument, Position] = {}
+
+            for entry in cursor:
+                log = entry["doc"]
+
+                symbol = log.get("symbol")
+                exchange = log.get("exchange")
+                market_type = log.get("market_type")
+
+                if not (symbol and exchange and market_type):
                     continue
-                seen_keys.add(key)
-
-                symbol = log["symbol"]
-                exchange = log["exchange"]
 
                 instrument = lookup.find_symbol(exchange, symbol)
                 if instrument is None:

{qubx-0.6.42 → qubx-0.6.44}/src/qubx/restorers/signal.py

@@ -208,13 +208,16 @@ class MongoDBSignalRestorer(ISignalRestorer):
             A dictionary mapping instruments to lists of signals.
         """
         try:
-            match_query = {
+            now = datetime.utcnow()
+            lookup_range = now - timedelta(days=30)
+            base_match = {
                 "log_type": "signals",
                 "strategy_name": self.strategy_name,
+                "timestamp": {"$gte": lookup_range}
             }
 
             latest_run_doc = (
-                self.collection.find(match_query, {"run_id": 1, "timestamp": 1})
+                self.collection.find(base_match, {"run_id": 1, "timestamp": 1})
                 .sort("timestamp", -1)
                 .limit(1)
             )
@@ -228,12 +231,33 @@ class MongoDBSignalRestorer(ISignalRestorer):
 
             logger.info(f"Restoring signals from MongoDB for run_id: {latest_run_id}")
 
-            query = {**match_query, "run_id": latest_run_id}
-            logs = self.collection.find(query).sort("timestamp", 1)
-
+            pipeline = [
+                {"$match": {"log_type": "signals", "strategy_name": self.strategy_name, "run_id": latest_run_id}},
+                {"$sort": {"timestamp": -1}},
+                {
+                    "$group": {
+                        "_id": {
+                            "symbol": "$symbol",
+                            "exchange": "$exchange",
+                            "market_type": "$market_type",
+                        },
+                        "signals": {"$push": "$$ROOT"}
+                    }
+                },
+                {
+                    "$project": {
+                        "signals": {"$slice": ["$signals", 20]}
+                    }
+                },
+                {"$unwind": "$signals"}
+            ]
+
+            cursor = self.collection.aggregate(pipeline)
+            
             result: dict[Instrument, list[TargetPosition]] = {}
 
-            for log in logs:
+            for entry in cursor:
+                log = entry["signals"]
                 try:
                     instrument = lookup.find_symbol(log["exchange"], log["symbol"])
                     if instrument is None:
@@ -281,7 +305,6 @@ class MongoDBSignalRestorer(ISignalRestorer):
                     )
 
                     result.setdefault(instrument, []).append(target_position)
-
                 except Exception as e:
                     logger.exception(f"Failed to process signal document: {e}")