buz 2.15.10rc6__py3-none-any.whl → 2.15.12__py3-none-any.whl

buz/command/asynchronous/base_command_handler.py

@@ -1,27 +1,34 @@
-from typing import Type, get_type_hints, Any
+from typing import Generic, Type, TypeVar, cast, get_type_hints, Any
 
 from buz.command import Command
 from buz.command.asynchronous.command_handler import CommandHandler
 
+TCommand = TypeVar("TCommand", bound=Command)
 
-class BaseCommandHandler(CommandHandler):
+
+class BaseCommandHandler(Generic[TCommand], CommandHandler[TCommand]):
     @classmethod
     def fqn(cls) -> str:
         return f"command_handler.{cls.__module__}.{cls.__name__}"
 
     @classmethod
-    def handles(cls) -> Type[Command]:
+    def handles(cls) -> Type[TCommand]:
         handle_types = get_type_hints(cls.handle)
 
-        if "command" not in handle_types:
+        t_command = handle_types.get("command")
+        if t_command is None:
             raise TypeError(
                 f"The method 'handle' in '{cls.fqn()}' doesn't have a parameter named 'command'. Found parameters: {cls.__get_method_parameter_names(handle_types)}"
             )
 
-        if not issubclass(handle_types["command"], Command):
+        # TypeVar mask the actual bound type
+        if hasattr(t_command, "__bound__"):
+            t_command = t_command.__bound__
+
+        if not issubclass(t_command, Command):
             raise TypeError(f"The parameter 'command' in '{cls.fqn()}.handle' is not a 'buz.command.Command' subclass")
 
-        return handle_types["command"]
+        return cast(Type[TCommand], t_command)
 
     @classmethod
     def __get_method_parameter_names(cls, handle_types: dict[str, Any]) -> list[str]:

buz/command/asynchronous/command_handler.py

@@ -1,16 +1,19 @@
-from abc import abstractmethod
-from typing import Type
+from abc import ABC, abstractmethod
+from typing import Generic, Type, TypeVar
 
 from buz import Handler
 from buz.command.command import Command
 
 
-class CommandHandler(Handler):
+TCommand = TypeVar("TCommand", bound=Command)
+
+
+class CommandHandler(Generic[TCommand], Handler[TCommand], ABC):
     @classmethod
     @abstractmethod
-    def handles(cls) -> Type[Command]:
+    def handles(cls) -> Type[TCommand]:
         pass
 
     @abstractmethod
-    async def handle(self, command: Command) -> None:
+    async def handle(self, command: TCommand) -> None:
         pass

buz/command/synchronous/base_command_handler.py

@@ -1,27 +1,35 @@
-from typing import Type, get_type_hints, Any
+from typing import Generic, Type, TypeVar, get_type_hints, Any, cast
 
 from buz.command import Command
 from buz.command.synchronous.command_handler import CommandHandler
 
 
-class BaseCommandHandler(CommandHandler):
+TCommand = TypeVar("TCommand", bound=Command)
+
+
+class BaseCommandHandler(Generic[TCommand], CommandHandler[TCommand]):
     @classmethod
     def fqn(cls) -> str:
         return f"command_handler.{cls.__module__}.{cls.__name__}"
 
     @classmethod
-    def handles(cls) -> Type[Command]:
+    def handles(cls) -> Type[TCommand]:
         handle_types = get_type_hints(cls.handle)
 
-        if "command" not in handle_types:
+        t_command = handle_types.get("command")
+        if t_command is None:
             raise TypeError(
                 f"The method 'handle' in '{cls.fqn()}' doesn't have a parameter named 'command'. Found parameters: {cls.__get_method_parameter_names(handle_types)}"
             )
 
-        if not issubclass(handle_types["command"], Command):
+        # TypeVar mask the actual bound type
+        if hasattr(t_command, "__bound__"):
+            t_command = t_command.__bound__
+
+        if not issubclass(t_command, Command):
             raise TypeError(f"The parameter 'command' in '{cls.fqn()}.handle' is not a 'buz.command.Command' subclass")
 
