infomankit 0.3.23__py3-none-any.whl

infoman/service/infrastructure/mq/__init__.py

@@ -0,0 +1,15 @@
+# !/usr/bin/env python
+# -*-coding:utf-8 -*-
+
+"""
+消息队列基础设施
+
+支持:
+- NATS: 高性能消息队列
+"""
+
+from .manager import NATSManager
+
+__all__ = [
+    "NATSManager",
+]

infoman/service/infrastructure/mq/manager.py

@@ -0,0 +1,178 @@
+# !/usr/bin/env python
+# -*-coding:utf-8 -*-
+
+"""
+消息队列管理器（支持延迟导入）
+
+支持：
+- NATS
+- 其他消息队列（待实现）
+"""
+
+from typing import Optional, Dict, Any, TYPE_CHECKING
+from fastapi import FastAPI
+from loguru import logger
+
+from infoman.config import settings
+
+if TYPE_CHECKING:
+    from infoman.service.infrastructure.mq.nats.nats_client import NATSClient
+
+
+class NATSManager:
+    """NATS 消息队列管理器"""
+
+    def __init__(self):
+        self.nats_client: Optional[Any] = None
+        self.initialized = False
+
+    @property
+    def is_available(self) -> bool:
+        """是否可用"""
+        return self.nats_client is not None and self.nats_client.connected
+
+    @property
+    def client(self):
+        """获取 NATS 客户端"""
+        return self.nats_client
+
+    async def startup(self, app: Optional[FastAPI] = None) -> bool:
+        """
+        启动 NATS 连接
+
+        Args:
+            app: FastAPI 应用实例（可选）
+
+        Returns:
+            是否成功启动
+        """
+        if self.initialized:
+            logger.warning("⚠️ NATSManager 已初始化，跳过重复初始化")
+            return True
+
+        if not settings.NATS_SERVERS:
+            logger.info("⏭️ NATS 未配置，跳过初始化")
+            return False
+
+        # 延迟导入 NATSClient
+        try:
+            from infoman.service.infrastructure.mq.nats.nats_client import NATSClient
+        except ImportError as e:
+            logger.error(f"❌ NATS 依赖未安装: {e}")
+            logger.error("请运行: pip install infomankit[messaging]")
+            return False
+
+        logger.info("🚀 初始化 NATS...")
+
+        try:
+            self.nats_client = NATSClient(
+                servers=settings.NATS_SERVERS,
+                name=settings.APP_NAME
+            )
+
+            # 连接到 NATS
+            await self.nats_client.connect()
+
+            # 挂载到 app.state（如果提供了 app）
+            if app:
+                app.state.nats_client = self.nats_client
+                logger.debug("✅ NATS 客户端已挂载到 app.state")
+
+            self.initialized = True
+            logger.success(f"✅ NATS 连接成功: {settings.NATS_SERVERS}")
+            return True
+
+        except Exception as e:
+            logger.error(f"❌ NATS 连接失败: {e}")
+            return False
+
+    async def shutdown(self):
+        """关闭 NATS 连接"""
+        if not self.initialized:
+            return
+
+        logger.info("⏹️ 关闭 NATS 连接...")
+
+        try:
+            if self.nats_client:
+                await self.nats_client.close()
+                logger.success("✅ NATS 连接已关闭")
+
+        except Exception as e:
+            logger.error(f"❌ NATS 关闭失败: {e}")
+
+        finally:
+            self.initialized = False
+
+    async def health_check(self) -> Dict[str, Any]:
+        """
+        健康检查
+
+        Returns:
+            {
+                "status": "healthy" | "unhealthy" | "not_configured",
+                "name": "nats",
+                "details": {...}
+            }
+        """
+        if not settings.NATS_SERVER:
+            return {
+                "status": "not_configured",
+                "name": "nats",
+                "details": {"enabled": False}
+            }
+
+        if not self.initialized or not self.nats_client:
+            return {
+                "status": "unhealthy",
+                "name": "nats",
+                "details": {"error": "未初始化"}
+            }
+
+        try:
+            # 检查连接状态
+            is_connected = self.nats_client.connected
+
+            if is_connected:
+                return {
+                    "status": "healthy",
+                    "name": "nats",
+                    "details": {
+                        "connected": True,
+                        "servers": self.nats_client.servers
+                    }
+                }
+            else:
+                return {
+                    "status": "unhealthy",
+                    "name": "nats",
+                    "details": {
+                        "connected": False,
+                        "error": "连接已断开"
+                    }
+                }
+
+        except Exception as e:
+            return {
+                "status": "unhealthy",
+                "name": "nats",
+                "details": {"error": str(e)}
+            }
+
+    async def get_stats(self) -> Dict[str, Any]:
+        """
+        获取统计信息
+
+        Returns:
+            {
+                "connected": bool,
+                "servers": list,
+            }
+        """
+        if not self.is_available:
+            return {}
+
+        return {
+            "connected": self.nats_client.connected,
+            "servers": self.nats_client.servers,
+        }

