hexcore 2.1.0__tar.gz → 2.2.0__tar.gz

{hexcore-2.1.0/hexcore.egg-info → hexcore-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hexcore
-Version: 2.1.0
+Version: 2.2.0
 Summary: Núcleo reutilizable para proyectos Python con arquitectura hexagonal y event handling. Provee abstracciones, utilidades y contratos para DDD, eventos y desacoplamiento de infraestructura.
 Author-email: "David Latosefki (Indroic)" <indroic@outlook.com>
 License-Expression: MIT
@@ -20,6 +20,8 @@ Requires-Dist: typer>=0.17.3
 Requires-Dist: ruff>=0.12.11
 Provides-Extra: procrastinate
 Requires-Dist: procrastinate>=3.0.0; extra == "procrastinate"
+Provides-Extra: rabbitmq
+Requires-Dist: aio-pika>=9.4.0; extra == "rabbitmq"
 Dynamic: license-file
 
 # HexCore [![PyPI Downloads](https://static.pepy.tech/personalized-badge/hexcore?period=total&units=INTERNATIONAL_SYSTEM&left_color=BLACK&right_color=GREEN&left_text=downloads)](https://pepy.tech/projects/hexcore)

{hexcore-2.1.0 → hexcore-2.2.0}/hexcore/infrastructure/api/utils.py

@@ -15,13 +15,15 @@ from hexcore.application.dtos.query import (
 from hexcore.application.use_cases.query import QueryEntitiesUseCase
 from hexcore.domain.uow import IUnitOfWork
 from hexcore.infrastructure.repositories.orms.sqlalchemy.session import (
-    AsyncSessionLocal,
+    get_async_db_session,
+    get_session_factory,
 )
 from hexcore.infrastructure.uow import SqlAlchemyUnitOfWork, NoSqlUnitOfWork
 
 
 async def get_session() -> AsyncGenerator[AsyncSession, None]:
-    async with AsyncSessionLocal() as session:
+    factory = get_session_factory()
+    async with factory() as session:
         yield session
 
 

{hexcore-2.1.0 → hexcore-2.2.0}/hexcore/infrastructure/cqrs/middlewares.py

@@ -123,8 +123,9 @@ class TransactionMiddleware(IMiddleware):
         # Heurística simple: Si hay una URL de SQL (por defecto siempre la hay), asume SQL.
         # En una app real de Hexcore se puede inyectar esto mejor, pero provee un default funcional.
         if config.sql_database_url:
-            from hexcore.infrastructure.repositories.orms.sqlalchemy.session import AsyncSessionLocal
-            return SqlAlchemyUnitOfWork(session=AsyncSessionLocal())
+            from hexcore.infrastructure.repositories.orms.sqlalchemy.session import get_session_factory
+            factory = get_session_factory()
+            return SqlAlchemyUnitOfWork(session=factory())
         return NoSqlUnitOfWork()
 
     async def handle(self, message: t.Any, next_handler: NextHandler) -> t.Any:

hexcore-2.2.0/hexcore/infrastructure/cqrs/rabbitmq.py

@@ -0,0 +1,182 @@
+"""
+Adaptador de RabbitMQ para el EventBus de HexCore CQRS usando aio-pika.
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import typing as t
+
+from hexcore.domain.cqrs.buses import AbstractEventBus
+from hexcore.domain.cqrs.middleware import NextHandler
+from hexcore.application.cqrs.pipeline import MiddlewarePipeline
+from hexcore.domain.cqrs.serializer import AbstractSerializer
+from hexcore.domain.events import DomainEvent
+
+if t.TYPE_CHECKING:
+    import aio_pika
+    from aio_pika.abc import AbstractRobustConnection, AbstractChannel, AbstractExchange
+
+
+logger = logging.getLogger("hexcore.cqrs.rabbitmq")
+
+
+class RabbitMQEventBus(AbstractEventBus):
+    """
+    Implementación del EventBus sobre RabbitMQ (usando aio-pika).
+    Permite publicar y consumir eventos de dominio distribuidos de forma asíncrona.
+    
+    Cada instancia de RabbitMQEventBus típicamente usará su propia cola 
+    enlazada a un exchange central de tipo 'topic' (o 'direct').
+    """
+
+    def __init__(
+        self,
+        connection: "AbstractRobustConnection",
+        serializer: AbstractSerializer,
+        pipeline: MiddlewarePipeline | None = None,
+        exchange_name: str = "hexcore.events",
+        queue_name: str = "hexcore.worker.queue",
+    ) -> None:
+        """
+        Args:
+            connection: Conexión robusta de aio-pika. Debe ser inyectada y gestionada
+                        por el ciclo de vida de la aplicación.
+            serializer: Implementación de AbstractSerializer (ej: PydanticSerializer).
+            pipeline: Pipeline opcional de middlewares.
+            exchange_name: Nombre del Topic Exchange para distribuir eventos.
+            queue_name: Nombre de la cola (queue) exclusiva para este worker/servicio.
+        """
+        self._connection = connection
+        self._serializer = serializer
+        self._pipeline = pipeline or MiddlewarePipeline([])
+        
+        self._exchange_name = exchange_name
+        self._queue_name = queue_name
+        
+        self._channel: "AbstractChannel" | None = None
+        self._exchange: "AbstractExchange" | None = None
+        
+        # event_name -> list of handlers
+        self._handlers: dict[str, list[t.Callable[[DomainEvent], t.Awaitable[None]]]] = {}
+        # event_name -> type
+        self._event_types: dict[str, type[DomainEvent]] = {}
+
+    async def _setup(self) -> None:
+        """Configura el channel y exchange una sola vez (lazy)."""
+        if self._channel is None or self._exchange is None:
+            import aio_pika
+            
+            self._channel = await self._connection.channel()
+            # Un topic exchange permite suscripciones flexibles mediante routing keys
+            self._exchange = await self._channel.declare_exchange(
+                self._exchange_name, aio_pika.ExchangeType.TOPIC, durable=True
+            )
+
+    async def publish(self, event: DomainEvent) -> None:
+        """
+        Publica el evento de dominio a RabbitMQ.
+        El routing_key es el nombre del evento.
+        """
+        import aio_pika
+        
+        await self._setup()
+        assert self._exchange is not None
+        
+        # Serializamos usando el pipeline y serializer configurado
+        data = self._serializer.serialize(event)
+        body = json.dumps(data).encode("utf-8")
+        
+        message = aio_pika.Message(
+            body=body,
+            delivery_mode=aio_pika.DeliveryMode.PERSISTENT,
+            content_type="application/json",
+            message_id=str(event.event_id),
+        )
+        
+        routing_key = event.event_name
+        
+        await self._exchange.publish(message, routing_key=routing_key)
+        logger.debug(f"[RabbitMQEventBus] Publicado evento {routing_key}")
+
+    def subscribe(
+        self,
+        event_type: type[DomainEvent],
+        handler: t.Callable[[DomainEvent], t.Awaitable[None]],
+    ) -> None:
+        """
+        Registra localmente un handler para un tipo de evento.
+        Nota: Esto solo guarda en memoria. Para empezar a consumir RabbitMQ,
+        debes llamar a `start_consuming()`.
+        """
+        # Obtenemos un event_name estandarizado (usamos una instancia temporal para leer properties o usar una heuristica estática)
+        # Por seguridad creamos un string fijo a partir del nombre de clase (como hace DomainEvent.event_name)
+        event_name = event_type.__name__.replace("Event", "").upper()
+        
+        if event_name not in self._handlers:
+            self._handlers[event_name] = []
+            self._event_types[event_name] = event_type
+            
+        self._handlers[event_name].append(handler)
+        logger.debug(f"[RabbitMQEventBus] Suscrito localmente a {event_name}")
+
+    async def _handle_message(self, message: "aio_pika.abc.AbstractIncomingMessage") -> None:
+        """Callback invocado por aio-pika para cada mensaje entrante."""
+        async with message.process(requeue=True, ignore_processed=True):
+            routing_key = message.routing_key
+            if not routing_key:
+                return
+
+            # Verificamos si tenemos handlers para este evento
+            if routing_key not in self._handlers:
+                return
+
+            try:
+                # 1. Deserialización
+                payload = json.loads(message.body.decode("utf-8"))
+                # Nos aseguramos que lleve el __type__ si el serializer lo requiere, 
+                # o el serializer sabrá reconstruirlo. Idealmente el serializer CQRS asume dict genérico
+                event = self._serializer.deserialize(payload)
+                
+                # Ejecutamos todos los handlers concurrentemente o secuencialmente
+                # En un bus robusto, el fallo de un handler no debería ocultar a otros, pero si falla, 
+                # el mensaje no se hace acknowledge. Para simplicidad, lanzamos gather:
+                handlers = self._handlers[routing_key]
+                
+                async def _execute_with_pipeline(h: t.Callable[[DomainEvent], t.Awaitable[None]], evt: DomainEvent) -> None:
+                    async def base_handler(m: DomainEvent) -> t.Any:
+                        await h(m)
+                    
+                    # Usamos el pipeline del bus
+                    await self._pipeline.execute(evt, base_handler)
+
+                await asyncio.gather(*(
+                    _execute_with_pipeline(handler, event) for handler in handlers
+                ))
+            
+            except Exception as exc:
+                logger.exception(f"[RabbitMQEventBus] Error procesando mensaje {routing_key}: {exc}")
+                # El mensaje será NACKed y requeueado o mandado a Dead Letter (depende del config de aio-pika process)
+                raise
+
+    async def start_consuming(self) -> None:
+        """
+        Conecta a la cola, hace bind a todos los eventos suscritos y comienza
+        a consumir permanentemente.
+        """
+        await self._setup()
+        assert self._channel is not None
+        assert self._exchange is not None
+        
+        # 1. Declarar la cola para este worker/microservicio
+        queue = await self._channel.declare_queue(self._queue_name, durable=True)
+        
+        # 2. Hacer bind para cada evento suscrito
+        for event_name in self._handlers.keys():
+            await queue.bind(self._exchange, routing_key=event_name)
+            logger.info(f"[RabbitMQEventBus] Bind queue '{self._queue_name}' to '{event_name}'")
+            
+        # 3. Empezar a consumir
+        await queue.consume(self._handle_message)
+        logger.info(f"[RabbitMQEventBus] Escuchando eventos en cola '{self._queue_name}'...")

hexcore-2.2.0/hexcore/infrastructure/repositories/orms/sqlalchemy/session.py

@@ -0,0 +1,66 @@
+from collections.abc import AsyncGenerator
+
+from sqlalchemy.ext.asyncio import (
+    AsyncEngine,
+    AsyncSession,
+    async_sessionmaker,
+    create_async_engine,
+)
+
+from hexcore.config import LazyConfig
+
+_engine: AsyncEngine | None = None
+_session_factory: async_sessionmaker[AsyncSession] | None = None
+
+
+def get_engine() -> AsyncEngine:
+    """
+    Retorna el engine asíncrono de SQLAlchemy.
+    Se inicializa de forma lazy (solo cuando se solicita).
+    """
+    global _engine
+    if _engine is None:
+        _engine = create_async_engine(
+            LazyConfig.get_config().async_sql_database_url,
+            # echo=True,
+        )
+    return _engine
+
+
+def get_session_factory() -> async_sessionmaker[AsyncSession]:
+    """
+    Retorna la factoría de sesiones de SQLAlchemy.
+    Se inicializa de forma lazy.
+    """
+    global _session_factory
+    if _session_factory is None:
+        _session_factory = async_sessionmaker(
+            autocommit=False,
+            autoflush=False,
+            bind=get_engine(),
+            class_=AsyncSession,
+        )
+    return _session_factory
+
+
+async def get_async_db_session() -> AsyncGenerator[AsyncSession, None]:
+    """Generador de sesiones asíncronas delegando el ciclo de vida al context manager."""
+    factory = get_session_factory()
+    async with factory() as db:
+        yield db
+
+
+async def reset_sqlalchemy_engine() -> None:
+    """
+    Cierra el pool de conexiones actual y recrea el engine de forma lazy.
+    Crítico para inicializar asíncronamente workers (ej. RabbitMQ, Celery) 
+    y evitar el error de 'Task attached to a different loop'.
+    """
+    global _engine
+    global _session_factory
+
+    if _engine is not None:
+        await _engine.dispose()
+    
+    _engine = None
+    _session_factory = None

hexcore-2.2.0/hexcore/infrastructure/workers/__init__.py

@@ -0,0 +1 @@
+"""Workers para tareas en segundo plano o consumidores asíncronos."""

hexcore-2.2.0/hexcore/infrastructure/workers/rabbitmq_worker.py

@@ -0,0 +1,93 @@
+"""
+Worker asíncrono para RabbitMQ. 
+Resuelve el problema de la duplicación de conexiones (SQLAlchemy y MongoDB)
+garantizando que todos los pools se inicializan *dentro* del nuevo Event Loop.
+"""
+import asyncio
+import logging
+import typing as t
+from contextlib import AsyncExitStack, asynccontextmanager
+
+from hexcore.config import LazyConfig
+
+logger = logging.getLogger("hexcore.workers.rabbitmq")
+
+
+@asynccontextmanager
+async def setup_sqlalchemy():
+    """Context manager para inicializar y limpiar conexiones SQL en el worker."""
+    from hexcore.infrastructure.repositories.orms.sqlalchemy.session import reset_sqlalchemy_engine, engine
+    
+    # 1. Resetear el pool para atarlo a ESTE event loop
+    logger.info("[Worker Lifecycle] Inicializando engine de SQLAlchemy...")
+    await reset_sqlalchemy_engine()
+    
+    try:
+        yield
+    finally:
+        logger.info("[Worker Lifecycle] Cerrando conexiones de SQLAlchemy...")
+        await engine.dispose()
+
+
+@asynccontextmanager
+async def setup_mongodb():
+    """Context manager para inicializar Beanie/MongoDB en el worker."""
+    from hexcore.infrastructure.repositories.orms.beanie.utils import init_beanie_documents
+    
+    logger.info("[Worker Lifecycle] Inicializando MongoDB (Beanie)...")
+    await init_beanie_documents()
+    
+    try:
+        yield
+    finally:
+        # Beanie/Motor no requiere un teardown estricto manual ya que se cierra
+        # con el event loop o GC, pero aquí podríamos cerrar el AsyncMongoClient si tuvieramos la ref.
+        logger.info("[Worker Lifecycle] MongoDB (Beanie) ciclo finalizado.")
+
+
+@asynccontextmanager
+async def connect_rabbitmq(amqp_url: str):
+    """Context manager para manejar la conexión de aio-pika."""
+    import aio_pika
+    
+    logger.info("[Worker Lifecycle] Conectando a RabbitMQ...")
+    connection = await aio_pika.connect_robust(amqp_url)
+    try:
+        yield connection
+    finally:
+        logger.info("[Worker Lifecycle] Cerrando conexión de RabbitMQ...")
+        await connection.close()
+
+
+async def run_worker(
+    amqp_url: str,
+    event_bus_factory: t.Callable[["aio_pika.abc.AbstractRobustConnection"], t.Any],
+) -> None:
+    """
+    Punto de entrada robusto para arrancar el Worker de RabbitMQ.
+    Asegura que no haya "magia negra" (fugas de conexiones o error de threads).
+    
+    Args:
+        amqp_url: URL de RabbitMQ (ej: amqp://guest:guest@localhost/)
+        event_bus_factory: Función/Callback que recibe la conexión aio-pika e 
+                           instancia un RabbitMQEventBus con sus handlers registrados.
+    """
+    logger.info("Iniciando Worker de EventBus...")
+    
+    async with AsyncExitStack() as stack:
+        # 1. Setup DataBases (SQL y NoSQL) atados a ESTE Loop
+        await stack.enter_async_context(setup_sqlalchemy())
+        await stack.enter_async_context(setup_mongodb())
+        
+        # 2. Setup RabbitMQ
+        rmq_conn = await stack.enter_async_context(connect_rabbitmq(amqp_url))
+        
+        # 3. Construir e inicializar el bus
+        event_bus = event_bus_factory(rmq_conn)
+        
+        # 4. Comenzar a consumir
+        await event_bus.start_consuming()
+        
+        # 5. Mantener vivo (forever)
+        logger.info("Worker corriendo eternamente. Presiona Ctrl+C para salir.")
+        await asyncio.Future()  # bloquea infinitamente hasta que se envíe una señal

{hexcore-2.1.0 → hexcore-2.2.0/hexcore.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hexcore
-Version: 2.1.0
+Version: 2.2.0
 Summary: Núcleo reutilizable para proyectos Python con arquitectura hexagonal y event handling. Provee abstracciones, utilidades y contratos para DDD, eventos y desacoplamiento de infraestructura.
 Author-email: "David Latosefki (Indroic)" <indroic@outlook.com>
 License-Expression: MIT
@@ -20,6 +20,8 @@ Requires-Dist: typer>=0.17.3
 Requires-Dist: ruff>=0.12.11
 Provides-Extra: procrastinate
 Requires-Dist: procrastinate>=3.0.0; extra == "procrastinate"
+Provides-Extra: rabbitmq
+Requires-Dist: aio-pika>=9.4.0; extra == "rabbitmq"
 Dynamic: license-file
 
 # HexCore [![PyPI Downloads](https://static.pepy.tech/personalized-badge/hexcore?period=total&units=INTERNATIONAL_SYSTEM&left_color=BLACK&right_color=GREEN&left_text=downloads)](https://pepy.tech/projects/hexcore)

{hexcore-2.1.0 → hexcore-2.2.0}/hexcore.egg-info/SOURCES.txt

@@ -57,6 +57,7 @@ hexcore/infrastructure/cqrs/__init__.py
 hexcore/infrastructure/cqrs/middlewares.py
 hexcore/infrastructure/cqrs/procrastinate.py
 hexcore/infrastructure/cqrs/pydantic_serializer.py
+hexcore/infrastructure/cqrs/rabbitmq.py
 hexcore/infrastructure/events/__init__.py
 hexcore/infrastructure/events/events_backends/__init__.py
 hexcore/infrastructure/events/events_backends/memory.py
@@ -74,6 +75,8 @@ hexcore/infrastructure/repositories/orms/sqlalchemy/utils.py
 hexcore/infrastructure/uow/__init__.py
 hexcore/infrastructure/uow/decorators.py
 hexcore/infrastructure/uow/helpers.py
+hexcore/infrastructure/workers/__init__.py
+hexcore/infrastructure/workers/rabbitmq_worker.py
 scripts/__init__.py
 scripts/main.py
 tests/conftest.py
@@ -84,6 +87,7 @@ tests/test_cqrs.py
 tests/test_domain_service_query.py
 tests/test_infrastructure_query_path.py
 tests/test_query_field_validation.py
+tests/test_rabbitmq_bus.py
 tests/test_repositories_utils.py
 tests/test_uow_session_regression.py
 tests/test_use_cases_query.py

{hexcore-2.1.0 → hexcore-2.2.0}/hexcore.egg-info/requires.txt

@@ -12,3 +12,6 @@ ruff>=0.12.11
 
 [procrastinate]
 procrastinate>=3.0.0
+
+[rabbitmq]
+aio-pika>=9.4.0

{hexcore-2.1.0 → hexcore-2.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "hexcore"
-version = "2.1.0"
+version = "2.2.0"
 authors = [
   { name="David Latosefki (Indroic)", email="indroic@outlook.com" },
 ]
@@ -26,6 +26,7 @@ license-files = ["LICEN[CS]E*"]
 
 [project.optional-dependencies]
 procrastinate = ["procrastinate>=3.0.0"]
+rabbitmq = ["aio-pika>=9.4.0"]
 
 
 [project.scripts]

hexcore-2.2.0/tests/test_rabbitmq_bus.py

@@ -0,0 +1,95 @@
+import asyncio
+import json
+import pytest
+import sys
+from unittest.mock import AsyncMock, MagicMock, ANY
+from uuid import uuid4
+
+# Mockear aio_pika globalmente para los tests (porque es una dependencia opcional)
+sys.modules["aio_pika"] = MagicMock()
+sys.modules["aio_pika"].Message = MagicMock
+sys.modules["aio_pika"].ExchangeType = MagicMock()
+
+from hexcore.domain.events import DomainEvent
+from hexcore.infrastructure.cqrs.rabbitmq import RabbitMQEventBus
+from hexcore.infrastructure.cqrs.pydantic_serializer import PydanticSerializer
+
+
+class DummyEvent(DomainEvent):
+    my_data: str
+
+
+@pytest.fixture
+def aio_pika_mocks():
+    """Retorna mocks para conexión, canal y exchange."""
+    connection = AsyncMock()
+    channel = AsyncMock()
+    exchange = AsyncMock()
+    queue = AsyncMock()
+    
+    connection.channel.return_value = channel
+    channel.declare_exchange.return_value = exchange
+    channel.declare_queue.return_value = queue
+    
+    return connection, channel, exchange, queue
+
+
+@pytest.fixture
+def anyio_backend():
+    return 'asyncio'
+
+
+@pytest.mark.anyio
+async def test_rabbitmq_event_bus_publish(aio_pika_mocks):
+    connection, channel, exchange, queue = aio_pika_mocks
+    
+    bus = RabbitMQEventBus(
+        connection=connection,
+        serializer=PydanticSerializer(),
+        exchange_name="test.events"
+    )
+    
+    event = DummyEvent(my_data="hello")
+    await bus.publish(event)
+    
+    # Verifica que se creó el canal y el exchange (lazy setup)
+    connection.channel.assert_awaited_once()
+    channel.declare_exchange.assert_awaited_once_with(
+        "test.events", 
+        ANY, 
+        durable=True
+    )
+    
+    # Verifica que se publicó en el exchange
+    exchange.publish.assert_awaited_once()
+    call_args = exchange.publish.call_args[0]
+    message = call_args[0]
+    
+    payload = json.loads(message.body.decode("utf-8"))
+    assert payload["__data__"]["my_data"] == "hello"
+    
+    # Routing key
+    kwargs = exchange.publish.call_args[1]
+    assert kwargs["routing_key"] == "DUMMY"
+
+
+@pytest.mark.anyio
+async def test_rabbitmq_event_bus_start_consuming(aio_pika_mocks):
+    connection, channel, exchange, queue = aio_pika_mocks
+    
+    bus = RabbitMQEventBus(
+        connection=connection,
+        serializer=PydanticSerializer(),
+        queue_name="test.queue"
+    )
+    
+    handler = AsyncMock()
+    bus.subscribe(DummyEvent, handler)
+    
+    await bus.start_consuming()
+    
+    # Debe haber hecho bind
+    queue.bind.assert_awaited_once_with(exchange, routing_key="DUMMY")
+    
+    # Debe haber iniciado a consumir
+    queue.consume.assert_awaited_once_with(bus._handle_message)

{hexcore-2.1.0 → hexcore-2.2.0}/tests/test_uow_session_regression.py

@@ -59,8 +59,8 @@ def test_get_async_db_session_no_manual_rollback_on_error():
         session.rollback = AsyncMock()
 
         with patch(
-            "hexcore.infrastructure.repositories.orms.sqlalchemy.session.AsyncSessionLocal",
-            return_value=_DummySessionContext(session),
+            "hexcore.infrastructure.repositories.orms.sqlalchemy.session.get_session_factory",
+            return_value=lambda: _DummySessionContext(session),
         ):
             session_generator = cast(AsyncGenerator[Any, None], get_async_db_session())
             yielded = await anext(session_generator)

hexcore-2.1.0/hexcore/infrastructure/repositories/orms/sqlalchemy/session.py

@@ -1,35 +0,0 @@
-from collections.abc import AsyncGenerator
-
-from sqlalchemy.ext.asyncio import (
-    AsyncEngine,
-    AsyncSession,
-    async_sessionmaker,
-    create_async_engine,
-)
-
-from hexcore.config import LazyConfig
-
-
-# 1. CREAR EL ENGINE ASÍNCRONO DE SQLAlchemy
-# Usamos create_async_engine en lugar de create_engine.
-engine: AsyncEngine = create_async_engine(
-    LazyConfig.get_config().async_sql_database_url,
-    # `echo=True` es útil para depuración, ya que imprime todas las sentencias SQL.
-    # Desactívalo en producción.
-    # echo=True,
-)
-
-# 2. CREAR UNA FACTORÍA DE SESIONES ASÍNCRONAS
-# Usamos async_sessionmaker y especificamos la clase AsyncSession.
-AsyncSessionLocal: async_sessionmaker[AsyncSession] = async_sessionmaker(
-    autocommit=False,
-    autoflush=False,
-    bind=engine,
-    class_=AsyncSession,
-)
-
-
-async def get_async_db_session() -> AsyncGenerator[AsyncSession, None]:
-    """Generador de sesiones asíncronas delegando el ciclo de vida al context manager."""
-    async with AsyncSessionLocal() as db:
-        yield db