BREAKING CHANGE: rename decorators and create isolated modules

tests/log/axioma/log.py

@@ -2,8 +2,7 @@
 from dataclasses import dataclass
 from typing import TypeAlias
 
-from turbobus.bus import Command, CommandHandler
-from turbobus.decorators import command
+from turbobus.command import Command, CommandHandler
 
 
 LogHandlerType: TypeAlias = "ILogHandler"
@@ -13,12 +12,12 @@ class LogCommand(Command[LogHandlerType]):
 
     content: str
 
-class ILogHandler(CommandHandler[str]):
+class ILogHandler(CommandHandler[LogCommand, str]):
 
     ...
 
 class ILogger(ABC):
 
     @abstractmethod
     def logger(self, text: str) -> None:
-        ...
+        ...

tests/log/capabilities/log.py

@@ -1,16 +1,15 @@
 from dataclasses import dataclass
-from turbobus.decorators import command, injecting
+from turbobus.injection import inject
+from turbobus.command import handler_of
 from ..axioma.log import ILogHandler, ILogger, LogCommand
 
 
-@command(LogCommand)
+@handler_of(LogCommand)
 @dataclass(kw_only=True)
 class LogHandler(ILogHandler):
 
-    dependency = injecting(ILogger)
+    dependency = inject(ILogger)
 
     def execute(self, cmd: LogCommand) -> str:
-        if self.dependency is not None:
-            self.dependency.logger(cmd.content)
-
+        self.dependency.logger(cmd.content)
         return cmd.content

tests/log/capabilities/logger.py

@@ -1,8 +1,8 @@
-from turbobus.decorators import injectable
+from turbobus.injection import injectable_of
 from log.axioma.log import ILogger
 
 
-@injectable(ILogger)
+@injectable_of(ILogger)
 class Logger:
 
     def logger(self, text: str):

tests/main.py

@@ -0,0 +1,9 @@
+from turbobus.bus import CommandBus
+
+from log.axioma import LogCommand
+
+bus = CommandBus()
+
+result = bus.execute(
+    LogCommand('Hello world')
+)

turbobus/__init__.py

@@ -1,3 +1,5 @@
+from .constants import *
+from .command import *
+from .injection import *
+from .exception import *
 from .bus import *
-from .decorators import *
-from .exception import *

turbobus/bus.py

@@ -1,32 +1,15 @@
-from abc import abstractmethod, ABC
-from typing import Any, Generic, TypeAlias, TypeVar
+from typing import Any, TypeVar
 
-CommandHandlerType: TypeAlias = 'CommandHandler'
-HandlerType = TypeVar('HandlerType', bound=CommandHandlerType, covariant=True)
-ReturnType = TypeVar('ReturnType')
-
-class Command(ABC, Generic[HandlerType]):
-
-    __handler__: type[HandlerType]
-
-
-class CommandHandler(ABC, Generic[ReturnType, ]):
-
-    def __init__(self, ) -> None:
-        super().__init__()
-
-    @abstractmethod
-    def execute(self, cmd: Command[HandlerType]) -> ReturnType:
-        ...
+from .exception import CommandHandlerDoesNotExistException
 
+ReturnType = TypeVar('ReturnType')
 
 class CommandBus:
 
     def execute(self, cmd, providers: dict[Any, Any] = {}):
         Handler = cmd.__handler__
 
         if Handler is None:
-            from turbobus.exception import CommandHandlerDoesNotExistException
             raise CommandHandlerDoesNotExistException()
 
         result = Handler(**providers).execute(cmd)

turbobus/command.py

@@ -0,0 +1,33 @@
+from abc import abstractmethod, ABC
+from typing import Generic, TypeAlias, TypeVar
+from .constants import providers
+
+CommandHandlerType: TypeAlias = 'CommandHandler'
+HandlerType = TypeVar('HandlerType', bound=CommandHandlerType, covariant=True)
+ReturnType = TypeVar('ReturnType')
+
+class Command(ABC, Generic[HandlerType]):
+
+    __handler__: type[HandlerType]
+
+
+CommandType = TypeVar('CommandType', bound=Command)
+class CommandHandler(ABC, Generic[CommandType, ReturnType]):
+
+    def __init__(self, ) -> None:
+        super().__init__()
+
+    @abstractmethod
+    def execute(self, cmd: CommandType) -> ReturnType:
+        ...
+
+
+def handler_of(commandClass, injectable: type | None = None):
+    def wrapper(handlerClass):
+        if injectable is not None:
+            providers.__setitem__(injectable.__name__, handlerClass)
+
+        commandClass.__handler__ = handlerClass
+        return handlerClass
+
+    return wrapper

turbobus/constants.py

@@ -0,0 +1 @@
+providers = {}

turbobus/injection.py

@@ -0,0 +1,21 @@
+from typing import TypeVar
+from .constants import providers
+
+
+T = TypeVar('T')
+
+
+def injectable_of(to: type):
+    def wrapper(cls):
+        providers.__setitem__(to.__name__, cls)
+        return cls
+
+    return wrapper
+
+
+def inject(cls: type[T]) -> T:
+    Provider = providers.get(cls.__name__)
+
+    assert Provider is not None
+
+    return Provider()