infoman/service/infrastructure/mq/nats/nats_client.py

@@ -0,0 +1,57 @@
+import asyncio
+import json
+from nats.aio.client import Client as NATS
+from nats.aio.errors import ErrConnectionClosed, ErrTimeout, ErrNoServers
+from infoman.logger import logger
+
+
+class NATSClient:
+
+    def __init__(self, servers=None, name="nats-client"):
+        if servers is None:
+            servers = ["nats://127.0.0.1:4222"]
+        self.nc = NATS()
+        self.servers = servers
+        self.name = name
+        self.connected = False
+
+    async def connect(self):
+        if not self.connected:
+            await self.nc.connect(servers=self.servers, name=self.name)
+            self.connected = True
+            logger.info(f"[NATS] Connected to {self.servers}")
+
+    async def publish(self, subject: str, message: dict):
+        if not self.connected:
+            await self.connect()
+        try:
+            payload = json.dumps(message).encode()
+            await self.nc.publish(subject, payload)
+            logger.info(f"[NATS] Published to {subject}: {message}")
+        except Exception as e:
+            logger.info(f"[NATS] Publish error: {e}")
+
+    async def request(self, subject: str, message: dict, timeout=1.0):
+        if not self.connected:
+            await self.connect()
+        try:
+            payload = json.dumps(message).encode()
+            msg = await self.nc.request(subject, payload, timeout=timeout)
+            return json.loads(msg.data.decode())
+        except ErrTimeout:
+            logger.info("[NATS] Request timeout")
+            return None
+        except Exception as e:
+            logger.info(f"[NATS] Request error: {e}")
+            return None
+
+    async def subscribe(self, subject: str, callback, queue: str):
+        if not self.connected:
+            await self.connect()
+        await self.nc.subscribe(subject, cb=callback, queue=queue)
+
+    async def close(self):
+        if self.connected:
+            await self.nc.drain()
+            self.connected = False
+            logger.info("[NATS] Connection closed")

infoman/service/infrastructure/mq/nats/nats_event_router.py

@@ -0,0 +1,25 @@
+from infoman.logger import logger
+
+
+class EventRouter:
+    def __init__(self):
+        self.routes = {}
+
+    def on(self, subject, queue=None):
+        def decorator(func):
+            self.routes[subject] = {"handler": func, "queue": queue}
+            return func
+
+        return decorator
+
+    async def register(self, nats_client):
+        for subject, meta in self.routes.items():
+
+            async def handler(msg, func=meta["handler"]):
+                await func(msg, nats_cli=nats_client)
+
+            await nats_client.subscribe(subject, handler, meta["queue"])
+            logger.info(f"[Router] Bound {meta['handler'].__name__} to '{subject}'")
+
+
+event_router = EventRouter()

infoman/service/launch.py

