infomankit 0.3.23__py3-none-any.whl

infoman/service/routers/health_router.py

@@ -0,0 +1,311 @@
+# !/usr/bin/env python
+# -*-coding:utf-8 -*-
+
+"""
+健康检查路由（支持可选依赖）
+
+提供多层次的健康检查端点，支持 Kubernetes 探针
+- /api/health - 基础健康检查
+- /api/health/liveness - 存活探针
+- /api/health/readiness - 就绪探针
+- /api/health/startup - 启动探针
+- /api/health/detailed - 详细健康状态
+
+注意：所有检查都会优雅处理可选依赖（Redis/Vector/NATS）
+未安装的依赖会标记为 "not_configured"，不影响整体健康状态
+"""
+
+import time
+from typing import Dict, Any, List
+from fastapi import Request, APIRouter, status
+from loguru import logger
+
+from infoman.service.core.response import success, failed
+
+health_router = APIRouter(prefix="")
+
+# 应用启动时间
+_startup_time = time.time()
+
+
+@health_router.get(
+    summary="基础健康检查",
+    path="",
+    description="返回应用的基本健康状态",
+)
+async def api_health(req: Request):
+    """基础健康检查 - 仅检查应用是否运行"""
+    uptime = time.time() - _startup_time
+    return success(data={
+        "status": "healthy",
+        "uptime_seconds": round(uptime, 2),
+    })
+
+
+@health_router.get(
+    "/liveness",
+    summary="存活探针",
+    description="Kubernetes liveness probe - 检查应用是否存活",
+    status_code=status.HTTP_200_OK,
+)
+async def liveness_check(req: Request):
+    """
+    存活探针 (Liveness Probe)
+
+    用于判断应用是否还活着，如果失败，Kubernetes 会重启 Pod
+    这个检查应该非常轻量，只检查应用进程是否响应
+    """
+    return {"status": "alive"}
+
+
+@health_router.get(
+    "/readiness",
+    summary="就绪探针",
+    description="Kubernetes readiness probe - 检查应用是否就绪接受流量",
+    status_code=status.HTTP_200_OK,
+    responses={
+        200: {"description": "Application is ready"},
+        503: {"description": "Application is not ready"},
+    },
+)
+async def readiness_check(req: Request):
+    """
+    就绪探针 (Readiness Probe)
+
+    用于判断应用是否准备好接受流量
+    如果失败，Kubernetes 会将 Pod 从 Service 负载均衡中移除
+
+    检查项：
+    - 数据库连接（必需）
+    - Redis 连接（可选）
+    - 向量数据库连接（可选）
+    - 消息队列连接（可选）
+
+    注意：只有必需的数据库会影响就绪状态，可选依赖不影响
+    """
+    checks: Dict[str, Any] = {}
+    all_ready = True
+
+    # 检查数据库（必需）
+    try:
+        if hasattr(req.app.state, "db_manager"):
+            db_health = await req.app.state.db_manager.health_check()
+            checks["database"] = db_health
+            if db_health.get("status") != "healthy":
+                all_ready = False
+        else:
+            checks["database"] = {"status": "not_configured"}
+            all_ready = False  # 数据库是必需的
+    except Exception as e:
+        logger.error(f"Database readiness check failed: {e}")
+        checks["database"] = {"status": "unhealthy", "error": str(e)}
+        all_ready = False
+
+    # 检查 Redis（可选，不影响就绪状态）
+    try:
+        if hasattr(req.app.state, "redis_manager"):
+            redis_health = await req.app.state.redis_manager.health_check()
+            checks["redis"] = redis_health
+            # 可选依赖不影响就绪状态
+        else:
+            checks["redis"] = {"status": "not_configured"}
+    except Exception as e:
+        logger.warning(f"Redis readiness check failed: {e}")
+        checks["redis"] = {"status": "unhealthy", "error": str(e)}
+
+    # 检查向量数据库（可选，不影响就绪状态）
+    try:
+        if hasattr(req.app.state, "vector_manager"):
+            vector_health = await req.app.state.vector_manager.health_check()
+            checks["vector_db"] = vector_health
+            # 可选依赖不影响就绪状态
+        else:
+            checks["vector_db"] = {"status": "not_configured"}
+    except Exception as e:
+        logger.warning(f"Vector DB readiness check failed: {e}")
+        checks["vector_db"] = {"status": "unhealthy", "error": str(e)}
+
+    # 检查消息队列（可选，不影响就绪状态）
+    try:
+        if hasattr(req.app.state, "nats_manager"):
+            nats_health = await req.app.state.nats_manager.health_check()
+            checks["message_queue"] = nats_health
+            # 可选依赖不影响就绪状态
+        else:
+            checks["message_queue"] = {"status": "not_configured"}
+    except Exception as e:
+        logger.warning(f"NATS readiness check failed: {e}")
+        checks["message_queue"] = {"status": "unhealthy", "error": str(e)}
+
+    if all_ready:
+        return {
+            "status": "ready",
+            "checks": checks,
+        }
+    else:
+        return JSONResponse(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+            content={
+                "status": "not_ready",
+                "checks": checks,
+            },
+        )
+
+
+@health_router.get(
+    "/startup",
+    summary="启动探针",
+    description="Kubernetes startup probe - 检查应用是否已完成启动",
+    status_code=status.HTTP_200_OK,
+    responses={
+        200: {"description": "Application has started"},
+        503: {"description": "Application is still starting"},
+    },
+)
+async def startup_check(req: Request):
+    """
+    启动探针 (Startup Probe)
+
+    用于检查应用是否已经完成启动
+    适用于启动缓慢的应用，避免 liveness probe 过早杀死容器
+
+    启动完成标准：
+    - 应用运行超过最小启动时间
+    - 所有关键服务已初始化
+    """
+    uptime = time.time() - _startup_time
+    min_startup_time = 5  # 最小启动时间（秒）
+
+    if uptime < min_startup_time:
+        return JSONResponse(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+            content={
+                "status": "starting",
+                "uptime_seconds": round(uptime, 2),
+                "message": f"Application is still starting (min: {min_startup_time}s)",
+            },
+        )
+
+    # 检查关键服务是否已初始化
+    checks = {}
+
+    if hasattr(req.app.state, "db_manager"):
+        checks["database"] = "initialized"
+    if hasattr(req.app.state, "redis_manager"):
+        checks["redis"] = "initialized"
+    if hasattr(req.app.state, "vector_manager"):
+        checks["vector_db"] = "initialized"
+    if hasattr(req.app.state, "nats_manager"):
+        checks["message_queue"] = "initialized"
+
+    return {
+        "status": "started",
+        "uptime_seconds": round(uptime, 2),
+        "initialized_services": checks,
+    }
+
+
+@health_router.get(
+    "/detailed",
+    summary="详细健康状态",
+    description="返回所有组件的详细健康状态",
+)
+async def detailed_health(req: Request):
+    """
+    详细健康检查
+
+    返回应用和所有依赖服务的详细健康状态
+    包括版本信息、连接状态、性能指标等
+    """
+    from infoman.config.settings import settings
+    import psutil
+
+    uptime = time.time() - _startup_time
+
+    health_data: Dict[str, Any] = {
+        "status": "healthy",
+        "timestamp": time.time(),
+        "uptime_seconds": round(uptime, 2),
+        "application": {
+            "name": settings.APP_NAME,
+            "version": settings.APP_VERSION,
+            "environment": settings.ENV,
+        },
+        "system": {
+            "cpu_percent": psutil.cpu_percent(interval=0.1),
+            "memory_percent": psutil.virtual_memory().percent,
+            "disk_percent": psutil.disk_usage('/').percent,
+        },
+        "dependencies": {},
+    }
+
+    # 收集所有依赖的健康状态
+    dependencies_health: List[Dict[str, Any]] = []
+
+    # 数据库
+    if hasattr(req.app.state, "db_manager"):
+        try:
+            db_health = await req.app.state.db_manager.health_check()
+            dependencies_health.append(db_health)
+            health_data["dependencies"]["database"] = db_health
+        except Exception as e:
+            logger.error(f"Database health check failed: {e}")
+            health_data["dependencies"]["database"] = {
+                "status": "error",
+                "error": str(e),
+            }
+
+    # Redis
+    if hasattr(req.app.state, "redis_manager"):
+        try:
+            redis_health = await req.app.state.redis_manager.health_check()
+            dependencies_health.append(redis_health)
+            health_data["dependencies"]["redis"] = redis_health
+        except Exception as e:
+            logger.error(f"Redis health check failed: {e}")
+            health_data["dependencies"]["redis"] = {
+                "status": "error",
+                "error": str(e),
+            }
+
+    # 向量数据库
+    if hasattr(req.app.state, "vector_manager"):
+        try:
+            vector_health = await req.app.state.vector_manager.health_check()
+            dependencies_health.append(vector_health)
+            health_data["dependencies"]["vector_db"] = vector_health
+        except Exception as e:
+            logger.error(f"Vector DB health check failed: {e}")
+            health_data["dependencies"]["vector_db"] = {
+                "status": "error",
+                "error": str(e),
+            }
+
+    # 消息队列
+    if hasattr(req.app.state, "nats_manager"):
+        try:
+            nats_health = await req.app.state.nats_manager.health_check()
+            dependencies_health.append(nats_health)
+            health_data["dependencies"]["message_queue"] = nats_health
+        except Exception as e:
+            logger.error(f"NATS health check failed: {e}")
+            health_data["dependencies"]["message_queue"] = {
+                "status": "error",
+                "error": str(e),
+            }
+
+    # 判断整体健康状态
+    unhealthy_count = sum(
+        1 for dep in dependencies_health
+        if dep.get("status") not in ["healthy", "not_configured"]
+    )
+
+    if unhealthy_count > 0:
+        health_data["status"] = "degraded"
+        health_data["unhealthy_dependencies"] = unhealthy_count
+
+    return success(data=health_data)
+
+
+# 导入 JSONResponse
+from fastapi.responses import JSONResponse

