nlbone 0.6.19__tar.gz → 0.7.0__tar.gz

{nlbone-0.6.19 → nlbone-0.7.0}/PKG-INFO

@@ -1,13 +1,15 @@
 Metadata-Version: 2.4
 Name: nlbone
-Version: 0.6.19
+Version: 0.7.0
 Summary: Backbone package for interfaces and infrastructure in Python projects
 Author-email: Amir Hosein Kahkbazzadeh <a.khakbazzadeh@gmail.com>
 License: MIT
 License-File: LICENSE
 Requires-Python: >=3.10
+Requires-Dist: aio-pika>=9.5.7
 Requires-Dist: anyio>=4.0
 Requires-Dist: cachetools>=6.2.0
+Requires-Dist: cryptography~=45.0.4
 Requires-Dist: dependency-injector>=4.48.1
 Requires-Dist: elasticsearch==8.14.0
 Requires-Dist: fastapi>=0.116
@@ -22,7 +24,7 @@ Requires-Dist: redis~=6.4.0
 Requires-Dist: sqlalchemy>=2.0
 Requires-Dist: starlette>=0.47
 Requires-Dist: typer>=0.17.4
-Requires-Dist: uvicorn>=0.35
+Requires-Dist: uvicorn==0.35
 Description-Content-Type: text/markdown
 
 # nlbone

