aury-boot 0.0.30__py3-none-any.whl → 0.0.32__py3-none-any.whl

aury/boot/infrastructure/channel/backends/memory.py

@@ -1,126 +0,0 @@
-"""内存通道后端。
-
-适用于单进程场景，如开发环境或简单应用。
-"""
-
-from __future__ import annotations
-
-import asyncio
-from collections.abc import AsyncIterator
-import contextlib
-import fnmatch
-
-from aury.boot.common.logging import logger
-
-from ..base import ChannelMessage, IChannel
-
-
-class MemoryChannel(IChannel):
-    """内存通道实现。
-
-    使用 asyncio.Queue 实现进程内的发布/订阅。
-
-    注意：仅适用于单进程，不支持跨进程通信。
-    """
-
-    def __init__(self, max_subscribers: int = 1000) -> None:
-        """初始化内存通道。
-
-        Args:
-            max_subscribers: 每个通道最大订阅者数量
-        """
-        self._max_subscribers = max_subscribers
-        # channel -> list of queues
-        self._subscribers: dict[str, list[asyncio.Queue[ChannelMessage]]] = {}
-        # pattern -> list of queues (用于 psubscribe)
-        self._pattern_subscribers: dict[str, list[asyncio.Queue[ChannelMessage]]] = {}
-        self._lock = asyncio.Lock()
-
-    async def publish(self, channel: str, message: ChannelMessage) -> None:
-        """发布消息到通道。"""
-        message.channel = channel
-        async with self._lock:
-            # 精确匹配订阅者
-            subscribers = self._subscribers.get(channel, [])
-            for queue in subscribers:
-                try:
-                    queue.put_nowait(message)
-                except asyncio.QueueFull:
-                    logger.warning(f"通道 [{channel}] 订阅者队列已满，消息被丢弃")
-
-            # 模式匹配订阅者
-            for pattern, queues in self._pattern_subscribers.items():
-                if fnmatch.fnmatch(channel, pattern):
-                    for queue in queues:
-                        try:
-                            queue.put_nowait(message)
-                        except asyncio.QueueFull:
-                            logger.warning(f"模式 [{pattern}] 订阅者队列已满，消息被丢弃")
-
-    async def subscribe(self, channel: str) -> AsyncIterator[ChannelMessage]:
-        """订阅通道。"""
-        queue: asyncio.Queue[ChannelMessage] = asyncio.Queue(maxsize=100)
-
-        async with self._lock:
-            if channel not in self._subscribers:
-                self._subscribers[channel] = []
-            if len(self._subscribers[channel]) >= self._max_subscribers:
-                raise RuntimeError(f"通道 [{channel}] 订阅者数量已达上限")
-            self._subscribers[channel].append(queue)
-
-        try:
-            while True:
-                message = await queue.get()
-                yield message
-        finally:
-            async with self._lock:
-                if channel in self._subscribers:
-                    with contextlib.suppress(ValueError):
-                        self._subscribers[channel].remove(queue)
-                    if not self._subscribers[channel]:
-                        del self._subscribers[channel]
-
-    async def psubscribe(self, pattern: str) -> AsyncIterator[ChannelMessage]:
-        """模式订阅通道。
-
-        使用 fnmatch 风格的通配符：
-        - `*` 匹配任意字符
-        - `?` 匹配单个字符
-        - `[seq]` 匹配 seq 中的任意字符
-        """
-        queue: asyncio.Queue[ChannelMessage] = asyncio.Queue(maxsize=100)
-
-        async with self._lock:
-            if pattern not in self._pattern_subscribers:
-                self._pattern_subscribers[pattern] = []
-            if len(self._pattern_subscribers[pattern]) >= self._max_subscribers:
-                raise RuntimeError(f"模式 [{pattern}] 订阅者数量已达上限")
-            self._pattern_subscribers[pattern].append(queue)
-
-        try:
-            while True:
-                message = await queue.get()
-                yield message
-        finally:
-            async with self._lock:
-                if pattern in self._pattern_subscribers:
-                    with contextlib.suppress(ValueError):
-                        self._pattern_subscribers[pattern].remove(queue)
-                    if not self._pattern_subscribers[pattern]:
-                        del self._pattern_subscribers[pattern]
-
-    async def unsubscribe(self, channel: str) -> None:
-        """取消订阅通道（清除所有订阅者）。"""
-        async with self._lock:
-            if channel in self._subscribers:
-                del self._subscribers[channel]
-
-    async def close(self) -> None:
-        """关闭通道，清理所有订阅。"""
-        async with self._lock:
-            self._subscribers.clear()
-            self._pattern_subscribers.clear()
-        logger.debug("内存通道已关闭")
-
-
-__all__ = ["MemoryChannel"]