infoman/service/routers/monitor_router.py

@@ -0,0 +1,44 @@
+# !/usr/bin/env python
+# -*-coding:utf-8 -*-
+
+"""
+# Time       ：2024/2/2 20:05
+# Author     ：Maxwell
+# Description：
+"""
+import pytz
+import psutil
+from fastapi import APIRouter
+from infoman.service.core.response import success
+from infoman.config.settings import settings
+from datetime import datetime
+
+
+monitor_router = APIRouter(prefix="")
+
+
+@monitor_router.get(path="/info")
+async def monitor():
+    cpu_percent = psutil.cpu_percent(interval=0.1)
+    memory = psutil.virtual_memory()
+    process = psutil.Process()
+    process_memory = process.memory_info().rss / (1024 * 1024)
+    return success(
+        {
+            "app": {
+                "version": settings.APP_VERSION,
+                "name": settings.APP_NAME,
+                "env": settings.ENV,
+            },
+            "system": {
+                "cpu_percent": f"{cpu_percent:.3f}",
+                "memory_percent": f"{memory.percent:.3f}",
+                "memory_available_mb": int(memory.available / (1024 * 1024)),
+            },
+            "process": {
+                "memory_mb": int(process_memory),
+                "cpu_percent": f"'{process.cpu_percent(interval=0.1):.3f}",
+            },
+            "timestamp": datetime.now(pytz.UTC).isoformat(),
+        }
+    )

