kaq-quant-common 0.2.12__py3-none-any.whl → 0.2.14__py3-none-any.whl

kaq_quant_common/api/rest/api_client_base.py

@@ -1,6 +1,15 @@
-from typing import Optional, Type, TypeVar
+from typing import Optional, Type, TypeVar, Callable
+import asyncio
+import threading
+import time
 
 import requests
+try:
+    import httpx
+    HTTPX_AVAILABLE = True
+except ImportError:
+    HTTPX_AVAILABLE = False
+    
 from kaq_quant_common.api.common.auth import get_auth_token
 from kaq_quant_common.utils import logger_utils
 from pydantic import BaseModel
@@ -12,11 +21,42 @@ class ApiClientBase:
     """
     api 客户端
     """
+    
+    # 类级别的共享 event loop 线程
+    _shared_loop: Optional[asyncio.AbstractEventLoop] = None
+    _shared_loop_thread: Optional[threading.Thread] = None
+    _loop_lock = threading.Lock()
 
     def __init__(self, base_url: str, token: Optional[str] = None):
         self._base_url = base_url.rstrip("/")
         self._token = token if token is not None else get_auth_token()
         self._logger = logger_utils.get_logger(self)
+        # 异步客户端（懒加载）
+        self._async_client: Optional[httpx.AsyncClient] = None
+
+    @classmethod
+    def _ensure_shared_loop(cls):
+        """确保共享的 event loop 已创建并运行"""
+        if cls._shared_loop is None or not cls._shared_loop.is_running():
+            with cls._loop_lock:
+                # 双重检查
+                if cls._shared_loop is None or not cls._shared_loop.is_running():
+                    def run_loop():
+                        """在后台线程中运行 event loop"""
+                        cls._shared_loop = asyncio.new_event_loop()
+                        asyncio.set_event_loop(cls._shared_loop)
+                        cls._shared_loop.run_forever()
+                    
+                    cls._shared_loop_thread = threading.Thread(
+                        target=run_loop,
+                        daemon=True,
+                        name="ApiClient-EventLoop"
+                    )
+                    cls._shared_loop_thread.start()
+                    
+                    # 等待 loop 启动
+                    while cls._shared_loop is None:
+                        time.sleep(0.01)
 
     # 发送请求
     def _make_request(self, method_name: str, request_data: BaseModel, response_model: Type[R]) -> R:
@@ -40,3 +80,108 @@ class ApiClientBase:
         except requests.exceptions.RequestException as e:
             self._logger.error(f"An error occurred: {e}")
             raise
+
+    # 异步发送请求
+    async def _make_request_async(self, method_name: str, request_data: BaseModel, response_model: Type[R]) -> R:
+        """
+        异步发送请求
+        
+        Args:
+            method_name: API方法名
+            request_data: 请求数据
+            response_model: 响应模型
+            
+        Returns:
+            响应对象
+        """
+        if not HTTPX_AVAILABLE:
+            raise RuntimeError("httpx library is required for async requests. Install it with: pip install httpx")
+        
+        url = f"{self._base_url}/api/{method_name}"
+        headers = {}
+        if self._token:
+            headers["Authorization"] = f"Bearer {self._token}"
+        
+        # 懒加载创建async client
+        if self._async_client is None:
+            self._async_client = httpx.AsyncClient(timeout=30.0)
+        
+        try:
+            # 发送异步post请求
+            response = await self._async_client.post(
+                url, 
+                json=request_data.model_dump(), 
+                headers=headers or None
+            )
+            # 检查响应状态码
+            if not response.is_success:
+                try:
+                    error_data = response.json()
+                    error_message = error_data.get("error", response.text)
+                except ValueError:
+                    error_message = response.text
+                raise httpx.HTTPStatusError(
+                    f"HTTP error occurred: {response.status_code} - {error_message}",
+                    request=response.request,
+                    response=response
+                )
+            # 返回请求结果
+            return response_model(**response.json())
+        except httpx.HTTPStatusError:
+            raise
+        except Exception as e:
+            self._logger.error(f"An error occurred: {e}")
+            raise
+
+    # 回调方式发送请求
+    def _make_request_callback(
+        self, 
+        method_name: str, 
+        request_data: BaseModel, 
+        response_model: Type[R],
+        on_success: Optional[Callable[[R], None]] = None,
+        on_error: Optional[Callable[[Exception], None]] = None
+    ) -> None:
+        """
+        回调方式发送请求，使用共享的 event loop
+        
+        Args:
+            method_name: API方法名
+            request_data: 请求数据
+            response_model: 响应模型
+            on_success: 成功回调，接收响应对象，可选
+            on_error: 错误回调，接收异常对象，可选
+        """
+        # 确保共享 loop 已启动
+        self._ensure_shared_loop()
+        
+        async def _async_task():
+            """异步任务"""
+            try:
+                result = await self._make_request_async(method_name, request_data, response_model)
+                # 调用成功回调（如果提供）
+                if on_success:
+                    on_success(result)
+            except Exception as e:
+                # 调用错误回调
+                if on_error:
+                    on_error(e)
+                else:
+                    self._logger.error(f"Callback request failed: {e}")
+        
+        # 将任务提交到共享的 event loop
+        asyncio.run_coroutine_threadsafe(_async_task(), self._shared_loop)
+    
+    async def close_async(self):
+        """关闭异步客户端连接"""
+        if self._async_client is not None:
+            await self._async_client.aclose()
+            self._async_client = None
+    
+    async def __aenter__(self):
+        """异步上下文管理器入口"""
+        return self
+    
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """异步上下文管理器出口"""
+        await self.close_async()

kaq_quant_common/api/rest/instruction/helper/commission_helper.py