aury/boot/infrastructure/channel/backends/redis.py

@@ -1,130 +0,0 @@
-"""Redis 通道后端。
-
-适用于多进程/多实例场景，支持跨进程通信。
-"""
-
-from __future__ import annotations
-
-from collections.abc import AsyncIterator
-from datetime import datetime
-import json
-from typing import TYPE_CHECKING
-
-from aury.boot.common.logging import logger
-
-from ..base import ChannelMessage, IChannel
-
-if TYPE_CHECKING:
-    from aury.boot.infrastructure.clients.redis import RedisClient
-
-
-class RedisChannel(IChannel):
-    """Redis 通道实现。
-
-    使用 Redis Pub/Sub 实现跨进程的发布/订阅。
-    """
-
-    def __init__(self, redis_client: RedisClient) -> None:
-        """初始化 Redis 通道。
-
-        Args:
-            redis_client: RedisClient 实例
-        """
-        self._client = redis_client
-        self._pubsub = None
-
-    async def publish(self, channel: str, message: ChannelMessage) -> None:
-        """发布消息到通道。"""
-        message.channel = channel
-        # 序列化消息
-        data = {
-            "data": message.data,
-            "event": message.event,
-            "id": message.id,
-            "channel": message.channel,
-            "timestamp": message.timestamp.isoformat(),
-        }
-        await self._client.connection.publish(channel, json.dumps(data))
-
-    async def subscribe(self, channel: str) -> AsyncIterator[ChannelMessage]:
-        """订阅通道。"""
-        pubsub = self._client.connection.pubsub()
-        await pubsub.subscribe(channel)
-
-        try:
-            async for raw_message in pubsub.listen():
-                if raw_message["type"] == "message":
-                    try:
-                        data = json.loads(raw_message["data"])
-                        message = ChannelMessage(
-                            data=data.get("data"),
-                            event=data.get("event"),
-                            id=data.get("id"),
-                            channel=data.get("channel"),
-                            timestamp=datetime.fromisoformat(data["timestamp"])
-                            if data.get("timestamp")
-                            else datetime.now(),
-                        )
-                        yield message
-                    except (json.JSONDecodeError, KeyError) as e:
-                        logger.warning(f"解析通道消息失败: {e}")
-        finally:
-            await pubsub.unsubscribe(channel)
-            await pubsub.close()
-
-    async def psubscribe(self, pattern: str) -> AsyncIterator[ChannelMessage]:
-        """模式订阅（通配符）。
-        
-        Args:
-            pattern: 通道模式，支持 * 和 ? 通配符
-                - * 匹配任意字符
-                - ? 匹配单个字符
-                - 示例: "space:123:*" 订阅 space:123 下所有事件
-        
-        Yields:
-            ChannelMessage: 接收到的消息
-        """
-        pubsub = self._client.connection.pubsub()
-        await pubsub.psubscribe(pattern)
-
-        try:
-            async for raw_message in pubsub.listen():
-                # psubscribe 的消息类型是 "pmessage"
-                if raw_message["type"] == "pmessage":
-                    try:
-                        data = json.loads(raw_message["data"])
-                        # pmessage 包含实际匹配的通道名
-                        actual_channel = raw_message.get("channel")
-                        if isinstance(actual_channel, bytes):
-                            actual_channel = actual_channel.decode("utf-8")
-                        
-                        message = ChannelMessage(
-                            data=data.get("data"),
-                            event=data.get("event"),
-                            id=data.get("id"),
-                            channel=actual_channel or data.get("channel"),
-                            timestamp=datetime.fromisoformat(data["timestamp"])
-                            if data.get("timestamp")
-                            else datetime.now(),
-                        )
-                        yield message
-                    except (json.JSONDecodeError, KeyError) as e:
-                        logger.warning(f"解析通道消息失败: {e}")
-        finally:
-            await pubsub.punsubscribe(pattern)
-            await pubsub.close()
-
-    async def unsubscribe(self, channel: str) -> None:
-        """取消订阅通道。"""
-        if self._pubsub:
-            await self._pubsub.unsubscribe(channel)
-
-    async def close(self) -> None:
-        """关闭通道。"""
-        if self._pubsub:
-            await self._pubsub.close()
-            self._pubsub = None
-        logger.debug("Redis 通道已关闭")
-
-
-__all__ = ["RedisChannel"]

