Qubx 0.6.43__tar.gz → 0.6.47__tar.gz

{qubx-0.6.43 → qubx-0.6.47}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: Qubx
-Version: 0.6.43
+Version: 0.6.47
 Summary: Qubx - Quantitative Trading Framework
 Author: Dmitry Marienko
 Author-email: dmitry.marienko@xlydian.com
@@ -11,7 +11,6 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: aiohttp (>=3.10.11,<3.11.0)
-Requires-Dist: bitfinex-api-py (>=3.0.4,<4.0.0)
 Requires-Dist: ccxt (>=4.2.68,<5.0.0)
 Requires-Dist: croniter (>=2.0.5,<3.0.0)
 Requires-Dist: cython (==3.0.8)
@@ -40,6 +39,7 @@ Requires-Dist: pymongo (>=4.6.1,<5.0.0)
 Requires-Dist: python-binance (>=1.0.19,<2.0.0)
 Requires-Dist: python-dotenv (>=1.0.0,<2.0.0)
 Requires-Dist: pyyaml (>=6.0.2,<7.0.0)
+Requires-Dist: qubx-bitfinex-api (>=3.0.7,<4.0.0)
 Requires-Dist: questdb (>=2.0.3,<3.0.0)
 Requires-Dist: redis (>=5.2.1,<6.0.0)
 Requires-Dist: scikit-learn (>=1.4.2,<2.0.0)
@@ -50,6 +50,7 @@ Requires-Dist: statsmodels (>=0.14.2,<0.15.0)
 Requires-Dist: tabulate (>=0.9.0,<0.10.0)
 Requires-Dist: toml (>=0.10.2,<0.11.0)
 Requires-Dist: tqdm
+Requires-Dist: websockets (==15.0.1)
 Project-URL: Repository, https://github.com/xLydianSoftware/Qubx
 Description-Content-Type: text/markdown
 

{qubx-0.6.43 → qubx-0.6.47}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "Qubx"
-version = "0.6.43"
+version = "0.6.47"
 description = "Qubx - Quantitative Trading Framework"
 authors = [ "Dmitry Marienko <dmitry.marienko@xlydian.com>", "Yuriy Arabskyy <yuriy.arabskyy@xlydian.com>",]
 readme = "README.md"
@@ -72,7 +72,8 @@ ipywidgets = "^8.1.5"
 questdb = "^2.0.3"
 orjson = "^3.10.15"
 aiohttp = "~3.10.11"
-bitfinex-api-py = "^3.0.4"
+websockets = "15.0.1"
+qubx-bitfinex-api = "^3.0.7"
 
 [tool.ruff.lint]
 extend-select = [ "I",]

{qubx-0.6.43 → qubx-0.6.47}/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.43 → qubx-0.6.47}/src/qubx/core/context.py

@@ -198,6 +198,9 @@ class StrategyContext(IStrategyContext):
             self.strategy.on_init(self.initializer)
             self._strategy_state.is_on_init_called = True
 
+        if subscription_warmup := self.initializer.get_subscription_warmup():
+            self.set_warmup(subscription_warmup)
+
         if base_sub := self.initializer.get_base_subscription():
             self.set_base_subscription(base_sub)
 

{qubx-0.6.43 → qubx-0.6.47}/src/qubx/core/initializer.py

@@ -31,6 +31,7 @@ class BasicStrategyInitializer(IStrategyInitializer):
     mismatch_resolver: Optional[StateResolverProtocol] = None
     auto_subscribe: Optional[bool] = None
     simulation: Optional[bool] = None
+    subscription_warmup: Optional[dict[Any, str]] = None
 
     # Additional configuration that might be needed
     config: Dict[str, Any] = field(default_factory=dict)
@@ -106,3 +107,9 @@ class BasicStrategyInitializer(IStrategyInitializer):
 
     def get_pending_instrument_subscriptions(self) -> dict[str, set[Instrument]]:
         return self._pending_instrument_subscriptions
+
+    def set_subscription_warmup(self, configs: dict[Any, str]) -> None:
+        self.subscription_warmup = configs
+
+    def get_subscription_warmup(self) -> dict[Any, str]:
+        return self.subscription_warmup if self.subscription_warmup else {}

{qubx-0.6.43 → qubx-0.6.47}/src/qubx/core/interfaces.py

@@ -1695,6 +1695,24 @@ class IStrategyInitializer:
         """
         ...
 
+    def set_subscription_warmup(self, configs: dict[Any, str]) -> None:
+        """
+        Set the warmup period for the subscription.
+
+        This method is used to set the warmup period for the subscription in on_init stage.
+        Then this config is used to translate warmup configs to StrategyContext
+
+        Args:
+            configs: A dictionary of subscription types and their warmup periods.
+        """
+        ...
+
+    def get_subscription_warmup(self) -> dict[Any, str]:
+        """
+        Get the warmup period for the subscription.
+        """
+        ...
+
 
 class IStrategy(metaclass=Mixable):
     """Base class for trading strategies."""

{qubx-0.6.43 → qubx-0.6.47}/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.43 → qubx-0.6.47}/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.43 → qubx-0.6.47}/src/qubx/pandaz/ta.py

@@ -1337,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
 
 

{qubx-0.6.43 → qubx-0.6.47}/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.43 → qubx-0.6.47}/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.43 → qubx-0.6.47}/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.43 → qubx-0.6.47}/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}")