-        return handle_types["command"]
+        return cast(Type[TCommand], t_command)
 
     @classmethod
     def __get_method_parameter_names(cls, handle_types: dict[str, Any]) -> list[str]:

buz/command/synchronous/command_handler.py

@@ -1,16 +1,18 @@
-from abc import abstractmethod
-from typing import Type
+from abc import ABC, abstractmethod
+from typing import Generic, Type, TypeVar
 
 from buz import Handler
 from buz.command import Command
 
+TCommand = TypeVar("TCommand", bound=Command)
 
-class CommandHandler(Handler):
+
+class CommandHandler(Generic[TCommand], Handler[TCommand], ABC):
     @classmethod
     @abstractmethod
-    def handles(cls) -> Type[Command]:
+    def handles(cls) -> Type[TCommand]:
         pass
 
     @abstractmethod
-    def handle(self, command: Command) -> None:
+    def handle(self, command: TCommand) -> None:
         pass

buz/event/infrastructure/buz_kafka/kafka_event_async_subscriber_executor.py

@@ -8,6 +8,7 @@ from buz.event.infrastructure.buz_kafka.consume_strategy.kafka_on_fail_strategy
 from buz.event.infrastructure.buz_kafka.exceptions.max_consumer_retry_exception import MaxConsumerRetryException
 from buz.event.infrastructure.buz_kafka.exceptions.retry_exception import ConsumerRetryException
 from buz.event.infrastructure.buz_kafka.kafka_event_subscriber_executor import KafkaEventSubscriberExecutor
+from buz.event.infrastructure.models.execution_context import ExecutionContext
 from buz.event.middleware.async_consume_middleware import AsyncConsumeMiddleware
 from buz.event.middleware.async_consume_middleware_chain_resolver import AsyncConsumeMiddlewareChainResolver
 from buz.event.strategies.retry.consume_retrier import ConsumeRetrier
@@ -15,6 +16,7 @@ from buz.event.strategies.retry.reject_callback import RejectCallback
 from buz.kafka.domain.exceptions.not_valid_kafka_message_exception import NotValidKafkaMessageException
 from buz.kafka.domain.models.kafka_consumer_record import KafkaConsumerRecord
 from buz.kafka.domain.models.kafka_poll_record import KafkaPollRecord
+from buz.event.infrastructure.buz_kafka.models.kafka_delivery_context import KafkaDeliveryContext
 from buz.kafka.infrastructure.deserializers.byte_deserializer import ByteDeserializer
 from buz.kafka.infrastructure.serializers.kafka_header_serializer import KafkaHeaderSerializer
 
@@ -67,18 +69,33 @@ class KafkaEventAsyncSubscriberExecutor(KafkaEventSubscriberExecutor):
                     value=deserialized_value,
                     headers=self.__header_deserializer.deserialize(kafka_poll_record.headers),
                 ),
+                ExecutionContext(
+                    delivery_context=KafkaDeliveryContext(
+                        topic=kafka_poll_record.topic,
+                        consumer_group=self.__subscriber.fqn(),
+                        partition=kafka_poll_record.partition,
+                        timestamp=kafka_poll_record.timestamp,
+                    )
+                ),
             )
         except NotValidKafkaMessageException:
             self.__logger.error(
                 f'The message "{str(kafka_poll_record.value)}" is not valid, it will be consumed but not processed'
             )
 
-    async def __consumption_callback(self, subscriber: AsyncSubscriber, message: KafkaConsumerRecord[Event]) -> None:
+    async def __consumption_callback(
+        self, subscriber: AsyncSubscriber, message: KafkaConsumerRecord[Event], execution_context: ExecutionContext
+    ) -> None:
         await self.__consume_middleware_chain_resolver.resolve(
-            event=message.value, subscriber=subscriber, consume=self.__perform_consume
+            event=message.value,
+            subscriber=subscriber,
+            execution_context=execution_context,
+            consume=self.__perform_consume,
         )
 