aury/boot/infrastructure/events/backends/memory.py

@@ -1,86 +0,0 @@
-"""内存事件总线后端。
-
-适用于单进程场景，如开发环境或简单应用。
-"""
-
-from __future__ import annotations
-
-import asyncio
-from collections.abc import Callable
-from typing import Any
-
-from aury.boot.common.logging import logger
-
-from ..base import Event, EventHandler, IEventBus
-
-
-class MemoryEventBus(IEventBus):
-    """内存事件总线实现。
-
-    使用内存中的字典存储订阅关系，支持同步和异步处理器。
-
-    注意：仅适用于单进程，不支持跨进程事件传递。
-    """
-
-    def __init__(self) -> None:
-        """初始化内存事件总线。"""
-        # event_name -> list of handlers
-        self._handlers: dict[str, list[EventHandler]] = {}
-
-    def _get_event_name(self, event_type: type[Event] | str) -> str:
-        """获取事件名称。"""
-        if isinstance(event_type, str):
-            return event_type
-        return event_type.__name__
-
-    def subscribe(
-        self,
-        event_type: type[Event] | str,
-        handler: EventHandler,
-    ) -> None:
-        """订阅事件。"""
-        event_name = self._get_event_name(event_type)
-        if event_name not in self._handlers:
-            self._handlers[event_name] = []
-        if handler not in self._handlers[event_name]:
-            self._handlers[event_name].append(handler)
-            logger.debug(f"订阅事件: {event_name} -> {handler.__name__}")
-
-    def unsubscribe(
-        self,
-        event_type: type[Event] | str,
-        handler: EventHandler,
-    ) -> None:
-        """取消订阅事件。"""
-        event_name = self._get_event_name(event_type)
-        if event_name in self._handlers:
-            try:
-                self._handlers[event_name].remove(handler)
-                logger.debug(f"取消订阅事件: {event_name} -> {handler.__name__}")
-            except ValueError:
-                pass
-
-    async def publish(self, event: Event) -> None:
-        """发布事件。"""
-        event_name = event.event_name
-        handlers = self._handlers.get(event_name, [])
-
-        if not handlers:
-            logger.debug(f"事件 {event_name} 没有订阅者")
-            return
-
-        for handler in handlers:
-            try:
-                result = handler(event)
-                if asyncio.iscoroutine(result):
-                    await result
-            except Exception as e:
-                logger.error(f"处理事件 {event_name} 失败: {e}")
-
-    async def close(self) -> None:
-        """关闭事件总线。"""
-        self._handlers.clear()
-        logger.debug("内存事件总线已关闭")
-
-
-__all__ = ["MemoryEventBus"]

aury/boot/infrastructure/events/backends/redis.py

