aury-boot 0.0.36__py3-none-any.whl → 0.0.38__py3-none-any.whl

aury/boot/infrastructure/cache/memory.py

@@ -0,0 +1,306 @@
+"""内存和 Memcached 缓存后端实现。"""
+
+from __future__ import annotations
+
+import asyncio
+import fnmatch
+import json
+import time
+from datetime import timedelta
+from typing import Any
+
+from aury.boot.common.logging import logger
+
+from .base import ICache
+
+
+class MemoryCache(ICache):
+    """内存缓存实现。"""
+    
+    def __init__(self, max_size: int = 1000):
+        """初始化内存缓存。
+        
+        Args:
+            max_size: 最大缓存项数
+        """
+        self._max_size = max_size
+        self._cache: dict[str, tuple[Any, float | None]] = {}
+        self._lock = asyncio.Lock()
+    
+    async def get(self, key: str, default: Any = None) -> Any:
+        """获取缓存。"""
+        async with self._lock:
+            if key not in self._cache:
+                return default
+            
+            value, expire_at = self._cache[key]
+            
+            # 检查过期
+            if expire_at is not None and asyncio.get_event_loop().time() > expire_at:
+                del self._cache[key]
+                return default
+            
+            return value
+    
+    async def set(
+        self,
+        key: str,
+        value: Any,
+        expire: int | timedelta | None = None,
+    ) -> bool:
+        """设置缓存。"""
+        async with self._lock:
+            # 转换过期时间
+            expire_at = None
+            if expire:
+                if isinstance(expire, timedelta):
+                    expire_seconds = expire.total_seconds()
+                else:
+                    expire_seconds = expire
+                expire_at = asyncio.get_event_loop().time() + expire_seconds
+            
+            # 如果超出容量，删除最旧的
+            if len(self._cache) >= self._max_size and key not in self._cache:
+                # 简单策略：删除第一个
+                first_key = next(iter(self._cache))
+                del self._cache[first_key]
+            
+            self._cache[key] = (value, expire_at)
+            return True
+    
+    async def delete(self, *keys: str) -> int:
+        """删除缓存。"""
+        async with self._lock:
+            count = 0
+            for key in keys:
+                if key in self._cache:
+                    del self._cache[key]
+                    count += 1
+            return count
+    
+    async def exists(self, *keys: str) -> int:
+        """检查缓存是否存在。"""
+        async with self._lock:
+            count = 0
+            for key in keys:
+                if key in self._cache:
+                    _value, expire_at = self._cache[key]
+                    # 检查是否过期
+                    if expire_at is None or asyncio.get_event_loop().time() <= expire_at:
+                        count += 1
+            return count
+    
+    async def clear(self) -> None:
+        """清空所有缓存。"""
+        async with self._lock:
+            self._cache.clear()
+            logger.info("内存缓存已清空")
+    
+    async def delete_pattern(self, pattern: str) -> int:
+        """按模式删除缓存。
+        
+        Args:
+            pattern: 通配符模式，支持 * 和 ?
+            
+        Returns:
+            int: 删除的键数量
+        """
+        async with self._lock:
+            keys_to_delete = [
+                key for key in self._cache
+                if fnmatch.fnmatch(key, pattern)
+            ]
+            for key in keys_to_delete:
+                del self._cache[key]
+            logger.debug(f"按模式删除缓存: {pattern}, 删除 {len(keys_to_delete)} 个键")
+            return len(keys_to_delete)
+    
+    async def close(self) -> None:
+        """关闭连接（内存缓存无需关闭）。"""
+        await self.clear()
+    
+    async def size(self) -> int:
+        """获取缓存大小。"""
+        return len(self._cache)
+    
+    # ==================== 内存锁 ====================
+    
+    async def acquire_lock(
+        self,
+        key: str,
+        token: str,
+        timeout: int,
+        blocking: bool,
+        blocking_timeout: float | None,
+    ) -> bool:
+        """获取内存锁（单进程）。"""
+        start_time = time.monotonic()
+        
+        while True:
+            async with self._lock:
+                # 检查锁是否存在
+                if key not in self._cache:
+                    # 设置锁
+                    expire_at = asyncio.get_event_loop().time() + timeout
+                    self._cache[key] = (token, expire_at)
+                    return True
+                
+                # 检查锁是否过期
+                existing_token, expire_at = self._cache[key]
+                if expire_at is not None and asyncio.get_event_loop().time() > expire_at:
+                    # 锁已过期，重新获取
+                    new_expire_at = asyncio.get_event_loop().time() + timeout
+                    self._cache[key] = (token, new_expire_at)
+                    return True
+            
+            if not blocking:
+                return False
+            
+            # 检查是否超时
+            if blocking_timeout is not None:
+                elapsed = time.monotonic() - start_time
+                if elapsed >= blocking_timeout:
+                    return False
+            
+            # 短暂等待后重试
+            await asyncio.sleep(0.05)
+    
+    async def release_lock(self, key: str, token: str) -> bool:
+        """释放内存锁。"""
+        async with self._lock:
+            if key not in self._cache:
+                return False
+            
+            existing_token, _ = self._cache[key]
+            if existing_token == token:
+                del self._cache[key]
+                return True
+            return False
+
+
+class MemcachedCache(ICache):
+    """Memcached缓存实现（可选）。"""
+    
+    def __init__(self, servers: list[str]):
+        """初始化Memcached缓存。
+        
+        Args:
+            servers: Memcached服务器列表，如 ["*********:11211"]
+        """
+        self._servers = servers
+        self._client = None
+    
+    async def initialize(self) -> None:
+        """初始化连接。"""
+        try:
+            # 需要安装 python-memcached 或 aiomcache
+            try:
+                import aiomcache
+                self._client = aiomcache.Client(
+                    self._servers[0].split(":")[0],
+                    int(self._servers[0].split(":")[1]) if ":" in self._servers[0] else 11211,
+                )
+                logger.info("Memcached缓存初始化成功")
+            except ImportError:
+                logger.error("请安装 aiomcache: pip install aiomcache")
+                raise
+        except Exception as exc:
+            logger.error(f"Memcached连接失败: {exc}")
+            raise
+    
+    async def get(self, key: str, default: Any = None) -> Any:
+        """获取缓存。"""
+        if not self._client:
+            return default
+        
+        try:
+            data = await self._client.get(key.encode())
+            if data is None:
+                return default
+            return json.loads(data.decode())
+        except Exception as exc:
+            logger.error(f"Memcached获取失败: {key}, {exc}")
+            return default
+    
+    async def set(
+        self,
+        key: str,
+        value: Any,
+        expire: int | timedelta | None = None,
+    ) -> bool:
+        """设置缓存。"""
+        if not self._client:
+            return False
+        
+        try:
+            if isinstance(expire, timedelta):
+                expire = int(expire.total_seconds())
+            
+            data = json.dumps(value).encode()
+            return await self._client.set(key.encode(), data, exptime=expire or 0)
+        except Exception as exc:
+            logger.error(f"Memcached设置失败: {key}, {exc}")
+            return False
+    
+    async def delete(self, *keys: str) -> int:
+        """删除缓存。"""
+        if not self._client or not keys:
+            return 0
+        
+        count = 0
+        for key in keys:
+            try:
+                if await self._client.delete(key.encode()):
+                    count += 1
+            except Exception as exc:
+                logger.error(f"Memcached删除失败: {key}, {exc}")
+        return count
+    
+    async def exists(self, *keys: str) -> int:
+        """检查缓存是否存在。"""
+        if not self._client or not keys:
+            return 0
+        
+        count = 0
+        for key in keys:
+            try:
+                if await self._client.get(key.encode()) is not None:
+                    count += 1
+            except Exception:
+                pass
+        return count
+    
+    async def clear(self) -> None:
+        """清空所有缓存（Memcached不支持）。"""
+        logger.warning("Memcached不支持清空所有缓存")
+    
+    async def delete_pattern(self, pattern: str) -> int:
+        """按模式删除缓存（Memcached 不支持）。"""
+        logger.warning("Memcached 不支持模式删除，请使用 Redis 或 Memory 后端")
+        return 0
+    
+    async def close(self) -> None:
+        """关闭连接。"""
+        if self._client:
+            self._client.close()
+            logger.info("Memcached连接已关闭")
+    
+    # Memcached 不支持分布式锁
+    async def acquire_lock(
+        self,
+        key: str,
+        token: str,
+        timeout: int,
+        blocking: bool,
+        blocking_timeout: float | None,
+    ) -> bool:
+        """获取锁（Memcached 不支持）。"""
+        logger.warning("Memcached 不支持分布式锁，请使用 Redis 或 Memory 后端")
+        return False
+    
+    async def release_lock(self, key: str, token: str) -> bool:
+        """释放锁（Memcached 不支持）。"""
+        return False
+
+
+__all__ = ["MemcachedCache", "MemoryCache"]

