aury-boot 0.0.42__tar.gz → 0.0.44__tar.gz

{aury_boot-0.0.42 → aury_boot-0.0.44}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aury-boot
-Version: 0.0.42
+Version: 0.0.44
 Summary: Aury Boot - 基于 FastAPI 生态的企业级 API 开发框架
 Requires-Python: >=3.13
 Requires-Dist: aiohttp>=3.11.0
@@ -28,7 +28,6 @@ Requires-Dist: aiosqlite>=0.21.0; extra == 'all'
 Requires-Dist: apscheduler>=3.11.1; extra == 'all'
 Requires-Dist: asyncpg>=0.31.0; extra == 'all'
 Requires-Dist: aury-sdk-storage[aws]>=0.0.1; extra == 'all'
-Requires-Dist: coredis>=5.6.0; extra == 'all'
 Requires-Dist: dramatiq>=1.18.0; extra == 'all'
 Requires-Dist: pika>=1.3.2; extra == 'all'
 Requires-Dist: psutil>=7.0.0; extra == 'all'
@@ -36,8 +35,6 @@ Requires-Dist: pyroscope-io>=0.8.7; extra == 'all'
 Requires-Dist: redis>=7.1.0; extra == 'all'
 Provides-Extra: broadcaster
 Requires-Dist: broadcaster[redis]>=0.3.1; extra == 'broadcaster'
-Provides-Extra: channel-cluster
-Requires-Dist: coredis>=5.6.0; extra == 'channel-cluster'
 Provides-Extra: dev
 Requires-Dist: httpx>=0.28.1; extra == 'dev'
 Requires-Dist: mypy>=1.19.0; extra == 'dev'
@@ -71,7 +68,6 @@ Requires-Dist: aiosqlite>=0.21.0; extra == 'recommended'
 Requires-Dist: apscheduler>=3.11.1; extra == 'recommended'
 Requires-Dist: asyncpg>=0.31.0; extra == 'recommended'
 Requires-Dist: aury-sdk-storage[aws]>=0.0.1; extra == 'recommended'
-Requires-Dist: coredis>=5.6.0; extra == 'recommended'
 Requires-Dist: dramatiq>=1.18.0; extra == 'recommended'
 Requires-Dist: opentelemetry-api>=1.25.0; extra == 'recommended'
 Requires-Dist: opentelemetry-instrumentation-aiohttp-client>=0.46b0; extra == 'recommended'

{aury_boot-0.0.42 → aury_boot-0.0.44}/aury/boot/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.0.42'
-__version_tuple__ = version_tuple = (0, 0, 42)
+__version__ = version = '0.0.44'
+__version_tuple__ = version_tuple = (0, 0, 44)
 
 __commit_id__ = commit_id = None

{aury_boot-0.0.42 → aury_boot-0.0.44}/aury/boot/infrastructure/cache/redis.py

@@ -96,46 +96,31 @@ class RedisCache(ICache):
         self._is_cluster = False
     
     async def _init_cluster(self) -> None:
-        """初始化 Redis Cluster（使用 coredis）。
+        """初始化 Redis Cluster（使用 redis-py）。
         
         支持 URL 格式:
         - redis-cluster://password@host:port （密码在用户名位置）
         - redis-cluster://:password@host:port （标准格式）
         - redis-cluster://username:password@host:port （ACL 模式）
         """
-        try:
-            from coredis import RedisCluster
-        except ImportError as exc:
-            raise ImportError(
-                "Redis Cluster 需要安装 coredis: pip install coredis"
-            ) from exc
-        
-        # 解析 URL
-        parsed_url = self._url.replace("redis-cluster://", "redis://")
-        parsed = urlparse(parsed_url)
-        
-        # 提取认证信息
-        username = parsed.username
-        password = parsed.password
-        
-        # 处理 password@host 格式
-        if username and not password:
-            password = username
-            username = None
+        from redis.asyncio.cluster import RedisCluster
         
-        # 构建连接参数
-        cluster_kwargs: dict = {
-            "host": parsed.hostname or "localhost",
-            "port": parsed.port or 6379,
-            "decode_responses": False,
-        }
+        # 转换 URL scheme
+        redis_url = self._url.replace("redis-cluster://", "redis://")
         
-        if username:
-            cluster_kwargs["username"] = username
-        if password:
-            cluster_kwargs["password"] = password
+        # 处理 password@host 格式（转换为标准 :password@host 格式）
+        parsed = urlparse(redis_url)
+        if parsed.username and not parsed.password:
+            # redis://password@host -> redis://:password@host
+            redis_url = redis_url.replace(
+                f"redis://{parsed.username}@",
+                f"redis://:{parsed.username}@"
+            )
         
-        self._redis = RedisCluster(**cluster_kwargs)
+        self._redis = RedisCluster.from_url(
+            redis_url,
+            decode_responses=False,
+        )
         self._is_cluster = True
     
     async def get(self, key: str, default: Any = None) -> Any:
@@ -254,8 +239,11 @@ class RedisCache(ICache):
     async def close(self) -> None:
         """关闭连接（仅当自己拥有连接时）。"""
         if self._redis and self._owns_connection:
-            # coredis 和 redis-py 都使用 close() 方法
-            await self._redis.close()
+            if self._is_cluster:
+                # redis-py cluster 使用 aclose()
+                await self._redis.aclose()
+            else:
+                await self._redis.close()
             logger.info("Redis连接已关闭")
         self._redis = None
     

{aury_boot-0.0.42 → aury_boot-0.0.44}/aury/boot/infrastructure/channel/__init__.py

@@ -5,11 +5,12 @@
 支持的后端（通过 Broadcaster 库）:
 - memory:// - 内存通道（单进程，开发/测试用）
 - redis:// - Redis Pub/Sub（多进程/分布式）
+- redis-cluster:// - Redis Cluster（自动转换为普通 Pub/Sub）
 - kafka:// - Apache Kafka
 - postgres:// - PostgreSQL LISTEN/NOTIFY
 """
 
