feat: ➖ Remove pydantic

Co-authored-by: remimd <[email protected]>

Author: remimd

cq/__init__.py

@@ -1,13 +1,11 @@
 from ._core.dispatcher.bus import Bus
 from ._core.dispatcher.pipe import Pipe
-from ._core.dto import DTO
 from ._core.message import (
     AnyCommandBus,
     Command,
     CommandBus,
     Event,
     EventBus,
-    Message,
     Query,
     QueryBus,
     command_handler,
@@ -27,10 +25,8 @@
     "CQScope",
     "Command",
     "CommandBus",
-    "DTO",
     "Event",
     "EventBus",
-    "Message",
     "Middleware",
     "MiddlewareResult",
     "Pipe",

cq/_core/dto.py

@@ -1,10 +1,8 @@
-from abc import ABC
 from typing import Any
 
 import injection
 
 from cq._core.dispatcher.bus import Bus, SimpleBus, TaskBus
-from cq._core.dto import DTO
 from cq._core.handler import (
     HandlerDecorator,
     MultipleHandlerManager,
@@ -13,22 +11,9 @@
 from cq._core.scope import CQScope
 from cq.middlewares.scope import InjectionScopeMiddleware
 
-
-class Message(DTO, ABC):
-    __slots__ = ()
-
-
-class Command(Message, ABC):
-    __slots__ = ()
-
-
-class Event(Message, ABC):
-    __slots__ = ()
-
-
-class Query(Message, ABC):
-    __slots__ = ()
-
+Command = object
+Event = object
+Query = object
 
 type CommandBus[T] = Bus[Command, T]
 type EventBus = Bus[Event, None]

cq/_core/message.py

@@ -20,7 +20,7 @@ def add(self, *events: Event) -> None:
 
 
 @dataclass(repr=False, eq=False, frozen=True, slots=True)
-class _RelatedEvents(RelatedEvents):
+class SimpleRelatedEvents(RelatedEvents):
     items: list[Event] = field(default_factory=list)
 
     def add(self, *events: Event) -> None:
@@ -29,7 +29,7 @@ def add(self, *events: Event) -> None:
 
 @injection.scoped(CQScope.ON_COMMAND, mode="fallback")
 async def related_events_recipe(event_bus: EventBus) -> AsyncIterator[RelatedEvents]:
-    yield (instance := _RelatedEvents())
+    yield (instance := SimpleRelatedEvents())
     events = instance.items
 
     if not events:

cq/_core/related_events.py

@@ -5,7 +5,8 @@ The advantage of `python-cq` is that it can be easily integrated into FastAPI.
 Here's an example of its integration:
 
 ```python
-from cq import Command, CommandBus, DTO, command_handler, new_command_bus
+import msgspec
+from cq import CommandBus, command_handler, new_command_bus
 from fastapi import FastAPI, status
 from injection import injectable, singleton
 from injection.integrations.fastapi import Inject
@@ -23,16 +24,16 @@ def override_command_bus_recipe() -> CommandBus:
 
 # ----- Command Definition -----
 
-class ExampleCommand(Command): ...
+class ExampleCommand(msgspec.Struct, frozen=True): ...
 
-class HandlerReturnType(DTO): ...
+class ExampleReturnType(msgspec.Struct, frozen=True): ...
 
 @command_handler(ExampleCommand)
 class ExampleHandler:
     def __init__(self, service: ExampleService) -> None:
         self.service = service
 
-    async def handle(self, command: ExampleCommand) -> HandlerReturnType: ...
+    async def handle(self, command: ExampleCommand) -> ExampleReturnType: ...
 
 # ----- FastAPI Setup -----
 
@@ -43,7 +44,8 @@ app = FastAPI()
 @app.post("/example", status_code=status.HTTP_204_NO_CONTENT)
 async def example(
     command: ExampleCommand,
-    command_bus: CommandBus[HandlerReturnType] = Inject(CommandBus),
+    command_bus: CommandBus[ExampleReturnType] = Inject(CommandBus),
 ) -> None:
     result = await command_bus.dispatch(command)
+    # ...
 ```

documentation/fastapi-example.md

@@ -2,42 +2,29 @@
 
 Set of tools to simplify application logic writing.
 
-* [Data Transfer Object (DTO)](#data-transfer-object-dto)
 * [Reading](#reading)
 * [Writing](#writing)
 * [Side effects](#side-effects)
 * [Bus Middleware](#bus-middleware)
 
-## Data Transfer Object (DTO)
-
-The idea is to have one DTO to enter the application layer and another to exit when needed.
-A DTO is a subclass of [Pydantic BaseModel](https://docs.pydantic.dev/latest/), so it contains all these properties.
-
-```python
-from cq import DTO
-
-class MyAwesomeDTO(DTO):
-    my_awesome_value: str
-```
-
 ## Reading
 
 ### Define a query
 
 The purpose of a query is to read data.
-The `Query` class is a subclass of DTO.
 
 The `query_handler` decorator associates a query type with a particular logic (handler).
 Only one handler can be associated with a query type.
 All handler dependencies are injected at runtime using [python-injection](https://github.com/100nm/python-injection).
 
 ```python
-from cq import DTO, Query, query_handler
+import msgspec
+from cq import query_handler
 
-class UserProfileView(DTO):
+class UserProfileView:
     """ Data to retrieve """
 
-class ReadUserProfileQuery(Query):
+class ReadUserProfileQuery(msgspec.Struct, frozen=True):
     user_id: int
 
 @query_handler(ReadUserProfileQuery)
@@ -69,16 +56,15 @@ async def get_user_profile_1(query_bus: QueryBus[UserProfileView]) -> UserProfil
 ### Define a command
 
 The purpose of a command is to write data.
-The `Command` class is a subclass of DTO.
 
 The `command_handler` decorator associates a command type with a particular logic (handler).
 Only one handler can be associated with a command type.
 All handler dependencies are injected at runtime using [python-injection](https://github.com/100nm/python-injection).
 
 ```python
-from cq import Command, command_handler
+from cq import command_handler
 
-class UpdateUserProfileCommand(Command):
+class UpdateUserProfileCommand:
     """ Data required to update user profile """
 
 @command_handler(UpdateUserProfileCommand)
@@ -110,16 +96,15 @@ async def update_user_profile(command_bus: CommandBus[None]) -> None:
 
 The purpose of an event is to execute side effects.
 An event is generally propagated at the end of a command.
-The `Event` class is a subclass of DTO.
 
 The `event_handler` decorator associates a event type with a particular logic (handler).
 Several handlers can be associated with an event type.
 All handler dependencies are injected at runtime using [python-injection](https://github.com/100nm/python-injection).
 
 ```python
-from cq import Event, event_handler
+from cq import event_handler
 
-class UserRegistered(Event):
+class UserRegistered:
     """ Data to process the event """
 
 @event_handler(UserRegistered)
@@ -133,9 +118,9 @@ class SendConfirmationEmailHandler:
 To propagate an event, it must be transmitted to `RelatedEvents` instance.
 
 ```python
-from cq import Command, RelatedEvents, command_handler
+from cq import RelatedEvents, command_handler
 
-class UserRegistrationCommand(Command):
+class UserRegistrationCommand:
     """ Data required to register a user """
 
 @command_handler(UserRegistrationCommand)

documentation/writing-application-layer.md

@@ -10,6 +10,7 @@ dev = [
 ]
 example = [
     "fastapi",
+    "msgspec",
 ]
 test = [
     "pytest",
@@ -41,7 +42,6 @@ classifiers = [
 ]
 dependencies = [
     "anyio",
-    "pydantic (>=2, <3)",
     "python-injection",
 ]
 
@@ -71,15 +71,9 @@ disallow_subclassing_any = true
 disallow_untyped_defs = true
 follow_imports = "silent"
 no_implicit_reexport = true
-plugins = ["pydantic.mypy"]
 warn_redundant_casts = true
 warn_unused_ignores = true
 
-[tool.pydantic-mypy]
-init_forbid_extra = true
-init_typed = true
-warn_required_dynamic_aliases = true
-
 [tool.pytest.ini_options]
 python_files = "test_*.py"
 addopts = "--tb short --cov ./ --cov-report term-missing:skip-covered"

pyproject.toml

@@ -1,13 +1,6 @@
 from injection import find_instance
 
-from cq import (
-    AnyCommandBus,
-    Command,
-    Event,
-    RelatedEvents,
-    command_handler,
-    event_handler,
-)
+from cq import AnyCommandBus, RelatedEvents, command_handler, event_handler
 from tests.helpers.history import HistoryMiddleware
 
 
@@ -16,13 +9,13 @@ async def test_dispatch_with_related_events(
         self,
         history: HistoryMiddleware,
     ) -> None:
-        class _Event(Event): ...
+        class _Event: ...
 
         @event_handler(_Event)
         class _EventHandler:
             async def handle(self, event: _Event) -> None: ...
 
-        class _Command(Command): ...
+        class _Command: ...
 
         @command_handler(_Command)
         class _CommandHandler: