nlbone 0.6.19__tar.gz → 0.6.20__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nlbone
-Version: 0.6.19
+Version: 0.6.20
 Summary: Backbone package for interfaces and infrastructure in Python projects
 Author-email: Amir Hosein Kahkbazzadeh <a.khakbazzadeh@gmail.com>
 License: MIT
@@ -8,6 +8,7 @@ License-File: LICENSE
 Requires-Python: >=3.10
 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

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "nlbone"
-version = "0.6.19"
+version = "0.6.20"
 description = "Backbone package for interfaces and infrastructure in Python projects"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -29,6 +29,7 @@ dependencies = [
     "typer>=0.17.4",
     "makefun>=1.16.0",
     "cachetools>=6.2.0",
+    "cryptography~=45.0.4",
 ]
 
 [tool.ruff]

{nlbone-0.6.19 → nlbone-0.6.20}/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.6.19 → nlbone-0.6.20}/src/nlbone/adapters/repositories/outbox_repo.py

@@ -1,20 +1,18 @@
 from typing import List
 
+
 class OutboxRecord(dict):
     pass
 
+
 class OutboxRepository:
     def __init__(self, engine):
         self._engine = engine
 
-    def add(self, msg) -> None:
-        ...
+    def add(self, msg) -> None: ...
 
-    def fetch_pending(self, limit: int = 100) -> List[OutboxRecord]:
-        ...
+    def fetch_pending(self, limit: int = 100) -> List[OutboxRecord]: ...
 
-    def mark_sent(self, msg_id: int) -> None:
-        ...
+    def mark_sent(self, msg_id: int) -> None: ...
 
-    def schedule_retry(self, msg_id: int, retries: int, backoff_base: int = 2) -> None:
-        ...
+    def schedule_retry(self, msg_id: int, retries: int, backoff_base: int = 2) -> None: ...

{nlbone-0.6.19 → nlbone-0.6.20}/src/nlbone/config/settings.py

@@ -96,6 +96,11 @@ class Settings(BaseSettings):
     # ---------------------------
     PRICING_SERVICE_URL: AnyHttpUrl = Field(default="https://pricing.numberland.ir/v1")
 