-from .backends import BroadcasterChannel, RedisClusterChannel
+from .backends import BroadcasterChannel
 from .base import ChannelBackend, ChannelMessage, IChannel
 from .manager import ChannelManager
 
@@ -22,5 +23,4 @@ __all__ = [
     "ChannelManager",
     # 后端实现
     "BroadcasterChannel",
-    "RedisClusterChannel",
 ]

aury_boot-0.0.44/aury/boot/infrastructure/channel/backends/__init__.py

@@ -0,0 +1,5 @@
+"""通道后端实现。"""
+
+from .broadcaster import BroadcasterChannel
+
+__all__ = ["BroadcasterChannel"]

{aury_boot-0.0.42 → aury_boot-0.0.44}/aury/boot/infrastructure/channel/base.py

@@ -16,10 +16,8 @@ from typing import Any
 class ChannelBackend(Enum):
     """通道后端类型。"""
 
-    # Broadcaster 统一后端（支持 memory/redis/kafka/postgres，通过 URL scheme 区分）
+    # Broadcaster 统一后端（支持 memory/redis/redis-cluster/kafka/postgres，通过 URL scheme 区分）
     BROADCASTER = "broadcaster"
-    # Redis Cluster + Sharded Pub/Sub (Redis 7.0+)，使用 coredis 库
-    REDIS_CLUSTER = "redis_cluster"
     # 未来扩展
     RABBITMQ = "rabbitmq"
     ROCKETMQ = "rocketmq"

{aury_boot-0.0.42 → aury_boot-0.0.44}/aury/boot/infrastructure/channel/manager.py

@@ -10,7 +10,6 @@ from collections.abc import AsyncIterator
 from aury.boot.common.logging import logger
 
 from .backends.broadcaster import BroadcasterChannel
-from .backends.redis_cluster_channel import RedisClusterChannel
 from .base import ChannelBackend, ChannelMessage, IChannel
 
 
@@ -94,7 +93,7 @@ class ChannelManager:
             url: 连接 URL，支持：
                 - memory:// - 内存后端（单进程，默认）
                 - redis://host:port/db - Redis Pub/Sub
-                - redis-cluster://[password@]host:port - Redis Cluster (Sharded Pub/Sub)
+                - redis-cluster://[password@]host:port - Redis Cluster (普通 Pub/Sub)
                 - kafka://host:port - Apache Kafka
                 - postgres://user:pass@host/db - PostgreSQL
 
@@ -109,17 +108,18 @@ class ChannelManager:
         if isinstance(backend, str):
             backend = ChannelBackend(backend.lower())
         
-        # 自动检测 redis-cluster:// scheme
+        # redis-cluster:// 转换为 redis://，使用 broadcaster 的普通 Pub/Sub
+        # 普通 Pub/Sub 在 Redis Cluster 中会自动广播到所有节点
+        broadcast_url = url
         if url.startswith("redis-cluster://"):
-            backend = ChannelBackend.REDIS_CLUSTER
+            broadcast_url = url.replace("redis-cluster://", "redis://")
+            logger.info(f"通道管理器 [{self.name}] Redis Cluster 使用普通 Pub/Sub 模式")
 
         self._backend_type = backend
         self._url = url
 