@@ -0,0 +1,141 @@
+import json
+import pandas as pd
+from typing import Optional
+
+from kaq_quant_common.utils import logger_utils
+
+
+class CommissionHelper:
+    """手续费助手，用于从Redis加载和获取交易对的手续费率"""
+
+    def __init__(self, ins_server):
+        # 必须放在这里 延迟引入，否则会有循环引用问题
+        from kaq_quant_common.api.rest.instruction.instruction_server_base import (
+            InstructionServerBase,
+        )
+
+        self._server: InstructionServerBase = ins_server
+        self._logger = logger_utils.get_logger(self)
+
+        # 手续费数据缓存
+        self._commission_data: Optional[pd.DataFrame] = None
+        # 是否已加载
+        self._loaded = False
+
+    def _load_commission_rates(self):
+        """从Redis加载手续费率数据"""
+        if self._loaded:
+            return
+
+        redis = self._server._redis
+        if redis is None:
+            self._logger.warning("Redis未配置，无法加载手续费率")
+            return
+
+        exchange = self._server._exchange
+        # 组装Redis key，格式: kaq_{exchange}_futures_commission_rate
+        redis_key = f"kaq_{exchange}_futures_commission_rate"
+
+        try:
+            self._logger.info(f"Loading commission rates from Redis key: {redis_key}")
+            # 从Redis读取list数据
+            data_list = redis.lrange(redis_key)
+            
+            if data_list is not None and not data_list.empty:
+                self._commission_data = data_list
+                self._loaded = True
+                self._logger.info(
+                    f"Successfully loaded {len(self._commission_data)} commission rates"
+                )
+            else:
+                self._logger.warning(f"No commission rate data found in Redis key: {redis_key}")
+        except Exception as e:
+            self._logger.error(f"Failed to load commission rates from Redis: {e}")
+
+    def get_taker_commission_rate(self, symbol: str, default_rate: float = 0.0005) -> float:
+        """
+        获取指定交易对的taker手续费率
+
+        Args:
+            symbol: 交易对，如 BTCUSDT
+            default_rate: 默认手续费率，如果获取失败则使用该值
+
+        Returns:
+            float: taker手续费率
+        """
+        # 如果还没加载，先加载
+        if not self._loaded:
+            self._load_commission_rates()
+
+        # 如果还是没有数据，返回默认值
+        if self._commission_data is None or self._commission_data.empty:
+            self._logger.warning(
+                f"Commission data not available, using default rate: {default_rate}"
+            )
+            return default_rate
+
+        try:
+            # 从DataFrame中查找对应的symbol
+            matched = self._commission_data[self._commission_data["symbol"] == symbol]
+            
+            if not matched.empty:
+                rate = float(matched.iloc[0]["takerCommissionRate"])
+                self._logger.debug(f"Found taker commission rate for {symbol}: {rate}")
+                return rate
+            else:
+                self._logger.warning(
+                    f"Symbol {symbol} not found in commission data, using default rate: {default_rate}"
+                )
+                return default_rate
+        except Exception as e:
+            self._logger.error(
+                f"Error getting commission rate for {symbol}: {e}, using default rate: {default_rate}"
+            )
+            return default_rate
+
+    def get_maker_commission_rate(self, symbol: str, default_rate: float = 0.0002) -> float:
+        """
+        获取指定交易对的maker手续费率
+
+        Args:
+            symbol: 交易对，如 BTCUSDT
+            default_rate: 默认手续费率，如果获取失败则使用该值
+
+        Returns:
+            float: maker手续费率
+        """
+        # 如果还没加载，先加载
+        if not self._loaded:
+            self._load_commission_rates()
+
+        # 如果还是没有数据，返回默认值
+        if self._commission_data is None or self._commission_data.empty:
+            self._logger.warning(
+                f"Commission data not available, using default rate: {default_rate}"
+            )
+            return default_rate
+
+        try:
+            # 从DataFrame中查找对应的symbol
+            matched = self._commission_data[self._commission_data["symbol"] == symbol]
+            
+            if not matched.empty:
+                rate = float(matched.iloc[0]["makerCommissionRate"])
+                self._logger.debug(f"Found maker commission rate for {symbol}: {rate}")
+                return rate
+            else:
+                self._logger.warning(
+                    f"Symbol {symbol} not found in commission data, using default rate: {default_rate}"
+                )
+                return default_rate
+        except Exception as e:
+            self._logger.error(
+                f"Error getting commission rate for {symbol}: {e}, using default rate: {default_rate}"
+            )
+            return default_rate
+
+    def reload(self):
+        """重新加载手续费率数据"""
+        self._loaded = False
+        self._commission_data = None
+        self._load_commission_rates()

kaq_quant_common/api/rest/instruction/helper/mock_order_helper.py

