buz 2.22.0__tar.gz → 2.23.0__tar.gz

{buz-2.22.0 → buz-2.23.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: buz
-Version: 2.22.0
+Version: 2.23.0
 Summary: Buz is a set of light, simple and extensible implementations of event, command and query buses.
 License: MIT
 Author: Luis Pintado Lozano

{buz-2.22.0 → buz-2.23.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "buz"
-version = "2.22.0"
+version = "2.23.0"
 description = "Buz is a set of light, simple and extensible implementations of event, command and query buses."
 readme = "README.md"
 authors = [

{buz-2.22.0 → buz-2.23.0}/src/buz/command/synchronous/command_handler.py

@@ -3,11 +3,18 @@ from typing import Generic, Type, TypeVar
 
 from buz import Handler
 from buz.command import Command
+from buz.wrapper.async_unsafe import async_unsafe
 
 TCommand = TypeVar("TCommand", bound=Command)
 
 
 class CommandHandler(Generic[TCommand], Handler[TCommand], ABC):
+    def __new__(cls, *args, **kwargs):
+        instance = super().__new__(cls)
+        original_handle = instance.handle
+        instance.handle = async_unsafe()(original_handle)
+        return instance
+
     @classmethod
     @abstractmethod
     def handles(cls) -> Type[TCommand]:

{buz-2.22.0 → buz-2.23.0}/src/buz/event/infrastructure/buz_kafka/buz_kafka_event_bus.py

@@ -16,6 +16,8 @@ from buz.kafka.domain.models.auto_create_topic_configuration import AutoCreateTo
 from buz.kafka.domain.models.create_kafka_topic import CreateKafkaTopic
 from buz.kafka.domain.services.kafka_admin_client import KafkaAdminClient
 from buz.kafka.domain.services.kafka_producer import KafkaProducer
+from buz.kafka.infrastructure.serializers.implementations.cdc_partition_key_serializer import CDCPartitionKeySerializer
+from buz.kafka.infrastructure.serializers.partitiion_key_generator import PartitionKeySerializer
 
 
 class BuzKafkaEventBus(EventBus):
@@ -28,6 +30,7 @@ class BuzKafkaEventBus(EventBus):
         kafka_admin_client: Optional[KafkaAdminClient] = None,
         publish_middlewares: Optional[list[PublishMiddleware]] = None,
         auto_create_topic_configuration: Optional[AutoCreateTopicConfiguration] = None,
+        partition_key_generator: Optional[PartitionKeySerializer] = None,
     ):
         self.__publish_middleware_chain_resolver = PublishMiddlewareChainResolver(publish_middlewares or [])
         self.__publish_strategy = publish_strategy
@@ -36,6 +39,7 @@ class BuzKafkaEventBus(EventBus):
         self.__kafka_admin_client = kafka_admin_client
         self.__auto_create_topic_configuration = auto_create_topic_configuration
         self.__logger = logger
+        self.__partition_key_generator: PartitionKeySerializer = partition_key_generator or CDCPartitionKeySerializer()
         self.__check_kafka_admin_client_is_needed()
 
     def __check_kafka_admin_client_is_needed(self) -> None:
@@ -74,7 +78,7 @@ class BuzKafkaEventBus(EventBus):
                 message=event,
                 headers=headers,
                 topic=topic,
-                partition_key=event.partition_key(),
+                partition_key=self.__partition_key_generator.generate_key(event),
             )
         except Exception as exc:
             raise EventNotPublishedException(event) from exc

buz-2.23.0/src/buz/kafka/infrastructure/serializers/implementations/cdc_partition_key_serializer.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from buz.event.event import Event
+from buz.kafka.infrastructure.serializers.implementations.json_byte_serializer import JSONByteSerializer
+from buz.kafka.infrastructure.serializers.partitiion_key_generator import PartitionKeySerializer
+
+# This is a static string because the order matters and we can not trust that json encoder libraries are deterministic
+PAYLOAD_CDC_SCHEMA = r"""{"schema":{"type":"string","optional":true},"payload":"[partition_key]"}"""
+
+
+class CDCPartitionKeySerializer(PartitionKeySerializer):
+    def __init__(self) -> None:
+        self.__json_serializer = JSONByteSerializer()
+
+    def __generate_payload_schema(self, partition_key: str) -> str:
+        return PAYLOAD_CDC_SCHEMA.replace("[partition_key]", partition_key)
+
+    def generate_key(self, event: Event) -> str:
+        return self.__generate_payload_schema(event.partition_key())

buz-2.23.0/src/buz/kafka/infrastructure/serializers/partitiion_key_generator.py

@@ -0,0 +1,9 @@
+from abc import ABC, abstractmethod
+
+from buz.event.event import Event
+
+
+class PartitionKeySerializer(ABC):
+    @abstractmethod
+    def generate_key(self, event: Event) -> str:
+        pass

{buz-2.22.0 → buz-2.23.0}/src/buz/query/synchronous/query_handler.py

@@ -3,12 +3,19 @@ from typing import Generic, Type, TypeVar
 
 from buz import Handler
 from buz.query import Query, QueryResponse
+from buz.wrapper.async_unsafe import async_unsafe
 
 TQuery = TypeVar("TQuery", bound=Query)
 TQueryResponse = TypeVar("TQueryResponse", bound=QueryResponse)
 
 
 class QueryHandler(Generic[TQuery, TQueryResponse], Handler[TQuery], ABC):
+    def __new__(cls, *args, **kwargs):
+        instance = super().__new__(cls)
+        original_handle = instance.handle
+        instance.handle = async_unsafe()(original_handle)
+        return instance
+
     @classmethod
     @abstractmethod
     def handles(cls) -> Type[TQuery]:

buz-2.23.0/src/buz/wrapper/async_unsafe.py

@@ -0,0 +1,67 @@
+import logging
+import os
+from asyncio import get_running_loop
+from functools import wraps
+from typing import Callable, Any
+
+from buz.wrapper.synchronous_only_operation_exception import SynchronousOnlyOperationException
+
+logger = logging.getLogger(__name__)
+
+
+def async_unsafe() -> Callable[[Callable], Callable]:
+    """
+    Copy-paste from Django source code. If BUZ_SYNC_HANDLERS_FAIL_ON_ASYNC env var is True then an exception is raised to
+    prevent event loop from being blocked. If the env var is False, a warning is logged.
+    """
+
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        def inner(*args: Any, **kwargs: Any) -> Any:
+            try:
+                get_running_loop()
+            except RuntimeError:
+                pass
+            else:
+                if __get_bool_env("BUZ_SYNC_HANDLERS_FAIL_ON_ASYNC") is True:
+                    raise SynchronousOnlyOperationException()
+
+                logger.warning(
+                    f"You should not call this from an async context - use a thread or sync_to_async. Class {__get_class_name(func, args)}"
+                )
+
+            return func(*args, **kwargs)
+
+        return inner
+
+    return decorator
+
+
+def __get_bool_env(var_name: str) -> bool:
+    """
+    >>> get_bool_env("MY_BOOL_VAR")
+    False
+    >>> os.environ["MY_BOOL_VAR"] = "1"
+    >>> get_bool_env("MY_BOOL_VAR")
+    True
+    >>> os.environ["MY_BOOL_VAR"] = "true"
+    >>> get_bool_env("MY_BOOL_VAR")
+    True
+    >>> os.environ["MY_BOOL_VAR"] = "True"
+    >>> get_bool_env("MY_BOOL_VAR")
+    True
+    >>> os.environ["MY_BOOL_VAR"] = "0"
+    >>> get_bool_env("MY_BOOL_VAR")
+    False
+    >>> os.environ["MY_BOOL_VAR"] = "false"
+    >>> get_bool_env("MY_BOOL_VAR")
+    False
+    """
+    return os.environ.get(var_name, "0").lower() in ("true", "1")
+
+
+def __get_class_name(func: Callable, args: tuple) -> str:
+    if hasattr(func, "__self__"):
+        return func.__self__.__class__.__name__
+
+    return args[0].__class__.__name__ if len(args) > 0 else "Unknown"

buz-2.23.0/src/buz/wrapper/synchronous_only_operation_exception.py

@@ -0,0 +1,3 @@
+class SynchronousOnlyOperationException(Exception):
+    def __init__(self):
+        super().__init__("You cannot call this from an async context - use a thread or sync_to_async.")