-        if backend == ChannelBackend.BROADCASTER:
-            self._backend = BroadcasterChannel(url)
-        elif backend == ChannelBackend.REDIS_CLUSTER:
-            self._backend = RedisClusterChannel(url)
+        if backend == ChannelBackend.BROADCASTER or url.startswith("redis-cluster://"):
+            self._backend = BroadcasterChannel(broadcast_url)
         elif backend in (ChannelBackend.RABBITMQ, ChannelBackend.ROCKETMQ):
             raise NotImplementedError(f"{backend.value} 后端暂未实现")
         else:

{aury_boot-0.0.42 → aury_boot-0.0.44}/aury/boot/infrastructure/clients/redis/manager.py

@@ -202,46 +202,30 @@ class RedisClient:
         self._is_cluster = False
     
     async def _initialize_cluster(self, url: str) -> None:
-        """初始化 Redis Cluster 连接（使用 coredis）。
+        """初始化 Redis Cluster 连接（使用 redis-py）。
         
         支持 URL 格式:
         - redis-cluster://password@host:port （密码在用户名位置）
         - redis-cluster://:password@host:port （标准格式）
         - redis-cluster://username:password@host:port （ACL 模式）
         """
-        try:
-            from coredis import RedisCluster
-        except ImportError as exc:
-            raise ImportError(
-                "Redis Cluster 需要安装 coredis: pip install coredis"
-            ) from exc
-        
-        # 解析 URL
-        parsed_url = url.replace("redis-cluster://", "redis://")
-        parsed = urlparse(parsed_url)
-        
-        # 提取认证信息
-        username = parsed.username
-        password = parsed.password
-        
-        # 处理 password@host 格式
-        if username and not password:
-            password = username
-            username = None
+        from redis.asyncio.cluster import RedisCluster
         
-        # 构建连接参数
-        cluster_kwargs: dict = {
-            "host": parsed.hostname or "localhost",
-            "port": parsed.port or 6379,
-            "decode_responses": self._config.decode_responses,
-        }
+        # 转换 URL scheme
+        redis_url = url.replace("redis-cluster://", "redis://")
         
-        if username:
-            cluster_kwargs["username"] = username
-        if password:
-            cluster_kwargs["password"] = password
+        # 处理 password@host 格式（转换为标准 :password@host 格式）
+        parsed = urlparse(redis_url)
+        if parsed.username and not parsed.password:
+            redis_url = redis_url.replace(
+                f"redis://{parsed.username}@",
+                f"redis://:{parsed.username}@"
+            )
         
-        self._redis = RedisCluster(**cluster_kwargs)
+        self._redis = RedisCluster.from_url(
+            redis_url,
+            decode_responses=self._config.decode_responses,
+        )
         self._is_cluster = True
     
     def _mask_url(self, url: str) -> str:
@@ -316,8 +300,8 @@ class RedisClient:
         """清理资源，关闭连接。"""
         if self._redis:
             if self._is_cluster:
-                # coredis 使用 close() 方法
-                await self._redis.close()
+                # redis-py cluster 使用 aclose()
+                await self._redis.aclose()
             else:
                 await self._redis.close()
             logger.info(f"Redis 客户端 [{self.name}] 已关闭")

{aury_boot-0.0.42 → aury_boot-0.0.44}/pyproject.toml

@@ -51,7 +51,6 @@ redis = ["redis>=7.1.0"]
 
 # ============ 实时通信 (Pub/Sub) ============
 broadcaster = ["broadcaster[redis]>=0.3.1"]
-channel-cluster = ["coredis>=5.6.0"]  # Redis Cluster Sharded Pub/Sub
 
 # ============ 对象存储 ============
 s3 = ["aury-sdk-storage[aws]>=0.0.1"]
@@ -97,7 +96,6 @@ admin = [
 recommended = [
     "asyncpg>=0.31.0",
     "redis>=7.1.0",
-    "coredis>=5.6.0",  # Redis Cluster Channel
     "dramatiq>=1.18.0",
     "apscheduler>=3.11.1",
     "aury-sdk-storage[aws]>=0.0.1",
@@ -115,7 +113,6 @@ all = [
     "aiomysql>=0.3.2",
     "aiosqlite>=0.21.0",
     "redis>=7.1.0",
-    "coredis>=5.6.0",  # Redis Cluster Channel
     "aury-sdk-storage[aws]>=0.0.1",
     "dramatiq>=1.18.0",
     "pika>=1.3.2",  # RabbitMQ

aury_boot-0.0.42/aury/boot/infrastructure/channel/backends/__init__.py

@@ -1,6 +0,0 @@
-"""通道后端实现。"""
-
-from .broadcaster import BroadcasterChannel
-from .redis_cluster_channel import RedisClusterChannel
-
-__all__ = ["BroadcasterChannel", "RedisClusterChannel"]

aury_boot-0.0.42/aury/boot/infrastructure/channel/backends/redis_cluster.py

@@ -1,124 +0,0 @@
-"""Redis Cluster 通道后端。
-
-使用 coredis 库支持异步 Redis Cluster Sharded Pub/Sub (Redis 7.0+)。
-
-URL 格式：
-    redis-cluster://password@host:port
-    redis-cluster://host:port
-"""
-
-from __future__ import annotations
-
-import asyncio
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any
-from urllib.parse import urlparse
-
-from aury.boot.common.logging import logger
-
-try:
-    from coredis import RedisCluster
-except ImportError as exc:
-    raise ImportError(
-        "Redis Cluster Channel 需要安装 coredis: pip install coredis"
-    ) from exc
-
-
-@dataclass
-class Event:
-    """与 broadcaster._base.Event 兼容的事件类。"""
-    channel: str
-    message: str
-
-
-class RedisClusterBackend:
-    """Redis Cluster Pub/Sub 后端。
-    
-    使用 coredis 库的 sharded_pubsub() 支持 Sharded Pub/Sub。
-    与 broadcaster.RedisBackend 接口兼容。
-    """
-
-    def __init__(self, url: str) -> None:
-        host, port, password = self._parse_url(url)
-        
-        self._client: RedisCluster = RedisCluster(
-            host=host,
-            port=port,
-            password=password,
-            decode_responses=True,
-        )
-        self._pubsub: Any = None
-        self._queue: asyncio.Queue[Event] = asyncio.Queue()
-        self._listener_task: asyncio.Task | None = None
-        self._subscribed_channels: set[str] = set()
-
-    def _parse_url(self, url: str) -> tuple[str, int, str | None]:
-        """解析 URL。"""
-        url = url.replace("redis-cluster://", "redis://")
-        parsed = urlparse(url)
-        password = parsed.password
-        # 支持 password@host 格式
-        if not password and parsed.username:
-            password = parsed.username
-        return parsed.hostname or "localhost", parsed.port or 6379, password
-
-    async def connect(self) -> None:
-        """连接并初始化 pubsub。"""
-        # coredis 的 sharded_pubsub() 支持 Redis 7.0+ Sharded Pub/Sub
-        self._pubsub = self._client.sharded_pubsub()
-        self._listener_task = asyncio.create_task(self._listen_loop())
-        logger.debug("Redis Cluster Channel 已连接")
-
-    async def disconnect(self) -> None:
-        """断开连接。"""
-        if self._listener_task:
-            self._listener_task.cancel()
-            try:
-                await self._listener_task
-            except asyncio.CancelledError:
-                pass
-        if self._pubsub:
-            await self._pubsub.sunsubscribe()
-        await self._client.close()
-        logger.debug("Redis Cluster Channel 已断开")
-
-    async def subscribe(self, channel: str) -> None:
-        """订阅频道。"""
-        if self._pubsub:
-            await self._pubsub.ssubscribe(channel)
-            self._subscribed_channels.add(channel)
-
-    async def unsubscribe(self, channel: str) -> None:
-        """取消订阅。"""
-        if self._pubsub and channel in self._subscribed_channels:
-            await self._pubsub.sunsubscribe(channel)
-            self._subscribed_channels.discard(channel)
-
-    async def publish(self, channel: str, message: str) -> None:
-        """发布消息（使用 SPUBLISH）。"""
-        await self._client.spublish(channel, message)
-
-    async def next_published(self) -> Event:
-        """获取下一条消息。"""
-        return await self._queue.get()
-
-    async def _listen_loop(self) -> None:
-        """监听消息循环。"""
-        while True:
-            try:
-                if self._pubsub:
-                    async for message in self._pubsub:
-                        if message and message.get("type") in ("message", "smessage"):
-                            event = Event(
-                                channel=message.get("channel", ""),
-                                message=message.get("data", ""),
-                            )
-                            await self._queue.put(event)
-            except asyncio.CancelledError:
-                break
-            except Exception as e:
-                logger.warning(f"Redis Cluster pubsub error: {e}")
-                await asyncio.sleep(1)
-
-
-__all__ = ["RedisClusterBackend"]

aury_boot-0.0.42/aury/boot/infrastructure/channel/backends/redis_cluster_channel.py

@@ -1,139 +0,0 @@
-"""Redis Cluster 通道封装。
-
-使用 RedisClusterBackend，提供与 BroadcasterChannel 一致的接口。
-"""
-
-from __future__ import annotations
-
-import json
-from collections.abc import AsyncIterator
-from datetime import datetime
-
-from aury.boot.common.logging import logger
-
-from ..base import ChannelMessage, IChannel
-from .redis_cluster import RedisClusterBackend
-
-
-class RedisClusterChannel(IChannel):
-    """Redis Cluster 通道实现。
-    
-    使用 broadcaster 架构：共享连接 + Queue 分发。
-    支持 Sharded Pub/Sub (Redis 7.0+)。
-    """
-
-    def __init__(self, url: str) -> None:
-        """初始化 Redis Cluster 通道。
-
-        Args:
-            url: redis-cluster://[password@]host:port
-        """
-        self._url = url
-        self._backend = RedisClusterBackend(url)
-        self._connected = False
-        # 订阅者管理（与 broadcaster 相同的模式）
-        self._subscribers: dict[str, set] = {}
-        self._listener_task = None
-
-    async def _ensure_connected(self) -> None:
-        if not self._connected:
-            await self._backend.connect()
-            self._listener_task = __import__("asyncio").create_task(self._listener())
-            self._connected = True
-            logger.debug(f"Redis Cluster 通道已连接: {self._mask_url(self._url)}")
-
-    def _mask_url(self, url: str) -> str:
-        if "@" in url:
-            parts = url.split("@")
-            prefix = parts[0]
-            suffix = parts[1]
-            if "://" in prefix:
-                scheme = prefix.split("://")[0]
-                return f"{scheme}://***@{suffix}"
-        return url
-
-    async def _listener(self) -> None:
-        """监听后端消息，分发到订阅者。"""
-        import asyncio
-        while True:
-            try:
-                event = await self._backend.next_published()
-                channel = event.channel
-                if channel in self._subscribers:
-                    for queue in list(self._subscribers[channel]):
-                        await queue.put(event)
-            except asyncio.CancelledError:
-                break
-            except Exception as e:
-                logger.warning(f"Redis Cluster listener error: {e}")
-
-    async def publish(self, channel: str, message: ChannelMessage) -> None:
-        await self._ensure_connected()
-        message.channel = channel
-        data = {
-            "data": message.data,
-            "event": message.event,
-            "id": message.id,
-            "channel": message.channel,
-            "timestamp": message.timestamp.isoformat(),
-        }
-        await self._backend.publish(channel, json.dumps(data))
-
-    async def subscribe(self, channel: str) -> AsyncIterator[ChannelMessage]:
-        import asyncio
-        await self._ensure_connected()
-        
-        queue: asyncio.Queue = asyncio.Queue()
-        
-        try:
-            # 首个订阅者时订阅 Redis
-            if channel not in self._subscribers:
-                await self._backend.subscribe(channel)
-                self._subscribers[channel] = set()
-            self._subscribers[channel].add(queue)
-            
-            while True:
-                event = await queue.get()
-                try:
-                    data = json.loads(event.message)
-                    yield ChannelMessage(
-                        data=data.get("data"),
-                        event=data.get("event"),
-                        id=data.get("id"),
-                        channel=data.get("channel") or channel,
-                        timestamp=datetime.fromisoformat(data["timestamp"])
-                        if data.get("timestamp")
-                        else datetime.now(),
-                    )
-                except (json.JSONDecodeError, KeyError, TypeError) as e:
-                    logger.warning(f"解析通道消息失败: {e}")
-        finally:
-            if channel in self._subscribers:
-                self._subscribers[channel].discard(queue)
-                if not self._subscribers[channel]:
-                    del self._subscribers[channel]
-                    try:
-                        await self._backend.unsubscribe(channel)
-                    except Exception:
-                        pass
-
-    async def psubscribe(self, pattern: str) -> AsyncIterator[ChannelMessage]:
-        raise NotImplementedError(
-            "Redis Cluster Sharded Pub/Sub 不支持模式订阅。"
-            "请使用具体的 channel 名称。"
-        )
-
-    async def unsubscribe(self, channel: str) -> None:
-        pass  # subscribe() 的 finally 块自动处理
-
-    async def close(self) -> None:
-        if self._connected:
-            if self._listener_task:
-                self._listener_task.cancel()
-            await self._backend.disconnect()
-            self._connected = False
-            self._subscribers.clear()
-            logger.debug("Redis Cluster 通道已关闭")
-
-
-__all__ = ["RedisClusterChannel"]