infoman/service/utils/__init__.py

@@ -0,0 +1,8 @@
+# !/usr/bin/env python
+# -*-coding:utf-8 -*-
+
+"""
+# Time       ：2025/6/26 16:29
+# Author     ：Maxwell
+# Description：
+"""

infoman/service/utils/cache/cache.py

@@ -0,0 +1,192 @@
+from infoman.logger import logger
+from functools import wraps
+from typing import (
+    Any,
+    Callable,
+    Optional,
+    Type,
+    TypeVar,
+    get_type_hints,
+    get_origin,
+    get_args,
+)
+import json
+from pydantic import BaseModel
+import inspect
+
+
+T = TypeVar("T")
+
+
+def redis_cache(
+    prefix: str,
+    ttl: int = 3600,
+    model: Optional[Type[BaseModel]] = None,  # ✅ 新增：指定返回模型
+    auto_detect: bool = True,  # ✅ 新增：自动检测返回类型
+):
+    """
+    Redis 缓存装饰器（支持 Pydantic 模型反序列化）
+
+    Args:
+        prefix: 缓存键前缀
+        ttl: 过期时间（秒）
+        model: 返回的 Pydantic 模型类（可选，如果指定则强制使用）
+        auto_detect: 是否自动从函数签名检测返回类型
+
+    Examples:
+        # 方式 1：手动指定模型
+        @redis_cache(prefix="config", ttl=3600, model=ConfigKeyLogSchema)
+        async def get_config(pub_key: str):
+            ...
+
+        # 方式 2：自动检测（推荐）
+        @redis_cache(prefix="config", ttl=3600)
+        async def get_config(pub_key: str) -> ConfigKeyLogSchema:
+            ...
+
+        # 方式 3：列表类型
+        @redis_cache(prefix="configs", ttl=3600)
+        async def list_configs() -> list[ConfigKeyLogSchema]:
+            ...
+    """
+
+    def decorator(func: Callable) -> Callable:
+        # ✅ 自动检测返回类型
+        return_type = model
+        is_list = False
+
+        if auto_detect and not return_type:
+            type_hints = get_type_hints(func)
+            if "return" in type_hints:
+                hint = type_hints["return"]
+
+                # 处理 Optional[Model]
+                origin = get_origin(hint)
+                if origin is Optional or str(origin) == "typing.Union":
+                    args = get_args(hint)
+                    for arg in args:
+                        if arg is not type(None) and (
+                            isinstance(arg, type) and issubclass(arg, BaseModel)
+                        ):
+                            return_type = arg
+                            break
+                elif origin is list:
+                    args = get_args(hint)
+                    if (
+                        args
+                        and isinstance(args[0], type)
+                        and issubclass(args[0], BaseModel)
+                    ):
+                        return_type = args[0]
+                        is_list = True
+
+                # 直接是 Model
+                elif isinstance(hint, type) and issubclass(hint, BaseModel):
+                    return_type = hint
+
+        @wraps(func)
+        async def wrapper(*args, **kwargs) -> Any:
+            # 获取 Redis 客户端
+            redis_client = _get_redis_client(args, kwargs)
+
+            if not redis_client:
+                logger.warning("Redis client not found, executing without cache")
+                return await func(*args, **kwargs)
+
+            # 构建缓存键
+            cache_key = f"{prefix}:{_build_cache_key(func, args, kwargs)}"
+
+            # ==================== 读取缓存 ====================
+            try:
+                cached = await redis_client.get(cache_key)
+                if cached:
+                    cached_data = json.loads(cached)
+                    logger.debug(f"Cache HIT: {cache_key}")
+
+                    if return_type:
+                        if is_list:
+                            return [return_type(**item) for item in cached_data]
+                        else:
+                            return return_type(**cached_data)
+                    return cached_data
+
+            except Exception as e:
+                logger.error(f"Cache read error for {cache_key}: {e}")
+
+            # ==================== 执行函数 ====================
+            result = await func(*args, **kwargs)
+
+            if result is None:
+                return None
+
+            # ==================== 写入缓存 ====================
+            try:
+                cache_data = _serialize_result(result)
+                json_str = json.dumps(cache_data, default=str, ensure_ascii=False)
+                await redis_client.setex(cache_key, ttl, json_str)
+                logger.debug(f"Cache SET: {cache_key}")
+
+            except Exception as e:
+                logger.error(f"Cache write error for {cache_key}: {e}")
+
+            return result
+
+        return wrapper
+
+    return decorator
+
+
+def _serialize_result(result: Any) -> Any:
+    """序列化结果"""
+    if isinstance(result, BaseModel):
+        return result.model_dump()
+    elif isinstance(result, list):
+        return [
+            item.model_dump() if isinstance(item, BaseModel) else item
+            for item in result
+        ]
+    elif isinstance(result, dict):
+        return {
+            k: v.model_dump() if isinstance(v, BaseModel) else v
+            for k, v in result.items()
+        }
+    return result
+
+
+def _get_redis_client(args: tuple, kwargs: dict):
+
+    for arg in list(args) + list(kwargs.values()):
+        if hasattr(arg, "app") and hasattr(arg.app, "state"):
+            redis = getattr(arg.app.state, "redis_client", None)
+            if redis:
+                return redis
+
+    return None
+
+
+def _build_cache_key(func: Callable, args: tuple, kwargs: dict) -> str:
+    """构建缓存键"""
+    key_parts = [func.__name__]
+
+    # 获取函数签名
+    sig = inspect.signature(func)
+    param_names = list(sig.parameters.keys())
+
+    # 处理位置参数（跳过 self 和 request）
+    for i, arg in enumerate(args):
+        if i == 0 and param_names and param_names[0] in ["self", "cls"]:
+            continue
+        if _is_cacheable_value(arg):
+            key_parts.append(str(arg))
+
+    # 处理关键字参数
+    for k, v in sorted(kwargs.items()):
+        if k not in ["req", "request"] and _is_cacheable_value(v):
+            key_parts.append(f"{k}={v}")
+
+    return ":".join(key_parts)
+
+
+def _is_cacheable_value(value: Any) -> bool:
+    """判断值是否可用于缓存键"""
+    return isinstance(value, (str, int, float, bool))

