nlbone 0.6.19__py3-none-any.whl → 0.7.0__py3-none-any.whl

nlbone/adapters/outbox/outbox_consumer.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+import asyncio
+import time
+from contextlib import asynccontextmanager, contextmanager
+from datetime import timedelta
+from typing import AsyncIterator, Iterable, Iterator, Optional
+
+from nlbone.adapters.outbox.outbox_repo import AsyncOutboxRepository, OutboxRepository
+from nlbone.core.domain.models import Outbox
+from nlbone.core.ports import UnitOfWork
+
+
+async def outbox_stream(
+        repo: AsyncOutboxRepository,
+        *,
+        batch_size: int = 100,
+        idle_sleep: float = 1.0,
+        stop_event: Optional[asyncio.Event] = None,
+) -> AsyncIterator[Outbox]:
+    """
+    Yields Outbox one-by-one. If none available, waits (idle_sleep) and tries again.
+    Designed to run forever until stop_event is set.
+    """
+    while True:
+        if stop_event and stop_event.is_set():
+            return
+        batch: list[Outbox] = await repo.claim_batch(limit=batch_size)
+        if not batch:
+            await asyncio.sleep(idle_sleep)
+            continue
+        for msg in batch:
+            yield msg
+
+
+@asynccontextmanager
+async def process_message(
+        repo: AsyncOutboxRepository,
+        msg: Outbox,
+        *,
+        backoff: timedelta = timedelta(seconds=30),
+):
+    """
+    Usage:
+        async with process_message(repo, msg):
+            ... do work ...
+    On success -> mark_published
+    On exception -> mark_failed with backoff
+    """
+    try:
+        yield msg
+    except Exception as e:  # noqa: BLE001
+        await repo.mark_failed(msg.id, str(e), backoff=backoff)
+        raise
+    else:
+        await repo.mark_published([msg.id])
+
+
+async def process_batch(
+        repo: AsyncOutboxRepository,
+        messages: Iterable[Outbox],
+        *,
+        backoff: timedelta = timedelta(seconds=30),
+        concurrency: int = 1,
+        handler=None,
+):
+    """
+    Optional helper: run a handler concurrently on a batch.
+    handler: async callable(msg) -> None/… ; ack/nack handled via context manager.
+    """
+    sem = asyncio.Semaphore(concurrency)
+
+    async def _run(m: Outbox):
+        async with sem:
+            async with process_message(repo, m, backoff=backoff):
+                if handler:
+                    await handler(m)
+
+    await asyncio.gather(*(_run(m) for m in messages))
+
+
+def outbox_stream_sync(
+        repo: OutboxRepository,
+        *,
+        topics : list[str] = None,
+        batch_size: int = 100,
+        idle_sleep: float = 1.0,
+        stop_flag: Optional[callable] = None,
+) -> Iterator[Outbox]:
+    while True:
+        if stop_flag and stop_flag():
+            return
+        batch = repo.claim_batch(limit=batch_size, topics=topics)
+        if not batch:
+            time.sleep(idle_sleep)
+            continue
+        for msg in batch:
+            yield msg
+
+
+@contextmanager
+def process_message_sync(uow: UnitOfWork, msg: Outbox, *, backoff: timedelta = timedelta(seconds=30)):
+    try:
+        yield msg
+    except Exception as e:
+        uow.rollback()
+        msg.mark_failed(str(e), backoff=backoff)
+        uow.commit()
+        raise
+    else:
+        msg.mark_published()
+        uow.commit()

nlbone/adapters/outbox/outbox_repo.py