-    async def __perform_consume(self, event: Event, subscriber: AsyncSubscriber) -> None:
+    async def __perform_consume(
+        self, event: Event, subscriber: AsyncSubscriber, execution_context: ExecutionContext
+    ) -> None:
         number_of_executions = 0
         should_retry = True
 

buz/event/infrastructure/buz_kafka/kafka_event_sync_subscriber_executor.py

@@ -7,6 +7,8 @@ from buz.event.infrastructure.buz_kafka.consume_strategy.kafka_on_fail_strategy
 from buz.event.infrastructure.buz_kafka.exceptions.max_consumer_retry_exception import MaxConsumerRetryException
 from buz.event.infrastructure.buz_kafka.exceptions.retry_exception import ConsumerRetryException
 from buz.event.infrastructure.buz_kafka.kafka_event_subscriber_executor import KafkaEventSubscriberExecutor
+from buz.event.infrastructure.buz_kafka.models.kafka_delivery_context import KafkaDeliveryContext
+from buz.event.infrastructure.models.execution_context import ExecutionContext
 from buz.event.middleware.consume_middleware import ConsumeMiddleware
 from buz.event.middleware.consume_middleware_chain_resolver import ConsumeMiddlewareChainResolver
 from buz.event.strategies.retry.consume_retrier import ConsumeRetrier
@@ -64,11 +66,19 @@ class KafkaEventSyncSubscriberExecutor(KafkaEventSubscriberExecutor):
             await get_running_loop().run_in_executor(
                 None,
                 lambda: self.__execution_callback(
-                    self.__subscriber,
-                    KafkaConsumerRecord(
+                    subscriber=self.__subscriber,
+                    message=KafkaConsumerRecord(
                         value=deserialized_value,
                         headers=self.__header_deserializer.deserialize(kafka_poll_record.headers),
                     ),
+                    execution_context=ExecutionContext(
+                        delivery_context=KafkaDeliveryContext(
+                            topic=kafka_poll_record.topic,
+                            consumer_group=self.__subscriber.fqn(),
+                            partition=kafka_poll_record.partition,
+                            timestamp=kafka_poll_record.timestamp,
+                        )
+                    ),
                 ),
             )
 
@@ -77,12 +87,17 @@ class KafkaEventSyncSubscriberExecutor(KafkaEventSubscriberExecutor):
                 f'The message "{str(kafka_poll_record.value)}" is not valid, it will be consumed but not processed'
             )
 
-    def __execution_callback(self, subscriber: Subscriber, message: KafkaConsumerRecord[Event]) -> None:
+    def __execution_callback(
+        self, subscriber: Subscriber, message: KafkaConsumerRecord[Event], execution_context: ExecutionContext
+    ) -> None:
         self.__consume_middleware_chain_resolver.resolve(
-            event=message.value, subscriber=subscriber, consume=self.__perform_consume
+            event=message.value,
+            subscriber=subscriber,
+            execution_context=execution_context,
+            consume=self.__perform_consume,
         )
 
-    def __perform_consume(self, event: Event, subscriber: Subscriber) -> None:
+    def __perform_consume(self, event: Event, subscriber: Subscriber, execution_context: ExecutionContext) -> None:
         number_of_executions = 0
         should_retry = True
 

buz/event/infrastructure/buz_kafka/models/kafka_delivery_context.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass
+from buz.event.infrastructure.models.delivery_context import DeliveryContext
+
+
+@dataclass(frozen=True)
+class KafkaDeliveryContext(DeliveryContext):
+    topic: str
+    consumer_group: str
+    partition: int
+    timestamp: int

buz/event/infrastructure/kombu/kombu_consumer.py

@@ -2,6 +2,8 @@ import asyncio
 from logging import Logger
 from typing import Optional, Callable, cast
 
+from buz.event.infrastructure.kombu.models.kombu_delivery_context import KombuDeliveryContext
+from buz.event.infrastructure.models.execution_context import ExecutionContext
 from kombu import Connection, Queue, Consumer as MessageConsumer, Message
 from kombu.mixins import ConsumerMixin
 from kombu.transport.pyamqp import Channel