+    # ---------------------------
+    # Crypto
+    # ---------------------------
+    FERNET_KEY: str = Field(default="")
+
     model_config = SettingsConfigDict(
         env_prefix="",
         env_file=None,

nlbone-0.6.20/src/nlbone/core/application/bus.py

@@ -0,0 +1,169 @@
+import traceback
+from typing import Optional, List, Callable, Coroutine, Any, Protocol
+
+from nlbone.core.application.registry import HandlerRegistry, AsyncHandlerRegistry
+from nlbone.core.domain.base import Command, DomainEvent
+from nlbone.core.ports import UnitOfWork, AsyncUnitOfWork
+from nlbone.core.ports.event_bus import OutboxPublisher, Message, AsyncOutboxPublisher
+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(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(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

nlbone-0.6.20/src/nlbone/core/application/di.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+import inspect
+from typing import Any, Callable, Dict, Optional, Type, get_type_hints, get_origin, get_args
+
+class TypeContainer:
+    """Tiny type-based DI: register_instance(T, obj) / register_factory(T, () -> obj)."""
+    def __init__(self) -> None:
+        self._instances: Dict[Type[Any], Any] = {}
+        self._factories: Dict[Type[Any], Callable[[], Any]] = {}
+
+    def register_instance(self, t: Type[Any], instance: Any) -> None:
+        self._instances[t] = instance
+
+    def register_factory(self, t: Type[Any], factory: Callable[[], Any]) -> None:
+        self._factories[t] = factory
+
+    def _providers(self):
+        for t, v in self._instances.items():
+            yield t, (lambda v=v: v)
+        for t, f in self._factories.items():
+            yield t, f
+
+    def _unwrap(self, ann: Any) -> tuple[list[Type[Any]], bool]:
+        if ann is inspect._empty:
+            return [], True
+        origin = get_origin(ann)
+        args = list(get_args(ann))
+        allow_none = False
+        if origin in (Optional, getattr(__import__("typing"), "Union")):
+            if type(None) in args:
+                allow_none = True
+                args = [a for a in args if a is not type(None)]
+            return [a for a in args if isinstance(a, type)], allow_none
+        if isinstance(ann, type):
+            return [ann], False
+        return [], True
+
+    def resolve(self, ann: Any) -> Any:
+        types, allow_none = self._unwrap(ann)
+        if not types:
+            if allow_none:
+                return None
+            raise LookupError(f"Cannot resolve {ann!r}")
+        for T in types:
+            # exact
+            for pt, make in self._providers():
+                if pt is T:
+                    return make()
+            # supertype/provider match
+            best = None
+            for pt, make in self._providers():
+                try:
+                    if issubclass(T, pt):
+                        dist = _mro_distance(T, pt)
+                        if best is None or dist < best[0]:
+                            best = (dist, make)
+                except TypeError:
+                    pass
+            if best:
+                return best[1]()
+        if allow_none:
+            return None
+        raise LookupError(f"No provider for {types}")
+
+def _mro_distance(sub: Type[Any], sup: Type[Any]) -> int:
+    try:
+        return sub.mro().index(sup)
+    except ValueError:
+        return 10**6
+
+
+def bind_callable(fn: Callable[..., Any], c: TypeContainer) -> Callable[..., Any]:
+    sig = inspect.signature(fn)
+    hints = get_type_hints(fn)
+    def wrapper(message: Any):
+        kwargs = {}
+        for name, param in list(sig.parameters.items())[1:]:
+            ann = hints.get(name, param.annotation)
+            kwargs[name] = c.resolve(ann)
+        return fn(message, **kwargs)
+    return wrapper
+
+
+def bind_handler(handler: Any, c: TypeContainer) -> Callable[..., Any]:
+    if inspect.isclass(handler):
+        init = handler.__init__  # type: ignore[attr-defined]
+        sig = inspect.signature(init)
+        hints = get_type_hints(init)
+        kwargs = {}
+        for name, param in list(sig.parameters.items())[1:]:
+            ann = hints.get(name, param.annotation)
+            kwargs[name] = c.resolve(ann)
+        instance = handler(**kwargs)  # type: ignore
+        if not callable(instance):
+            raise TypeError(f"{handler!r} must implement __call__")
+        return instance
+    elif callable(handler):
+        return bind_callable(handler, c)
+    raise TypeError(f"Unsupported handler: {handler!r}")

nlbone-0.6.20/src/nlbone/core/application/registry.py

@@ -0,0 +1,123 @@
+from typing import Dict, Type, List, Callable, TypeVar, Optional, Iterable, Coroutine, Any
+
+from nlbone.core.application.di import TypeContainer, bind_handler
+from nlbone.core.domain.base import DomainEvent, Command
+from nlbone.core.ports.event_bus import Message
+
+TMsg = TypeVar("TMsg", bound=Message)
+SyncHandler = Callable[[TMsg], Optional[Iterable[Message]]]
+AsyncHandler = Callable[[TMsg], Coroutine[Any, Any, Optional[Iterable[Message]]]]
+
+
+class HandlerRegistry:
+    def __init__(self) -> None:
+        self._event_handlers: Dict[Type[DomainEvent], List[SyncHandler[Any]]] = {}
+        self._command_handlers: Dict[Type[Command], SyncHandler[Any]] = {}
+
+    def register_event(self, event_type: Type[DomainEvent], handler: SyncHandler[Any]) -> None:
+        self._event_handlers.setdefault(event_type, []).append(handler)
+
+    def register_command(self, cmd_type: Type[Command], handler: SyncHandler[Any]) -> None:
+        if cmd_type in self._command_handlers:
+            raise ValueError(f"Command handler already registered for {cmd_type!r}")
+        self._command_handlers[cmd_type] = handler
+
+    def for_event(self, event_type: Type[DomainEvent]) -> List[SyncHandler[Any]]:
+        return self._event_handlers.get(event_type, [])
+
+    def for_command(self, cmd_type: Type[Command]) -> SyncHandler[Any]:
+        try:
+            return self._command_handlers[cmd_type]
+        except KeyError as e:
+            raise KeyError(f"No handler for command {cmd_type.__name__}") from e
+
+
+class AsyncHandlerRegistry:
+    def __init__(self) -> None:
+        self._event_handlers: Dict[Type[DomainEvent], List[AsyncHandler[Any]]] = {}
+        self._command_handlers: Dict[Type[Command], AsyncHandler[Any]] = {}
+
+    def register_event(self, event_type: Type[DomainEvent], handler: AsyncHandler[Any]) -> None:
+        self._event_handlers.setdefault(event_type, []).append(handler)
+
+    def register_command(self, cmd_type: Type[Command], handler: AsyncHandler[Any]) -> None:
+        if cmd_type in self._command_handlers:
+            raise ValueError(f"Command handler already registered for {cmd_type!r}")
+        self._command_handlers[cmd_type] = handler
+
+    def for_event(self, event_type: Type[DomainEvent]) -> List[AsyncHandler[Any]]:
+        return self._event_handlers.get(event_type, [])
+
+    def for_command(self, cmd_type: Type[Command]) -> AsyncHandler[Any]:
+        try:
+            return self._command_handlers[cmd_type]
+        except KeyError as e:
+            raise KeyError(f"No handler for command {cmd_type.__name__}") from e
+
+
+def handles_event(event_type: Type[DomainEvent], registry: HandlerRegistry):
+    def deco(fn: SyncHandler[Any]) -> SyncHandler[Any]:
+        registry.register_event(event_type, fn)
+        return fn
+
+    return deco
+
+
+def handles_command(cmd_type: Type[Command], registry: HandlerRegistry):
+    def deco(fn: SyncHandler[Any]) -> SyncHandler[Any]:
+        registry.register_command(cmd_type, fn)
+        return fn
+
+    return deco
+
+
+def handles_event_async(event_type: Type[DomainEvent], registry: AsyncHandlerRegistry):
+    def deco(fn: AsyncHandler[Any]) -> AsyncHandler[Any]:
+        registry.register_event(event_type, fn)
+        return fn
+
+    return deco
+
+
+def handles_command_async(cmd_type: Type[Command], registry: AsyncHandlerRegistry):
+    def deco(fn: AsyncHandler[Any]) -> AsyncHandler[Any]:
+        registry.register_command(cmd_type, fn)
+        return fn
+
+    return deco
+
+
+def make_sync_decorators(registry: HandlerRegistry, container: TypeContainer):
+    def handles_command(cmd_type: Type[Any]):
+        def deco(h: Any):
+            registry.register_command(cmd_type, bind_handler(h, container))
+            return h
+
+        return deco
+
+    def handles_event(evt_type: Type[Any]):
+        def deco(h: Any):
+            registry.register_event(evt_type, bind_handler(h, container))
+            return h
+
+        return deco
+
+    return handles_command, handles_event
+
+
+def make_async_decorators(registry: AsyncHandlerRegistry, container: TypeContainer):
+    def handles_command_async(cmd_type: Type[Any]):
+        def deco(h: Any):
+            registry.register_command(cmd_type, bind_handler(h, container))
+            return h
+
+        return deco
+
+    def handles_event_async(evt_type: Type[Any]):
+        def deco(h: Any):
+            registry.register_event(evt_type, bind_handler(h, container))
+            return h
+
+        return deco
+
+    return handles_command_async, handles_event_async

nlbone-0.6.20/src/nlbone/core/ports/repository.py

@@ -0,0 +1,115 @@
+from abc import ABC, abstractmethod
+from typing import (
+    TypeVar,
+    Generic,
+    Optional,
+    Iterable,
+    Callable,
+    List,
+    ClassVar,
+    Type,
+    Any,
+)
+
+from nlbone.interfaces.api.exceptions import NotFoundException
+
+ID = TypeVar("ID")
+T = TypeVar("T", bound="HasId")
+
+
+class Repository(Generic[T, ID], ABC):
+    model: ClassVar[Type[Any]]
+
+    @abstractmethod
+    def get(self, id: ID) -> Optional[T]: ...
+
+    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
+
+    @abstractmethod
+    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]: ...
+
+    @abstractmethod
+    def count(self, *, where: Optional[Callable[[T], bool]] = None) -> int: ...
+
+    @abstractmethod
+    def exists(self, id: ID) -> bool: ...
+
+    # --- Write ---
+    @abstractmethod
+    def add(self, entity: T) -> T: ...
+
+    @abstractmethod
+    def add_many(self, entities: Iterable[T]) -> List[T]: ...
+
+    @abstractmethod
+    def update(self, entity: T) -> T: ...
+
+    @abstractmethod
+    def delete(self, id: ID) -> bool: ...
+
+    @abstractmethod
+    def clear(self) -> None: ...
+
+
+# -----------------------------
+# Async Repository (Abstract)
+# -----------------------------
+class AsyncRepository(Generic[T, ID], ABC):
+    @property
+    @abstractmethod
+    def model(self) -> type[T]: ...
+
+    @abstractmethod
+    async def get(self, id: ID) -> Optional[T]: ...
+
+    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
+
+    @abstractmethod
+    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]: ...
+
+    @abstractmethod
+    async def count(self, *, where: Optional[Callable[[T], bool]] = None) -> int: ...
+
+    @abstractmethod
+    async def exists(self, id: ID) -> bool: ...
+
+    # --- Write ---
+    @abstractmethod
+    async def add(self, entity: T) -> T: ...
+
+    @abstractmethod
+    async def add_many(self, entities: Iterable[T]) -> List[T]: ...
+
+    @abstractmethod
+    async def update(self, entity: T) -> T: ...
+
+    @abstractmethod
+    async def delete(self, id: ID) -> bool: ...
+
+    @abstractmethod
+    async def clear(self) -> None: ...

nlbone-0.6.20/src/nlbone/interfaces/cli/crypto.py

@@ -0,0 +1,22 @@
+import typer
+
+from nlbone.utils.crypto import decrypt_text, encrypt_text
+
+crypto_command = typer.Typer(help="Encryption / Decryption utilities")
+
+
+@crypto_command.command("encrypt")
+def encrypt_cmd(value: str):
+    """Encrypt a plain text string."""
+    encrypted = encrypt_text(value)
+    typer.secho(f"🔐 Encrypted:\n{encrypted}", fg=typer.colors.GREEN)
+
+
+@crypto_command.command("decrypt")
+def decrypt_cmd(value: str):
+    """Decrypt an encrypted token string."""
+    try:
+        decrypted = decrypt_text(value)
+        typer.secho(f"🔓 Decrypted:\n{decrypted}", fg=typer.colors.CYAN)
+    except Exception as e:
+        typer.secho(f"❌ Failed to decrypt: {e}", fg=typer.colors.RED)

{nlbone-0.6.19 → nlbone-0.6.20}/src/nlbone/interfaces/cli/main.py

@@ -4,11 +4,13 @@ import typer
 
 from nlbone.adapters.db import init_sync_engine
 from nlbone.config.settings import get_settings
+from nlbone.interfaces.cli.crypto import crypto_command
 from nlbone.interfaces.cli.init_db import init_db_command
 
 app = typer.Typer(help="NLBone CLI")
 
 app.add_typer(init_db_command, name="db")
+app.add_typer(crypto_command, name="crypto")
 
 
 @app.callback()

{nlbone-0.6.19 → nlbone-0.6.20}/src/nlbone/interfaces/jobs/dispatch_outbox.py

@@ -1,6 +1,7 @@
 from nlbone.adapters.messaging.internal_router import internal_router
 from nlbone.core.ports.event_bus import IntegrationPublisher
 
+
 def run_dispatch_outbox(outbox_repo, publisher: IntegrationPublisher):
     batch = outbox_repo.fetch_pending(limit=200)
     for rec in batch:

nlbone-0.6.20/src/nlbone/utils/crypto.py

@@ -0,0 +1,29 @@
+import base64
+import hashlib
+
+from cryptography.fernet import Fernet
+
+from nlbone.config.settings import get_settings
+
+
+def _get_fernet_key() -> Fernet:
+    settings = get_settings()
+    fernet_key = settings.FERNET_KEY
+
+    if not fernet_key or not fernet_key.strip():
+        raise Exception("❌ FERNET_KEY is required in .env")
+
+    digest = hashlib.sha256(fernet_key.encode()).digest()
+
+    return base64.urlsafe_b64encode(digest)
+
+
+fernet = Fernet(_get_fernet_key())
+
+
+def encrypt_text(plaintext: str) -> str:
+    return fernet.encrypt(plaintext.encode()).decode()
+
+
+def decrypt_text(token: str) -> str:
+    return fernet.decrypt(token.encode()).decode()

nlbone-0.6.20/src/nlbone/utils/normalize_mobile.py

@@ -0,0 +1,33 @@
+import re
+from typing import List
+
+
+def normalize_mobile(mobile, strip_zero=True, add_country_code=True):
+    if not mobile:
+        return ""
+
+    mobile = re.sub(r"\D", "", str(mobile))
+
+    if mobile.startswith("0098"):
+        mobile = mobile[4:]
+    elif mobile.startswith("98") and len(mobile) > 10:
+        mobile = mobile[2:]
+
+    if strip_zero and mobile.startswith("0"):
+        mobile = mobile[1:]
+
+    if add_country_code:
+        if not mobile.startswith("98"):
+            mobile = f"98{mobile}"
+
+    return mobile
+
+
+def remove_duplicates(items: List[str]) -> List[str]:
+    seen = set()
+    out = []
+    for x in items:
+        if x and x not in seen:
+            seen.add(x)
+            out.append(x)
+    return out

nlbone-0.6.19/src/nlbone/core/application/command_bus.py

@@ -1,25 +0,0 @@
-from dataclasses import dataclass
-from typing import Protocol, Type, Any, Dict
-
-
-@dataclass(frozen=True)
-class Command:
-    pass
-
-
-class CommandHandler(Protocol):
-    def __call__(self, command: Command) -> Any: ...
-
-
-class CommandBus:
-    def __init__(self) -> None:
-        self._handlers: Dict[Type[Command], CommandHandler] = {}
-
-    def register(self, cmd_type: Type[Command], handler: CommandHandler) -> None:
-        self._handlers[cmd_type] = handler
-
-    def dispatch(self, command: Command) -> Any:
-        handler = self._handlers.get(type(command))
-        if handler is None:
-            raise LookupError(f"No handler registered for {type(command).__name__}")
-        return handler(command)