@@ -1,169 +0,0 @@
-"""Redis 事件总线后端。
-
-适用于多进程/多实例场景，支持跨进程事件传递。
-"""
-
-from __future__ import annotations
-
-import asyncio
-import json
-from typing import TYPE_CHECKING
-
-from aury.boot.common.logging import logger
-
-from ..base import Event, EventHandler, IEventBus
-
-if TYPE_CHECKING:
-    from aury.boot.infrastructure.clients.redis import RedisClient
-
-
-# 框架默认前缀
-DEFAULT_CHANNEL_PREFIX = "aury:event:"
-
-
-class RedisEventBus(IEventBus):
-    """Redis 事件总线实现。
-
-    使用 Redis Pub/Sub 实现跨进程的事件发布/订阅。
-    
-    频道命名格式：{channel_prefix}{event_name}
-    默认：aury:event:user.created
-    """
-
-    def __init__(
-        self,
-        url: str | None = None,
-        *,
-        redis_client: RedisClient | None = None,
-        channel_prefix: str = DEFAULT_CHANNEL_PREFIX,
-    ) -> None:
-        """初始化 Redis 事件总线。
-
-        Args:
-            url: Redis 连接 URL（当 redis_client 为 None 时必须提供）
-            redis_client: RedisClient 实例（可选，优先使用）
-            channel_prefix: 频道名称前缀，默认 "aury:event:"
-        
-        Raises:
-            ValueError: 当 url 和 redis_client 都为 None 时
-        """
-        if redis_client is None and url is None:
-            raise ValueError("Redis 事件总线需要提供 url 或 redis_client 参数")
-        
-        self._url = url
-        self._client = redis_client
-        self._channel_prefix = channel_prefix
-        # event_name -> list of handlers (本地订阅)
-        self._handlers: dict[str, list[EventHandler]] = {}
-        self._pubsub = None
-        self._listener_task: asyncio.Task | None = None
-        self._running = False
-        self._owns_client = False  # 是否自己创建的客户端
-    
-    async def _ensure_client(self) -> None:
-        """确保 Redis 客户端已初始化。"""
-        if self._client is None and self._url:
-            from aury.boot.infrastructure.clients.redis import RedisClient
-            self._client = RedisClient()
-            await self._client.initialize(url=self._url)
-            self._owns_client = True
-
-    def _get_event_name(self, event_type: type[Event] | str) -> str:
-        """获取事件名称。"""
-        if isinstance(event_type, str):
-            return event_type
-        return event_type.__name__
-
-    def _get_channel(self, event_name: str) -> str:
-        """获取 Redis 频道名称。"""
-        return f"{self._channel_prefix}{event_name}"
-
-    def subscribe(
-        self,
-        event_type: type[Event] | str,
-        handler: EventHandler,
-    ) -> None:
-        """订阅事件。"""
-        event_name = self._get_event_name(event_type)
-        if event_name not in self._handlers:
-            self._handlers[event_name] = []
-        if handler not in self._handlers[event_name]:
-            self._handlers[event_name].append(handler)
-            logger.debug(f"订阅事件: {event_name} -> {handler.__name__}")
-
-    def unsubscribe(
-        self,
-        event_type: type[Event] | str,
-        handler: EventHandler,
-    ) -> None:
-        """取消订阅事件。"""
-        event_name = self._get_event_name(event_type)
-        if event_name in self._handlers:
-            try:
-                self._handlers[event_name].remove(handler)
-                logger.debug(f"取消订阅事件: {event_name} -> {handler.__name__}")
-            except ValueError:
-                pass
-
-    async def publish(self, event: Event) -> None:
-        """发布事件。"""
-        await self._ensure_client()
-        event_name = event.event_name
-        channel = self._get_channel(event_name)
-        data = json.dumps(event.to_dict())
-        await self._client.connection.publish(channel, data)
-
-    async def start_listening(self) -> None:
-        """开始监听事件（需要在后台任务中运行）。"""
-        if self._running:
-            return
-        
-        await self._ensure_client()
-        self._pubsub = self._client.connection.pubsub()
-        self._running = True
-
-        # 订阅所有已注册事件的频道
-        channels = [self._get_channel(name) for name in self._handlers]
-        if channels:
-            await self._pubsub.subscribe(*channels)
-
-        # 监听消息
-        async for message in self._pubsub.listen():
-            if not self._running:
-                break
-
-            if message["type"] == "message":
-                try:
-                    data = json.loads(message["data"])
-                    event_name = data.get("event_name")
-                    handlers = self._handlers.get(event_name, [])
-
-                    for handler in handlers:
-                        try:
-                            # 创建事件对象
-                            event = Event.from_dict(data)
-                            result = handler(event)
-                            if asyncio.iscoroutine(result):
-                                await result
-                        except Exception as e:
-                            logger.error(f"处理事件 {event_name} 失败: {e}")
-                except (json.JSONDecodeError, KeyError) as e:
-                    logger.warning(f"解析事件消息失败: {e}")
-
-    async def close(self) -> None:
-        """关闭事件总线。"""
-        self._running = False
-        if self._pubsub:
-            await self._pubsub.close()
-            self._pubsub = None
-        if self._listener_task:
-            self._listener_task.cancel()
-            self._listener_task = None
-        if self._owns_client and self._client:
-            await self._client.close()
-            self._client = None
-        self._handlers.clear()
-        logger.debug("Redis 事件总线已关闭")
-
-
-__all__ = ["RedisEventBus"]