@@ -0,0 +1,344 @@
+import json
+import time
+from typing import Optional
+
+from kaq_quant_common.api.rest.instruction.models.order import (
+    OrderInfo,
+    OrderSide,
+    OrderStatus,
+    PositionStatus,
+)
+from kaq_quant_common.api.rest.instruction.models.position import PositionSide
+from kaq_quant_common.utils import logger_utils, uuid_utils
+
+
+class MockOrderHelper:
+    """模拟订单助手，用于模拟下单流程，不调用真实交易所API"""
+
+    def __init__(self, ins_server):
+        # 必须放在这里 延迟引入，否则会有循环引用问题
+        from kaq_quant_common.api.rest.instruction.instruction_server_base import (
+            InstructionServerBase,
+        )
+
+        self._server: InstructionServerBase = ins_server
+        self._logger = logger_utils.get_logger(self)
+
+        self._mysql_table_name_order = "kaq_futures_instruction_order"
+        self._mysql_table_name_position = "kaq_futures_instruction_position"
+        # 当前持仓
+        self._redis_key_position = "kaq_futures_instruction_position"
+        # 持仓历史
+        self._redis_key_position_history = "kaq_futures_instruction_position_history"
+
+    def _write_position_open_to_redis(
+        self,
+        position_id: str,
+        exchange: str,
+        symbol: str,
+        position_side,
+        coin_quantity: float,
+        usdt_quantity: float,
+        open_ins_id: str,
+        open_price: float,
+        open_fee: float,
+        open_fee_rate: float,
+        open_time: int,
+    ):
+        redis = self._server._redis
+        if redis is None:
+            return
+        data = {
+            "id": position_id,
+            "exchange": exchange,
+            "symbol": symbol,
+            "position_side": position_side.value,
+            "coin_quantity": coin_quantity,
+            "usdt_quantity": usdt_quantity,
+            "open_ins_id": open_ins_id,
+            "open_price": open_price,
+            "open_fee": open_fee,
+            "open_fee_rate": open_fee_rate,
+            "open_time": open_time,
+            "close_ins_id": None,
+            "close_price": 0,
+            "close_time": 0,
+            "status": PositionStatus.OPEN.value,
+            # 标识模拟
+            "is_mock": True,
+        }
+        redis.client.hset(self._redis_key_position, position_id, json.dumps(data))
+
+    def _write_position_close_to_redis(
+        self,
+        position_id: str,
+        exchange: str,
+        symbol: str,
+        position_side,
+        coin_quantity: float,
+        usdt_quantity: float,
+        open_ins_id: str,
+        open_price: float,
+        open_fee: float,
+        open_fee_rate: float,
+        open_time: int,
+        close_ins_id: str,
+        close_price: float,
+        close_fee: float,
+        close_fee_rate: float,
+        close_time: int,
+    ):
+        redis = self._server._redis
+        if redis is None:
+            return
+
+        # 先从 redis 读取现有的 position 数据，获取 funding_rate_records 字段
+        funding_rate_records = None
+        try:
+            existing_position_json = redis.client.hget(
+                self._redis_key_position, position_id
+            )
+            if existing_position_json:
+                existing_position = json.loads(existing_position_json)
+                if existing_position and "funding_rate_records" in existing_position:
+                    funding_rate_records = existing_position.get(
+                        "funding_rate_records"
+                    )
+        except Exception as e:
+            # 读取失败不影响后续流程，记录日志
+            self._logger.warning(
+                f"Failed to get funding_rate_records for position {position_id}: {e}"
+            )
+
+        data = {
+            "id": position_id,
+            "exchange": exchange,
+            "symbol": symbol,
+            "position_side": position_side.value,
+            "coin_quantity": coin_quantity,
+            "usdt_quantity": usdt_quantity,
+            "open_ins_id": open_ins_id,
+            "open_price": open_price,
+            "open_fee": open_fee,
+            "open_fee_rate": open_fee_rate,
+            "open_time": open_time,
+            "close_ins_id": close_ins_id,
+            "close_price": close_price,
+            "close_fee": close_fee,
+            "close_fee_rate": close_fee_rate,
+            "close_time": close_time,
+            "status": PositionStatus.CLOSE.value,
+            # 标识模拟
+            "is_mock": True,
+        }
+
+        # 如果存在 funding_rate_records，添加到 data 中
+        if funding_rate_records is not None:
+            data["funding_rate_records"] = funding_rate_records
+
+        redis.client.hdel(self._redis_key_position, position_id)
+        redis.client.rpush(self._redis_key_position_history, json.dumps(data))
+
+    def process_order(
+        self,
+        order: OrderInfo,
+        mock_fill_price: Optional[float] = None,
+        mock_fee_rate: float = 0.0005,
+    ):
+        """
+        处理模拟订单
+
+        Args:
+            order: 订单信息
+            mock_fill_price: 模拟成交价格，如果为None则使用订单的target_price
+            mock_fee_rate: 模拟手续费率，默认0.05%
+        """
+        # 获取交易所
+        exchange = self._server._exchange
+
+        # 记录开始时间
+        start_time = time.time()
+
+        # 执行模拟订单处理
+        self._do_process_mock_order(exchange, order, mock_fill_price, mock_fee_rate, start_time)
+
+    def _do_process_mock_order(
+        self,
+        exchange: str,
+        order: OrderInfo,
+        mock_fill_price: Optional[float],
+        mock_fee_rate: float,
+        start_time: float,
+    ):
+        # 获取mysql
+        mysql = self._server._mysql
+
+        ins_id = order.instruction_id
+        order_id = order.order_id
+        symbol = order.symbol
+        side = order.side
+        position_side = order.position_side
+
+        is_open = True
+        side_str = "开仓"
+        if position_side == PositionSide.LONG:
+            # 多单是正向理解的
+            if side == OrderSide.SELL:
+                side_str = "平仓"
+                is_open = False
+            else:
+                side_str = "开仓"
+                is_open = True
+        else:
+            # 空单是反向理解的
+            if side == OrderSide.SELL:
+                side_str = "开仓"
+                is_open = True
+            else:
+                side_str = "平仓"
+                is_open = False
+
+        self._logger.info(
+            f"[MOCK] {ins_id}_{exchange}_{symbol} step 1. {side_str}模拟挂单 {order_id}"
+        )
+
+        # 步骤1.挂单成功 插入到订单记录
+        current_time = int(time.time() * 1000)
+
+        if mysql is not None:
+            status = OrderStatus.CREATE
+            sql = f"""
+            INSERT INTO {self._mysql_table_name_order} (ins_id, exchange, symbol, side, position_side, orig_price, orig_coin_quantity, order_id, status, create_time, last_update_time, is_mock) 
+            VALUES ( '{ins_id}', '{exchange}', '{symbol}', '{side.value}', '{order.position_side.value}', {order.current_price or order.target_price}, {order.quantity}, '{order_id}', '{status.value}', {current_time}, {current_time}, 1 );
+            """
+            execute_ret = mysql.execute_sql(sql, True)
+
+        # 步骤2.模拟成交 - 直接使用模拟价格
+        # 如果没有指定模拟成交价，使用订单的当前价格
+        avg_price = mock_fill_price if mock_fill_price is not None else order.current_price or order.target_price
+        # 成交数量就是订单数量
+        executed_qty = order.quantity
+        # 计算出usdt数量
+        executed_usdt = avg_price * executed_qty
+        # 计算手续费
+        fee = executed_usdt * mock_fee_rate
+        # 费率
+        fee_rate = mock_fee_rate
+
+        # 模拟处理时间（可以立即完成）
+        end_time = time.time()
+        cost_time = end_time - start_time
+
+        self._logger.info(
+            f"[MOCK] {ins_id}_{exchange}_{symbol} step 2. {side_str}模拟订单 {order_id} 成交 耗时 {int(cost_time * 1000)}ms"
+        )
+
+        # 步骤3.把最终持仓写进去
+        current_time = int(time.time() * 1000)
+
+        if mysql is None:
+            self._logger.warning(
+                f"[MOCK] {ins_id}_{exchange}_{symbol} 仅操作，没有入库，请设置 mysql!!"
+            )
+            return
+
+        status = OrderStatus.FINISH
+        # 更新写入最终信息
+        sql = f"""
+        UPDATE {self._mysql_table_name_order} 
+        SET price = {avg_price}, coin_quantity = {executed_qty}, usdt_quantity = {executed_usdt}, fee = {fee}, fee_rate = {fee_rate}, status = '{status.value}', last_update_time = {current_time} 
+        WHERE ins_id = '{ins_id}' AND exchange = '{exchange}' AND symbol = '{symbol}';
+        """
+        execute_ret = mysql.execute_sql(sql, True)
+
+        self._logger.info(
+            f"[MOCK] {ins_id}_{exchange}_{symbol} step 2. 模拟订单成交 {order_id}, {side_str}价格 {avg_price}, {side_str}数量 {executed_qty}, {side_str}usdt {executed_usdt}"
+        )
+
+        if is_open:
+            # 同时插入持仓表
+            position_id = uuid_utils.generate_uuid()
+            sql = f"""
+            INSERT INTO {self._mysql_table_name_position} (id, exchange, symbol, position_side, coin_quantity, usdt_quantity, open_ins_id, open_price, open_fee, open_fee_rate, open_time, status, is_mock) 
+            VALUES ( '{position_id}', '{exchange}', '{symbol}', '{position_side.value}', '{executed_qty}', '{executed_usdt}', '{ins_id}', '{avg_price}', '{fee}', '{fee_rate}', {current_time}, '{PositionStatus.OPEN.value}', 1 );
+            """
+            execute_ret = mysql.execute_sql(sql, True)
+
+            self._logger.info(
+                f"[MOCK] {ins_id}_{exchange}_{symbol} step 3. 创建持仓记录 {position_id}"
+            )
+            try:
+                self._write_position_open_to_redis(
+                    position_id,
+                    exchange,
+                    symbol,
+                    position_side,
+                    executed_qty,
+                    executed_usdt,
+                    ins_id,
+                    avg_price,
+                    fee,
+                    fee_rate,
+                    current_time,
+                )
+            except:
+                pass
+        else:
+            # 需要找到对应的持仓记录
+            sql = f"""
+            SELECT * FROM {self._mysql_table_name_position}
+            WHERE exchange = '{exchange}' AND symbol = '{symbol}' AND position_side = '{position_side.value}' AND status = '{PositionStatus.OPEN.value}' AND is_mock = 1 
+            ORDER BY open_time ASC;
+            """
+
+            # 如果有指定仓位id，就用指定的
+            if hasattr(order, "position_id") and order.position_id:
+                sql = f"""
+                SELECT * FROM {self._mysql_table_name_position}
+                WHERE id = '{order.position_id}' AND status = '{PositionStatus.OPEN.value}' AND is_mock = 1
+                """
+                self._logger.info(
+                    f"[MOCK] {ins_id}_{exchange}_{symbol} get position by id {order.position_id}"
+                )
+
+            execute_ret = mysql.execute_sql(sql)
+            try:
+                row = execute_ret.fetchone()
+                position_id = row.id
+                if position_id is not None:
+                    # 更新持仓信息
+                    sql = f"""
+                    UPDATE {self._mysql_table_name_position} 
+                    SET close_ins_id = '{ins_id}', close_price = {avg_price}, close_fee = '{fee}', close_fee_rate = '{fee_rate}', close_time = {current_time}, status = '{PositionStatus.CLOSE.value}'
+                    WHERE id = '{position_id}';
+                    """
+                    execute_ret = mysql.execute_sql(sql, True)
+
+                    self._logger.info(
+                        f"[MOCK] {ins_id}_{exchange}_{symbol} step 3. 更新持仓记录 {position_id}"
+                    )
+                    try:
+                        self._write_position_close_to_redis(
+                            position_id,
+                            exchange,
+                            symbol,
+                            position_side,
+                            float(row.coin_quantity),
+                            float(row.usdt_quantity),
+                            row.open_ins_id,
+                            float(row.open_price),
+                            float(row.open_fee),
+                            float(row.open_fee_rate),
+                            int(row.open_time),
+                            ins_id,
+                            avg_price,
+                            fee,
+                            fee_rate,
+                            current_time,
+                        )
+                    except:
+                        pass
+            except:
+                pass
+
+        return True

