fiuai-sdk-python 0.7.5__tar.gz → 0.8.0__tar.gz

{fiuai_sdk_python-0.7.5 → fiuai_sdk_python-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fiuai_sdk_python
-Version: 0.7.5
+Version: 0.8.0
 Summary: FiuAI Python SDK - 企业级AI服务集成开发工具包
 Project-URL: Homepage, https://github.com/fiuai/fiuai-sdk-python
 Project-URL: Documentation, https://github.com/fiuai/fiuai-sdk-python#readme

{fiuai_sdk_python-0.7.5 → fiuai_sdk_python-0.8.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fiuai_sdk_python"
-version = "0.7.5"
+version = "0.8.0"
 description = "FiuAI Python SDK - 企业级AI服务集成开发工具包"
 readme = "README.md"
 requires-python = ">=3.12"

{fiuai_sdk_python-0.7.5 → fiuai_sdk_python-0.8.0}/src/fiuai_sdk_python/__init__.py

@@ -11,7 +11,7 @@ from .context import (
     get_trace_id,
 )
 
-__version__ = "0.6.5"
+__version__ = "0.8.0"
 
 __all__ = [
     'FiuaiSDK',

fiuai_sdk_python-0.8.0/src/fiuai_sdk_python/pkg/cache/__init__.py

@@ -0,0 +1,30 @@
+# -- coding: utf-8 --
+# Project: fiuai-sdk-python
+# Created Date: 2026-03-09
+# Author: liming
+# Agent: Cursor
+# Email: lmlala@aliyun.com
+# Copyright (c) 2025 FiuAI
+
+from .cache_client import CacheClient
+from .circuit_breaker import CircuitBreaker
+from .decorator import cached, get_default_client, init_cache
+from .redis_manager import RedisDBConfig, redis_manager
+from .types import CacheConfig, CircuitBreakerConfig, CircuitState
+
+__all__ = [
+    # 连接池 (已有)
+    "redis_manager",
+    "RedisDBConfig",
+    # 缓存客户端
+    "CacheClient",
+    "CacheConfig",
+    # 装饰器
+    "cached",
+    "init_cache",
+    "get_default_client",
+    # 熔断
+    "CircuitBreaker",
+    "CircuitBreakerConfig",
+    "CircuitState",
+]

fiuai_sdk_python-0.8.0/src/fiuai_sdk_python/pkg/cache/cache_client.py

@@ -0,0 +1,233 @@
+# -- coding: utf-8 --
+# Project: fiuai-sdk-python
+# Created Date: 2026-03-09
+# Author: liming
+# Agent: Cursor
+# Email: lmlala@aliyun.com
+# Copyright (c) 2025 FiuAI
+
+import json
+from typing import Awaitable, Callable, Optional, TypeVar
+
+from redis import Redis as SyncRedis
+from redis.asyncio import Redis as AsyncRedis
+
+from ...utils.logger import get_logger
+from .circuit_breaker import CircuitBreaker
+from .redis_manager import redis_manager
+from .types import CacheConfig
+
+logger = get_logger(__name__)
+T = TypeVar("T")
+
+
+class CacheClient:
+    """通用缓存客户端
+
+    能力: KV / Hash / TTL / get_or_load (cache-aside) / 熔断降级
+    不含业务语义 (无 tenant/company 前缀), 由项目层包装。
+    """
+
+    def __init__(self, config: CacheConfig):
+        self._config = config
+        self._breaker = CircuitBreaker(config.circuit_breaker)
+
+    def _full_key(self, key: str) -> str:
+        if self._config.key_prefix:
+            return f"{self._config.key_prefix}:{key}"
+        return key
+
+    def _get_async_client(self) -> AsyncRedis:
+        return redis_manager.get_async_client(self._config.redis_db_name)
+
+    def _get_sync_client(self) -> SyncRedis:
+        return redis_manager.get_sync_client(self._config.redis_db_name)
+
+    def _effective_ttl(self, ttl: Optional[int]) -> Optional[int]:
+        return ttl if ttl is not None else self._config.default_ttl
+
+    # ── KV async ──────────────────────────────────────────
+
+    async def get(self, key: str) -> Optional[str]:
+        if not self._breaker.allow_request:
+            return None
+        try:
+            client = self._get_async_client()
+            val = await client.get(self._full_key(key))
+            self._breaker.record_success()
+            return val
+        except Exception as e:
+            self._breaker.record_failure()
+            logger.warning(f"cache get failed: key={key}, {e}")
+            return None
+
+    async def set(self, key: str, value: str, ttl: Optional[int] = None) -> bool:
+        if not self._breaker.allow_request:
+            return False
+        try:
+            client = self._get_async_client()
+            effective_ttl = self._effective_ttl(ttl)
+            if effective_ttl:
+                await client.setex(self._full_key(key), effective_ttl, value)
+            else:
+                await client.set(self._full_key(key), value)
+            self._breaker.record_success()
+            return True
+        except Exception as e:
+            self._breaker.record_failure()
+            logger.warning(f"cache set failed: key={key}, {e}")
+            return False
+
+    async def delete(self, key: str) -> bool:
+        if not self._breaker.allow_request:
+            return False
+        try:
+            client = self._get_async_client()
+            await client.delete(self._full_key(key))
+            self._breaker.record_success()
+            return True
+        except Exception as e:
+            self._breaker.record_failure()
+            logger.warning(f"cache delete failed: key={key}, {e}")
+            return False
+
+    async def exists(self, key: str) -> bool:
+        if not self._breaker.allow_request:
+            return False
+        try:
+            client = self._get_async_client()
+            result = await client.exists(self._full_key(key))
+            self._breaker.record_success()
+            return bool(result)
+        except Exception as e:
+            self._breaker.record_failure()
+            return False
+
+    # ── Hash async ────────────────────────────────────────
+
+    async def hset(self, key: str, field: str, value: str) -> bool:
+        if not self._breaker.allow_request:
+            return False
+        try:
+            client = self._get_async_client()
+            await client.hset(self._full_key(key), field, value)
+            self._breaker.record_success()
+            return True
+        except Exception as e:
+            self._breaker.record_failure()
+            logger.warning(f"cache hset failed: key={key}, field={field}, {e}")
+            return False
+
+    async def hget(self, key: str, field: str) -> Optional[str]:
+        if not self._breaker.allow_request:
+            return None
+        try:
+            client = self._get_async_client()
+            val = await client.hget(self._full_key(key), field)
+            self._breaker.record_success()
+            return val
+        except Exception as e:
+            self._breaker.record_failure()
+            return None
+
+    async def hgetall(self, key: str) -> dict:
+        if not self._breaker.allow_request:
+            return {}
+        try:
+            client = self._get_async_client()
+            val = await client.hgetall(self._full_key(key))
+            self._breaker.record_success()
+            return val or {}
+        except Exception as e:
+            self._breaker.record_failure()
+            return {}
+
+    # ── cache-aside async ─────────────────────────────────
+
+    async def get_or_load(
+        self,
+        key: str,
+        loader: Callable[[], Awaitable[T]],
+        ttl: Optional[int] = None,
+        serializer: Callable[[T], str] = json.dumps,
+        deserializer: Callable[[str], T] = json.loads,
+    ) -> T:
+        """Cache-aside: 命中返回缓存, miss 或熔断时调 loader。
+
+        loader 返回值写回 cache (best-effort)。
+        熔断时不报错, 直接走 loader — 保证业务不中断。
+        """
+        if self._breaker.allow_request:
+            try:
+                client = self._get_async_client()
+                cached = await client.get(self._full_key(key))
+                if cached is not None:
+                    self._breaker.record_success()
+                    return deserializer(cached)
+                self._breaker.record_success()
+            except Exception as e:
+                self._breaker.record_failure()
+                logger.warning(f"cache get_or_load read failed: key={key}, {e}")
+
+        value = await loader()
+        await self.set(key, serializer(value), ttl)
+        return value
+
+    # ── KV sync ───────────────────────────────────────────
+
+    def get_sync(self, key: str) -> Optional[str]:
+        if not self._breaker.allow_request:
+            return None
+        try:
+            client = self._get_sync_client()
+            val = client.get(self._full_key(key))
+            self._breaker.record_success()
+            return val
+        except Exception as e:
+            self._breaker.record_failure()
+            logger.warning(f"cache get_sync failed: key={key}, {e}")
+            return None
+
+    def set_sync(self, key: str, value: str, ttl: Optional[int] = None) -> bool:
+        if not self._breaker.allow_request:
+            return False
+        try:
+            client = self._get_sync_client()
+            effective_ttl = self._effective_ttl(ttl)
+            if effective_ttl:
+                client.setex(self._full_key(key), effective_ttl, value)
+            else:
+                client.set(self._full_key(key), value)
+            self._breaker.record_success()
+            return True
+        except Exception as e:
+            self._breaker.record_failure()
+            logger.warning(f"cache set_sync failed: key={key}, {e}")
+            return False
+
+    # ── cache-aside sync ──────────────────────────────────
+
+    def get_or_load_sync(
+        self,
+        key: str,
+        loader: Callable[[], T],
+        ttl: Optional[int] = None,
+        serializer: Callable[[T], str] = json.dumps,
+        deserializer: Callable[[str], T] = json.loads,
+    ) -> T:
+        """同步版 cache-aside"""
+        if self._breaker.allow_request:
+            try:
+                client = self._get_sync_client()
+                cached = client.get(self._full_key(key))
+                if cached is not None:
+                    self._breaker.record_success()
+                    return deserializer(cached)
+                self._breaker.record_success()
+            except Exception as e:
+                self._breaker.record_failure()
+                logger.warning(f"cache get_or_load_sync read failed: key={key}, {e}")
+
+        value = loader()
+        self.set_sync(key, serializer(value), ttl)
+        return value

fiuai_sdk_python-0.8.0/src/fiuai_sdk_python/pkg/cache/circuit_breaker.py

@@ -0,0 +1,78 @@
+# -- coding: utf-8 --
+# Project: fiuai-sdk-python
+# Created Date: 2026-03-09
+# Author: liming
+# Agent: Cursor
+# Email: lmlala@aliyun.com
+# Copyright (c) 2025 FiuAI
+
+import threading
+import time
+
+from ...utils.logger import get_logger
+from .types import CircuitBreakerConfig, CircuitState
+
+logger = get_logger(__name__)
+
+
+class CircuitBreaker:
+    """三态熔断器 (CLOSED -> OPEN -> HALF_OPEN -> CLOSED)
+
+    CLOSED:    正常, 记录连续失败
+    OPEN:      熔断, 所有调用直接跳过 Redis, 走 fallback
+    HALF_OPEN: 冷却期过后, 允许少量探测请求
+    """
+
+    def __init__(self, config: CircuitBreakerConfig):
+        self._config = config
+        self._state = CircuitState.CLOSED
+        self._failure_count = 0
+        self._last_failure_time: float = 0
+        self._half_open_calls = 0
+        self._lock = threading.Lock()
+
+    @property
+    def state(self) -> CircuitState:
+        with self._lock:
+            if self._state == CircuitState.OPEN:
+                elapsed = time.monotonic() - self._last_failure_time
+                if elapsed >= self._config.recovery_timeout:
+                    self._state = CircuitState.HALF_OPEN
+                    self._half_open_calls = 0
+                    logger.info("circuit breaker: OPEN -> HALF_OPEN")
+            return self._state
+
+    @property
+    def allow_request(self) -> bool:
+        """当前是否允许请求 Redis"""
+        current_state = self.state
+        if current_state == CircuitState.CLOSED:
+            return True
+        if current_state == CircuitState.HALF_OPEN:
+            with self._lock:
+                if self._half_open_calls < self._config.half_open_max_calls:
+                    self._half_open_calls += 1
+                    return True
+            return False
+        return False
+
+    def record_success(self):
+        with self._lock:
+            if self._state == CircuitState.HALF_OPEN:
+                logger.info("circuit breaker: HALF_OPEN -> CLOSED")
+            self._state = CircuitState.CLOSED
+            self._failure_count = 0
+
+    def record_failure(self):
+        with self._lock:
+            self._failure_count += 1
+            self._last_failure_time = time.monotonic()
+            if self._state == CircuitState.HALF_OPEN:
+                self._state = CircuitState.OPEN
+                logger.warning("circuit breaker: HALF_OPEN -> OPEN (probe failed)")
+            elif self._failure_count >= self._config.failure_threshold:
+                self._state = CircuitState.OPEN
+                logger.warning(
+                    f"circuit breaker: CLOSED -> OPEN "
+                    f"(failures={self._failure_count})"
+                )

fiuai_sdk_python-0.8.0/src/fiuai_sdk_python/pkg/cache/decorator.py

@@ -0,0 +1,105 @@
+# -- coding: utf-8 --
+# Project: fiuai-sdk-python
+# Created Date: 2026-03-09
+# Author: liming
+# Agent: Cursor
+# Email: lmlala@aliyun.com
+# Copyright (c) 2025 FiuAI
+
+import asyncio
+import functools
+from typing import Callable, Optional, Union
+
+from ...utils.logger import get_logger
+from .cache_client import CacheClient
+from .types import CacheConfig
+
+logger = get_logger(__name__)
+
+_default_client: Optional[CacheClient] = None
+
+
+def init_cache(config: CacheConfig) -> CacheClient:
+    """初始化模块级默认 CacheClient (供 @cached 装饰器使用)
+
+    项目启动时调用一次:
+        from fiuai_sdk_python.pkg.cache import init_cache, CacheConfig
+        init_cache(CacheConfig(redis_db_name="default", default_ttl=120, key_prefix="finnexus"))
+    """
+    global _default_client
+    _default_client = CacheClient(config)
+    return _default_client
+
+
+def get_default_client() -> Optional[CacheClient]:
+    return _default_client
+
+
+def cached(
+    key: Union[str, Callable[..., str]],
+    ttl: Optional[int] = None,
+    prefix: str = "",
+    client: Optional[CacheClient] = None,
+):
+    """函数级缓存装饰器 (cache-aside)
+
+    支持 sync 和 async 函数。
+    key 可以是固定字符串, 也可以是根据函数参数动态生成 key 的 callable。
+
+    用法:
+        @cached(key=lambda company_id, side: f"config:{company_id}:{side}", ttl=120)
+        def get_company_config(company_id: str, side: str) -> Config:
+            ...
+
+        @cached(key="global_settings", ttl=300)
+        async def get_settings() -> Settings:
+            ...
+    """
+
+    def decorator(fn: Callable) -> Callable:
+        @functools.wraps(fn)
+        async def async_wrapper(*args, **kwargs):
+            cache = client or _default_client
+            if cache is None:
+                return await fn(*args, **kwargs)
+
+            cache_key = _resolve_key(key, prefix, args, kwargs)
+            return await cache.get_or_load(
+                key=cache_key,
+                loader=lambda: fn(*args, **kwargs),
+                ttl=ttl,
+            )
+
+        @functools.wraps(fn)
+        def sync_wrapper(*args, **kwargs):
+            cache = client or _default_client
+            if cache is None:
+                return fn(*args, **kwargs)
+
+            cache_key = _resolve_key(key, prefix, args, kwargs)
+            return cache.get_or_load_sync(
+                key=cache_key,
+                loader=lambda: fn(*args, **kwargs),
+                ttl=ttl,
+            )
+
+        if asyncio.iscoroutinefunction(fn):
+            return async_wrapper
+        return sync_wrapper
+
+    return decorator
+
+
+def _resolve_key(
+    key: Union[str, Callable],
+    prefix: str,
+    args: tuple,
+    kwargs: dict,
+) -> str:
+    if callable(key) and not isinstance(key, str):
+        raw = key(*args, **kwargs)
+    else:
+        raw = str(key)
+    if prefix:
+        return f"{prefix}:{raw}"
+    return raw

fiuai_sdk_python-0.8.0/src/fiuai_sdk_python/pkg/cache/redis_manager.py

@@ -0,0 +1,152 @@
+# -- coding: utf-8 --
+# Project: fiuai-sdk-python
+# Created Date: 2024-03-21
+# Author: liming
+# Agent: Cursor
+# Email: lmlala@aliyun.com
+# Copyright (c) 2025 FiuAI
+
+from typing import Dict, List, Set
+
+from pydantic import BaseModel, Field
+from redis import ConnectionPool as SyncConnectionPool
+from redis import Redis as SyncRedis
+from redis.asyncio import ConnectionPool as AsyncConnectionPool
+from redis.asyncio import Redis as AsyncRedis
+
+from ...utils.logger import get_logger
+from ...utils.text import safe_str
+
+logger = get_logger(__name__)
+
+
+class RedisDBConfig(BaseModel):
+    name: str = Field(description="连接名称")
+    host: str = Field(description="Redis主机")
+    port: int = Field(description="Redis端口")
+    password: str = Field(description="Redis密码")
+    db: int = Field(description="Redis数据库编号")
+    pool_size: int = Field(description="Redis连接池大小", default=20)
+    ttl: int = Field(description="Redis TTL", default=86400)
+
+
+class RedisManager:
+    """Redis 连接池管理器 (单例)
+
+    管理多个 Redis 连接池, 每个连接池对应不同的数据库。
+    支持同步和异步两种模式, 支持增量注册新连接池。
+    """
+
+    _instance = None
+    _async_pools: Dict[str, AsyncConnectionPool] = {}
+    _sync_pools: Dict[str, SyncConnectionPool] = {}
+    _registered_names: Set[str] = set()
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(self):
+        if not hasattr(self, "_inited"):
+            self._async_pools = {}
+            self._sync_pools = {}
+            self._registered_names = set()
+            self._inited = True
+
+    @property
+    def is_initialized(self) -> bool:
+        return len(self._registered_names) > 0
+
+    async def initialize(
+        self,
+        async_dbs: List[RedisDBConfig] | None = None,
+        sync_dbs: List[RedisDBConfig] | None = None,
+    ):
+        """初始化 Redis 连接池 (支持增量注册: 已存在的 pool 跳过, 新的追加)"""
+        for db in async_dbs or []:
+            if db.name not in self._registered_names:
+                await self.get_async_pool(db)
+                self._registered_names.add(db.name)
+                logger.info(f"registered async pool: {db.name}")
+
+        for db in sync_dbs or []:
+            if db.name not in self._registered_names:
+                self.get_sync_pool(db)
+                self._registered_names.add(db.name)
+                logger.info(f"registered sync pool: {db.name}")
+
+    async def get_async_pool(self, db: RedisDBConfig) -> AsyncConnectionPool:
+        """获取指定数据库的异步连接池, 不存在则创建"""
+        if db.name not in self._async_pools:
+            self._async_pools[db.name] = AsyncConnectionPool.from_url(
+                f"redis://:{safe_str(db.password)}@{db.host}:{db.port}/{db.db}",
+                db=db.db,
+                decode_responses=True,
+                max_connections=db.pool_size,
+            )
+        return self._async_pools[db.name]
+
+    def get_sync_pool(self, db: RedisDBConfig) -> SyncConnectionPool:
+        """获取指定数据库的同步连接池, 不存在则创建 (纯连接池, 不执行 LangGraph setup)"""
+        if db.name not in self._sync_pools:
+            self._sync_pools[db.name] = SyncConnectionPool.from_url(
+                f"redis://:{safe_str(db.password)}@{db.host}:{db.port}/{db.db}",
+                db=db.db,
+                decode_responses=True,
+                max_connections=db.pool_size,
+            )
+        return self._sync_pools[db.name]
+
+    def get_async_client(self, db_name: str) -> AsyncRedis:
+        """获取指定数据库的异步 Redis 客户端"""
+        if db_name not in self._async_pools:
+            raise RuntimeError(f"async pool not registered: {db_name}")
+        return AsyncRedis(connection_pool=self._async_pools[db_name])
+
+    def get_sync_client(self, db_name: str) -> SyncRedis:
+        """获取指定数据库的同步 Redis 客户端"""
+        if db_name not in self._sync_pools:
+            raise RuntimeError(f"sync pool not registered: {db_name}")
+        return SyncRedis(connection_pool=self._sync_pools[db_name])
+
+    def setup_langgraph_checkpoint(self, db_name: str):
+        """按需初始化 LangGraph checkpoint (仅 Agent 场景需要, lazy import)"""
+        from langgraph.checkpoint.redis import RedisSaver
+
+        pool = self._sync_pools.get(db_name)
+        if not pool:
+            raise RuntimeError(f"sync pool not registered: {db_name}")
+
+        client = SyncRedis(connection_pool=pool)
+        with RedisSaver.from_conn_string(redis_client=client) as saver:
+            saver.setup()
+        logger.info(f"langgraph checkpoint setup done: {db_name}")
+
+    async def setup_langgraph_checkpoint_async(self, db_name: str):
+        """异步版 LangGraph checkpoint 初始化"""
+        from langgraph.checkpoint.redis import AsyncRedisSaver
+
+        pool = self._async_pools.get(db_name)
+        if not pool:
+            raise RuntimeError(f"async pool not registered: {db_name}")
+
+        client = AsyncRedis(connection_pool=pool)
+        async with AsyncRedisSaver.from_conn_string(redis_client=client) as saver:
+            await saver.asetup()
+        logger.info(f"langgraph async checkpoint setup done: {db_name}")
+
+    async def close_all(self):
+        """关闭所有连接池"""
+        for pool in self._async_pools.values():
+            await pool.disconnect()
+        self._async_pools.clear()
+
+        for pool in self._sync_pools.values():
+            pool.disconnect()
+        self._sync_pools.clear()
+
+        self._registered_names.clear()
+
+
+redis_manager = RedisManager()

fiuai_sdk_python-0.8.0/src/fiuai_sdk_python/pkg/cache/types.py

@@ -0,0 +1,58 @@
+# -- coding: utf-8 --
+# Project: fiuai-sdk-python
+# Created Date: 2026-03-09
+# Author: liming
+# Agent: Cursor
+# Email: lmlala@aliyun.com
+# Copyright (c) 2025 FiuAI
+
+from enum import Enum
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+class CircuitState(str, Enum):
+    """熔断器状态"""
+
+    CLOSED = "closed"
+    OPEN = "open"
+    HALF_OPEN = "half_open"
+
+
+class CircuitBreakerConfig(BaseModel):
+    """熔断器配置"""
+
+    failure_threshold: int = Field(
+        default=5,
+        description="连续失败次数达此值后熔断",
+    )
+    recovery_timeout: float = Field(
+        default=30.0,
+        description="熔断后冷却秒数, 之后进入半开",
+    )
+    half_open_max_calls: int = Field(
+        default=1,
+        description="半开状态允许探测的请求数",
+    )
+
+
+class CacheConfig(BaseModel):
+    """CacheClient 配置"""
+
+    default_ttl: Optional[int] = Field(
+        default=None,
+        description="默认 TTL (秒), None 表示不过期",
+    )
+    key_prefix: str = Field(
+        default="",
+        description="key 前缀, 如 'finnexus' 或 'world'",
+    )
+    redis_db_name: str = Field(
+        default="default",
+        description="redis_manager 中注册的连接池名称",
+    )
+    circuit_breaker: CircuitBreakerConfig = Field(
+        default_factory=CircuitBreakerConfig,
+        description="熔断器配置, 用于 Redis 不可用时降级",
+    )

fiuai_sdk_python-0.7.5/src/fiuai_sdk_python/pkg/cache/__init__.py

@@ -1,6 +0,0 @@
-from .redis_manager import redis_manager, RedisDBConfig
-
-__all__ = [
-    "redis_manager",
-    "RedisDBConfig",
-]

fiuai_sdk_python-0.7.5/src/fiuai_sdk_python/pkg/cache/redis_manager.py

@@ -1,188 +0,0 @@
-"""
-Project: fiuai-agent
-Created Date: 2024-03-21
-Author: liming
-Email: lmlala@aliyun.com
-Copyright (c) 2025 FiuAI
-"""
-
-from typing import Dict, Optional, List, Union, Tuple
-from redis.asyncio import Redis as AsyncRedis, ConnectionPool as AsyncConnectionPool
-from redis import Redis as SyncRedis, ConnectionPool as SyncConnectionPool
-from langgraph.checkpoint.redis import RedisSaver, AsyncRedisSaver
-from pydantic import BaseModel, Field
-from ...utils.text import safe_str
-
-class RedisDBConfig(BaseModel):
-    name: str = Field(description="连接名称")
-    host: str = Field(description="Redis主机")
-    port: int = Field(description="Redis端口")
-    password: str = Field(description="Redis密码")
-    db: int = Field(description="Redis数据库编号")
-    pool_size: int = Field(description="Redis连接池大小", default=20)
-    ttl: int = Field(description="Redis TTL", default=86400)
-
-class RedisManager:
-    """Redis连接池管理器单例类
-    
-    用于管理多个Redis连接池，每个连接池对应不同的数据库
-    支持同步和异步两种模式
-    """
-    _instance = None
-    _async_pools: Dict[str, AsyncConnectionPool] = {}
-    _sync_pools: Dict[str, SyncConnectionPool] = {}
-    _initialized = False
-    
-    def __new__(cls):
-        if cls._instance is None:
-            cls._instance = super().__new__(cls)
-        return cls._instance
-    
-    def __init__(self):
-        if not hasattr(self, '_initialized'):
-            self._initialized = False
-    
-    async def initialize(
-        self,
-        async_dbs: List[RedisDBConfig] = [],
-        sync_dbs: List[RedisDBConfig] = []
-    ):
-        """初始化Redis连接池
-        
-        Args:
-            async_dbs: 需要初始化的异步数据库列表
-            sync_dbs: 需要初始化的同步数据库列表
-        """
-        if self._initialized:
-            return
-            
-        # 初始化异步连接池
-        for db in async_dbs:
-            await self.get_async_pool(db)
-            # await self._init_async_index(db)
-            
-        # 初始化同步连接池
-        for db in sync_dbs:
-            self.get_sync_pool(db)
-            # self._init_sync_index(db)
-        self._initialized = True
-    
-    def _init_sync_index(self, db: RedisDBConfig) -> SyncConnectionPool:
-        """初始化索引"""
-        _client = SyncRedis(connection_pool=self._sync_pools[db.name])
-        with RedisSaver.from_conn_string(
-            redis_client=_client
-        ) as c:
-            c.setup()
-
-    async def _init_async_index(self, db: RedisDBConfig) -> AsyncConnectionPool:
-        """初始化索引"""
-        _client = AsyncRedis(connection_pool=self._async_pools[db.name])
-        async with AsyncRedisSaver.from_conn_string(
-            redis_client=_client
-        ) as c:
-            await c.asetup()
-
-    async def get_async_pool(self, db: RedisDBConfig) -> AsyncConnectionPool:
-        """获取指定数据库的异步连接池
-        
-        Args:
-            db: RedisDBConfig
-            
-        Returns:
-            AsyncConnectionPool: Redis异步连接池实例
-        """
-        
-        if db.name not in self._async_pools:
-            self._async_pools[db.name] = AsyncConnectionPool.from_url(
-                f"redis://:{safe_str(db.password)}@{db.host}:{db.port}/{db.db}",
-                db=db.db,
-                decode_responses=True,
-                max_connections=db.pool_size
-            )
-            
-        return self._async_pools[db.name]
-    
-    def get_sync_pool(self, db: RedisDBConfig) -> SyncConnectionPool:
-        """获取指定数据库的同步连接池
-        
-        Args:
-            db: RedisDBConfig
-            
-        Returns:
-            SyncConnectionPool: Redis同步连接池实例
-        """
-        if db.name not in self._sync_pools:
-            self._sync_pools[db.name] = SyncConnectionPool.from_url(
-                f"redis://:{safe_str(db.password)}@{db.host}:{db.port}/{db.db}",
-                db=db.db,
-                decode_responses=True,
-                max_connections=db.pool_size
-            )
-        
-        # 初始化
-        with RedisSaver.from_conn_string(
-            redis_client=self._sync_pools[db.name]
-        ) as c:
-            c.setup()
-
-        return self._sync_pools[db.name]
-    
-    def get_async_client(self, db_name: str) -> AsyncRedis:
-        """获取指定数据库的异步Redis客户端
-        
-        Args:
-            db_name: 数据库名称
-            
-        Returns:
-            AsyncRedis: Redis异步客户端实例
-            
-        Raises:
-            RuntimeError: 如果Redis连接池未初始化
-        """
-        if not self._initialized:
-            raise RuntimeError("pool not initialized")
-            
-        if db_name not in self._async_pools:
-            raise RuntimeError(f"pool not found: {db_name}")
-        
-        pool = self._async_pools[db_name]
-        return AsyncRedis(connection_pool=pool)
-    
-    def get_sync_client(self, db_name: str) -> SyncRedis:
-        """获取指定数据库的同步Redis客户端
-        
-        Args:
-            db_name: 数据库名称
-            
-        Returns:
-            SyncRedis: Redis同步客户端实例
-            
-        Raises:
-            RuntimeError: 如果Redis连接池未初始化
-        """
-        if not self._initialized:
-            raise RuntimeError("pool not initialized")
-            
-        if db_name not in self._sync_pools:
-            raise RuntimeError(f"pool not found: {db_name}")
-        
-        pool = self._sync_pools[db_name]
-        return SyncRedis(connection_pool=pool)
-    
-    async def close_all(self):
-        """关闭所有连接池"""
-        # 关闭异步连接池
-        for pool in self._async_pools.values():
-            await pool.disconnect()
-        self._async_pools.clear()
-        
-        # 关闭同步连接池
-        for pool in self._sync_pools.values():
-            pool.disconnect()
-        self._sync_pools.clear()
-        
-        self._initialized = False
-
-# 创建全局单例实例
-redis_manager = RedisManager()