@@ -0,0 +1,191 @@
+from __future__ import annotations
+
+from datetime import datetime, timedelta, timezone
+from typing import Any, Dict, Iterable, List, Optional, Tuple
+
+from sqlalchemy import (
+    delete,
+    select,
+    update,
+)
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import Session
+
+from nlbone.core.domain.models import Outbox, OutboxStatus
+from nlbone.core.ports.outbox import AsyncOutboxRepository, OutboxRepository
+
+
+class SQLAlchemyOutboxRepository(OutboxRepository):
+    def __init__(self, session: Session) -> None:
+        self.session = session
+
+    def _now(self) -> datetime:
+        return datetime.now(timezone.utc)
+
+    def enqueue(self, topic: str, payload: Dict[str, Any], *, headers=None, key=None, available_at=None) -> Outbox:
+        row = Outbox(
+            topic=topic,
+            payload=payload,
+            headers=headers or {},
+            key=key,
+            available_at=available_at or self._now(),
+        )
+        self.session.add(row)
+        # Do not commit here; caller's transaction should commit
+        self.session.flush()
+        return row
+
+    def enqueue_many(
+            self, items: Iterable[Tuple[str, Dict[str, Any]]], *, headers=None, available_at=None
+    ) -> List[Outbox]:
+        rows = [
+            Outbox(topic=t, payload=p, headers=headers or {}, available_at=available_at or self._now())
+            for t, p in items
+        ]
+        self.session.add_all(rows)
+        self.session.flush()
+        return [r for r in rows]
+
+    def claim_batch(self, *, topics: list[str] = None, limit: int = 100, now: Optional[datetime] = None) -> List[
+        Outbox]:
+        now = now or self._now()
+        # Select candidates eligible to process
+        stmt = (
+            select(Outbox)
+            .where(
+                Outbox.topic.in_(topics),
+                Outbox.status.in_([OutboxStatus.PENDING, OutboxStatus.FAILED]),
+                Outbox.available_at <= now,
+                (Outbox.next_attempt_at.is_(None)) | (Outbox.next_attempt_at <= now),
+            )
+            .order_by(Outbox.id)
+            .limit(limit)
+            .with_for_update(skip_locked=True)
+        )
+        rows = self.session.execute(stmt).scalars().all()
+        if not rows:
+            return []
+        # Mark as PROCESSING and increment attempts
+        ids = [r.id for r in rows]
+        self.session.execute(
+            update(Outbox)
+            .where(Outbox.id.in_(ids))
+            .values(status=OutboxStatus.PROCESSING, attempts=Outbox.attempts + 1)
+        )
+        self.session.flush()
+        return [r for r in rows]
+
+    def mark_published(self, ids: Iterable[int]) -> None:
+        ids = list(ids)
+        if not ids:
+            return
+        self.session.execute(
+            update(Outbox)
+            .where(Outbox.id.in_(ids))
+            .values(status=OutboxStatus.PUBLISHED, last_error=None, next_attempt_at=None)
+        )
+
+    def mark_failed(self, id: int, error: str, *, backoff: timedelta = timedelta(seconds=30)) -> None:
+        self.session.execute(
+            update(Outbox)
+            .where(Outbox.id == id)
+            .values(
+                status=OutboxStatus.FAILED,
+                last_error=error,
+                next_attempt_at=self._now() + backoff,
+            )
+        )
+
+    def delete_older_than(self, *, before: datetime, status: Optional[OutboxStatus] = None) -> int:
+        conds = [Outbox.created_at < before]
+        if status is not None:
+            conds.append(Outbox.status == status)
+        stmt = delete(Outbox).where(*conds)
+        res = self.session.execute(stmt)
+        return res.rowcount or 0
+
+
+class SQLAlchemyAsyncOutboxRepository(AsyncOutboxRepository):
+    def __init__(self, session: AsyncSession) -> None:
+        self.session = session
+
+    def _now(self) -> datetime:
+        return datetime.now(timezone.utc)
+
+    async def enqueue(
+            self, topic: str, payload: Dict[str, Any], *, headers=None, key=None, available_at=None
+    ) -> Outbox:
+        row = Outbox(
+            topic=topic,
+            payload=payload,
+            headers=headers or {},
+            key=key,
+            available_at=available_at or self._now(),
+        )
+        self.session.add(row)
+        await self.session.flush()
+        return row
+
+    async def enqueue_many(
+            self, items: Iterable[Tuple[str, Dict[str, Any]]], *, headers=None, available_at=None
+    ) -> List[Outbox]:
+        rows = [
+            Outbox(topic=t, payload=p, headers=headers or {}, available_at=available_at or self._now())
+            for t, p in items
+        ]
+        self.session.add_all(rows)
+        await self.session.flush()
+        return [r for r in rows]
+
+    async def claim_batch(self, *, limit: int = 100, now: Optional[datetime] = None) -> List[Outbox]:
+        now = now or self._now()
+        stmt = (
+            select(Outbox)
+            .where(
+                Outbox.status.in_([OutboxStatus.PENDING, OutboxStatus.FAILED]),
+                Outbox.available_at <= now,
+                (Outbox.next_attempt_at.is_(None)) | (Outbox.next_attempt_at <= now),
+            )
+            .order_by(Outbox.id)
+            .limit(limit)
+            .with_for_update(skip_locked=True)
+        )
+        rows = (await self.session.execute(stmt)).scalars().all()
+        if not rows:
+            return []
+        ids = [r.id for r in rows]
+        await self.session.execute(
+            update(Outbox)
+            .where(Outbox.id.in_(ids))
+            .values(status=OutboxStatus.PROCESSING, attempts=Outbox.attempts + 1)
+        )
+        await self.session.flush()
+        return [r.to_domain() for r in rows]
+
+    async def mark_published(self, ids: Iterable[int]) -> None:
+        ids = list(ids)
+        if not ids:
+            return
+        await self.session.execute(
+            update(Outbox)
+            .where(Outbox.id.in_(ids))
+            .values(status=OutboxStatus.PUBLISHED, last_error=None, next_attempt_at=None)
+        )
+
+    async def mark_failed(self, id: int, error: str, *, backoff: timedelta = timedelta(seconds=30)) -> None:
+        await self.session.execute(
+            update(Outbox)
+            .where(Outbox.id == id)
+            .values(
+                status=OutboxStatus.FAILED,
+                last_error=error,
+                next_attempt_at=self._now() + backoff,
+            )
+        )
+
+    async def delete_older_than(self, *, before: datetime, status: Optional[OutboxStatus] = None) -> int:
+        conds = [Outbox.created_at < before]
+        if status is not None:
+            conds.append(Outbox.status == status)
+        res = await self.session.execute(delete(Outbox).where(*conds))
+        return res.rowcount or 0

