kaq-quant-common 0.1.97__tar.gz

kaq_quant_common-0.1.97/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.3
+Name: kaq_quant_common
+Version: 0.1.97
+Summary: 
+Author: kevinfuture
+Author-email: liuenbofuture@foxmail.com
+Requires-Python: >=3.11, <3.13
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: aiohttp (>=3.13.2,<4.0.0)
+Requires-Dist: certifi (>=2025.11.12,<2026.0.0)
+Requires-Dist: cryptography (>=46.0.3,<47.0.0)
+Requires-Dist: dagster (==1.11.16)
+Requires-Dist: dagster-embedded-elt (==0.27.16)
+Requires-Dist: dagster-mysql (==0.27.16)
+Requires-Dist: dagster-webserver (==1.11.16)
+Requires-Dist: dlt (==1.19.1)
+Requires-Dist: dolphindb (>=3.0.4.0,<4.0.0.0)
+Requires-Dist: flask (>=3.1.2)
+Requires-Dist: loguru (>=0.7.3,<0.8.0)
+Requires-Dist: mysql-connector-python (>=9.5.0,<10.0.0)
+Requires-Dist: mysqlclient (>=2.2.7,<3.0.0)
+Requires-Dist: natsort (>=8.4.0,<9.0.0)
+Requires-Dist: plotly (>=6.5.0,<7.0.0)
+Requires-Dist: psycopg2-binary (>=2.9.11,<3.0.0)
+Requires-Dist: pyarrow (>=21.0.0,<22.0.0)
+Requires-Dist: pycryptodome (>=3.23.0)
+Requires-Dist: pydantic (>=2.12.5)
+Requires-Dist: pyhive (>=0.7.0,<0.8.0)
+Requires-Dist: pyyaml (>=6.0.3,<7.0.0)
+Requires-Dist: redis (>=6.4.0,<7.0.0)
+Requires-Dist: requests (>=2.32.0)
+Requires-Dist: requests (>=2.32.5,<3.0.0)
+Requires-Dist: retrying (>=1.4.2,<2.0.0)
+Requires-Dist: sqlalchemy (>=2.0.44,<3.0.0)
+Requires-Dist: thrift (>=0.22.0,<0.23.0)
+Requires-Dist: twine (>=6.2.0,<7.0.0)
+Requires-Dist: uuid (>=1.30,<2.0)
+Requires-Dist: vectorbt (>=0.28.1,<0.29.0)
+Requires-Dist: websocket-client (>=1.9.0,<2.0.0)
+Requires-Dist: websockets (>=15.0.1)
+Requires-Dist: werkzeug (>=3.1.4)
+Description-Content-Type: text/markdown
+
+# KAQ_QUANT_COMMON
+
+A simple Python package that does amazing things.
+
+## Features
+
+- Feature 1: Does X
+- Feature 2: Does Y
+
+## Installation
+
+You can install this package using:
+
+```bash
+pip install my-package
+```
+
+## Pub
+Command:
+```bash
+twine upload dist/* --verbose

kaq_quant_common-0.1.97/README.md

@@ -0,0 +1,21 @@
+# KAQ_QUANT_COMMON
+
+A simple Python package that does amazing things.
+
+## Features
+
+- Feature 1: Does X
+- Feature 2: Does Y
+
+## Installation
+
+You can install this package using:
+
+```bash
+pip install my-package
+```
+
+## Pub
+Command:
+```bash
+twine upload dist/* --verbose

kaq_quant_common-0.1.97/kaq_quant_common/api/common/__init__.py

@@ -0,0 +1 @@
+

kaq_quant_common-0.1.97/kaq_quant_common/api/common/api_interface.py

@@ -0,0 +1,38 @@
+from abc import ABC
+from functools import wraps
+from typing import Callable, Type
+
+from pydantic import BaseModel
+
+
+def api_method(request_model: Type[BaseModel], response_model: Type[BaseModel]):
+    """
+    api 方法注解
+    :param request_model: 请求模型
+    :param response_model: 响应模型
+    :return:
+    """
+
+    def decorator(func: Callable):
+        # 将注解信息绑定到原始函数
+        func._is_api_method = True
+        func._request_model = request_model
+        func._response_model = response_model
+
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            return func(*args, **kwargs)
+
+        # 同步注解信息到包装函数，便于通过inspect发现
+        wrapper._is_api_method = True
+        wrapper._request_model = request_model
+        wrapper._response_model = response_model
+
+        return wrapper
+
+    return decorator
+
+
+# 定义 api 接口，暂时没啥用
+class ApiInterface(ABC):
+    pass

kaq_quant_common-0.1.97/kaq_quant_common/api/common/auth.py

@@ -0,0 +1,118 @@
+import os
+from typing import Any, Optional, Tuple
+
+from kaq_quant_common.utils import yml_utils
+
+# 统一的简单鉴权：基于一个共享的 token
+# - 来源优先级：环境变量 KAQ_API_TOKEN > 配置文件 kaq.api_token
+# - 如果未配置 token，则认为鉴权关闭（通过）
+
+
+def _get_expected_token(pkg_name: Optional[str] = None) -> Optional[str]:
+    # 环境变量优先
+    token = os.getenv("KAQ_API_TOKEN")
+    if token:
+        return token.strip()
+    # 配置文件兜底
+    try:
+        token_cfg = yml_utils.get(pkg_name or "kaq_quant_common", "api_token")
+        if isinstance(token_cfg, str) and token_cfg.strip():
+            return token_cfg.strip()
+    except Exception as e:
+        # 配置读取失败则视为未配置
+        pass
+    return None
+
+
+def _extract_token_from_authorization(auth_header: Optional[str]) -> Optional[str]:
+    if not auth_header:
+        return None
+    # 支持 Bearer/Token 两种前缀
+    val = auth_header.strip()
+    lower = val.lower()
+    if lower.startswith("bearer "):
+        return val[7:].strip()
+    if lower.startswith("token "):
+        return val[6:].strip()
+    # 若为纯 token 也接受
+    return val
+
+
+def _extract_token_from_headers(headers: Any) -> Optional[str]:
+    # 兼容 Flask/Werkzeug 和 websockets.Headers
+    try:
+        # Flask/requests：大小写不敏感
+        auth = headers.get("Authorization") if hasattr(headers, "get") else None
+        if not auth and hasattr(headers, "get"):
+            auth = headers.get("authorization")
+        token = _extract_token_from_authorization(auth)
+        if token:
+            return token
+        # 备用头
+        x_token = headers.get("X-API-Token") if hasattr(headers, "get") else None
+        if not x_token and hasattr(headers, "get"):
+            x_token = headers.get("x-api-token")
+        return x_token.strip() if isinstance(x_token, str) and x_token.strip() else None
+    except Exception:
+        return None
+
+
+def _extract_token_from_path_query(path: Optional[str]) -> Optional[str]:
+    # 解析 ?token=xxx 简单查询参数
+    if not path or "?" not in path:
+        return None
+    try:
+        query = path.split("?", 1)[1]
+        for pair in query.split("&"):
+            if not pair:
+                continue
+            k, _, v = pair.partition("=")
+            if k.lower() == "token" and v:
+                return v
+    except Exception:
+        pass
+    return None
+
+
+# ----------------- 对外校验方法 -----------------
+
+
+def verify_http_request(flask_request: Any, pkg_name: Optional[str] = None) -> Tuple[bool, Optional[str]]:
+    """校验 HTTP 请求头中的 token。
+    返回 (是否通过, 错误信息)。未配置 token 时默认放行。
+    """
+    expected = _get_expected_token(pkg_name)
+    if not expected:
+        return True, None
+    # 从 Header 提取
+    token = _extract_token_from_headers(getattr(flask_request, "headers", None))
+    if token and token == expected:
+        return True, None
+    return False, "Unauthorized"
+
+
+def verify_ws_handshake(path: Optional[str], headers: Any, pkg_name: Optional[str] = None) -> Tuple[bool, Optional[str]]:
+    """校验 WebSocket 握手阶段的路径与请求头。
+    支持从 Header 与 ?token=xx 解析。未配置 token 时默认放行。
+    """
+    expected = _get_expected_token(pkg_name)
+    if not expected:
+        return True, None
+    # Header 优先
+    token = _extract_token_from_headers(headers)
+    if not token:
+        # 再从路径查询参数解析
+        token = _extract_token_from_path_query(path)
+    if token and token == expected:
+        return True, None
+    return False, "Unauthorized"
+
+
+# ----------------- 客户端复用：获取默认 token -----------------
+
+
+def get_auth_token(pkg_name: Optional[str] = None) -> Optional[str]:
+    """供客户端复用的获取默认 token 的方法。
+    与服务器端校验使用相同的来源规则。
+    """
+    return _get_expected_token(pkg_name)

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

@@ -0,0 +1,42 @@
+from typing import Optional, Type, TypeVar
+
+import requests
+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 客户端
+    """
+
+    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)
+
+    # 发送请求
+    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

kaq_quant_common-0.1.97/kaq_quant_common/api/rest/api_server_base.py

@@ -0,0 +1,135 @@
+import inspect
+import threading
+import time
+
+from flask import Flask, jsonify, request
+from werkzeug.serving import make_server
+
+from kaq_quant_common.api.common.api_interface import ApiInterface
+from kaq_quant_common.api.common.auth import verify_http_request
+from kaq_quant_common.utils import logger_utils, signal_utils
+
+
+class ApiServerBase:
+    """
+    API服务器基类，用于动态发现和分派API方法。
+    """
+
+    def __init__(self, api: ApiInterface, host="0.0.0.0", port=5000):
+        """
+        初始化API服务器。
+
+        :param api: 实现了ApiInterface的API实例。
+        :param host: 服务器主机地址。
+        :param port: 服务器端口。
+        """
+        self._app = Flask(__name__)
+        self._api = api
+        self._host = host
+        self._port = port
+        self._server = make_server(self._host, self._port, self._app)
+        self._api_methods = self._discover_api_methods()
+        self._logger = logger_utils.get_logger(self)
+
+        @self._app.route("/api/<method_name>", methods=["POST"])
+        def handle_request(method_name: str):
+            """
+            处理API请求。
+            """
+            # 简单鉴权（若未配置 token 则默认放行）
+            ok, err = verify_http_request(request)
+            if not ok:
+                return jsonify({"error": err or "Unauthorized"}), 401
+
+            if method_name not in self._api_methods:
+                return jsonify({"error": f"Method '{method_name}' not found"}), 404
+
+            method, request_model, response_model = self._api_methods[method_name]
+
+            try:
+                # 使用请求模型验证和解析JSON数据
+                request_data = request_model(**request.json)
+                # 调用API方法
+                response_data = method(request_data)
+                # 验证响应类型
+                if not isinstance(response_data, response_model):
+                    return jsonify({"error": "Invalid response type from method"}), 500
+                # 允许子类包装响应
+                response_data = self._wrap_response(response_data)
+                # 返回JSON响应
+                return jsonify(response_data.model_dump())
+            except Exception as e:
+                # 捕获请求处理过程中的异常
+                return jsonify({"error": str(e)}), 400
+
+    def _discover_api_methods(self):
+        """
+        发现并注册所有使用@api_method装饰器标记的API方法。
+        """
+        methods = {}
+        for name, func in inspect.getmembers(self._api, predicate=inspect.ismethod):
+            if hasattr(func, "_is_api_method") and func._is_api_method:
+                methods[name] = (func, func._request_model, func._response_model)
+        return methods
+
+    # 子类用来包装响应，例如添加时间戳
+    def _wrap_response(self, rsp: any):
+        return rsp
+
+    def run(self):
+        """
+        启动API服务器。
+        """
+        self._logger.info(f"Starting server on {self._host}:{self._port}")
+        self._server.serve_forever()
+
+    def shutdown(self):
+        """
+        关闭API服务器。
+        """
+        self._logger.info(f"Shutting down server on {self._host}:{self._port}")
+        self._server.shutdown()
+
+    def run_with_thread(self, block=True):
+        """
+        启动API服务器在一个新线程中。
+        """
+        self._server_thread = threading.Thread(target=self.run)
+        self._server_thread.name = "ApiServerThread"
+        self._server_thread.daemon = True
+        self._server_thread.start()
+        time.sleep(1)
+
+        if block:
+            self.wait_for_termination()
+
+    def shutdown_with_thread(self):
+        """
+        关闭服务器并等待线程退出
+        """
+        try:
+            self.shutdown()
+        finally:
+            if hasattr(self, "_server_thread") and self._server_thread.is_alive():
+                self._server_thread.join(timeout=3)
+
+    #
+    def wait_for_termination(self):
+        # 全局退出事件，用于传递终止信号
+        exit_event = threading.Event()
+
+        def handle_terminate_signal(signum, frame=None):
+            """信号处理函数：捕获终止信号并触发退出事件"""
+            self._logger.info(f"收到终止信号 {signum}")
+            exit_event.set()
+            # 优雅地停止服务器
+            self.shutdown()
+
+        # 监听信号
+        signal_utils.register_signal_handler(handle_terminate_signal)
+
+        # 监听退出事件
+        while not exit_event.is_set():
+            time.sleep(1)
+
+        self._logger.warning("ApiServer 线程退出")