@@ -110,12 +112,18 @@ class KombuConsumer(ConsumerMixin, Consumer):
                 # The problem here is that the chain resolver works with syncsubscribers, an asyncsubscriber would require of a async function,
                 # but we are using run-until-complete to run the async function, so we are not really using the async function, we are just running it as a sync function, so we can cast the asyncsubscriber to a subscriber
                 subscriber = cast(Subscriber, meta_subscriber)
-                self.__consume_middleware_chain_resolver.resolve(event, subscriber, self.__perform_consume)
+                execution_context = ExecutionContext(delivery_context=KombuDeliveryContext())
+                self.__consume_middleware_chain_resolver.resolve(
+                    event=event,
+                    subscriber=subscriber,
+                    execution_context=execution_context,
+                    consume=self.__perform_consume,
+                )
             message.ack()
         except Exception as exc:
             self.__on_consume_exception(message, event, meta_subscribers, exc)
 
-    def __perform_consume(self, event: Event, subscriber: MetaSubscriber) -> None:
+    def __perform_consume(self, event: Event, subscriber: MetaSubscriber, execution_context: ExecutionContext) -> None:
         if isinstance(subscriber, AsyncSubscriber):
             self.__get_or_create_event_loop().run_until_complete(subscriber.consume(event))
             return

buz/event/infrastructure/kombu/models/kombu_delivery_context.py

@@ -0,0 +1,7 @@
+from dataclasses import dataclass
+from buz.event.infrastructure.models.delivery_context import DeliveryContext
+
+
+@dataclass(frozen=True)
+class KombuDeliveryContext(DeliveryContext):
+    pass

buz/event/infrastructure/models/delivery_context.py

@@ -0,0 +1,6 @@
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class DeliveryContext:
+    pass

buz/event/infrastructure/models/execution_context.py

@@ -0,0 +1,8 @@
+from dataclasses import dataclass
+
+from buz.event.infrastructure.models.delivery_context import DeliveryContext
+
+
+@dataclass(frozen=True)
+class ExecutionContext:
+    delivery_context: DeliveryContext

buz/event/middleware/async_consume_middleware.py

@@ -3,12 +3,19 @@ from typing import Awaitable, Callable
 
 from buz.event import Event
 from buz.event.async_subscriber import AsyncSubscriber
+from buz.event.infrastructure.models.execution_context import ExecutionContext
 from buz.middleware import Middleware
 
-AsyncConsumeCallable = Callable[[Event, AsyncSubscriber], Awaitable[None]]
+AsyncConsumeCallable = Callable[[Event, AsyncSubscriber, ExecutionContext], Awaitable[None]]
 
 
 class AsyncConsumeMiddleware(Middleware):
     @abstractmethod
-    async def on_consume(self, event: Event, subscriber: AsyncSubscriber, consume: AsyncConsumeCallable) -> None:
+    async def on_consume(
+        self,
+        event: Event,
+        subscriber: AsyncSubscriber,
+        consume: AsyncConsumeCallable,
+        execution_context: ExecutionContext,
+    ) -> None:
         pass

buz/event/middleware/async_consume_middleware_chain_resolver.py

@@ -2,6 +2,7 @@ from typing import Sequence
 from buz.event import Event
 from buz.event.async_subscriber import AsyncSubscriber
 
+from buz.event.infrastructure.models.execution_context import ExecutionContext
 from buz.event.middleware.async_consume_middleware import AsyncConsumeCallable, AsyncConsumeMiddleware
 from buz.middleware import MiddlewareChainBuilder
 
@@ -14,16 +15,26 @@ class AsyncConsumeMiddlewareChainResolver:
         self.__middlewares = middlewares
         self.__middleware_chain_builder: MiddlewareChainBuilder[
             AsyncConsumeCallable, AsyncConsumeMiddleware
-        ] = MiddlewareChainBuilder(middlewares)
+        ] = MiddlewareChainBuilder(self.__middlewares)
 