nlbone/adapters/ticketing/client.py

@@ -0,0 +1,39 @@
+from typing import Any, Dict, Optional
+
+from pydantic import BaseModel
+
+from nlbone.adapters.messaging.rabbitmq import RabbitMQEventBus
+from nlbone.config.settings import get_settings
+
+
+class CreateTicketIn(BaseModel):
+    assignee_id: str
+    category_id: int
+    channel: str
+    direction: str
+    entity_id: str
+    entity_type: str
+    message: str
+    priority: str
+    product_id: int
+    status: str
+    title: str
+    user_id: int
+
+
+class TicketingClient:
+    def __init__(self):
+        settings = get_settings()
+        self._bus = RabbitMQEventBus(settings.RABBITMQ_URL)
+        self._exchange = settings.RABBITMQ_TICKETING_EXCHANGE
+        self._rk_create_v1 = settings.RABBITMQ_TICKETING_ROUTING_KEY_CREATE_V1
+
+    async def create_ticket(self, payload: CreateTicketIn, created_by_id: int, *,
+                            override_exchange: Optional[str] = None,
+                            override_routing_key: Optional[str] = None) -> None:
+        exchange = override_exchange or self._exchange
+        routing_key = override_routing_key or self._rk_create_v1
+        payload = payload.model_dump()
+        payload.update({'created_by_id': created_by_id})
+        print(payload)
+        await self._bus.publish(exchange=exchange, routing_key=routing_key, payload=payload)

nlbone/config/settings.py

@@ -26,11 +26,11 @@ def _guess_env_file() -> str | None:
         raise Exception("Failed to guess env file path!") from e
 
 
-def is_production_env() -> bool:
+def read_from_env_fild() -> bool:
     raw = os.getenv("NLBONE_ENV") or os.getenv("ENV") or os.getenv("ENVIRONMENT")
     if not raw:
         return False
-    return raw.strip().lower() in {"prod", "production"}
+    return raw.strip().lower() not in {"prod", "production", "stage", "staging"}
 
 
 class Settings(BaseSettings):
@@ -96,6 +96,15 @@ class Settings(BaseSettings):
     # ---------------------------
     PRICING_SERVICE_URL: AnyHttpUrl = Field(default="https://pricing.numberland.ir/v1")
 