infoman/service/utils/module_loader.py

@@ -0,0 +1,10 @@
+import importlib
+from pathlib import Path
+
+
+def auto_import_modules_from_folder(package: str, folder: str):
+    for file in Path(folder).glob("*.py"):
+        if file.name.startswith("_"):
+            continue
+        module_name = f"{package}.{file.stem}"
+        importlib.import_module(module_name)

infoman/service/utils/parse.py

@@ -0,0 +1,10 @@
+import json
+
+
+def parse_message(msg):
+    try:
+        data = json.loads(msg.data.decode())
+        return data
+    except json.JSONDecodeError:
+        print("[NATS] Failed to decode message")
+        return {}

infoman/service/utils/resolver/__init__.py

@@ -0,0 +1,8 @@
+# !/usr/bin/env python
+# -*-coding:utf-8 -*-
+
+"""
+# Time       ：2025/6/25 21:51
+# Author     ：Maxwell
+# Description：
+"""

infoman/service/utils/resolver/base.py

@@ -0,0 +1,47 @@
+# !/usr/bin/env python
+# -*-coding:utf-8 -*-
+
+"""
+# Time       ：2025/7/9 16:10
+# Author     ：Maxwell
+# Description：
+"""
+from pydantic import BaseModel
+from datetime import datetime
+
+
+class BaseResp(BaseModel):
+    class Config:
+        arbitrary_types_allowed = True
+
+    def _format_price(self, value: float) -> str:
+        """格式化价格显示（带两位小数）"""
+        if value:
+            return f"{value:.2f} 元"
+        return ""
+
+    def _format_percentage(self, value: float) -> str:
+        """格式化百分比显示（带百分号）"""
+        if value:
+            return f"{value:.2%}"
+        return ""
+
+    def _format_volume(self, value: int) -> str:
+        """格式化成交量显示（带千位分隔符）"""
+        if value:
+            return f"{value:,} 股"
+        return ""
+
+    def _format_amount(self, value: float) -> str:
+        """格式化成交额显示（带千位分隔符）"""
+        if value:
+            return f"{value:,} 元"
+        return ""
+
+    def _format_time(self, timestamp: int) -> str:
+        """将时间戳转换为可读时间"""
+        if timestamp:
+            return datetime.fromtimestamp(timestamp / 1000).strftime(
+                "%Y-%m-%d %H:%M:%S"
+            )
+        return ""