-    async def resolve(self, event: Event, subscriber: AsyncSubscriber, consume: AsyncConsumeCallable) -> None:
+    async def resolve(
+        self,
+        event: Event,
+        subscriber: AsyncSubscriber,
+        consume: AsyncConsumeCallable,
+        execution_context: ExecutionContext,
+    ) -> None:
         chain_callable: AsyncConsumeCallable = self.__middleware_chain_builder.get_chain_callable(
             consume, self.__get_middleware_callable
         )
 
-        await chain_callable(event, subscriber)
+        await chain_callable(event, subscriber, execution_context)
 
     def __get_middleware_callable(
-        self, middleware: AsyncConsumeMiddleware, consume_callable: AsyncConsumeCallable
+        self,
+        middleware: AsyncConsumeMiddleware,
+        consume_callable: AsyncConsumeCallable,
     ) -> AsyncConsumeCallable:
-        return lambda event, subscriber: middleware.on_consume(event, subscriber, consume_callable)
+        return lambda event, subscriber, execution_context: middleware.on_consume(
+            event, subscriber, consume_callable, execution_context
+        )

buz/event/middleware/base_async_consume_middleware.py

@@ -2,19 +2,36 @@ from abc import abstractmethod
 
 from buz.event import Event
 from buz.event.async_subscriber import AsyncSubscriber
+from buz.event.infrastructure.models.execution_context import ExecutionContext
 from buz.event.middleware.async_consume_middleware import AsyncConsumeMiddleware, AsyncConsumeCallable
 
 
 class BaseAsyncConsumeMiddleware(AsyncConsumeMiddleware):
-    async def on_consume(self, event: Event, subscriber: AsyncSubscriber, consume: AsyncConsumeCallable) -> None:
-        await self._before_on_consume(event, subscriber)
-        await consume(event, subscriber)
-        await self._after_on_consume(event, subscriber)
+    async def on_consume(
+        self,
+        event: Event,
+        subscriber: AsyncSubscriber,
+        consume: AsyncConsumeCallable,
+        execution_context: ExecutionContext,
+    ) -> None:
+        await self._before_on_consume(event, subscriber, execution_context)
+        await consume(event, subscriber, execution_context)
+        await self._after_on_consume(event, subscriber, execution_context)
 
     @abstractmethod
-    async def _before_on_consume(self, event: Event, subscriber: AsyncSubscriber) -> None:
+    async def _before_on_consume(
+        self,
+        event: Event,
+        subscriber: AsyncSubscriber,
+        execution_context: ExecutionContext,
+    ) -> None:
         pass
 
     @abstractmethod
-    async def _after_on_consume(self, event: Event, subscriber: AsyncSubscriber) -> None:
+    async def _after_on_consume(
+        self,
+        event: Event,
+        subscriber: AsyncSubscriber,
+        execution_context: ExecutionContext,
+    ) -> None:
         pass

buz/event/middleware/base_consume_middleware.py

@@ -1,19 +1,22 @@
 from abc import abstractmethod
 
 from buz.event import Event, Subscriber
+from buz.event.infrastructure.models.execution_context import ExecutionContext
 from buz.event.middleware import ConsumeMiddleware, ConsumeCallable
 
 
 class BaseConsumeMiddleware(ConsumeMiddleware):
-    def on_consume(self, event: Event, subscriber: Subscriber, consume: ConsumeCallable) -> None:
-        self._before_on_consume(event, subscriber)
-        consume(event, subscriber)
-        self._after_on_consume(event, subscriber)
+    def on_consume(
+        self, event: Event, subscriber: Subscriber, consume: ConsumeCallable, execution_context: ExecutionContext
+    ) -> None:
+        self._before_on_consume(event, subscriber, execution_context)
+        consume(event, subscriber, execution_context)
+        self._after_on_consume(event, subscriber, execution_context)
 
     @abstractmethod
-    def _before_on_consume(self, event: Event, subscriber: Subscriber) -> None:
+    def _before_on_consume(self, event: Event, subscriber: Subscriber, execution_context: ExecutionContext) -> None:
         pass
 
     @abstractmethod