@@ -0,0 +1,284 @@
+#!/usr/bin/env python
+# -*-coding:utf-8 -*-
+
+"""
+应用启动入口（库模式）
+
+作为基础库使用时，支持：
+1. 直接启动内置应用：python -m infoman.service.launch
+2. 启动用户应用：python -m infoman.service.launch --app your_module:app
+3. 作为库函数调用：from infoman.service.launch import serve
+
+支持多种 ASGI 服务器：
+- granian (推荐生产环境，Rust 实现，性能最佳)
+- uvicorn (开发环境友好，热重载)
+- gunicorn (传统部署)
+"""
+
+import os
+from typing import Optional, Dict, Any
+
+
+def serve(
+    app_target: str = "infoman.service.app:application",
+    server: str = "granian",
+    host: Optional[str] = None,
+    port: Optional[int] = None,
+    workers: Optional[int] = None,
+    log_level: Optional[str] = None,
+    **kwargs
+):
+    """
+    启动 ASGI 应用服务器（库函数）
+
+    Args:
+        app_target: 应用目标 (格式: "module.path:app_instance")
+        server: 服务器类型 (granian/uvicorn/gunicorn)
+        host: 监听地址
+        port: 监听端口
+        workers: 工作进程数
+        threads: 线程数（仅 Granian）
+        reload: 是否启用热重载
+        log_level: 日志级别
+        **kwargs: 其他服务器特定参数
+
+    Examples:
+        >>> # 启动默认应用
+        >>> from infoman.service.launch import serve
+        >>> serve()
+
+        >>> # 启动自定义应用
+        >>> serve(app_target="myapp.main:app", port=8080)
+
+        >>> # 生产环境配置
+        >>> serve(
+        ...     app_target="myapp.main:app",
+        ...     server="granian",
+        ...     workers=4,
+        ...     reload=False,
+        ...     log_level="info"
+        ... )
+    """
+    # 导入配置（优先使用参数，其次使用配置文件）
+    try:
+        from infoman.config import settings
+    except ImportError:
+        settings = None
+
+    # 参数优先级：函数参数 > 配置文件 > 默认值
+    # 注意：在 macOS 上使用 Granian 时，0.0.0.0 可能导致 "Can't assign requested address" 错误
+    import platform
+
+    # 确定主机地址
+    if host:
+        # 用户明确指定，直接使用
+        resolved_host = host
+    elif settings and settings.APP_HOST != "0.0.0.0":
+        # 配置文件中有非默认值，使用配置
+        resolved_host = settings.APP_HOST
+    else:
+        # 使用平台相关的默认值
+        if server == "granian" and platform.system() == "Darwin":
+            # macOS + Granian: 使用 127.0.0.1
+            resolved_host = "127.0.0.1"
+        else:
+            # 其他情况：使用 0.0.0.0
+            resolved_host = "0.0.0.0"
+
+    config = {
+        "host": resolved_host,
+        "port": port or (settings.APP_PORT if settings else 8000),
+        "workers": workers or (settings.APP_WORKERS if settings and hasattr(settings, "APP_WORKERS") else 2),
+        "log_level": log_level or (settings.LOG_LEVEL.lower() if settings and hasattr(settings, "LOG_LEVEL") else "info"),
+        "app_name": settings.APP_NAME if settings else "Application",
+        "env": settings.ENV if settings else "unknown",
+        "docs_url": settings.DOCS_URL if settings and hasattr(settings, "DOCS_URL") else "/docs",
+    }
+
+    # 合并 kwargs
+    config.update(kwargs)
+
+    # 根据服务器类型启动
+    if server == "granian":
+        _run_granian(app_target, config)
+    elif server == "uvicorn":
+        _run_uvicorn(app_target, config)
+    elif server == "gunicorn":
+        _run_gunicorn(app_target, config)
+    else:
+        raise ValueError(f"不支持的服务器类型: {server}")
+
+
+def _run_granian(app_target: str, config: Dict[str, Any]):
+    """使用 Granian 启动（内部函数）"""
+    try:
+        from granian import Granian
+        from granian.constants import Interfaces, Loops
+    except ImportError:
+        raise ImportError(
+            "Granian 未安装。请运行: pip install granian\n"
+            "或安装完整 web 依赖: pip install infomankit[web]"
+        )
+
+    print(f"🚀 使用 Granian 启动 [{config['app_name']}]")
+    print(f"   应用: {app_target}")
+    print(f"   环境: {config['env']}")
+    print(f"   地址: http://{config['host']}:{config['port']}")
+    print(f"   文档: http://{config['host']}:{config['port']}{config['docs_url']}")
+    print(f"   进程: {config['workers']} workers")
+    # 创建 Granian 实例（仅使用核心兼容参数）
+    # Granian 2.6.0+ 的核心参数
+    app = Granian(
+        target=app_target,
+        address=config["host"],
+        port=int(config["port"]),
+        interface=Interfaces.ASGI,
+        workers=config["workers"],
+        loop=Loops.auto,
+        log_level=config["log_level"],
+        reload=config["reload"],
+    )
+    app.serve()
+
+
+def _run_uvicorn(app_target: str, config: Dict[str, Any]):
+    """使用 Uvicorn 启动（内部函数）"""
+    try:
+        import uvicorn
+    except ImportError:
+        raise ImportError(
+            "Uvicorn 未安装。请运行: pip install uvicorn\n"
+            "或安装完整 web 依赖: pip install infomankit[web]"
+        )
+
+    print(f"🚀 使用 Uvicorn 启动 [{config['app_name']}]")
+    print(f"   应用: {app_target}")
+    print(f"   环境: {config['env']}")
+    print(f"   地址: http://{config['host']}:{config['port']}")
+    uvicorn.run(
+        app_target,
+        host=config["host"],
+        port=int(config["port"]),
+        reload=config["reload"],
+        log_level=config["log_level"],
+        access_log=config.get("access_log", config["reload"]),
+        workers=config["workers"] if not config["reload"] else 1,  # reload 模式只能单进程
+    )
+
+
+def _run_gunicorn(app_target: str, config: Dict[str, Any]):
+    """使用 Gunicorn 启动（内部函数）"""
+    try:
+        import gunicorn
+    except ImportError:
+        raise ImportError(
+            "Gunicorn 未安装。请运行: pip install gunicorn\n"
+            "注意: Gunicorn 仅支持 Linux/macOS"
+        )
+
+    print(f"🚀 使用 Gunicorn 启动 [{config['app_name']}]")
+    print(f"   应用: {app_target}")
+    print(f"   环境: {config['env']}")
+    print(f"   地址: http://{config['host']}:{config['port']}")
+
+    # Gunicorn 配置
+    bind_address = f"{config['host']}:{config['port']}"
+    worker_class = "uvicorn.workers.UvicornWorker"
+    workers = config["workers"]
+    os.system(
+        f'gunicorn {app_target} '
+        f'-b {bind_address} '
+        f'-w {workers} '
+        f'-k {worker_class} '
+        f'--log-level {config["log_level"]} '
+        f'--access-logfile - '
+        f'--error-logfile -'
+    )
+
+
+def main():
+    """命令行入口"""
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description="Infoman Service Launcher - 启动 ASGI 应用服务器",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+示例:
+  # 启动内置应用
+  python -m infoman.service.launch
+
+  # 启动自定义应用
+  python -m infoman.service.launch --app myapp.main:app
+
+  # 生产环境配置
+  python -m infoman.service.launch --server granian --workers 4 --port 8080
+
+  # 开发环境热重载
+  python -m infoman.service.launch --server uvicorn --reload
+        """
+    )
+
+    parser.add_argument(
+        "--app",
+        default="infoman.service.app:application",
+        help="应用目标 (格式: module.path:app_instance, 默认: infoman.service.app:application)",
+    )
+    parser.add_argument(
+        "--server",
+        choices=["granian", "uvicorn", "gunicorn"],
+        default="granian",
+        help="选择 ASGI 服务器 (默认: granian)",
+    )
+    parser.add_argument(
+        "--host",
+        default=None,
+        help="监听地址 (默认: 从配置文件读取或 0.0.0.0)",
+    )
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=None,
+        help="监听端口 (默认: 从配置文件读取或 8000)",
+    )
+    parser.add_argument(
+        "--workers",
+        type=int,
+        default=None,
+        help="工作进程数 (默认: 从配置文件读取或 2)",
+    )
+    parser.add_argument(
+        "--threads",
+        type=int,
+        default=None,
+        help="线程数 (仅 Granian, 默认: 1)",
+    )
+    parser.add_argument(
+        "--reload",
+        action="store_true",
+        help="启用热重载 (开发环境)",
+    )
+    parser.add_argument(
+        "--log-level",
+        choices=["debug", "info", "warning", "error", "critical"],
+        default=None,
+        help="日志级别 (默认: info)",
+    )
+
+    args = parser.parse_args()
+
+    # 调用 serve 函数
+    serve(
+        app_target=args.app,
+        server=args.server,
+        host=args.host,
+        port=args.port,
+        workers=args.workers,
+        threads=args.threads,
+        reload=args.reload,
+        log_level=args.log_level,
+    )
+
+
+if __name__ == "__main__":
+    main()

infoman/service/middleware/__init__.py

@@ -0,0 +1,7 @@
+# !/usr/bin/env python
+# -*-coding:utf-8 -*-
+"""
+# Time       ：2024/2/2 10:36
+# Author     ：Maxwell
+# Description：
+"""

infoman/service/middleware/base.py

@@ -0,0 +1,41 @@
+# -*- coding:utf-8 -*-
+"""
+# Time       ：2023/12/8 18:23
+# Author     ：Maxwell
+# version    ：python 3.9
+# Description：
+"""
+
+import time
+from fastapi import Request
+from starlette.datastructures import MutableHeaders
+from starlette.types import ASGIApp, Receive, Scope, Send, Message
+from infoman.utils.hash.hash import HashManager
+
+
+class BaseMiddleware:
+
+    def __init__(
+        self,
+        app: ASGIApp,
+    ) -> None:
+        self.app = app
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] != "http":
+            await self.app(scope, receive, send)
+            return
+
+        start_time = time.time()
+        req = Request(scope, receive, send)
+        if not req.session.get("session"):
+            req.session.setdefault("session", HashManager.uuid())
+
+        async def send_wrapper(message: Message) -> None:
+            process_time = time.time() - start_time
+            if message["type"] == "http.response.start":
+                headers = MutableHeaders(scope=message)
+                headers.append("X-Process-Time", str(process_time))
+            await send(message)
+
+        await self.app(scope, receive, send_wrapper)

infoman/service/middleware/logging.py

@@ -0,0 +1,51 @@
+# !/usr/bin/env python
+# -*-coding:utf-8 -*-
+
+"""
+# Time       ：2024/1/12 10:27
+# Author     ：Maxwell
+# Description：
+"""
+import time
+import traceback
+from fastapi import Request, Response
+from starlette.middleware.base import BaseHTTPMiddleware
+from infoman.logger import logger
+from infoman.utils.http.info import ClientInfoExtractor
+from starlette.responses import StreamingResponse, FileResponse
+
+
+class LoggingMiddleware(BaseHTTPMiddleware):
+
+    @staticmethod
+    def format_size(size_bytes: int) -> str:
+        if size_bytes < 1024:
+            return f"{size_bytes}B"
+        elif size_bytes < 1024 * 1024:
+            return f"{size_bytes / 1024:.2f}KB"
+        else:
+            return f"{size_bytes / (1024 * 1024):.2f}MB"
+
+    async def dispatch(self, request: Request, call_next) -> Response:
+        start_time = time.monotonic()
+        client_ip = ClientInfoExtractor.ip_address(request=request)
+        path = request.url.path[:200]
+
+        response = await call_next(request)
+        elapsed_ms = int((time.monotonic() - start_time) * 1000)
+
+        content_length = response.headers.get("content-length")
+        if content_length:
+            response_size = int(content_length)
+            size_str = self.format_size(response_size)
+        else:
+            size_str = "unknown"
+
+        logger.info(
+            f"Req: ip={client_ip}, elapsed_ms={elapsed_ms}, "
+            f"path={path}, status={response.status_code}, "
+            f"size={size_str}"
+        )
+        return response
+
+