kaq_quant_common/api/rest/instruction/helper/order_helper.py

@@ -194,7 +194,7 @@ class OrderHelper:
                 status = OrderStatus.CREATE
                 sql = f"""
                 INSERT INTO {self._mysql_table_name_order} (ins_id, exchange, symbol, side, position_side, orig_price, orig_coin_quantity, order_id, status, create_time, last_update_time) 
-                VALUES ( '{ins_id}', '{exchange}', '{symbol}', '{side.value}', '{order.position_side.value}', {order.target_price}, {order.quantity}, '{order_id}', '{status.value}', {current_time}, {current_time} );
+                VALUES ( '{ins_id}', '{exchange}', '{symbol}', '{side.value}', '{order.position_side.value}', {order.current_price or order.target_price}, {order.quantity}, '{order_id}', '{status.value}', {current_time}, {current_time} );
                 """
                 execute_ret = mysql.execute_sql(sql, True)
 

kaq_quant_common/api/rest/instruction/instruction_client.py

@@ -1,6 +1,6 @@
 # 定义 客户端
 import time
-from typing import Type, TypeVar
+from typing import Type, TypeVar, Callable, Optional
 
 from kaq_quant_common.api.rest.api_client_base import ApiClientBase
 from kaq_quant_common.api.rest.instruction.models import (
@@ -41,6 +41,10 @@ class InstructionClient(ApiClientBase):
     def order(self, request: OrderRequest) -> OrderResponse:
         return self._make_request("order", request, OrderResponse)
 
+    # 模拟下单
+    def mock_order(self, request: OrderRequest) -> OrderResponse:
+        return self._make_request("mock_order", request, OrderResponse)
+
     # 修改订单
     def modify_order(self, request: ModifyOrderRequest) -> ModifyOrderResponse:
         return self._make_request("modify_order", request, ModifyOrderResponse)
@@ -83,4 +87,202 @@ class InstructionClient(ApiClientBase):
 
     # 查询未平仓合约数量
     def query_open_interest(self, request: QueryOpenInterestRequest) -> QueryOpenInterestResponse:
-        return self._make_request("query_open_interest", request, QueryOpenInterestResponse)
+        return self._make_request("query_open_interest", request, QueryOpenInterestResponse)
+
+    # ==================== 异步方法 ====================
+    
+    async def _make_request_async(self, method: str, request: InstructionRequestBase, response_model: Type[R]) -> R:
+        """异步版本的_make_request，处理公用字段"""
+        # 处理公用字段
+        if request.event_time is None:
+            request.event_time = int(time.time() * 1000)
+        if request.task_id is None:
+            request.task_id = f"t_{uuid_utils.generate_uuid()}"
+        return await super()._make_request_async(method, request, response_model)
+    
+    # 异步下单
+    async def order_async(self, request: OrderRequest) -> OrderResponse:
+        return await self._make_request_async("order", request, OrderResponse)
+    
+    # 异步模拟下单
+    async def mock_order_async(self, request: OrderRequest) -> OrderResponse:
+        return await self._make_request_async("mock_order", request, OrderResponse)
+    
+    # 异步修改订单
+    async def modify_order_async(self, request: ModifyOrderRequest) -> ModifyOrderResponse:
+        return await self._make_request_async("modify_order", request, ModifyOrderResponse)
+    
+    # 异步取消订单
+    async def cancel_order_async(self, request: CancelOrderRequest) -> CancelOrderResponse:
+        return await self._make_request_async("cancel_order", request, CancelOrderResponse)
+    
+    # 异步查询当前全部挂单
+    async def all_open_orders_async(self, request: AllOpenOrdersRequest) -> AllOpenOrdersResponse:
+        return await self._make_request_async("all_open_orders", request, AllOpenOrdersResponse)
+    
+    # 异步查询交易对设置
+    async def query_symbol_config_async(self, request: QuerySymbolConfigRequest) -> QuerySymbolConfigResponse:
+        return await self._make_request_async("query_symbol_config", request, QuerySymbolConfigResponse)
+    
+    # 异步调整杠杆
+    async def change_leverage_async(self, request: ChangeLeverageRequest) -> ChangeLeverageResponse:
+        return await self._make_request_async("change_leverage", request, ChangeLeverageResponse)
+    
+    # 异步查询持仓
+    async def query_position_async(self, request: QueryPositionRequest) -> QueryPositionResponse:
+        return await self._make_request_async("query_position", request, QueryPositionResponse)
+    
+    # 异步划转
+    async def transfer_async(self, request: TransferRequest) -> TransferResponse:
+        return await self._make_request_async("transfer", request, TransferResponse)
+    
+    # 异步查询合约账户余额
+    async def contract_balance_async(self, request: ContractBalanceRequest) -> ContractBalanceResponse:
+        return await self._make_request_async("contract_balance", request, ContractBalanceResponse)
+    
+    # 异步查询5档深度
+    async def get_limit_order_async(self, request: LimitOrderBookRequest) -> LimitOrderBookResponse:
+        return await self._make_request_async("get_limit_order", request, LimitOrderBookResponse)
+    
+    # 异步查询账户损益资金流水
+    async def get_account_income_async(self, request: AccountIncomeRequest) -> AccountIncomeResponse:
+        return await self._make_request_async("get_account_income", request, AccountIncomeResponse)
+    
+    # 异步查询未平仓合约数量
+    async def query_open_interest_async(self, request: QueryOpenInterestRequest) -> QueryOpenInterestResponse:
+        return await self._make_request_async("query_open_interest", request, QueryOpenInterestResponse)
+
+    # ==================== 回调方法 ====================
+    
+    def _make_request_callback(
+        self, 
+        method: str, 
+        request: InstructionRequestBase, 
+        response_model: Type[R],
+        on_success: Optional[Callable[[R], None]] = None,
+        on_error: Optional[Callable[[Exception], None]] = None
+    ) -> None:
+        """回调版本的_make_request，处理公用字段"""
+        # 处理公用字段
+        if request.event_time is None:
+            request.event_time = int(time.time() * 1000)
+        if request.task_id is None:
+            request.task_id = f"t_{uuid_utils.generate_uuid()}"
+        super()._make_request_callback(method, request, response_model, on_success, on_error)
+    
+    # 回调下单
+    def order_callback(
+        self, 
+        request: OrderRequest, 
+        on_success: Optional[Callable[[OrderResponse], None]] = None,
+        on_error: Optional[Callable[[Exception], None]] = None
+    ) -> None:
+        self._make_request_callback("order", request, OrderResponse, on_success, on_error)
+    
+    # 回调模拟下单
+    def mock_order_callback(
+        self, 
+        request: OrderRequest, 
+        on_success: Optional[Callable[[OrderResponse], None]] = None,
+        on_error: Optional[Callable[[Exception], None]] = None
+    ) -> None:
+        self._make_request_callback("mock_order", request, OrderResponse, on_success, on_error)
+    
+    # 回调修改订单
+    def modify_order_callback(
+        self, 
+        request: ModifyOrderRequest, 
+        on_success: Optional[Callable[[ModifyOrderResponse], None]] = None,
+        on_error: Optional[Callable[[Exception], None]] = None
+    ) -> None:
+        self._make_request_callback("modify_order", request, ModifyOrderResponse, on_success, on_error)
+    
+    # 回调取消订单
+    def cancel_order_callback(
+        self, 
+        request: CancelOrderRequest, 
+        on_success: Optional[Callable[[CancelOrderResponse], None]] = None,
+        on_error: Optional[Callable[[Exception], None]] = None
+    ) -> None:
+        self._make_request_callback("cancel_order", request, CancelOrderResponse, on_success, on_error)
+    
+    # 回调查询当前全部挂单
+    def all_open_orders_callback(
+        self, 
+        request: AllOpenOrdersRequest, 
+        on_success: Optional[Callable[[AllOpenOrdersResponse], None]] = None,
+        on_error: Optional[Callable[[Exception], None]] = None
+    ) -> None:
+        self._make_request_callback("all_open_orders", request, AllOpenOrdersResponse, on_success, on_error)
+    
+    # 回调查询交易对设置
+    def query_symbol_config_callback(
+        self, 
+        request: QuerySymbolConfigRequest, 
+        on_success: Optional[Callable[[QuerySymbolConfigResponse], None]] = None,
+        on_error: Optional[Callable[[Exception], None]] = None
+    ) -> None:
+        self._make_request_callback("query_symbol_config", request, QuerySymbolConfigResponse, on_success, on_error)
+    
+    # 回调调整杠杆
+    def change_leverage_callback(
+        self, 
+        request: ChangeLeverageRequest, 
+        on_success: Optional[Callable[[ChangeLeverageResponse], None]] = None,
+        on_error: Optional[Callable[[Exception], None]] = None
+    ) -> None:
+        self._make_request_callback("change_leverage", request, ChangeLeverageResponse, on_success, on_error)
+    
+    # 回调查询持仓
+    def query_position_callback(
+        self, 
+        request: QueryPositionRequest, 
+        on_success: Optional[Callable[[QueryPositionResponse], None]] = None,
+        on_error: Optional[Callable[[Exception], None]] = None
+    ) -> None:
+        self._make_request_callback("query_position", request, QueryPositionResponse, on_success, on_error)
+    
+    # 回调划转
+    def transfer_callback(
+        self, 
+        request: TransferRequest, 
+        on_success: Optional[Callable[[TransferResponse], None]] = None,
+        on_error: Optional[Callable[[Exception], None]] = None
+    ) -> None:
+        self._make_request_callback("transfer", request, TransferResponse, on_success, on_error)
+    
+    # 回调查询合约账户余额
+    def contract_balance_callback(
+        self, 
+        request: ContractBalanceRequest, 
+        on_success: Optional[Callable[[ContractBalanceResponse], None]] = None,
+        on_error: Optional[Callable[[Exception], None]] = None
+    ) -> None:
+        self._make_request_callback("contract_balance", request, ContractBalanceResponse, on_success, on_error)
+    
+    # 回调查询5档深度
+    def get_limit_order_callback(
+        self, 
+        request: LimitOrderBookRequest, 
+        on_success: Optional[Callable[[LimitOrderBookResponse], None]] = None,
+        on_error: Optional[Callable[[Exception], None]] = None
+    ) -> None:
+        self._make_request_callback("get_limit_order", request, LimitOrderBookResponse, on_success, on_error)
+    
+    # 回调查询账户损益资金流水
+    def get_account_income_callback(
+        self, 
+        request: AccountIncomeRequest, 
+        on_success: Optional[Callable[[AccountIncomeResponse], None]] = None,
+        on_error: Optional[Callable[[Exception], None]] = None
+    ) -> None:
+        self._make_request_callback("get_account_income", request, AccountIncomeResponse, on_success, on_error)
+    
+    # 回调查询未平仓合约数量
+    def query_open_interest_callback(
+        self, 
+        request: QueryOpenInterestRequest, 
+        on_success: Optional[Callable[[QueryOpenInterestResponse], None]] = None,
+        on_error: Optional[Callable[[Exception], None]] = None
+    ) -> None:
+        self._make_request_callback("query_open_interest", request, QueryOpenInterestResponse, on_success, on_error)

kaq_quant_common/api/rest/instruction/instruction_server_base.py

@@ -6,6 +6,10 @@ from kaq_quant_common.api.common.api_interface import ApiInterface, api_method
 from kaq_quant_common.api.rest.api_server_base import ApiServerBase
 from kaq_quant_common.api.rest.instruction.helper.order_helper import \
     OrderHelper
+from kaq_quant_common.api.rest.instruction.helper.mock_order_helper import \
+    MockOrderHelper
+from kaq_quant_common.api.rest.instruction.helper.commission_helper import \
+    CommissionHelper
 from kaq_quant_common.api.rest.instruction.models import \
     InstructionResponseBase
 from kaq_quant_common.api.rest.instruction.models.account import (
@@ -39,6 +43,8 @@ class InstructionServerBase(ApiServerBase, ApiInterface, ABC):
 
         # helper
         self._order_helper = OrderHelper(self)
+        self._mock_order_helper = MockOrderHelper(self)
+        self._commission_helper = CommissionHelper(self)
 
     # 统一处理返回数据
     def _wrap_response(self, rsp: InstructionResponseBase):
@@ -57,6 +63,54 @@ class InstructionServerBase(ApiServerBase, ApiInterface, ABC):
             raise Exception(f"order failed: {ret.orders[0].message}")
         return ret
 
+    # 模拟下单
+    @api_method(OrderRequest, OrderResponse)
+    def mock_order(self, request: OrderRequest) -> OrderResponse:
+        """
+        模拟下单，不调用真实交易所API
+        直接在父类处理，子类无需重写
+        """
+        ret = OrderResponse(orders=[])
+        
+        # 遍历所有订单
+        for order in request.orders:
+            # 获取模拟成交价
+            mock_fill_price = order.current_price
+            
+            # 从commission_helper获取手续费率，如果获取失败使用默认值0.0005
+            mock_fee_rate = self._commission_helper.get_taker_commission_rate(
+                symbol=order.symbol,
+                default_rate=0.0005
+            )
+            
+            # 使用mock_order_helper处理
+            try:
+                self._mock_order_helper.process_order(
+                    order=order,
+                    mock_fill_price=mock_fill_price,
+                    mock_fee_rate=mock_fee_rate
+                )
+                # 成功的订单
+                from kaq_quant_common.api.rest.instruction.models.order import OpenedOrderInfo
+                ret.orders.append(
+                    OpenedOrderInfo(
+                        order_id=order.order_id,
+                        symbol=order.symbol
+                    )
+                )
+            except Exception as e:
+                self._logger.error(f"Mock order failed: {e}")
+                from kaq_quant_common.api.rest.instruction.models.order import OpenedOrderInfo
+                ret.orders.append(
+                    OpenedOrderInfo(
+                        order_id=order.order_id,
+                        symbol=order.symbol,
+                        message=str(e)
+                    )
+                )
+        
+        return ret
+
     # 修改订单
     @api_method(ModifyOrderRequest, ModifyOrderResponse)
     def modify_order(self, request: ModifyOrderRequest) -> ModifyOrderResponse:

kaq_quant_common/api/rest/instruction/models/loan.py

@@ -0,0 +1,22 @@
+from typing import Optional
+
+from kaq_quant_common.api.rest.instruction.models import (
+    InstructionRequestBase, InstructionResponseBase)
+
+# -----------------------------借贷-------------------
+
+
+# ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ 活期借币
+class QueryFlexibleLoanAssetRequest(InstructionRequestBase):
+    # 币种代码
+    coin: str
+
+class QueryFlexibleLoanAssetResponse(InstructionResponseBase):
+    # 币种代码
+    coin: str
+    # 活期借币利率
+    interestRate: Optional[float] = None
+    # 最低可借数量
+    minLimit: Optional[float] = None
+    # 最高可借数量
+    maxLimit: Optional[float] = None

kaq_quant_common/api/rest/instruction/models/order.py

@@ -75,7 +75,7 @@ class OrderInfo(BaseModel):
     quantity: float
     # 限价单才用
     target_price: float
-    # 当前价格，？什么时候用
+    # 当前价格,模拟下单可以用 
     current_price: Optional[float] = 0.0
     # 交易类型 市价单/限价单
     trade_type: OrderTradeType

kaq_quant_common/common/modules/funding_rate_helper.py

@@ -132,6 +132,8 @@ class FundingRateHelper:
                             # 避免刷库异常导致线程退出
                             self._logger.error(f"批量写入list失败: {e}")
 
-            # mtw交由ddb自己控制节奏
             if not self._isMtwDdb:
                 time.sleep(self._flush_interval_ms / 1000.0)
+            else:
+                # mtw交由ddb自己控制节奏
+                time.sleep(50 / 1000.0)

kaq_quant_common/common/modules/limit_order_helper.py

@@ -153,6 +153,8 @@ class LimitOrderHelper:
                 #         f"批量写入{len(to_process)}条数据耗时{total_use_time}ms(avg {cum_total_use_time / cum_count:.2f}ms) 转换耗时{convert_use}ms(avg {cum_convert_time / cum_count:.2f}ms) 写入ddb耗时{write_ddb_use}ms(avg {cum_write_ddb_time / cum_count:.2f}ms)"
                 #     )
 
-            # mtw交由ddb自己控制节奏
             if not self._isMtwDdb:
                 time.sleep(self._flush_interval_ms / 1000.0)
+            else:
+                # mtw交由ddb自己控制节奏
+                time.sleep(50 / 1000.0)

{kaq_quant_common-0.2.12.dist-info → kaq_quant_common-0.2.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kaq_quant_common
-Version: 0.2.12
+Version: 0.2.14
 Summary: 
 Author: kevinfuture
 Author-email: liuenbofuture@foxmail.com

{kaq_quant_common-0.2.12.dist-info → kaq_quant_common-0.2.14.dist-info}/RECORD

@@ -4,14 +4,17 @@ kaq_quant_common/api/common/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY7
 kaq_quant_common/api/common/api_interface.py,sha256=E59C2Gh51wmy9NpD9y_SnCh_J-ZbZhT7rUsaORWzXHI,962
 kaq_quant_common/api/common/auth.py,sha256=XqirJRL4D01YfSrBY4hyugw-Op6OJveNE--AnaqhYTQ,3987
 kaq_quant_common/api/rest/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kaq_quant_common/api/rest/api_client_base.py,sha256=LYpqjjVGbVRVyP8qdmlgMelUtEY-jGA0JlMJy9d1r4w,1673
+kaq_quant_common/api/rest/api_client_base.py,sha256=BtJbN8tB-HqLiH_usDq3I6ZWkFtMh9yizWWOe2HzfD4,6945
 kaq_quant_common/api/rest/api_server_base.py,sha256=URrvzerHIE6XQLERYFcFH1ftLbCYTz3sENAxFD0HWY0,4653
-kaq_quant_common/api/rest/instruction/helper/order_helper.py,sha256=eZ-iEZ7HegHYkqpflwKicbdLlp12gcV2wEtBVNLMBiQ,13195
-kaq_quant_common/api/rest/instruction/instruction_client.py,sha256=NwTEypC4eajGq8oWIgvKSbIAO-KMPH4jQ-7J2b9iN4g,4037
-kaq_quant_common/api/rest/instruction/instruction_server_base.py,sha256=pq1wghAlgtm10aWz70-x1OAqtoRH3lBu-HsIuVRHkqY,6223
+kaq_quant_common/api/rest/instruction/helper/commission_helper.py,sha256=lVthj5SENMylH2VH90b77jeCM1sTN9JJXYkSyfsLUgA,5234
+kaq_quant_common/api/rest/instruction/helper/mock_order_helper.py,sha256=VgmQiXSM4Cd7M4CZSiY_szODvLJ3Nwv4998Kn6OGb7E,12968
+kaq_quant_common/api/rest/instruction/helper/order_helper.py,sha256=rQ2R0noKecfCX7CXnHEtGQLx0qTs19VRq2uTTW-yWiE,13218
+kaq_quant_common/api/rest/instruction/instruction_client.py,sha256=JlsHg_A9HBuAfqPFpINtWWL-mvPxUUMsODMdIMyeg3Q,13400
+kaq_quant_common/api/rest/instruction/instruction_server_base.py,sha256=KWOKynlZzAkMUKa8gRMLtD2t9bR2iziu5x0wuTRZAo4,8342
 kaq_quant_common/api/rest/instruction/models/__init__.py,sha256=fx5pnfcf9L5KvAqhsQBZkl9fUf9oABuroLGZqDNycpc,312
 kaq_quant_common/api/rest/instruction/models/account.py,sha256=Lj12EvWNxEt7k9dAKSsFhTJDmLX553duMRa5NroJW30,1375
-kaq_quant_common/api/rest/instruction/models/order.py,sha256=F941DPXlbsklpc8jHLaJ2nQZiUmjPt0zyL_bagijSzI,6847
+kaq_quant_common/api/rest/instruction/models/loan.py,sha256=0K6_hTmGNPQagUaNg0-5io8a19NZTBjweBmyPE0h7Ms,781
+kaq_quant_common/api/rest/instruction/models/order.py,sha256=TO_1Z4TYNQSHW7dCe_M7F4lxQJq33ymPtDJV8Qohz2w,6849
 kaq_quant_common/api/rest/instruction/models/position.py,sha256=OqtfWWcpGhbijJbwJqERkeFxPiIkzdBnhPx5CfXj8W0,1744
 kaq_quant_common/api/rest/instruction/models/transfer.py,sha256=htjk4hb9THUZP4REW5gtyPdo850jHPtHPWFLPA2ERzo,775
 kaq_quant_common/api/ws/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -27,8 +30,8 @@ kaq_quant_common/api/ws/ws_server_base.py,sha256=-JFA5fnYHXPYBZ09aZmhYuhgDHFfJbk
 kaq_quant_common/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 kaq_quant_common/common/ddb_table_monitor.py,sha256=7Yihz_uGGujo_QqqPl45Gp8fwUMMw1auXx5egbzyYlE,3662
 kaq_quant_common/common/http_monitor.py,sha256=_yChiwfVv1c5g_lKgYUjWY40fX61BWVK8SL4kXwRfwk,2375
-kaq_quant_common/common/modules/funding_rate_helper.py,sha256=Q6GfEF1J78ynw-FSNG8DvoCd_FkrkeLaWh9dddP89l0,5738
-kaq_quant_common/common/modules/limit_order_helper.py,sha256=bFeg3xEiFNeNm2PzVdntcGZ9-XwGbbfK3wXb2tD97ng,6810
+kaq_quant_common/common/modules/funding_rate_helper.py,sha256=IHBOMZuTpCqvLlPzrB0KquqEWVeIOEEE1wBsNM4VS9g,5800
+kaq_quant_common/common/modules/limit_order_helper.py,sha256=TB7aXOaQBvWJfJD58qTDEtSgrzExD1zEAc0h8jSiVio,6872
 kaq_quant_common/common/modules/limit_order_symbol_monitor.py,sha256=TBK48qyeCSQvkfDMv3J_0UM7f3OuBRKRFYDcL9kG6Cs,2876
 kaq_quant_common/common/modules/limit_order_symbol_monitor_group.py,sha256=oEqHIwxhqAzckmluHJHZHiHUNmAyaS2JyK2nXO58UhY,2394
 kaq_quant_common/common/monitor_base.py,sha256=E4EUMsO3adNltCDNRgxkvUSbTTfKOL9S1zzN3WkZvpU,2467
@@ -62,6 +65,6 @@ kaq_quant_common/utils/signal_utils.py,sha256=zBSyEltNTKqkQCsrETd47kEBb3Q_OWUBUn
 kaq_quant_common/utils/sqlite_utils.py,sha256=UDDFKfwL0N-jFifl40HdyOCENh2YQfW5so6hRaSJpv0,5722
 kaq_quant_common/utils/uuid_utils.py,sha256=pm_pnXpd8n9CI66x3A20cOEUiriJyqHaKGCeLrgkBxU,71
 kaq_quant_common/utils/yml_utils.py,sha256=gcKjb_-uuUajBGAl5QBPIZTg2wXm7qeeJvtHflj_zOE,4513
-kaq_quant_common-0.2.12.dist-info/METADATA,sha256=01-VmQRR1xKShnvPmuQq13AHY2vuATgs_xPf31wuHAo,1971
-kaq_quant_common-0.2.12.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-kaq_quant_common-0.2.12.dist-info/RECORD,,
+kaq_quant_common-0.2.14.dist-info/METADATA,sha256=pJ3PpYNzfqPpmGgqeNaei6_W6c0_LhHKbQQqN890rTY,1971
+kaq_quant_common-0.2.14.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+kaq_quant_common-0.2.14.dist-info/RECORD,,