kaq-quant-common 0.2.11__tar.gz → 0.2.13__tar.gz

{kaq_quant_common-0.2.11 → kaq_quant_common-0.2.13}/PKG-INFO

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

kaq_quant_common-0.2.13/kaq_quant_common/api/rest/api_client_base.py

@@ -0,0 +1,187 @@
+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
+
+R = TypeVar("R", bound=BaseModel)
+
+
+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:
+        url = f"{self._base_url}/api/{method_name}"
+        headers = {}
+        if self._token:
+            headers["Authorization"] = f"Bearer {self._token}"
+        try:
+            # 发送post请求
+            response = requests.post(url, json=request_data.model_dump(), headers=headers or None)
+            # 检查响应状态码，如果不成功，则尝试解析错误信息并抛出异常
+            if not response.ok:
+                try:
+                    error_data = response.json()
+                    error_message = error_data.get("error", response.text)
+                except ValueError:
+                    error_message = response.text
+                raise requests.exceptions.HTTPError(f"HTTP error occurred: {response.status_code} - {error_message}", response=response)
+            # 返回请求结果
+            return response_model(**response.json())
+        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-0.2.13/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-0.2.13/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-0.2.11 → kaq_quant_common-0.2.13}/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)