+    # ---------------------------
+    # Crypto
+    # ---------------------------
+    FERNET_KEY: str = Field(default="")
+
+    RABBITMQ_URL: str = Field(default="", description="amqp(s)://user:pass@host:5672/vhost")
+    RABBITMQ_TICKETING_EXCHANGE: str = "crm_stage.ticket"
+    RABBITMQ_TICKETING_ROUTING_KEY_CREATE_V1: str = "crm_stage.ticket.create.v1"
+
     model_config = SettingsConfigDict(
         env_prefix="",
         env_file=None,
@@ -105,9 +114,9 @@ class Settings(BaseSettings):
 
     @classmethod
     def load(cls, env_file: str | None = None) -> "Settings":
-        if is_production_env():
-            return cls()
-        return cls(_env_file=env_file or _guess_env_file())
+        if read_from_env_fild():
+            return cls(_env_file=env_file or _guess_env_file())
+        return cls()
 
 
 @lru_cache(maxsize=4)

nlbone/container.py

@@ -10,13 +10,10 @@ from nlbone.adapters.auth.token_provider import ClientTokenProvider
 from nlbone.adapters.cache.async_redis import AsyncRedisCache
 from nlbone.adapters.cache.memory import InMemoryCache
 from nlbone.adapters.cache.redis import RedisCache
-from nlbone.adapters.db.postgres import AsyncSqlAlchemyUnitOfWork, SqlAlchemyUnitOfWork
 from nlbone.adapters.db.postgres.engine import get_async_session_factory, get_sync_session_factory
 from nlbone.adapters.http_clients import PricingService
 from nlbone.adapters.http_clients.uploadchi import UploadchiClient
 from nlbone.adapters.http_clients.uploadchi.uploadchi_async import UploadchiAsyncClient
-from nlbone.adapters.messaging import InMemoryEventBus
-from nlbone.core.ports import EventBusPort
 from nlbone.core.ports.cache import AsyncCachePort, CachePort
 from nlbone.core.ports.files import AsyncFileServicePort, FileServicePort
 
@@ -27,12 +24,8 @@ class Container(containers.DeclarativeContainer):
     sync_session_factory = providers.Singleton(get_sync_session_factory)
     async_session_factory = providers.Singleton(get_async_session_factory)
 
-    # --- UoW ---
-    uow = providers.Factory(SqlAlchemyUnitOfWork, session_factory=sync_session_factory)
-    async_uow = providers.Factory(AsyncSqlAlchemyUnitOfWork, session_factory=async_session_factory)
-
     # --- Event bus ---
-    event_bus: providers.Singleton[EventBusPort] = providers.Singleton(InMemoryEventBus)
+    # event_bus: providers.Singleton[EventBusPort] = providers.Singleton(InMemoryEventBus)
 
     # --- Services ---
     auth: providers.Singleton[KeycloakAuthService] = providers.Singleton(KeycloakAuthService)

nlbone/core/application/bus.py

@@ -0,0 +1,169 @@
+import traceback
+from typing import Any, Callable, Coroutine, List, Optional, Protocol
+
+from nlbone.core.application.registry import AsyncHandlerRegistry, HandlerRegistry
+from nlbone.core.domain.base import Command, DomainEvent, Message
+from nlbone.core.ports import AsyncUnitOfWork, UnitOfWork
+from nlbone.core.ports.event_bus import AsyncOutboxPublisher, OutboxPublisher
+from nlbone.interfaces.api.middleware.access_log import logger
+
+
+class SyncMiddleware(Protocol):
+    def __call__(self, message: Message, next_: Callable[[Message], None]) -> None:  # noqa: D401
+        ...
+
+
+class AsyncMiddleware(Protocol):
+    async def __call__(self, message: Message, next_: Callable[[Message], Coroutine[Any, Any, None]]) -> None: ...
+
+
+class SyncMessageBus:
+    def __init__(
+        self,
+        uow: UnitOfWork,
+        registry: HandlerRegistry,
+        middlewares: Optional[List[SyncMiddleware]] = None,
+        outbox: Optional[OutboxPublisher] = None,
+    ) -> None:
+        self.uow = uow
+        self.registry = registry
+        self.middlewares = middlewares or []
+        self.outbox = outbox
+        self._queue: List[Message] = []
+
+    def handle(self, message: Message) -> None:
+        self._queue.append(message)
+        while self._queue:
+            msg = self._queue.pop(0)
+            self._dispatch_with_pipeline(msg)
+
+    # pipeline that wraps dispatch
+    def _dispatch_with_pipeline(self, message: Message) -> None:
+        def terminal(m: Message) -> None:
+            self._dispatch(m)
+
+        # build chain right-to-left
+        next_callable = terminal
+        for mw in reversed(self.middlewares):
+            current_mw = mw
+
+            def make_next(nxt: Callable[[Message], None]):  # closure helper
+                def _mw_call(m: Message) -> None:
+                    return current_mw(m, nxt)
+
+                return _mw_call
+
+            next_callable = make_next(next_callable)
+        next_callable(message)
+
+    def _dispatch(self, message: Message) -> None:
+        if isinstance(message, DomainEvent):
+            self._handle_event(message)
+        elif isinstance(message, Command):
+            self._handle_command(message)
+        else:
+            raise TypeError(f"Unknown message type: {type(message)!r}")
+
+    def _handle_event(self, event: DomainEvent) -> None:
+        handlers = self.registry.for_event(type(event))
+        for handler in handlers:
+            try:
+                logger.debug("handling event %s with %s", event, handler)
+                produced = handler(event)
+                if produced:
+                    self._queue.extend(produced)
+                self._queue.extend(self.uow.collect_new_events())
+            except Exception:  # noqa: BLE001
+                logger.exception("Exception handling event %s\n%s", event, traceback.format_exc())
+                continue
+
+    def _handle_command(self, command: Command) -> None:
+        handler = self.registry.for_command(type(command))
+        try:
+            logger.debug("handling command %s with %s", command, handler)
+            produced = handler(command)
+            if produced:
+                self._queue.extend(produced)
+            # commit (and gather/emit domain events)
+            self._queue.extend(self.uow.collect_new_events())
+            if self.outbox:
+                self.outbox.publish(self._queue)  # best-effort; in real systems use a DB-backed outbox
+        except Exception:  # noqa: BLE001
+            logger.exception("Exception handling command %s\n%s", command, traceback.format_exc())
+            raise
+
+
+# ==========================
+# MessageBus (async)
+# ==========================
+class AsyncMessageBus:
+    def __init__(
+        self,
+        uow: AsyncUnitOfWork,
+        registry: AsyncHandlerRegistry,
+        middlewares: Optional[List[AsyncMiddleware]] = None,
+        outbox: Optional[AsyncOutboxPublisher] = None,
+    ) -> None:
+        self.uow = uow
+        self.registry = registry
+        self.middlewares = middlewares or []
+        self.outbox = outbox
+        self._queue: List[Message] = []
+
+    async def handle(self, message: Message) -> None:
+        self._queue.append(message)
+        while self._queue:
+            msg = self._queue.pop(0)
+            await self._dispatch_with_pipeline(msg)
+
+    async def _dispatch_with_pipeline(self, message: Message) -> None:
+        async def terminal(m: Message) -> None:
+            await self._dispatch(m)
+
+        next_callable = terminal
+        for mw in reversed(self.middlewares):
+            current_mw = mw
+
+            def make_next(nxt: Callable[[Message], Coroutine[Any, Any, None]]):
+                async def _mw_call(m: Message) -> None:
+                    return await current_mw(m, nxt)
+
+                return _mw_call
+
+            next_callable = make_next(next_callable)
+        await next_callable(message)
+
+    async def _dispatch(self, message: Message) -> None:
+        if isinstance(message, DomainEvent):
+            await self._handle_event(message)
+        elif isinstance(message, Command):
+            await self._handle_command(message)
+        else:
+            raise TypeError(f"Unknown message type: {type(message)!r}")
+
+    async def _handle_event(self, event: DomainEvent) -> None:
+        handlers = self.registry.for_event(type(event))
+        for handler in handlers:
+            try:
+                logger.debug("handling event %s with %s", event, handler)
+                produced = await handler(event)
+                if produced:
+                    self._queue.extend(produced)
+                self._queue.extend(await self.uow.collect_new_events())
+            except Exception:  # noqa: BLE001
+                logger.exception("Exception handling event %s\n%s", event, traceback.format_exc())
+                continue
+
+    async def _handle_command(self, command: Command) -> None:
+        handler = self.registry.for_command(type(command))
+        try:
+            logger.debug("handling command %s with %s", command, handler)
+            produced = await handler(command)
+            if produced:
+                self._queue.extend(produced)
+            self._queue.extend(await self.uow.collect_new_events())
+            if self.outbox:
+                await self.outbox.publish(self._queue)
+        except Exception:  # noqa: BLE001
+            logger.exception("Exception handling command %s\n%s", command, traceback.format_exc())
+            raise