walrasquant-lib 0.4.23__tar.gz → 0.4.24__tar.gz

{walrasquant_lib-0.4.23 → walrasquant_lib-0.4.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: walrasquant-lib
-Version: 0.4.23
+Version: 0.4.24
 Summary: fastest python trading bot
 Author: River-Shi
 Author-email: River-Shi <nachuan.shi.quant@gmail.com>
@@ -23,13 +23,13 @@ Requires-Dist: dynaconf[redis]>=3.2.12
 Requires-Dist: aiohttp>=3.13.3
 Requires-Dist: rich>=14.0.0
 Requires-Dist: picows>=2.1.1
-Requires-Dist: ccxt>=4.5.63
 Requires-Dist: nexuscore-lib>=0.2.0
 Requires-Dist: flashduty-lib>=0.2.0
 Requires-Dist: nexuslog-lib>=0.5.0
 Requires-Dist: msgspec>=0.21.1
 Requires-Dist: pandas<3.0.0
 Requires-Dist: numpy>=2.2.0
+Requires-Dist: ccxt>=4.5.64
 Requires-Python: >=3.11, <3.15
 Description-Content-Type: text/markdown
 

{walrasquant_lib-0.4.23 → walrasquant_lib-0.4.24}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "walrasquant-lib"
-version = "0.4.23"
+version = "0.4.24"
 description = "fastest python trading bot"
 authors = [
     {name = "River-Shi",email = "nachuan.shi.quant@gmail.com"}
@@ -27,13 +27,13 @@ dependencies = [
     "aiohttp>=3.13.3",
     "rich>=14.0.0",
     "picows>=2.1.1",
-    "ccxt>=4.5.63",
     "nexuscore-lib>=0.2.0",
     "flashduty-lib>=0.2.0",
     "nexuslog-lib>=0.5.0",
     "msgspec>=0.21.1",
     "pandas<3.0.0",
     "numpy>=2.2.0",
+    "ccxt>=4.5.64",
 ]
 
 [project.scripts]

{walrasquant_lib-0.4.23 → walrasquant_lib-0.4.24}/src/walrasquant/base/api_client.py

@@ -29,8 +29,18 @@ class ApiClient(ABC):
 
     async def _init_session(self, base_url: str | None = None):
         if self._session is None:
+            # The default TCPConnector drops idle connections after 15s and
+            # resolves DNS on a thread pool, so intermittent traders pay a
+            # fresh DNS + TCP + TLS handshake on the order path.
+            connector = aiohttp.TCPConnector(
+                limit=64,
+                ttl_dns_cache=300,
+                keepalive_timeout=60,
+                resolver=aiohttp.AsyncResolver(),
+            )
             kwargs: Dict[str, Any] = {
                 "timeout": aiohttp.ClientTimeout(total=self._timeout),
+                "connector": connector,
             }
             if base_url:
                 kwargs["base_url"] = base_url

{walrasquant_lib-0.4.23 → walrasquant_lib-0.4.24}/src/walrasquant/base/ems.py

@@ -1,7 +1,7 @@
 import asyncio
 import traceback
 from abc import ABC, abstractmethod
-from typing import Any, Mapping, List, Dict, cast
+from typing import Any, Mapping, List, Dict, cast, Tuple
 from typing import Literal
 from decimal import Decimal
 import nexuslog as logging
@@ -39,7 +39,7 @@ from walrasquant.base.connector import PrivateConnector
 _CREATE_SUBMIT_TYPES: frozenset = frozenset({SubmitType.CREATE, SubmitType.CREATE_WS})
 
 
-def _item_priority(item: tuple) -> int:
+def _item_priority(item: Tuple[OrderSubmit, SubmitType]) -> int:
     """Return the scheduling priority for a queue item.
 
     Priority scale (lower = higher priority):
@@ -89,9 +89,6 @@ class PriorityOrderQueue:
         _, _, item = await self._queue.get()
         return item
 
-    def task_done(self) -> None:
-        self._queue.task_done()
-
 
 class ExecutionManagementSystem(ABC):
     _BATCH_CHUNK_SIZE: int = 20
@@ -105,6 +102,7 @@ class ExecutionManagementSystem(ABC):
         task_manager: TaskManager,
         registry: OrderRegistry,
         queue_maxsize: int = 100_000,
+        concurrency: int = 3,
     ):
         self._log = logging.getLogger(name=type(self).__name__)
 
@@ -115,9 +113,10 @@ class ExecutionManagementSystem(ABC):
         self._registry = registry
         self._clock = clock
         self._queue_maxsize = queue_maxsize
+        self._concurrency = concurrency
         self._order_submit_queues: Dict[AccountType, PriorityOrderQueue] = {}
         self._private_connectors: Dict[AccountType, PrivateConnector] = {}
-        self._pending_create_oids: set[str] = set()
+        self._shutdown: bool = False
 
     def _safe_put(self, queue: PriorityOrderQueue, item: Any) -> None:
         # Order submits may originate off the event loop (e.g. threaded scheduled
@@ -138,15 +137,11 @@ class ExecutionManagementSystem(ABC):
 
     def _do_put(self, queue: PriorityOrderQueue, item: Any) -> None:
         # Always runs on the loop thread: queue access + bookkeeping are serialized.
-        order_submit, submit_type = item
+        if self._shutdown:
+            self._log.warning(f"EMS is shutting down; order submit rejected: {item}")
+            return
         priority = _item_priority(item)
 
-        if submit_type in _CREATE_SUBMIT_TYPES:
-            self._pending_create_oids.add(order_submit.oid)
-        elif submit_type in (SubmitType.CANCEL, SubmitType.CANCEL_WS):
-            if order_submit.oid in self._pending_create_oids:
-                priority = 6  # demote: paired create must execute first
-
         if queue.maxsize == 0 or queue.qsize() < queue.maxsize:
             try:
                 queue.put_nowait(item, priority=priority)
@@ -323,7 +318,6 @@ class ExecutionManagementSystem(ABC):
         Cancel an order
         """
         # self._cache.mark_cancel_intent(order_submit.oid)
-        self._pending_create_oids.discard(order_submit.oid)
         await self._private_connectors[account_type]._oms.cancel_order(
             oid=order_submit.oid,
             symbol=order_submit.symbol,
@@ -337,7 +331,6 @@ class ExecutionManagementSystem(ABC):
         Cancel an order
         """
         # self._cache.mark_cancel_intent(order_submit.oid)
-        self._pending_create_oids.discard(order_submit.oid)
         await self._private_connectors[account_type]._oms.cancel_order_ws(
             oid=order_submit.oid,
             symbol=order_submit.symbol,
@@ -350,7 +343,6 @@ class ExecutionManagementSystem(ABC):
         """
         Create an order
         """
-        self._pending_create_oids.discard(order_submit.oid)
         self._registry.register_order(order_submit.oid)
         self._cache.add_inflight_order(order_submit.symbol, order_submit.oid)
         await self._private_connectors[account_type]._oms.create_order(
@@ -371,7 +363,6 @@ class ExecutionManagementSystem(ABC):
         """
         Create an order
         """
-        self._pending_create_oids.discard(order_submit.oid)
         self._registry.register_order(order_submit.oid)
         self._cache.add_inflight_order(order_submit.symbol, order_submit.oid)
         await self._private_connectors[account_type]._oms.create_order_ws(
@@ -404,293 +395,6 @@ class ExecutionManagementSystem(ABC):
         """
         pass
 
-    # async def _auto_maker(self, order_submit: OrderSubmit, account_type: AccountType):
-    #     """
-    #     Auto maker order: always place the order at the best price
-    #     """
-    #     pass
-
-    # def _calculate_twap_orders(
-    #     self,
-    #     symbol: str,
-    #     total_amount: Decimal,
-    #     duration: float,
-    #     wait: float,
-    #     min_order_amount: Decimal,
-    #     reduce_only: bool = False,
-    # ) -> Tuple[List[Decimal], float]:
-    #     """
-    #     Calculate the amount list and wait time for the twap order
-
-    #     eg:
-    #     amount_list = [10, 10, 10]
-    #     wait = 10
-    #     """
-    #     amount_list = []
-    #     if total_amount == 0 or total_amount < min_order_amount:
-    #         if reduce_only and total_amount > 0:
-    #             self._log.info(
-    #                 f"TWAP ORDER: {symbol} Total amount is less than min order amount: {total_amount} < {min_order_amount}, reduce_only: {reduce_only}"
-    #             )
-    #             return [total_amount], 0
-    #         self._log.info(
-    #             f"TWAP ORDER: {symbol} Total amount is less than min order amount: {total_amount} < {min_order_amount}"
-    #         )
-    #         return [], 0
-
-    #     interval = duration // wait
-    #     base_amount = float(total_amount) / interval
-
-    #     base_amount = max(
-    #         min_order_amount, self._amount_to_precision(symbol, base_amount)
-    #     )
-
-    #     interval = int(total_amount // base_amount)
-    #     remaining = total_amount - interval * base_amount
-
-    #     amount_list = [base_amount] * interval
-
-    #     if remaining >= min_order_amount or (reduce_only and remaining > 0):
-    #         amount_list.append(remaining)
-    #     else:
-    #         amount_list[-1] += remaining
-
-    #     wait = duration / len(amount_list)
-
-    #     self._log.info(f"TWAP ORDER: {symbol} Amount list: {amount_list}, Wait: {wait}")
-
-    #     return amount_list, wait
-
-    # def _cal_limit_order_price(
-    #     self, symbol: str, side: OrderSide, market: BaseMarket
-    # ) -> Decimal:
-    #     """
-    #     Calculate the limit order price
-    #     """
-    #     basis_point = market.precision.price
-    #     book = self._cache.bookl1(symbol)
-
-    #     if side.is_buy:
-    #         # if the spread is greater than the basis point
-    #         if book.spread > basis_point:
-    #             price = book.ask - basis_point
-    #         else:
-    #             price = book.bid
-    #     elif side.is_sell:
-    #         # if the spread is greater than the basis point
-    #         if book.spread > basis_point:
-    #             price = book.bid + basis_point
-    #         else:
-    #             price = book.ask
-    #     price = self._price_to_precision(symbol, price)
-    #     self._log.debug(
-    #         f"CALCULATE LIMIT ORDER PRICE: symbol: {symbol}, side: {side}, price: {price}, ask: {book.ask}, bid: {book.bid}"
-    #     )
-    #     return price
-
-    # NOTE: TWAP order related code is commented out for now
-    # async def _twap_order(
-    #     self, order_submit: TWAPOrderSubmit, account_type: AccountType
-    # ):
-    #     """
-    #     Execute the twap order
-    #     """
-    #     symbol = order_submit.symbol
-    #     instrument_id = order_submit.instrument_id
-    #     side = order_submit.side
-    #     market = self._market[symbol]
-    #     position_side = order_submit.position_side
-    #     kwargs = order_submit.kwargs
-    #     twap_uuid = order_submit.uuid
-    #     check_interval = order_submit.check_interval
-    #     reduce_only = order_submit.kwargs.get("reduce_only", False)
-
-    #     algo_order = AlgoOrder(
-    #         symbol=symbol,
-    #         uuid=twap_uuid,
-    #         side=side,
-    #         amount=order_submit.amount,
-    #         duration=order_submit.duration,
-    #         wait=order_submit.wait,
-    #         status=AlgoOrderStatus.RUNNING,
-    #         exchange=instrument_id.exchange,
-    #         timestamp=self._clock.timestamp_ms(),
-    #         position_side=position_side,
-    #     )
-
-    #     self._cache._order_initialized(algo_order)
-
-    #     min_order_amount: Decimal = self._get_min_order_amount(symbol, market)
-    #     amount_list, wait = self._calculate_twap_orders(
-    #         symbol=symbol,
-    #         total_amount=order_submit.amount,
-    #         duration=order_submit.duration,
-    #         wait=order_submit.wait,
-    #         min_order_amount=min_order_amount,
-    #         reduce_only=reduce_only,
-    #     )
-
-    #     order_id = None
-    #     elapsed_time = 0
-
-    #     try:
-    #         while amount_list:
-    #             if order_id:
-    #                 order = self._cache.get_order(order_id)
-
-    #                 is_opened = order.bind_optional(
-    #                     lambda order: order.is_opened
-    #                 ).value_or(False)
-    #                 on_flight = order.bind_optional(
-    #                     lambda order: order.on_flight
-    #                 ).value_or(False)
-    #                 is_closed = order.bind_optional(
-    #                     lambda order: order.is_closed
-    #                 ).value_or(False)
-
-    #                 # 检查现价单是否已成交，不然的话立刻下市价单成交 或者 把remaining amount加到下一个市价单上
-    #                 if is_opened and not on_flight:
-    #                     await self._cancel_order(
-    #                         order_submit=CancelOrderSubmit(
-    #                             symbol=symbol,
-    #                             instrument_id=instrument_id,
-    #                             submit_type=SubmitType.CANCEL,
-    #                             uuid=order_id,
-    #                         ),
-    #                         account_type=account_type,
-    #                     )
-    #                 elif is_closed:
-    #                     order_id = None
-    #                     remaining = order.unwrap().remaining
-    #                     if remaining >= min_order_amount or (
-    #                         reduce_only and remaining > 0
-    #                     ):
-    #                         order = await self._create_order(
-    #                             order_submit=CreateOrderSubmit(
-    #                                 symbol=symbol,
-    #                                 instrument_id=instrument_id,
-    #                                 submit_type=SubmitType.CREATE,
-    #                                 side=side,
-    #                                 type=OrderType.MARKET,
-    #                                 amount=remaining,
-    #                                 position_side=position_side,
-    #                                 time_in_force=TimeInForce.IOC,
-    #                                 kwargs=kwargs,
-    #                             ),
-    #                             account_type=account_type,
-    #                         )
-    #                         if order.success:
-    #                             algo_order.orders.append(order.uuid)
-    #                             self._cache._order_status_update(algo_order)
-    #                         else:
-    #                             algo_order.status = AlgoOrderStatus.FAILED
-    #                             self._cache._order_status_update(algo_order)
-    #                             self._log.error(
-    #                                 f"TWAP ORDER FAILED: symbol: {symbol}, side: {side}"
-    #                             )
-    #                             break
-    #                     else:
-    #                         if amount_list:
-    #                             amount_list[-1] += remaining
-    #                 await asyncio.sleep(check_interval)
-    #                 elapsed_time += check_interval
-    #             else:
-    #                 price = self._cal_limit_order_price(
-    #                     symbol=symbol,
-    #                     side=side,
-    #                     market=market,
-    #                 )
-    #                 amount = amount_list.pop()
-    #                 if amount_list:
-    #                     order_submit = CreateOrderSubmit(
-    #                         symbol=symbol,
-    #                         instrument_id=instrument_id,
-    #                         submit_type=SubmitType.CREATE,
-    #                         type=OrderType.LIMIT,
-    #                         side=side,
-    #                         amount=amount,
-    #                         price=price,
-    #                         time_in_force=TimeInForce.GTC,
-    #                         position_side=position_side,
-    #                         kwargs=kwargs,
-    #                     )
-    #                 else:
-    #                     order_submit = CreateOrderSubmit(
-    #                         symbol=symbol,
-    #                         instrument_id=instrument_id,
-    #                         submit_type=SubmitType.CREATE,
-    #                         type=OrderType.MARKET,
-    #                         side=side,
-    #                         amount=amount,
-    #                         time_in_force=TimeInForce.IOC,
-    #                         position_side=position_side,
-    #                         kwargs=kwargs,
-    #                     )
-    #                 order = await self._create_order(order_submit, account_type)
-    #                 if order.success:
-    #                     order_id = order.uuid
-    #                     algo_order.orders.append(order_id)
-    #                     self._cache._order_status_update(algo_order)
-    #                     await asyncio.sleep(wait - elapsed_time)
-    #                     elapsed_time = 0
-    #                 else:
-    #                     algo_order.status = AlgoOrderStatus.FAILED
-    #                     self._cache._order_status_update(algo_order)
-
-    #                     self._log.error(
-    #                         f"TWAP ORDER FAILED: symbol: {symbol}, side: {side}, uuid: {twap_uuid}"
-    #                     )
-    #                     break
-
-    #         algo_order.status = AlgoOrderStatus.FINISHED
-    #         self._cache._order_status_update(algo_order)
-
-    #         self._log.info(
-    #             f"TWAP ORDER FINISHED: symbol: {symbol}, side: {side}, uuid: {twap_uuid}"
-    #         )
-    #     except asyncio.CancelledError:
-    #         algo_order.status = AlgoOrderStatus.CANCELING
-    #         self._cache._order_status_update(algo_order)
-
-    #         open_orders = self._cache.get_open_orders(symbol=symbol)
-    #         for uuid in open_orders.copy():
-    #             await self._cancel_order(
-    #                 order_submit=CancelOrderSubmit(
-    #                     symbol=symbol,
-    #                     instrument_id=instrument_id,
-    #                     submit_type=SubmitType.CANCEL,
-    #                     uuid=uuid,
-    #                 ),
-    #                 account_type=account_type,
-    #             )
-
-    #         algo_order.status = AlgoOrderStatus.CANCELED
-    #         self._cache._order_status_update(algo_order)
-
-    #         self._log.info(
-    #             f"TWAP ORDER CANCELLED: symbol: {symbol}, side: {side}, uuid: {twap_uuid}"
-    #         )
-
-    # async def _create_twap_order(
-    #     self, order_submit: TWAPOrderSubmit, account_type: AccountType
-    # ):
-    #     """
-    #     Create a twap order
-    #     """
-    #     uuid = order_submit.uuid
-    #     self._task_manager.create_task(
-    #         self._twap_order(order_submit, account_type), name=uuid
-    #     )
-
-    # async def _cancel_twap_order(
-    #     self, order_submit: CancelTWAPOrderSubmit, account_type: AccountType
-    # ):
-    #     """
-    #     Cancel a twap order
-    #     """
-    #     uuid = order_submit.uuid
-    #     self._task_manager.cancel_task(uuid)
-
     async def _create_tp_sl_order(
         self, order_submit: TakeProfitAndStopLossOrderSubmit, account_type: AccountType
     ):
@@ -737,32 +441,47 @@ class ExecutionManagementSystem(ABC):
         }
 
         self._log.debug(f"Handling orders for account type: {account_type}")
+        # Each dequeued item runs as its own task so one in-flight REST round
+        # trip does not block the rest of the queue. The semaphore throttles
+        # the dequeue itself: excess items stay in the priority queue (where
+        # cancels can still jump ahead) instead of piling up as tasks parked
+        # on a FIFO semaphore. Rate-limit quota compliance stays with the
+        # per-exchange throttled-py limiters.
+        semaphore = asyncio.Semaphore(self._concurrency)
         while True:
             queue_item = await queue.get()
-            order_submit: Any | None = None
-            submit_type: SubmitType | None = None
-            try:
-                (order_submit, submit_type) = queue_item
-                self._log.debug(f"[ORDER SUBMIT]: {order_submit}")
-                handler = submit_handlers[submit_type]
-                await handler(order_submit, account_type)
-            except Exception:
-                self._log.error(
-                    "Order submit handler failed, "
-                    f"account_type={account_type}, submit_type={submit_type}, "
-                    f"order_submit={order_submit}, queue_item={queue_item}\n"
-                    f"Traceback: {traceback.format_exc()}"
+            await semaphore.acquire()
+            (order_submit, submit_type) = queue_item
+            self._log.debug(f"[ORDER SUBMIT]: {order_submit}")
+            self._task_manager.create_task(
+                self._run_submit(
+                    submit_handlers[submit_type],
+                    order_submit,
+                    submit_type,
+                    account_type,
+                    semaphore,
                 )
-            finally:
-                try:
-                    queue.task_done()
-                except Exception:
-                    self._log.error(
-                        "Order submit queue task_done failed, "
-                        f"account_type={account_type}, submit_type={submit_type}, "
-                        f"order_submit={order_submit}, queue_item={queue_item}\n"
-                        f"Traceback: {traceback.format_exc()}"
-                    )
+            )
+
+    async def _run_submit(
+        self,
+        handler: Any,
+        order_submit: Any,
+        submit_type: SubmitType,
+        account_type: AccountType,
+        semaphore: asyncio.Semaphore,
+    ) -> None:
+        try:
+            await handler(order_submit, account_type)
+        except Exception:
+            self._log.error(
+                "Order submit handler failed, "
+                f"account_type={account_type}, submit_type={submit_type}, "
+                f"order_submit={order_submit}\n"
+                f"Traceback: {traceback.format_exc()}"
+            )
+        finally:
+            semaphore.release()
 
     async def _create_batch_orders(
         self, batch_orders: List[BatchOrderSubmit], account_type: AccountType
@@ -782,6 +501,12 @@ class ExecutionManagementSystem(ABC):
             orders=orders
         )
 
+    def shutdown(self) -> None:
+        # Stop accepting new order submits; the engine calls this before the
+        # final cancel-all sweep so late strategy callbacks cannot slip new
+        # orders past it.
+        self._shutdown = True
+
     async def start(self):
         """
         Start the order submit

{walrasquant_lib-0.4.23 → walrasquant_lib-0.4.24}/src/walrasquant/config.py

@@ -135,6 +135,9 @@ class WebConfig:
 class QueueConfig:
     ems_maxsize: int = 100_000
     sms_maxsize: int = 100_000
+    # Max concurrent in-flight order submits per account; 1 restores strictly
+    # serial submission.
+    ems_concurrency: int = 7
 
 
 @dataclass

{walrasquant_lib-0.4.23 → walrasquant_lib-0.4.24}/src/walrasquant/engine.py

@@ -310,12 +310,13 @@ class Engine:
             registry=self._registry,
             order_query_config=self._config.order_query_config,
             queue_maxsize=self._config.queue_config.ems_maxsize,
+            ems_concurrency=self._config.queue_config.ems_concurrency,
         )
 
         for exchange_id, exchange in self._exchanges.items():
             # Check if there's a custom EMS for this exchange
             if exchange_id in self._custom_ems:
-                self._ems[exchange_id] = self._custom_ems[exchange_id](
+                ems = self._custom_ems[exchange_id](
                     market=exchange.market,
                     cache=self._cache,
                     msgbus=self._msgbus,
@@ -324,6 +325,10 @@ class Engine:
                     registry=self._registry,
                     queue_maxsize=self._config.queue_config.ems_maxsize,
                 )
+                # Set directly instead of via __init__: custom EMS classes
+                # may predate the concurrency parameter.
+                ems._concurrency = self._config.queue_config.ems_concurrency
+                self._ems[exchange_id] = ems
                 self._ems[exchange_id]._build(self._private_connectors)
                 continue
 
@@ -673,6 +678,12 @@ class Engine:
                 # Suppress expected shutdown exceptions
                 pass
 
+        # Refuse any further order submits: late WS callbacks can still fire
+        # until the connectors are torn down below, and a new order slipping in
+        # after the cancel-all sweep would survive it.
+        for ems in self._ems.values():
+            ems.shutdown()
+
         # Cancel all open orders if configured
         if self._config.exit_after_cancel:
             await self._cancel_all_open_orders()

{walrasquant_lib-0.4.23 → walrasquant_lib-0.4.24}/src/walrasquant/exchange/base_factory.py

@@ -35,6 +35,7 @@ class BuildContext:
     registry: Any  # OrderRegistry
     order_query_config: OrderQueryConfig
     queue_maxsize: int = 0
+    ems_concurrency: int = 3
 
 
 class ExchangeFactory(ABC):