Qubx 0.6.20__tar.gz → 0.6.21__tar.gz

{qubx-0.6.20 → qubx-0.6.21}/PKG-INFO

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

{qubx-0.6.20 → qubx-0.6.21}/pyproject.toml

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

{qubx-0.6.20 → qubx-0.6.21}/src/qubx/connectors/ccxt/broker.py

@@ -12,6 +12,7 @@ from qubx.core.basics import (
     CtrlChannel,
     Instrument,
     Order,
+    OrderSide,
 )
 from qubx.core.errors import OrderCancellationError, OrderCreationError, create_error_event
 from qubx.core.exceptions import BadRequest, InvalidOrderParameters
@@ -63,7 +64,7 @@ class CcxtBroker(IBroker):
     def send_order_async(
         self,
         instrument: Instrument,
-        order_side: str,
+        order_side: OrderSide,
         order_type: str,
         amount: float,
         price: float | None = None,
@@ -127,7 +128,7 @@ class CcxtBroker(IBroker):
     def send_order(
         self,
         instrument: Instrument,
-        order_side: str,
+        order_side: OrderSide,
         order_type: str,
         amount: float,
         price: float | None = None,
@@ -195,7 +196,7 @@ class CcxtBroker(IBroker):
     async def _create_order(
         self,
         instrument: Instrument,
-        order_side: str,
+        order_side: OrderSide,
         order_type: str,
         amount: float,
         price: float | None = None,
@@ -246,13 +247,12 @@ class CcxtBroker(IBroker):
             logger.error(
                 f"(::_create_order) {order_side} {amount} {order_type} for {instrument.symbol} exception : {err}"
             )
-            logger.error(traceback.format_exc())
             return None, err
 
     def _prepare_order_payload(
         self,
         instrument: Instrument,
-        order_side: str,
+        order_side: OrderSide,
         order_type: str,
         amount: float,
         price: float | None = None,
@@ -263,11 +263,6 @@ class CcxtBroker(IBroker):
         params = {}
         _is_trigger_order = order_type.startswith("stop_")
 
-        if order_type == "limit" or _is_trigger_order:
-            params["timeInForce"] = time_in_force.upper()
-            if price is None:
-                raise InvalidOrderParameters(f"Price must be specified for '{order_type}' order")
-
         quote = self.data_provider.get_quote(instrument)
         if quote is None:
             logger.warning(f"[<y>{instrument.symbol}</y>] :: Quote is not available for order creation.")
@@ -293,10 +288,27 @@ class CcxtBroker(IBroker):
             params["type"] = "swap"
 
         ccxt_symbol = instrument_to_ccxt_symbol(instrument)
+
+        if order_type == "limit" or _is_trigger_order:
+            time_in_force = time_in_force.upper()
+            params["timeInForce"] = time_in_force
+            if price is None:
+                raise InvalidOrderParameters(f"Price must be specified for '{order_type}' order")
+            if order_side == "BUY" and time_in_force == "GTX" and price >= quote.ask:
+                logger.info(
+                    f"[{instrument.symbol}] :: GTX BUY order price {price} is greater than ask price {quote.ask}. Setting 1 tick below ask."
+                )
+                price = quote.ask - instrument.tick_size
+            elif order_side == "SELL" and time_in_force == "GTX" and price <= quote.bid:
+                logger.info(
+                    f"[{instrument.symbol}] :: GTX SELL order price {price} is less than bid price {quote.bid}. Setting 1 tick above bid."
+                )
+                price = quote.bid + instrument.tick_size
+
         return {
             "symbol": ccxt_symbol,
-            "type": order_type,
-            "side": order_side,
+            "type": order_type.lower(),
+            "side": order_side.lower(),
             "amount": amount,
             "price": price,
             "params": params,
@@ -336,11 +348,10 @@ class CcxtBroker(IBroker):
                     logger.debug(f"[{order_id}] Could not cancel order: {err}")
                     return False
             except (ccxt.NetworkError, ccxt.ExchangeError, ccxt.ExchangeNotAvailable) as e:
-                logger.debug(f"[{order_id}] Network or exchange error while cancelling: {e}")
+                logger.warning(f"[{order_id}] Network or exchange error while cancelling: {e}")
                 # Continue with retry logic
             except Exception as err:
                 logger.error(f"Unexpected error canceling order {order_id}: {err}")
-                logger.error(traceback.format_exc())
                 return False
 
             # Common retry logic for all retryable errors

{qubx-0.6.20 → qubx-0.6.21}/src/qubx/connectors/ccxt/exchanges/binance/broker.py

@@ -2,7 +2,7 @@ from typing import Any
 
 from qubx import logger
 from qubx.connectors.ccxt.broker import CcxtBroker
-from qubx.core.basics import Instrument
+from qubx.core.basics import Instrument, OrderSide
 from qubx.core.exceptions import BadRequest
 
 
@@ -21,7 +21,7 @@ class BinanceCcxtBroker(CcxtBroker):
     def _prepare_order_payload(
         self,
         instrument: Instrument,
-        order_side: str,
+        order_side: OrderSide,
         order_type: str,
         amount: float,
         price: float | None = None,
@@ -42,8 +42,8 @@ class BinanceCcxtBroker(CcxtBroker):
             raise BadRequest(f"Quote is not available for price match for {instrument.symbol}")
 
         if time_in_force == "gtx" and price is not None and self.enable_price_match:
-            if (order_side == "buy" and quote.bid - price < self.price_match_ticks * instrument.tick_size) or (
-                order_side == "sell" and price - quote.ask < self.price_match_ticks * instrument.tick_size
+            if (order_side == "BUY" and quote.bid - price < self.price_match_ticks * instrument.tick_size) or (
+                order_side == "SELL" and price - quote.ask < self.price_match_ticks * instrument.tick_size
             ):
                 params["priceMatch"] = "QUEUE"
                 logger.debug(f"[<y>{instrument.symbol}</y>] :: Price match is set to QUEUE. Price will be ignored.")

{qubx-0.6.20 → qubx-0.6.21}/src/qubx/core/mixins/trading.py

@@ -1,17 +1,68 @@
 from typing import Any
 
 from qubx import logger
-from qubx.core.basics import Instrument, MarketType, Order, OrderRequest
+from qubx.core.basics import Instrument, MarketType, Order, OrderRequest, OrderSide
 from qubx.core.interfaces import IAccountProcessor, IBroker, ITimeProvider, ITradingManager
 
 
+class ClientIdStore:
+    """Manages generation of unique client order IDs."""
+
+    def __init__(self):
+        """Initialize a client ID store."""
+        self._order_id: int | None = None
+
+    def generate_id(self, time_provider: ITimeProvider, symbol: str) -> str:
+        """Generate a unique client order ID.
+
+        Args:
+            time_provider: Time provider to get current timestamp
+            symbol: Trading symbol for the order
+
+        Returns:
+            A unique client order ID
+        """
+        # Initialize order ID from timestamp if not yet set
+        if self._order_id is None:
+            self._order_id = self._initialize_id_from_timestamp(time_provider)
+
+        # Increment order ID to ensure uniqueness across calls
+        self._order_id += 1
+
+        # Create and return the unique ID
+        return self._create_id(symbol, self._order_id)
+
+    def _initialize_id_from_timestamp(self, time_provider: ITimeProvider) -> int:
+        """Initialize the order ID from the current timestamp.
+
+        Args:
+            time_provider: Time provider to get current timestamp
+
+        Returns:
+            Initial order ID value
+        """
+        return time_provider.time().astype("int64") // 100_000_000
+
+    def _create_id(self, symbol: str, order_id: int) -> str:
+        """Create the ID from symbol and order ID.
+
+        Args:
+            symbol: Trading symbol
+            order_id: Current order ID counter
+
+        Returns:
+            Client ID string
+        """
+        return "_".join(["qubx", symbol, str(order_id)])
+
+
 class TradingManager(ITradingManager):
     _time_provider: ITimeProvider
     _broker: IBroker
     _account: IAccountProcessor
     _strategy_name: str
 
-    _order_id: int | None = None
+    _client_id_store: ClientIdStore
 
     def __init__(
         self, time_provider: ITimeProvider, broker: IBroker, account: IAccountProcessor, strategy_name: str
@@ -20,6 +71,7 @@ class TradingManager(ITradingManager):
         self._broker = broker
         self._account = account
         self._strategy_name = strategy_name
+        self._client_id_store = ClientIdStore()
 
     def trade(
         self,
@@ -97,8 +149,8 @@ class TradingManager(ITradingManager):
             return price
         return instrument.round_price_down(price) if amount > 0 else instrument.round_price_up(price)
 
-    def _get_side(self, amount: float) -> str:
-        return "buy" if amount > 0 else "sell"
+    def _get_side(self, amount: float) -> OrderSide:
+        return "BUY" if amount > 0 else "SELL"
 
     def _get_order_type(self, instrument: Instrument, price: float | None, options: dict[str, Any]) -> str:
         if price is None:
@@ -137,11 +189,7 @@ class TradingManager(ITradingManager):
             self.cancel_order(o.id)
 
     def _generate_order_client_id(self, symbol: str) -> str:
-        if self._order_id is None:
-            self._order_id = self._time_provider.time().astype("int64") // 100_000_000
-        assert self._order_id is not None
-        self._order_id += 1
-        return "_".join(["qubx", symbol, str(self._order_id)])
+        return self._client_id_store.generate_id(self._time_provider, symbol)
 
     def exchanges(self) -> list[str]:
         return [self._broker.exchange()]