aury/boot/infrastructure/cache/redis.py

@@ -0,0 +1,259 @@
+"""Redis 缓存后端实现。"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import pickle
+import time
+from collections.abc import Callable
+from datetime import timedelta
+from typing import TYPE_CHECKING, Any
+
+from redis.asyncio import Redis
+
+from aury.boot.common.logging import logger
+
+from .base import ICache
+
+if TYPE_CHECKING:
+    from aury.boot.infrastructure.clients.redis import RedisClient
+
+
+class RedisCache(ICache):
+    """Redis缓存实现。
+    
+    支持两种初始化方式：
+    1. 传入 URL 自行创建连接
+    2. 传入 RedisClient 实例（推荐）
+    """
+    
+    def __init__(
+        self,
+        url: str | None = None,
+        *,
+        redis_client: RedisClient | None = None,
+        serializer: str = "json",
+    ):
+        """初始化Redis缓存。
+        
+        Args:
+            url: Redis连接URL
+            redis_client: RedisClient 实例（推荐）
+            serializer: 序列化方式（json/pickle）
+        """
+        self._url = url
+        self._redis_client = redis_client
+        self._serializer = serializer
+        self._redis: Redis | None = None
+        self._owns_connection = False  # 是否自己拥有连接（需要自己关闭）
+    
+    async def initialize(self) -> None:
+        """初始化连接。"""
+        # 优先使用 RedisClient
+        if self._redis_client is not None:
+            self._redis = self._redis_client.connection
+            self._owns_connection = False
+            logger.info("Redis缓存初始化成功（使用 RedisClient）")
+            return
+        
+        # 使用 URL 创建连接
+        if self._url:
+            try:
+                self._redis = Redis.from_url(
+                    self._url,
+                    encoding="utf-8",
+                    decode_responses=False,
+                    socket_connect_timeout=5,
+                    socket_timeout=5,
+                )
+                await self._redis.ping()
+                self._owns_connection = True
+                logger.info("Redis缓存初始化成功")
+            except Exception as exc:
+                logger.error(f"Redis连接失败: {exc}")
+                raise
+        else:
+            raise ValueError("Redis缓存需要提供 url 或 redis_client 参数")
+    
+    async def get(self, key: str, default: Any = None) -> Any:
+        """获取缓存。"""
+        if not self._redis:
+            return default
+        
+        try:
+            data = await self._redis.get(key)
+            if data is None:
+                return default
+            
+            # 使用函数式编程处理序列化器
+            deserializers: dict[str, Callable[[bytes], Any]] = {
+                "json": lambda d: json.loads(d.decode()),
+                "pickle": pickle.loads,
+            }
+            
+            deserializer = deserializers.get(self._serializer)
+            if deserializer:
+                return deserializer(data)
+            return data.decode()
+        except Exception as exc:
+            logger.error(f"Redis获取失败: {key}, {exc}")
+            return default
+    
+    async def set(
+        self,
+        key: str,
+        value: Any,
+        expire: int | timedelta | None = None,
+    ) -> bool:
+        """设置缓存。"""
+        if not self._redis:
+            return False
+        
+        try:
+            # 使用函数式编程处理序列化器
+            serializers: dict[str, Callable[[Any], bytes]] = {
+                "json": lambda v: json.dumps(v).encode(),
+                "pickle": pickle.dumps,
+            }
+            
+            serializer = serializers.get(self._serializer)
+            if serializer:
+                data = serializer(value)
+            else:
+                data = str(value).encode()
+            
+            # 转换过期时间
+            if isinstance(expire, timedelta):
+                expire = int(expire.total_seconds())
+            
+            await self._redis.set(key, data, ex=expire)
+            return True
+        except Exception as exc:
+            logger.error(f"Redis设置失败: {key}, {exc}")
+            return False
+    
+    async def delete(self, *keys: str) -> int:
+        """删除缓存。"""
+        if not self._redis or not keys:
+            return 0
+        
+        try:
+            return await self._redis.delete(*keys)
+        except Exception as exc:
+            logger.error(f"Redis删除失败: {keys}, {exc}")
+            return 0
+    
+    async def exists(self, *keys: str) -> int:
+        """检查缓存是否存在。"""
+        if not self._redis or not keys:
+            return 0
+        
+        try:
+            return await self._redis.exists(*keys)
+        except Exception as exc:
+            logger.error(f"Redis检查失败: {keys}, {exc}")
+            return 0
+    
+    async def clear(self) -> None:
+        """清空所有缓存。"""
+        if self._redis:
+            await self._redis.flushdb()
+            logger.info("Redis缓存已清空")
+    
+    async def delete_pattern(self, pattern: str) -> int:
+        """按模式删除缓存。
+        
+        Args:
+            pattern: 通配符模式，如 "todo:*"
+            
+        Returns:
+            int: 删除的键数量
+        """
+        if not self._redis:
+            return 0
+        
+        try:
+            # 使用 SCAN 遍历匹配的键（比 KEYS 更安全，不会阻塞）
+            count = 0
+            cursor = 0
+            while True:
+                cursor, keys = await self._redis.scan(cursor, match=pattern, count=100)
+                if keys:
+                    count += await self._redis.delete(*keys)
+                if cursor == 0:
+                    break
+            logger.debug(f"按模式删除缓存: {pattern}, 删除 {count} 个键")
+            return count
+        except Exception as exc:
+            logger.error(f"Redis模式删除失败: {pattern}, {exc}")
+            return 0
+    
+    async def close(self) -> None:
+        """关闭连接（仅当自己拥有连接时）。"""
+        if self._redis and self._owns_connection:
+            await self._redis.close()
+            logger.info("Redis连接已关闭")
+        self._redis = None
+    
+    @property
+    def redis(self) -> Redis | None:
+        """获取Redis客户端。"""
+        return self._redis
+    
+    # ==================== 分布式锁 ====================
+    # TODO: 后续优化考虑：
+    #   - 看门狗（Watchdog）机制：自动续期，防止业务执行超过锁超时导致提前释放
+    #   - 可重入锁（Reentrant Lock）
+    #   - Redlock 算法（多 Redis 实例）
+    
+    async def acquire_lock(
+        self,
+        key: str,
+        token: str,
+        timeout: int,
+        blocking: bool,
+        blocking_timeout: float | None,
+    ) -> bool:
+        """获取 Redis 分布式锁。"""
+        if not self._redis:
+            return False
+        
+        start_time = time.monotonic()
+        
+        while True:
+            # SET NX EX 原子操作
+            acquired = await self._redis.set(key, token, nx=True, ex=timeout)
+            if acquired:
+                return True
+            
+            if not blocking:
+                return False
+            
+            # 检查是否超时
+            if blocking_timeout is not None:
+                elapsed = time.monotonic() - start_time
+                if elapsed >= blocking_timeout:
+                    return False
+            
+            # 短暂等待后重试
+            await asyncio.sleep(0.05)
+    
+    async def release_lock(self, key: str, token: str) -> bool:
+        """释放 Redis 锁（Lua 脚本保证原子性）。"""
+        if not self._redis:
+            return False
+        
+        # Lua 脚本：只有 token 匹配才删除
+        script = """
+        if redis.call("get", KEYS[1]) == ARGV[1] then
+            return redis.call("del", KEYS[1])
+        else
+            return 0
+        end
+        """
+        result = await self._redis.eval(script, 1, key, token)
+        return bool(result)
+
+
+__all__ = ["RedisCache"]

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

@@ -159,7 +159,7 @@ class RedisMQ(IMQ):
         """关闭连接。"""
         self._consuming = False
         if self._owns_client and self._client:
-            await self._client.close()
+            await self._client.cleanup()
             self._client = None
         logger.debug("Redis 消息队列已关闭")
 

aury/boot/infrastructure/mq/backends/redis_stream.py

@@ -420,7 +420,7 @@ class RedisStreamMQ(IMQ):
         """关闭连接。"""
         self._consuming = False
         if self._owns_client and self._client:
-            await self._client.close()
+            await self._client.cleanup()
             self._client = None
         logger.debug("Redis Stream 消息队列已关闭")
 

{aury_boot-0.0.36.dist-info → aury_boot-0.0.38.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aury-boot
-Version: 0.0.36
+Version: 0.0.38
 Summary: Aury Boot - 基于 FastAPI 生态的企业级 API 开发框架
 Requires-Python: >=3.13
 Requires-Dist: alembic>=1.17.2

{aury_boot-0.0.36.dist-info → aury_boot-0.0.38.dist-info}/RECORD

@@ -1,5 +1,5 @@
 aury/boot/__init__.py,sha256=pCno-EInnpIBa1OtxNYF-JWf9j95Cd2h6vmu0xqa_-4,1791
-aury/boot/_version.py,sha256=0ktbVh2xRI7xnrojV_sDPVhrN753EK8vWN68JQalwWk,706
+aury/boot/_version.py,sha256=vz5IG1ZbpfA63zA7xZI2HHU8kmL9ekzBS0BXtKYIdco,706
 aury/boot/application/__init__.py,sha256=I2KqNVdYg2q5nlOXr0TtFGyHmhj4oWdaR6ZB73Mwg7Y,3041
 aury/boot/application/adapter/__init__.py,sha256=e1bcSb1bxUMfofTwiCuHBZJk5-STkMCWPF2EJXHQ7UU,3976
 aury/boot/application/adapter/base.py,sha256=Ar_66fiHPDEmV-1DKnqXKwc53p3pozG31bgTJTEUriY,15763
@@ -14,7 +14,7 @@ aury/boot/application/app/middlewares.py,sha256=BXe2H14FHzJUVpQM6DZUm-zfZRXSXIi1
 aury/boot/application/app/startup.py,sha256=DHKt3C2G7V5XfFr1SQMl14tNzcuDd9MqUVAxi274HDQ,7873
 aury/boot/application/config/__init__.py,sha256=Dd-myRSBCM18DXXsi863h0cJG5VFrI10xMRtjnvelGo,1894
 aury/boot/application/config/multi_instance.py,sha256=RXSp-xP8-bKMDEhq3SeL7T3lS8-vpRlvBEVBuZVjVK4,6475
-aury/boot/application/config/settings.py,sha256=YxcR75SxdjJznJ1813sK4dhUPJ5ac5ATvGuT6IbNst0,37998
+aury/boot/application/config/settings.py,sha256=JZuLVKH13cuBdlHdtrt7ZZ4d7KD8as5DWBv0d9enHDk,38026
 aury/boot/application/constants/__init__.py,sha256=DCXs13_VVaQWHqO-qpJoZwRd7HIexiirtw_nu8msTXE,340
 aury/boot/application/constants/components.py,sha256=I4SlsF2DpSzMiLsi1wVrEmdHn4yV5J2h3ikMQqufPmM,1120
 aury/boot/application/constants/scheduler.py,sha256=S77FBIvHlyruvlabRWZJ2J1YAs2xWXPQI2yuGdGUDNA,471
@@ -47,7 +47,7 @@ aury/boot/commands/config.py,sha256=gPkG_jSWrXidjpyVdzABH7uRhoCgX5yrOcdKabtX5wY,
 aury/boot/commands/docker.py,sha256=7mKorZCPZgxH1XFslzo6W-uzpe61hGXz86JKOhOeBlo,9006
 aury/boot/commands/docs.py,sha256=Hz1W-2TW8DzaPxARqEF4UncPhGMI9h97jJ962dlox3U,14327
 aury/boot/commands/generate.py,sha256=WZieSXuofxJOC7NBiVGpBigB9NZ4GMcF2F1ReTNun1I,44420
-aury/boot/commands/init.py,sha256=W_eCL3wydWaMSLqTpadREDnzC0w-LGgNnj3IBjuQAfA,32348
+aury/boot/commands/init.py,sha256=6reBpZ5jS4O9QTfXHKt4MCXPn3WcubjUfOtB5tKdy0s,32349
 aury/boot/commands/pkg.py,sha256=bw0QPptKscNgQ4I1SfSehTio9Q5KrvxgvkYx4tbZ7Vs,14495
 aury/boot/commands/scheduler.py,sha256=XO3Gq7PqNxXNz5Gw0xNUHa_bEnAKZ9AkzLc062QJ3j8,3669
 aury/boot/commands/worker.py,sha256=OEvfDiiM_pV3Mj73HKhSm1RNqFPuS125iNM0qNCTHFY,4316
@@ -61,7 +61,7 @@ aury/boot/commands/templates/generate/model.py.tpl,sha256=knFwMyGZ7wMpzH4_bQD_V1
 aury/boot/commands/templates/generate/repository.py.tpl,sha256=Uj9jNEI9Zn8W061FGFlRaIfAy9IhdassYH6noEjG0z0,662
 aury/boot/commands/templates/generate/schema.py.tpl,sha256=HIaY5B0UG_S188nQLrZDEJ0q73WPdb7BmCdc0tseZA4,545
 aury/boot/commands/templates/generate/service.py.tpl,sha256=2hwQ8e4a5d_bIMx_jGDobdmKPMFLBlfQrQVQH4Ym5k4,1842
-aury/boot/commands/templates/project/AGENTS.md.tpl,sha256=sp5qyzU-SGhgQCobpMW4EXRzpGsEsVdmJvspnKAP4AQ,10059
+aury/boot/commands/templates/project/AGENTS.md.tpl,sha256=KdCqZJeI6cRwjTxX0B2u9fcGQKUi2fJrIjTJBkm3c4U,10063
 aury/boot/commands/templates/project/README.md.tpl,sha256=oCeBiukk6Pa3hrCKybkfM2sIRHsPZ15nlwuFTUSFDwY,2459
 aury/boot/commands/templates/project/admin_console_init.py.tpl,sha256=K81L14thyEhRA8lFCQJVZL_NU22-sBz0xS68MJPeoCo,1541
 aury/boot/commands/templates/project/alert_rules.example.yaml.tpl,sha256=QZH6SC5TcUhgX_2JRXk0k0g26wJf9xNwsdquiEIgg-I,2492
@@ -83,7 +83,7 @@ aury/boot/commands/templates/project/aury_docs/10-storage.md.tpl,sha256=mhe0j0S5
 aury/boot/commands/templates/project/aury_docs/11-logging.md.tpl,sha256=bwxFCGQsO9cTEbwqJF1xcjsZKP82HRWhIMRUS0c9_ZI,2435
 aury/boot/commands/templates/project/aury_docs/12-admin.md.tpl,sha256=6z3mN54qP2jtpTFOJBLVexvEv0ZHXYKjncvpZG4yOdw,1883
 aury/boot/commands/templates/project/aury_docs/13-channel.md.tpl,sha256=aGpf2phQBMRs6Uh1DfjNl06pC_niea91Sm8sTq_NFec,4443
-aury/boot/commands/templates/project/aury_docs/14-mq.md.tpl,sha256=4bxLQBbCi0Fue0VQWOPt6acZ5P00BoLkCoLPQe_8k4U,2396
+aury/boot/commands/templates/project/aury_docs/14-mq.md.tpl,sha256=irrKal6y8pPAjifntnOLfRzzllvBQinKMjIjKd-_ANc,4016
 aury/boot/commands/templates/project/aury_docs/15-events.md.tpl,sha256=a4wQRgVPuYUGTGmw_lX1HJH_yFTbD30mBz7Arc4zgfs,3361
 aury/boot/commands/templates/project/aury_docs/16-adapter.md.tpl,sha256=pkmJkZw2Ca6_uYk2jZvAb8DozjBa2tWq_t3gtq1lFSk,11456
 aury/boot/commands/templates/project/aury_docs/17-alerting.md.tpl,sha256=2MosApSAuGerBw7SOO-ihk4NTp2qEkgOUyu6pS2m0UY,5709
@@ -93,7 +93,7 @@ aury/boot/commands/templates/project/env_templates/admin.tpl,sha256=wWt3iybOpBHt
 aury/boot/commands/templates/project/env_templates/cache.tpl,sha256=_sK-p_FECj4mVvggNvgb4Wu0yGii0Ocz560syG7DU2c,498
 aury/boot/commands/templates/project/env_templates/database.tpl,sha256=2lWzTKt4X0SpeBBCkrDV90Di4EfoAuqYzhVsh74vTUI,907
 aury/boot/commands/templates/project/env_templates/log.tpl,sha256=x5rkrEFJISH0gaCcr-wTCbDYtyFnlLNJpY789fqjZgc,754
-aury/boot/commands/templates/project/env_templates/messaging.tpl,sha256=SzPRKwN0wO5e1kpjkSwpPJfVmiUDzZkK4Qm-qNsCvVE,2178
+aury/boot/commands/templates/project/env_templates/messaging.tpl,sha256=AgfsXTRnvDySFERoCVop89jsC_h8hzj1sPeq5MczSXM,2462
 aury/boot/commands/templates/project/env_templates/monitoring.tpl,sha256=Zq0xQzDrCRtbeLCQB3pkEE2p8FFED6IjQo4TqMyd_P8,2584
 aury/boot/commands/templates/project/env_templates/rpc.tpl,sha256=FhweCFakawGLSs01a_BkmZo11UhWax2-VCBudHj68WA,1163
 aury/boot/commands/templates/project/env_templates/scheduler.tpl,sha256=c8Grcs1rgBB58RHlxqmDMPHQl8BnbcqNW473ctmsojU,752
@@ -136,11 +136,13 @@ aury/boot/domain/service/base.py,sha256=6sN0nf8r5yUZsE6AcZOiOXFCqzb61oCxTfrWlqjI
 aury/boot/domain/transaction/__init__.py,sha256=EKnjJ235SYjMCvGIuLVlTdYRzU35RxNMejRGUExYqqE,15488
 aury/boot/infrastructure/__init__.py,sha256=DDEr_BIL5OyMJjNlI05jGIUrSHn6MPdnW9xnCS4eHfg,2949
 aury/boot/infrastructure/cache/__init__.py,sha256=G40uCkpJ1jSs2fc_CBDem73iQQzCcp-4GG1WpDJzwaA,658
-aury/boot/infrastructure/cache/backends.py,sha256=9QMQ8G9DtZgzVXZ_Ng7n1gXRu-_OQZgw4FHPOfr1qco,13585
-aury/boot/infrastructure/cache/base.py,sha256=Yn-h_SGcOoGGZW1unOnz_zgcuHaMKOEmwiUP0P7_pIM,1624
+aury/boot/infrastructure/cache/backends.py,sha256=wh9U2LjlXV22dpV87ID8DL9Rmgztw3yMUrDjJdGgTQw,245
+aury/boot/infrastructure/cache/base.py,sha256=3XA6v_zwsgMSUDN8aG7eu_2-zCnGWF9eeEyVZxxezBU,2621
 aury/boot/infrastructure/cache/exceptions.py,sha256=KZsFIHXW3_kOh_KB93EVZJKbiDvDw8aloAefJ3kasP8,622
 aury/boot/infrastructure/cache/factory.py,sha256=aF74JoiiSKFgctqqh2Z8OtGRS2Am_ou-I40GyygLzC0,2489
-aury/boot/infrastructure/cache/manager.py,sha256=GGoOgYyIdWKMmhej5cRvEfpNeMN1GaSaU9hc0dy8_sA,12106
+aury/boot/infrastructure/cache/manager.py,sha256=2jlshbO4NqpPxH-8DBiMFNAvWuZUI3atUCsw9GGlzc8,16807
+aury/boot/infrastructure/cache/memory.py,sha256=qGhLKKjGsEUHjVRFMV6A33MB_1iPaKCEEkT6VFrLkQY,9832
+aury/boot/infrastructure/cache/redis.py,sha256=MxLwqnBrPWmkS_AGDq4hKfPlBrF358cq_nKbUlP-JYE,8085
 aury/boot/infrastructure/channel/__init__.py,sha256=NmjddenZPz1Dcl0glwIF1Xn9gxBzvGvlOlzhV3eEnEQ,664
 aury/boot/infrastructure/channel/base.py,sha256=TDiP7pXyd2ixiOM3cbxqCSOluGLTkmLCa8pv-KyQ0jo,2941
 aury/boot/infrastructure/channel/manager.py,sha256=GT6eG6PglduKAr23i1PSmjjTQsALvGGoLjYiQ33aZiw,7488
@@ -190,8 +192,8 @@ aury/boot/infrastructure/mq/base.py,sha256=ld4wtzhO_6y8wJRXL1DagqJiwhd0VQ6MJlJGD
 aury/boot/infrastructure/mq/manager.py,sha256=Bu4E1Tgz0CzFvJuCS9_fBMj9eAqmXcZp8aFIYhvNUl4,7692
 aury/boot/infrastructure/mq/backends/__init__.py,sha256=10nggw2V-AzuZ1vvzq_ksoXR4FI3e4BR36EfY49Pek4,200
 aury/boot/infrastructure/mq/backends/rabbitmq.py,sha256=0NWgPKEwtbmI63EVvKINdfXXDNyOvuOOP9LlBzqH91E,5493
-aury/boot/infrastructure/mq/backends/redis.py,sha256=i8KECToIFEZ6CnHyNCk34_xdff5ioK172_knOy6EeUU,5279
-aury/boot/infrastructure/mq/backends/redis_stream.py,sha256=hbSX03d0BLshE10GryjyvqybtjDBOS4pQUsNHhQFB-Q,14420
+aury/boot/infrastructure/mq/backends/redis.py,sha256=B89U7mqIceUsCXE4G3u1u6aFM9hv4mmLLwuCYq1T9tQ,5281
+aury/boot/infrastructure/mq/backends/redis_stream.py,sha256=-ZMW4RuQdpmH3hBIqRP7ROyW1gbt8bZ1ZSTrTOynXQQ,14422
 aury/boot/infrastructure/scheduler/__init__.py,sha256=eTRJ5dSPcKvyFvLVtraoQteXTTDDGwIrmw06J2hoNdA,323
 aury/boot/infrastructure/scheduler/exceptions.py,sha256=ROltrhSctVWA-6ulnjuYeHAk3ZF-sykDoesuierYzew,634
 aury/boot/infrastructure/scheduler/manager.py,sha256=OHQOHQlcoN8yFnky4kfuhsEIk39qX6nLZ7xJ51tfg68,23130
@@ -210,7 +212,7 @@ aury/boot/testing/client.py,sha256=KOg1EemuIVsBG68G5y0DjSxZGcIQVdWQ4ASaHE3o1R0,4
 aury/boot/testing/factory.py,sha256=8GvwX9qIDu0L65gzJMlrWB0xbmJ-7zPHuwk3eECULcg,5185
 aury/boot/toolkit/__init__.py,sha256=AcyVb9fDf3CaEmJPNkWC4iGv32qCPyk4BuFKSuNiJRQ,334
 aury/boot/toolkit/http/__init__.py,sha256=zIPmpIZ9Qbqe25VmEr7jixoY2fkRbLm7NkCB9vKpg6I,11039
-aury_boot-0.0.36.dist-info/METADATA,sha256=dyV3mpOq5ZzkAUCbQdLt4Bmxw_vyLSyNcuUaJOtF6B8,8694
-aury_boot-0.0.36.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-aury_boot-0.0.36.dist-info/entry_points.txt,sha256=f9KXEkDIGc0BGkgBvsNx_HMz9VhDjNxu26q00jUpDwQ,49
-aury_boot-0.0.36.dist-info/RECORD,,
+aury_boot-0.0.38.dist-info/METADATA,sha256=jv4ryFTmPLz8qul4nDVB1ju3ftR7oatLmwexC68sM1w,8694
+aury_boot-0.0.38.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+aury_boot-0.0.38.dist-info/entry_points.txt,sha256=f9KXEkDIGc0BGkgBvsNx_HMz9VhDjNxu26q00jUpDwQ,49
+aury_boot-0.0.38.dist-info/RECORD,,