-    def _after_on_consume(self, event: Event, subscriber: Subscriber) -> None:
+    def _after_on_consume(self, event: Event, subscriber: Subscriber, execution_context: ExecutionContext) -> None:
         pass

buz/event/middleware/consume_middleware.py

@@ -2,12 +2,15 @@ from abc import abstractmethod
 from typing import Callable
 
 from buz.event import Event, Subscriber
+from buz.event.infrastructure.models.execution_context import ExecutionContext
 from buz.middleware import Middleware
 
-ConsumeCallable = Callable[[Event, Subscriber], None]
+ConsumeCallable = Callable[[Event, Subscriber, ExecutionContext], None]
 
 
 class ConsumeMiddleware(Middleware):
     @abstractmethod
-    def on_consume(self, event: Event, subscriber: Subscriber, consume: ConsumeCallable) -> None:
+    def on_consume(
+        self, event: Event, subscriber: Subscriber, consume: ConsumeCallable, execution_context: ExecutionContext
+    ) -> None:
         pass

buz/event/middleware/consume_middleware_chain_resolver.py

@@ -1,5 +1,6 @@
 from typing import Sequence
 from buz.event import Event, Subscriber
+from buz.event.infrastructure.models.execution_context import ExecutionContext
 from buz.event.middleware import ConsumeMiddleware, ConsumeCallable
 from buz.middleware import MiddlewareChainBuilder
 
@@ -9,15 +10,23 @@ class ConsumeMiddlewareChainResolver:
         self.__middlewares = middlewares
         self.__middleware_chain_builder: MiddlewareChainBuilder[
             ConsumeCallable, ConsumeMiddleware
-        ] = MiddlewareChainBuilder(middlewares)
+        ] = MiddlewareChainBuilder(self.__middlewares)
 
-    def resolve(self, event: Event, subscriber: Subscriber, consume: ConsumeCallable) -> None:
+    def resolve(
+        self,
+        event: Event,
+        subscriber: Subscriber,
+        consume: ConsumeCallable,
+        execution_context: ExecutionContext,
+    ) -> None:
         chain_callable: ConsumeCallable = self.__middleware_chain_builder.get_chain_callable(
             consume, self.__get_middleware_callable
         )
-        chain_callable(event, subscriber)
+        chain_callable(event, subscriber, execution_context)
 
     def __get_middleware_callable(
         self, middleware: ConsumeMiddleware, consume_callable: ConsumeCallable
     ) -> ConsumeCallable:
-        return lambda event, subscriber: middleware.on_consume(event, subscriber, consume_callable)
+        return lambda event, subscriber, execution_context: middleware.on_consume(
+            event, subscriber, consume_callable, execution_context
+        )

buz/event/sync/models/sync_delivery_context.py

@@ -0,0 +1,7 @@
+from dataclasses import dataclass
+from buz.event.infrastructure.models.delivery_context import DeliveryContext
+
+
+@dataclass(frozen=True)
+class SyncDeliveryContext(DeliveryContext):
+    pass

buz/event/sync/sync_event_bus.py

@@ -1,12 +1,14 @@
 from typing import Optional, Iterable
 
 from buz.event import Event, EventBus, Subscriber
+from buz.event.infrastructure.models.execution_context import ExecutionContext
 from buz.event.middleware import (
     PublishMiddleware,
     ConsumeMiddleware,
     PublishMiddlewareChainResolver,
     ConsumeMiddlewareChainResolver,
 )
+from buz.event.sync.models.sync_delivery_context import SyncDeliveryContext
 from buz.locator import Locator
 
 
@@ -26,10 +28,16 @@ class SyncEventBus(EventBus):
 
     def __perform_publish(self, event: Event) -> None:
         subscribers = self.__locator.get(event)
+        execution_context = ExecutionContext(delivery_context=SyncDeliveryContext())
         for subscriber in subscribers:
