Qubx 0.6.24__tar.gz → 0.6.26__tar.gz

{qubx-0.6.24 → qubx-0.6.26}/PKG-INFO

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

{qubx-0.6.24 → qubx-0.6.26}/pyproject.toml

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

{qubx-0.6.24 → qubx-0.6.26}/src/qubx/connectors/ccxt/account.py

@@ -170,7 +170,7 @@ class CcxtAccountProcessor(BasicAccountProcessor):
         self._instrument_to_last_price[instrument] = (time, extract_price(update))
         super().update_position_price(time, instrument, update)
 
-    def get_total_capital(self) -> float:
+    def get_total_capital(self, exchange: str | None = None) -> float:
         # sum of balances + market value of all positions on non spot/margin
         _currency_to_value = {c: self._get_currency_value(b.total, c) for c, b in self._balances.items()}
         _positions_value = sum([p.market_value_funds for p in self._positions.values() if p.instrument.is_futures()])

{qubx-0.6.24 → qubx-0.6.26}/src/qubx/connectors/ccxt/exchanges/binance/exchange.py

@@ -32,7 +32,8 @@ class BinanceQV(cxp.binance):
                 "options": {
                     "watchTrades": {
                         "name": "aggTrade",
-                    }
+                    },
+                    "localOrderBookLimit": 10_000,  # set a large limit to avoid cutting off the orderbook
                 }
             },
         )
@@ -210,6 +211,22 @@ class BinanceQV(cxp.binance):
         self.trades[symbol] = tradesArray
         client.resolve(tradesArray, messageHash)
 
+    def handle_order_book_subscription(self, client: Client, message, subscription):
+        defaultLimit = self.safe_integer(self.options, "localOrderBookLimit", 4000)
+        # messageHash = self.safe_string(subscription, 'messageHash')
+        symbolOfSubscription = self.safe_string(subscription, "symbol")  # watchOrderBook
+        symbols = self.safe_value(subscription, "symbols", [symbolOfSubscription])  # watchOrderBookForSymbols
+        limit = self.safe_integer(subscription, "limit", defaultLimit)
+        # handle list of symbols
+        for i in range(0, len(symbols)):
+            symbol = symbols[i]
+            if symbol in self.orderbooks:
+                del self.orderbooks[symbol]
+            self.orderbooks[symbol] = self.order_book({}, limit)
+            subscription = self.extend(subscription, {"symbol": symbol})
+            # fetch the snapshot in a separate async call
+            self.spawn(self.fetch_order_book_snapshot, client, message, subscription)
+
 
 class BinanceQVUSDM(cxp.binanceusdm, BinanceQV):
     """

{qubx-0.6.24 → qubx-0.6.26}/src/qubx/connectors/tardis/data.py

@@ -687,7 +687,7 @@ class TardisDataProvider(IDataProvider):
         elif data_type == DataType.QUOTE:
             return "quote"
         elif data_type == DataType.ORDERBOOK:
-            return "book_snapshot_1000_100ms"  # Default depth and interval
+            return "book_snapshot_2000_100ms"  # Default depth and interval
         elif data_type == DataType.OHLC:
             return "trade_bar_1m"  # Default timeframe
         else:

{qubx-0.6.24 → qubx-0.6.26}/src/qubx/core/interfaces.py

@@ -1090,10 +1090,6 @@ class IStrategyContext(
         """Check if the strategy context is running."""
         return False
 
-    @property
-    def is_warmup(self) -> bool:
-        return self._strategy_state.is_warmup_in_progress
-
     @property
     def is_simulation(self) -> bool:
         """Check if the strategy context is running in simulation mode."""

qubx-0.6.26/src/qubx/utils/questdb.py

@@ -0,0 +1,79 @@
+from typing import Any, Dict, List, Optional, Union
+
+import pandas as pd
+import psycopg as pg
+from psycopg.sql import SQL, Composed
+
+
+class QuestDBClient:
+    """
+    A helper class for interacting with QuestDB.
+    """
+
+    def __init__(
+        self,
+        host: str = "nebula",
+        port: int = 8812,
+        user: str = "admin",
+        password: str = "quest",
+        dbname: Optional[str] = None,
+    ):
+        """
+        Initialize the QuestDB client.
+
+        Args:
+            host: The hostname of the QuestDB server
+            port: The port number for QuestDB PostgreSQL interface
+            user: The username for authentication
+            password: The password for authentication
+            dbname: Optional database name
+        """
+        conn_str = f"user={user} password={password} host={host} port={port}"
+        if dbname:
+            conn_str += f" dbname={dbname}"
+
+        self.conn_str = conn_str
+
+    def query(self, query: str, params: Optional[Dict[str, Any]] = None) -> pd.DataFrame:
+        """
+        Execute a SQL query and return the results as a pandas DataFrame.
+
+        Args:
+            query: The SQL query to execute
+            params: Optional parameters for the query
+
+        Returns:
+            A pandas DataFrame containing the query results
+        """
+        with pg.connect(self.conn_str) as conn:
+            with conn.cursor() as cursor:
+                cursor.execute(query, params)
+                if cursor.description:  # Check if the query returns data
+                    column_names = [desc.name for desc in cursor.description]
+                    records = cursor.fetchall()
+                    return pd.DataFrame(records, columns=column_names)
+                return pd.DataFrame()
+
+    def execute(self, query: str, params: Optional[Dict[str, Any]] = None) -> int:
+        """
+        Execute a SQL statement that doesn't return data (INSERT, UPDATE, etc.).
+
+        Args:
+            query: The SQL query to execute
+            params: Optional parameters for the query
+
+        Returns:
+            The number of rows affected
+        """
+        with pg.connect(self.conn_str) as conn:
+            with conn.cursor() as cursor:
+                cursor.execute(query, params)
+                conn.commit()
+                return cursor.rowcount
+
+    def __enter__(self):
+        """Context manager entry point."""
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit point."""