{nlbone-0.6.19 → nlbone-0.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "nlbone"
-version = "0.6.19"
+version = "0.7.0"
 description = "Backbone package for interfaces and infrastructure in Python projects"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -19,7 +19,7 @@ dependencies = [
     "python-keycloak==5.8.1",
     "fastapi>=0.116",
     "starlette>=0.47",
-    "uvicorn>=0.35",
+    "uvicorn==0.35",
     "sqlalchemy>=2.0",
     "psycopg>=3.2.9",
     "dependency-injector>=4.48.1",
@@ -29,6 +29,8 @@ dependencies = [
     "typer>=0.17.4",
     "makefun>=1.16.0",
     "cachetools>=6.2.0",
+    "cryptography~=45.0.4",
+    "aio-pika>=9.5.7",
 ]
 
 [tool.ruff]

{nlbone-0.6.19 → nlbone-0.7.0}/src/nlbone/adapters/db/postgres/__init__.py

@@ -1,4 +1,4 @@
 from .engine import async_ping, async_session, init_async_engine, init_sync_engine, sync_ping, sync_session
 from .query_builder import apply_pagination, get_paginated_response
-from .repository import AsyncSqlAlchemyRepository, SqlAlchemyRepository
+from .repository import SQLAlchemyAsyncRepository, SQLAlchemyRepository
 from .uow import AsyncSqlAlchemyUnitOfWork, SqlAlchemyUnitOfWork

nlbone-0.7.0/src/nlbone/adapters/db/postgres/base.py

@@ -0,0 +1,4 @@
+from sqlalchemy.orm import declarative_base, registry
+
+Base = declarative_base()
+mapper_registry = registry(metadata=Base.metadata)

{nlbone-0.6.19 → nlbone-0.7.0}/src/nlbone/adapters/db/postgres/query_builder.py

@@ -340,7 +340,7 @@ def get_paginated_response(
     with_count: bool = True,
     output_cls: Optional[Type] = None,
     eager_options: Optional[Sequence[LoaderOption]] = None,
-    query = None
+    query=None,
 ) -> dict:
     if not query:
         query = session.query(entity)

nlbone-0.7.0/src/nlbone/adapters/db/postgres/repository.py

@@ -0,0 +1,279 @@
+from __future__ import annotations
+
+from abc import ABC
+from typing import Any, Callable, Iterable, List, Optional, Sequence
+
+from sqlalchemy import delete as sqla_delete
+from sqlalchemy import desc as sa_desc
+from sqlalchemy import func, select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import Session
+
+from nlbone.core.ports.repository import ID, AsyncRepository, Repository, T
+from nlbone.interfaces.api.exceptions import NotFoundException
+
+
+# -----------------------------
+# Helper utilities
+# -----------------------------
+def _apply_python_filters(
+    items: Sequence[T],
+    *,
+    where: Optional[Callable[[T], bool]] = None,
+    order_by: Optional[Callable[[T], object]] = None,
+    reverse: bool = False,
+    offset: int = 0,
+    limit: Optional[int] = None,
+) -> List[T]:
+    data = list(items)
+    if where:
+        data = [x for x in data if where(x)]
+    if order_by:
+        data.sort(key=order_by, reverse=reverse)
+    else:
+        if reverse:
+            data.reverse()
+    if offset:
+        data = data[offset:]
+    if limit is not None:
+        data = data[:limit]
+    return data
+
+
+def _has_attr_id(entity: Any) -> bool:
+    return hasattr(entity, "id")
+
+
+# -----------------------------
+# SQLAlchemy (sync)
+# -----------------------------
+class SQLAlchemyRepository(Repository, ABC):
+    """
+    Concrete Repository[T, ID] backed by SQLAlchemy Session (sync).
+    Assumes entities have an `id` attribute and are mapped.
+    """
+
+    def __init__(self, session: Session, *, autocommit: bool = False):
+        self.session = session
+        self.autocommit = autocommit
+
+    def get(self, id: ID) -> Optional[T]:
+        return self.session.get(self.model, id)
+
+    def get_or_raise(self, id: ID) -> T:
+        entity = self.get(id)
+        if entity is None:
+            raise NotFoundException(f"Entity with id={id!r} not found")
+        return entity
+
+    def list(
+        self,
+        *,
+        offset: int = 0,
+        limit: Optional[int] = None,
+        where: Optional[Callable[[T], bool]] = None,
+        order_by: Optional[Callable[[T], object]] = None,
+        reverse: bool = False,
+    ) -> List[T]:
+        # If where/order_by look like SQLAlchemy expressions (not callables), push down to DB.
+        if where is None and (order_by is None or callable(order_by)):
+            stmt = select(self.model)
+        elif callable(where) or (order_by is not None and callable(order_by)):
+            # Fallback to Python-side filtering
+            stmt = select(self.model)
+        else:
+            stmt = select(self.model).where(where)  # type: ignore[arg-type]
+            if order_by is not None:
+                stmt = stmt.order_by(sa_desc(order_by) if reverse else order_by)  # type: ignore[arg-type]
+        if where is None and (order_by is None or not callable(order_by)):
+            if offset:
+                stmt = stmt.offset(offset)
+            if limit is not None:
+                stmt = stmt.limit(limit)
+            result = self.session.execute(stmt)
+            rows = result.scalars().all()
+            # If order_by was a Python callable, apply now
+            if order_by is not None and callable(order_by):
+                return _apply_python_filters(rows, order_by=order_by, reverse=reverse, offset=0, limit=None)
+            return rows
+        # Python-side filtering path
+        rows = self.session.execute(select(self.model)).scalars().all()
+        return _apply_python_filters(rows, where=where, order_by=order_by, reverse=reverse, offset=offset, limit=limit)
+
+    def count(self, *, where: Optional[Callable[[T], bool]] = None) -> int:
+        if where is None:
+            stmt = select(func.count()).select_from(self.model)
+            return self.session.execute(stmt).scalar_one()
+        # Python-side when `where` is a callable
+        rows = self.session.execute(select(self.model)).scalars().all()
+        return sum(1 for x in rows if where(x))
+
+    def exists(self, id: ID) -> bool:
+        return self.get(id) is not None
+
+    # --- Write ---
+    def add(self, entity: T) -> T:
+        if not _has_attr_id(entity):
+            raise ValueError("Entity must have an `id` attribute.")
+        if self.exists(getattr(entity, "id")):
+            raise ValueError(f"Entity with id={getattr(entity, 'id')!r} already exists")
+        self.session.add(entity)
+        self.session.flush()
+        if self.autocommit:
+            self.session.commit()
+        return entity
+
+    def add_many(self, entities: Iterable[T]) -> List[T]:
+        data = list(entities)
+        for e in data:
+            if not _has_attr_id(e):
+                raise ValueError("All entities must have an `id` attribute.")
+        # Basic duplicate check in memory (best-effort)
+        ids = [getattr(e, "id") for e in data]
+        if len(ids) != len(set(ids)):
+            raise ValueError("Duplicate IDs in input batch.")
+        self.session.add_all(data)
+        if self.autocommit:
+            self.session.commit()
+        return data
+
+    def update(self, entity: T) -> T:
+        if not _has_attr_id(entity):
+            raise ValueError("Entity must have an `id` attribute.")
+        id_value = getattr(entity, "id")
+        if not self.exists(id_value):
+            raise NotFoundException(f"Entity with id={id_value!r} not found")
+        merged = self.session.merge(entity)
+        if self.autocommit:
+            self.session.commit()
+        return merged
+
+    def delete(self, id: ID) -> bool:
+        obj = self.get(id)
+        if not obj:
+            return False
+        self.session.delete(obj)
+        if self.autocommit:
+            self.session.commit()
+        return True
+
+    def clear(self) -> None:
+        self.session.execute(sqla_delete(self.model))
+        if self.autocommit:
+            self.session.commit()
+
+
+# -----------------------------
+# SQLAlchemy (async)
+# -----------------------------
+class SQLAlchemyAsyncRepository(AsyncRepository, ABC):
+    """
+    Concrete AsyncRepository[T, ID] backed by SQLAlchemy AsyncSession.
+    Assumes entities have an `id` attribute and are mapped.
+    """
+
+    def __init__(self, session: AsyncSession, *, autocommit: bool = True):
+        self.session = session
+        self.autocommit = autocommit
+
+    # --- Read ---
+    async def get(self, id: ID) -> Optional[T]:
+        return await self.session.get(self.model, id)
+
+    async def get_or_raise(self, id: ID) -> T:
+        entity = await self.get(id)
+        if entity is None:
+            raise NotFoundException(f"Entity with id={id!r} not found")
+        return entity
+
+    async def list(
+        self,
+        *,
+        offset: int = 0,
+        limit: Optional[int] = None,
+        where: Optional[Callable[[T], bool]] = None,
+        order_by: Optional[Callable[[T], object]] = None,
+        reverse: bool = False,
+    ) -> List[T]:
+        if where is None and (order_by is None or callable(order_by)):
+            stmt = select(self.model)
+        elif callable(where) or (order_by is not None and callable(order_by)):
+            stmt = select(self.model)
+        else:
+            stmt = select(self.model).where(where)  # type: ignore[arg-type]
+            if order_by is not None:
+                stmt = stmt.order_by(sa_desc(order_by) if reverse else order_by)  # type: ignore[arg-type]
+        if where is None and (order_by is None or not callable(order_by)):
+            if offset:
+                stmt = stmt.offset(offset)
+            if limit is not None:
+                stmt = stmt.limit(limit)
+            result = await self.session.execute(stmt)
+            rows = result.scalars().all()
+            if order_by is not None and callable(order_by):
+                return _apply_python_filters(rows, order_by=order_by, reverse=reverse, offset=0, limit=None)
+            return rows
+        result = await self.session.execute(select(self.model))
+        rows = result.scalars().all()
+        return _apply_python_filters(rows, where=where, order_by=order_by, reverse=reverse, offset=offset, limit=limit)
+
+    async def count(self, *, where: Optional[Callable[[T], bool]] = None) -> int:
+        if where is None:
+            stmt = select(func.count()).select_from(self.model)
+            result = await self.session.execute(stmt)
+            return result.scalar_one()
+        result = await self.session.execute(select(self.model))
+        rows = result.scalars().all()
+        return sum(1 for x in rows if where(x))
+
+    async def exists(self, id: ID) -> bool:
+        return (await self.get(id)) is not None
+
+    # --- Write ---
+    async def add(self, entity: T) -> T:
+        if not _has_attr_id(entity):
+            raise ValueError("Entity must have an `id` attribute.")
+        if await self.exists(getattr(entity, "id")):
+            raise ValueError(f"Entity with id={getattr(entity, 'id')!r} already exists")
+        self.session.add(entity)
+        if self.autocommit:
+            await self.session.commit()
+        return entity
+
+    async def add_many(self, entities: Iterable[T]) -> List[T]:
+        data = list(entities)
+        for e in data:
+            if not _has_attr_id(e):
+                raise ValueError("All entities must have an `id` attribute.")
+        ids = [getattr(e, "id") for e in data]
+        if len(ids) != len(set(ids)):
+            raise ValueError("Duplicate IDs in input batch.")
+        self.session.add_all(data)
+        if self.autocommit:
+            await self.session.commit()
+        return data
+
+    async def update(self, entity: T) -> T:
+        if not _has_attr_id(entity):
+            raise ValueError("Entity must have an `id` attribute.")
+        id_value = getattr(entity, "id")
+        if not await self.exists(id_value):
+            raise NotFoundException(f"Entity with id={id_value!r} not found")
+        merged = await self.session.merge(entity)
+        if self.autocommit:
+            await self.session.commit()
+        return merged
+
+    async def delete(self, id: ID) -> bool:
+        obj = await self.get(id)
+        if not obj:
+            return False
+        await self.session.delete(obj)
+        if self.autocommit:
+            await self.session.commit()
+        return True
+
+    async def clear(self) -> None:
+        await self.session.execute(sqla_delete(self.model))
+        if self.autocommit:
+            await self.session.commit()

{nlbone-0.6.19 → nlbone-0.7.0}/src/nlbone/adapters/db/postgres/uow.py

@@ -1,10 +1,13 @@
 from __future__ import annotations
 
-from typing import Optional
+from typing import AsyncIterator, Iterator, Optional
 
 from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
 from sqlalchemy.orm import Session, sessionmaker
 
+from nlbone.adapters.outbox.outbox_repo import SQLAlchemyAsyncOutboxRepository, SQLAlchemyOutboxRepository
+from nlbone.core.domain.base import DomainEvent
+from nlbone.core.ports.repository import AsyncRepository, Repository
 from nlbone.core.ports.uow import AsyncUnitOfWork as AsyncUnitOfWorkPort
 from nlbone.core.ports.uow import UnitOfWork
 
@@ -18,6 +21,7 @@ class SqlAlchemyUnitOfWork(UnitOfWork):
 
     def __enter__(self) -> "SqlAlchemyUnitOfWork":
         self.session = self._session_factory()
+        self.outbox_repo = SQLAlchemyOutboxRepository(self.session)
         return self
 
     def __exit__(self, exc_type, exc, tb) -> None:
@@ -34,11 +38,26 @@ class SqlAlchemyUnitOfWork(UnitOfWork):
     def commit(self) -> None:
         if self.session:
             self.session.commit()
+        # if self.event_bus:
+        #     for obj in self.session:
+        #         events = getattr(obj, "events", None)
+        #         if events:
+        #             for evt in list(events):
+        #                 self.event_bus.publish(evt)
+        #             obj.clear_events()
 
     def rollback(self) -> None:
         if self.session:
             self.session.rollback()
 
+    def collect_new_events(self) -> Iterator[DomainEvent]:
+        for name, type_ in self.__annotations__.items():
+            if isinstance(type_, type) and issubclass(type_, Repository):
+                repo = getattr(self, name)
+                for entity in repo.seen:
+                    for event in entity.events:
+                        yield event
+
 
 class AsyncSqlAlchemyUnitOfWork(AsyncUnitOfWorkPort):
     """Transactional boundary for async SQLAlchemy."""
@@ -49,6 +68,7 @@ class AsyncSqlAlchemyUnitOfWork(AsyncUnitOfWorkPort):
 
     async def __aenter__(self) -> "AsyncSqlAlchemyUnitOfWork":
         self.session = self._sf()
+        self.outbox_repo = SQLAlchemyAsyncOutboxRepository(self.session)
         return self
 
     async def __aexit__(self, exc_type, exc, tb) -> None:
@@ -65,7 +85,22 @@ class AsyncSqlAlchemyUnitOfWork(AsyncUnitOfWorkPort):
     async def commit(self) -> None:
         if self.session:
             await self.session.commit()
+        if self.event_bus:
+            for obj in self.session:
+                events = getattr(obj, "events", None)
+                if events:
+                    for evt in list(events):
+                        self.event_bus.publish(evt)
+                    obj.clear_events()
 
     async def rollback(self) -> None:
         if self.session:
             await self.session.rollback()
+
+    async def collect_new_events(self) -> AsyncIterator[DomainEvent]:
+        for name, type_ in self.__annotations__.items():
+            if isinstance(type_, type) and issubclass(type_, AsyncRepository):
+                repo = getattr(self, name)
+                for entity in repo.seen:
+                    for event in entity.events:
+                        yield event

nlbone-0.7.0/src/nlbone/adapters/messaging/__init__.py

@@ -0,0 +1 @@
+from .event_bus import InProcessEventBus

nlbone-0.7.0/src/nlbone/adapters/messaging/event_bus.py

@@ -0,0 +1,103 @@
+import asyncio
+import json
+import time
+from typing import Callable, Dict, Iterable, List, Type
+
+import redis
+
+from nlbone.core.domain.base import DomainEvent
+from nlbone.core.domain.models import Outbox
+from nlbone.core.ports.event_bus import EventBus, EventHandler
+
+
+class InProcessEventBus(EventBus):
+    def __init__(self) -> None:
+        self._handlers: Dict[Type[DomainEvent], List[EventHandler]] = {}
+
+    def subscribe(self, event_type: Type[DomainEvent], handler: EventHandler) -> None:
+        self._handlers.setdefault(event_type, []).append(handler)
+
+    def publish(self, event: DomainEvent) -> None:
+        handlers = list(self._handlers.get(type(event), []))
+        loop = None
+        for h in handlers:
+            res = h(event)
+            if asyncio.iscoroutine(res):
+                loop = loop or asyncio.get_event_loop()
+                loop.create_task(res)
+
+
+class OutboxDispatcher:
+    def __init__(self, session_factory, event_bus: EventBus, batch_size: int = 100):
+        self._sf = session_factory
+        self._bus = event_bus
+        self._batch = batch_size
+
+    def run_once(self) -> int:
+        sent = 0
+        with self._sf() as s:  # type: Session
+            rows: Iterable[Outbox] = (
+                s.query(Outbox).filter_by(published=False).order_by(Outbox.occurred_at).limit(self._batch).all()
+            )
+            for r in rows:
+                self._bus.publish(type("OutboxEvent", (), r.payload))
+                r.published = True
+                sent += 1
+            s.commit()
+        return sent
+
+
+class RedisStreamsEventBus(EventBus):
+    """Topic = stream name. routing_key = event.type"""
+
+    def __init__(self, client: redis.Redis, stream: str = "nlb:domain:events"):
+        self.client = client
+        self.stream = stream
+        self._local_handlers: dict[type[DomainEvent], list[EventHandler]] = {}
+
+    def subscribe(self, event_type: type[DomainEvent], handler: EventHandler) -> None:
+        self._local_handlers.setdefault(event_type, []).append(handler)
+
+    def publish(self, event: DomainEvent) -> None:
+        self.client.xadd(
+            self.stream,
+            {
+                "type": event.type,
+                "payload": json.dumps(event.__dict__, default=str),
+            },
+            maxlen=10_000,
+            approximate=True,
+        )
+        # optional: local handlers in same process (choreography ترکیبی)
+        for h in self._local_handlers.get(type(event), []):
+            h(event)
+
+
+class RedisStreamsConsumer:
+    def __init__(self, client: redis.Redis, stream: str, group: str, consumer: str, dlq: str | None = None):
+        self.client = client
+        self.stream = stream
+        self.group = group
+        self.consumer = consumer
+        self.dlq = dlq or f"{stream}:dlq"
+
+        try:
+            self.client.xgroup_create(name=self.stream, groupname=self.group, id="$", mkstream=True)
+        except redis.ResponseError:
+            pass  # group exists
+
+    def consume_forever(self, handler: Callable[[dict], None], block_ms: int = 2000, count: int = 32):
+        while True:
+            resp = self.client.xreadgroup(self.group, self.consumer, {self.stream: ">"}, count=count, block=block_ms)
+            if not resp:
+                continue
+            for _stream, messages in resp:
+                for msg_id, fields in messages:
+                    try:
+                        payload = json.loads(fields[b"payload"].decode())
+                        handler(payload)
+                        self.client.xack(self.stream, self.group, msg_id)
+                    except Exception:
+                        self.client.xack(self.stream, self.group, msg_id)
+                        self.client.xadd(self.dlq, fields)
+            time.sleep(0.05)

nlbone-0.7.0/src/nlbone/adapters/messaging/rabbitmq.py

@@ -0,0 +1,45 @@
+import json
+from typing import Mapping, Any, Optional
+
+import aio_pika
+from aio_pika import ExchangeType, Message
+
+
+import json
+from typing import Mapping, Any, Optional
+import aio_pika
+from aio_pika import ExchangeType, Message
+from nlbone.core.ports.event_bus import EventBus
+
+class RabbitMQEventBus(EventBus):
+    def __init__(self, amqp_url: str, declare_passive: bool = True, exchange_type: ExchangeType = ExchangeType.DIRECT):
+        self._amqp_url = amqp_url
+        self._declare_passive = declare_passive
+        self._exchange_type = exchange_type
+        self._connection: Optional[aio_pika.RobustConnection] = None
+        self._channel: Optional[aio_pika.Channel] = None
+        self._exchange_cache: dict[str, aio_pika.Exchange] = {}
+
+    async def _ensure_channel(self) -> aio_pika.Channel:
+        if not self._connection or self._connection.is_closed:
+            self._connection = await aio_pika.connect_robust(self._amqp_url)
+        if not self._channel or self._channel.is_closed:
+            self._channel = await self._connection.channel(publisher_confirms=True)
+        return self._channel
+
+    async def _get_exchange(self, name: str) -> aio_pika.Exchange:
+        if name in self._exchange_cache:
+            return self._exchange_cache[name]
+        ch = await self._ensure_channel()
+        if self._declare_passive:
+            ex = await ch.declare_exchange(name, self._exchange_type, durable=True, passive=True)
+        else:
+            ex = await ch.declare_exchange(name, self._exchange_type, durable=True, passive=False)
+        self._exchange_cache[name] = ex
+        return ex
+
+    async def publish(self, *, exchange: str, routing_key: str, payload: Mapping[str, Any]) -> None:
+        ex = await self._get_exchange(exchange)
+        body = json.dumps(payload, ensure_ascii=False).encode("utf-8")
+        msg = Message(body=body, content_type="application/json", delivery_mode=aio_pika.DeliveryMode.PERSISTENT)
+        await ex.publish(msg, routing_key=routing_key)

nlbone-0.7.0/src/nlbone/adapters/outbox/__init__.py

@@ -0,0 +1 @@
+from .outbox_consumer import outbox_stream, outbox_stream_sync, process_batch, process_message, process_message_sync