-            self.__consume_middleware_chain_resolver.resolve(event, subscriber, self.__perform_consume)
+            self.__consume_middleware_chain_resolver.resolve(
+                event=event,
+                subscriber=subscriber,
+                execution_context=execution_context,
+                consume=self.__perform_consume,
+            )
 
-    def __perform_consume(self, event: Event, subscriber: Subscriber) -> None:
+    def __perform_consume(self, event: Event, subscriber: Subscriber, execution_context: ExecutionContext) -> None:
         subscriber.consume(event)
 
     def bulk_publish(self, events: Iterable[Event]) -> None:

buz/handler.py

@@ -1,13 +1,16 @@
 from abc import ABC, abstractmethod
-from typing import Type
+from typing import Generic, Type, TypeVar
 
 from buz import Message
 
 
-class Handler(ABC):
+TMessage = TypeVar("TMessage", bound=Message)
+
+
+class Handler(Generic[TMessage], ABC):
     @classmethod
     @abstractmethod
-    def handles(cls) -> Type[Message]:
+    def handles(cls) -> Type[TMessage]:
         pass
 
     @classmethod

buz/kafka/domain/models/kafka_poll_record.py

@@ -9,6 +9,7 @@ class KafkaPollRecord:
     key: Optional[Union[str, bytes]]
     headers: list[tuple[str, bytes]]
     value: Optional[bytes]
+    timestamp: int
     partition: int
     topic: str
     offset: int

buz/query/asynchronous/base_query_handler.py

@@ -1,27 +1,36 @@
-from typing import Type, get_type_hints, Any
+from typing import Generic, Type, TypeVar, cast, get_type_hints, Any
 
 from buz.query import Query
 from buz.query.asynchronous.query_handler import QueryHandler
+from buz.query.query_response import QueryResponse
 
+TQuery = TypeVar("TQuery", bound=Query)
+TQueryResponse = TypeVar("TQueryResponse", bound=QueryResponse)
 
-class BaseQueryHandler(QueryHandler):
+
+class BaseQueryHandler(Generic[TQuery, TQueryResponse], QueryHandler[TQuery, TQueryResponse]):
     @classmethod
     def fqn(cls) -> str:
         return f"query_handler.{cls.__module__}.{cls.__name__}"
 
     @classmethod
-    def handles(cls) -> Type[Query]:
+    def handles(cls) -> Type[TQuery]:
         handle_types = get_type_hints(cls.handle)
 
-        if "query" not in handle_types:
+        t_query = handle_types.get("query")
+        if t_query is None:
             raise TypeError(
                 f"The method 'handle' in '{cls.fqn()}' doesn't have a parameter named 'query'. Found parameters: {cls.__get_method_parameter_names(handle_types)}"
             )
 
-        if not issubclass(handle_types["query"], Query):
+        # TypeVar mask the actual bound type
+        if hasattr(t_query, "__bound__"):
+            t_query = t_query.__bound__
+
+        if not issubclass(t_query, Query):
             raise TypeError(f"The parameter 'query' in '{cls.fqn()}.handle' is not a 'buz.query.Query' subclass")
 
-        return handle_types["query"]
+        return cast(Type[TQuery], t_query)
 
     @classmethod
     def __get_method_parameter_names(cls, handle_types: dict[str, Any]) -> list[str]:

buz/query/asynchronous/query_handler.py

@@ -1,16 +1,20 @@
 from abc import abstractmethod
-from typing import Type
+from typing import Generic, Type, TypeVar
 
 from buz import Handler
 from buz.query import Query, QueryResponse
 
 
-class QueryHandler(Handler):
+TQuery = TypeVar("TQuery", bound=Query)
+TQueryResponse = TypeVar("TQueryResponse", bound=QueryResponse)
+
+
+class QueryHandler(Generic[TQuery, TQueryResponse], Handler[TQuery]):
     @classmethod
     @abstractmethod
-    def handles(cls) -> Type[Query]:
+    def handles(cls) -> Type[TQuery]:
         pass
 
     @abstractmethod
-    async def handle(self, query: Query) -> QueryResponse:
+    async def handle(self, query: Query) -> TQueryResponse:
         pass