zrb 0.6.0__py3-none-any.whl → 0.6.1__py3-none-any.whl

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/config.py

@@ -1,136 +1,101 @@
+import json
+import os
 from typing import List
+
 from helper.conversion import str_to_boolean, str_to_logging_level
-import os
-import json
 
 app_src_dir = os.path.dirname(__file__)
 
-zrb_app_name = os.getenv('APP_NAME', 'app')
-app_logging_level = str_to_logging_level(
-    os.getenv('APP_LOGGING_LEVEL', 'INFO')
-)
-app_host = os.getenv('APP_HOST', '0.0.0.0')
-app_port = int(os.getenv('APP_PORT', '8080'))
-app_reload = str_to_boolean(os.getenv('APP_RELOAD', 'true'))
-app_max_not_ready = int(os.getenv('APP_MAX_NOT_READY', '10'))
-
-app_enable_otel = str_to_boolean(os.getenv('APP_ENABLE_OTEL', 'false'))
-app_otel_exporter_otlp_endpoint = os.getenv(
-    'APP_OTEL_EXPORTER_OTLP_ENDPOINT', 'false'
-)
+zrb_app_name = os.getenv("APP_NAME", "app")
+app_logging_level = str_to_logging_level(os.getenv("APP_LOGGING_LEVEL", "INFO"))
+app_host = os.getenv("APP_HOST", "0.0.0.0")
+app_port = int(os.getenv("APP_PORT", "8080"))
+app_reload = str_to_boolean(os.getenv("APP_RELOAD", "true"))
+app_max_not_ready = int(os.getenv("APP_MAX_NOT_READY", "10"))
+
+app_enable_otel = str_to_boolean(os.getenv("APP_ENABLE_OTEL", "false"))
+app_otel_exporter_otlp_endpoint = os.getenv("APP_OTEL_EXPORTER_OTLP_ENDPOINT", "false")
 
 app_auth_access_token_cookie_key = os.getenv(
-    'PUBLIC_AUTH_ACCESS_TOKEN_COOKIE_KEY', 'access_token'
+    "PUBLIC_AUTH_ACCESS_TOKEN_COOKIE_KEY", "access_token"
 )
 app_auth_refresh_token_cookie_key = os.getenv(
-    'PUBLIC_AUTH_REFRESH_TOKEN_COOKIE_KEY', 'refresh_token'
+    "PUBLIC_AUTH_REFRESH_TOKEN_COOKIE_KEY", "refresh_token"
 )
 
-app_auth_access_token_type = os.getenv('APP_AUTH_ACCESS_TOKEN_TYPE', 'jwt')
-app_auth_access_token_expire_seconds = int(os.getenv(
-    'APP_AUTH_ACCESS_TOKEN_EXPIRE_SECONDS', '300'
-))
-app_auth_refresh_token_type = os.getenv('APP_AUTH_REFRESH_TOKEN_TYPE', 'jwt')
-app_auth_refresh_token_expire_seconds = int(os.getenv(
-    'APP_AUTH_REFRESH_TOKEN_EXPIRE_SECONDS', '86400'
-))
-app_auth_jwt_token_secret_key = os.getenv(
-    'APP_AUTH_JWT_TOKEN_SECRET_KEY', 'secret'
+app_auth_access_token_type = os.getenv("APP_AUTH_ACCESS_TOKEN_TYPE", "jwt")
+app_auth_access_token_expire_seconds = int(
+    os.getenv("APP_AUTH_ACCESS_TOKEN_EXPIRE_SECONDS", "300")
 )
-app_auth_jwt_token_algorithm = os.getenv(
-    'APP_AUTH_JWT_TOKEN_ALGORITHM', 'HS256'
+app_auth_refresh_token_type = os.getenv("APP_AUTH_REFRESH_TOKEN_TYPE", "jwt")
+app_auth_refresh_token_expire_seconds = int(
+    os.getenv("APP_AUTH_REFRESH_TOKEN_EXPIRE_SECONDS", "86400")
 )
+app_auth_jwt_token_secret_key = os.getenv("APP_AUTH_JWT_TOKEN_SECRET_KEY", "secret")
+app_auth_jwt_token_algorithm = os.getenv("APP_AUTH_JWT_TOKEN_ALGORITHM", "HS256")
 
-app_auth_admin_active = str_to_boolean(os.getenv(
-    'APP_AUTH_ADMIN_ACTIVE', 'true'
-))
-app_auth_admin_user_id = os.getenv('APP_AUTH_ADMIN_USER_ID', 'root')
-app_auth_admin_username = os.getenv('APP_AUTH_ADMIN_USERNAME', 'admin')
-app_auth_admin_password = os.getenv('APP_AUTH_ADMIN_PASSWORD', 'admin')
-app_auth_admin_email = os.getenv('APP_AUTH_ADMIN_EMAIL', '')
-app_auth_admin_phone = os.getenv('APP_AUTH_ADMIN_PHONE', '')
-app_auth_guest_user_id = os.getenv('APP_AUTH_GUEST_USER_ID', 'guest')
-app_auth_guest_username = os.getenv('APP_AUTH_GUEST_USERNAME', 'guest')
-app_auth_guest_email = os.getenv('APP_AUTH_GUEST_EMAIL', '')
-app_auth_guest_phone = os.getenv('APP_AUTH_GUEST_PHONE', '')
-
-app_db_connection = os.getenv('APP_DB_CONNECTION', 'sqlite://')
-app_db_engine_show_log = str_to_boolean(
-    os.getenv('APP_DB_ENGINE_SHOW_LOG', 'false')
-)
-app_db_auto_migrate = str_to_boolean(os.getenv('APP_DB_AUTO_MIGRATE', 'true'))
+app_auth_admin_active = str_to_boolean(os.getenv("APP_AUTH_ADMIN_ACTIVE", "true"))
+app_auth_admin_user_id = os.getenv("APP_AUTH_ADMIN_USER_ID", "root")
+app_auth_admin_username = os.getenv("APP_AUTH_ADMIN_USERNAME", "admin")
+app_auth_admin_password = os.getenv("APP_AUTH_ADMIN_PASSWORD", "admin")
+app_auth_admin_email = os.getenv("APP_AUTH_ADMIN_EMAIL", "")
+app_auth_admin_phone = os.getenv("APP_AUTH_ADMIN_PHONE", "")
+app_auth_guest_user_id = os.getenv("APP_AUTH_GUEST_USER_ID", "guest")
+app_auth_guest_username = os.getenv("APP_AUTH_GUEST_USERNAME", "guest")
+app_auth_guest_email = os.getenv("APP_AUTH_GUEST_EMAIL", "")
+app_auth_guest_phone = os.getenv("APP_AUTH_GUEST_PHONE", "")
+
+app_db_connection = os.getenv("APP_DB_CONNECTION", "sqlite://")
+app_db_engine_show_log = str_to_boolean(os.getenv("APP_DB_ENGINE_SHOW_LOG", "false"))
+app_db_auto_migrate = str_to_boolean(os.getenv("APP_DB_AUTO_MIGRATE", "true"))
 
-app_broker_type = os.getenv('APP_BROKER_TYPE', 'mock')
+app_broker_type = os.getenv("APP_BROKER_TYPE", "mock")
 
-app_enable_rpc_server: bool = str_to_boolean(os.getenv(
-    'APP_ENABLE_RPC_SERVER', 'true'
-))
+app_enable_rpc_server: bool = str_to_boolean(os.getenv("APP_ENABLE_RPC_SERVER", "true"))
 
-app_enable_event_handler: bool = str_to_boolean(os.getenv(
-    'APP_ENABLE_EVENT_HANDLER', 'true'
-))
+app_enable_event_handler: bool = str_to_boolean(
+    os.getenv("APP_ENABLE_EVENT_HANDLER", "true")
+)
 
-app_enable_frontend: bool = str_to_boolean(os.getenv(
-    'APP_ENABLE_FRONTEND', 'true'
-))
+app_enable_frontend: bool = str_to_boolean(os.getenv("APP_ENABLE_FRONTEND", "true"))
 
-app_enable_api: bool = str_to_boolean(os.getenv(
-    'APP_ENABLE_API', 'true'
-))
+app_enable_api: bool = str_to_boolean(os.getenv("APP_ENABLE_API", "true"))
 
 app_rmq_connection_string = os.getenv(
-    'APP_RMQ_CONNECTION', 'amqp://guest:guest@localhost/'
+    "APP_RMQ_CONNECTION", "amqp://guest:guest@localhost/"
 )
 
-app_kafka_bootstrap_servers = os.getenv(
-    'APP_KAFKA_BOOTSTRAP_SERVERS', 'localhost:9092'
+app_kafka_bootstrap_servers = os.getenv("APP_KAFKA_BOOTSTRAP_SERVERS", "localhost:9092")
+app_kafka_security_protocol = os.getenv("APP_KAFKA_SECURITY_PROTOCOL", "PLAINTEXT")
+app_kafka_sasl_mechanism = os.getenv("APP_KAFKA_SASL_MECHANISM", "SCRAM-SHA-512")
+app_kafka_sasl_user = os.getenv("APP_KAFKA_SASL_USER", "admin")
+app_kafka_sasl_pass = os.getenv("APP_KAFKA_SASL_PASS", "admin")
+
+app_cors_allow_origins: List[str] = json.loads(
+    os.getenv("APP_CORS_ALLOW_ORIGINS", '["*"]')
 )
-app_kafka_security_protocol = os.getenv(
-    'APP_KAFKA_SECURITY_PROTOCOL', 'PLAINTEXT'
+app_cors_allow_origin_regex: str = os.getenv("APP_CORS_ALLOW_ORIGIN_REGEX", "")
+app_cors_allow_methods: List[str] = json.loads(
+    os.getenv("APP_CORS_ALLOW_METHODS", '["*"]')
 )
-app_kafka_sasl_mechanism = os.getenv(
-    'APP_KAFKA_SASL_MECHANISM', 'SCRAM-SHA-512'
+app_cors_allow_headers: List[str] = json.loads(
+    os.getenv("APP_CORS_ALLOW_HEADERS", '["*"]')
 )
-app_kafka_sasl_user = os.getenv(
-    'APP_KAFKA_SASL_USER', 'admin'
+app_cors_allow_credentials: bool = str_to_boolean(
+    os.getenv("APP_CORS_ALLOW_CREDENTIALS", "false")
 )
-app_kafka_sasl_pass = os.getenv(
-    'APP_KAFKA_SASL_PASS', 'admin'
+app_cors_expose_headers: bool = str_to_boolean(
+    os.getenv("APP_CORS_EXPOSE_HEADERS", "false")
 )
+app_cors_max_age: int = int(os.getenv("APP_CORS_MAX_AGE", "600"))
+app_enable_auth_module = str_to_boolean(os.getenv("APP_ENABLE_AUTH_MODULE", "true"))
+app_enable_log_module = str_to_boolean(os.getenv("APP_ENABLE_LOG_MODULE", "true"))
 
-app_cors_allow_origins: List[str] = json.loads(os.getenv(
-    'APP_CORS_ALLOW_ORIGINS', '["*"]'
-))
-app_cors_allow_origin_regex: str = os.getenv(
-    'APP_CORS_ALLOW_ORIGIN_REGEX', ''
-)
-app_cors_allow_methods: List[str] = json.loads(os.getenv(
-    'APP_CORS_ALLOW_METHODS', '["*"]'
-))
-app_cors_allow_headers: List[str] = json.loads(os.getenv(
-    'APP_CORS_ALLOW_HEADERS', '["*"]'
-))
-app_cors_allow_credentials: bool = str_to_boolean(os.getenv(
-    'APP_CORS_ALLOW_CREDENTIALS', 'false'
-))
-app_cors_expose_headers: bool = str_to_boolean(os.getenv(
-    'APP_CORS_EXPOSE_HEADERS', 'false'
-))
-app_cors_max_age: int = int(os.getenv(
-    'APP_CORS_MAX_AGE', '600'
-))
-app_enable_auth_module = str_to_boolean(os.getenv(
-    'APP_ENABLE_AUTH_MODULE', 'true'
-))
-app_enable_log_module = str_to_boolean(os.getenv(
-    'APP_ENABLE_LOG_MODULE', 'true'
-))
-
-public_brand = os.getenv('PUBLIC_BRAND', 'PascalZrbAppName')
-public_title = os.getenv('PUBLIC_TITLE', 'PascalZrbAppName')
+public_brand = os.getenv("PUBLIC_BRAND", "PascalZrbAppName")
+public_title = os.getenv("PUBLIC_TITLE", "PascalZrbAppName")
 public_auth_access_token_cookie_key = os.getenv(
-    'PUBLIC_AUTH_ACCESS_TOKEN_COOKIE_KEY', 'access_token'
+    "PUBLIC_AUTH_ACCESS_TOKEN_COOKIE_KEY", "access_token"
 )
 public_auth_refresh_token_cookie_key = os.getenv(
-    'PUBLIC_AUTH_REFRESH_TOKEN_COOKIE_KEY', 'refresh_token'
+    "PUBLIC_AUTH_REFRESH_TOKEN_COOKIE_KEY", "refresh_token"
 )

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/core/error.py

@@ -1,4 +1,5 @@
 from typing import Any, Mapping, Optional
+
 from fastapi import HTTPException
 
 
@@ -11,14 +12,14 @@ class HTTPAPIException(HTTPException):
         error: Optional[Exception] = None,
     ):
         if error is HTTPException:
-            status_code = error.status_code,
-            detail = error.detail,
+            status_code = (error.status_code,)
+            detail = (error.detail,)
             headers = self._get_headers(error.headers)
             return super().__init__(
                 status_code=status_code, detail=detail, headers=headers
             )
         if error is not None:
-            error_message = f'{error}'
+            error_message = f"{error}"
         status_code = self._get_status_code(status_code, error_message)
         headers = self._get_headers(headers)
         return super().__init__(
@@ -32,17 +33,17 @@ class HTTPAPIException(HTTPException):
             return status_code
         if error_message is None:
             return 500
-        if error_message.lower().startswith('not found'):
+        if error_message.lower().startswith("not found"):
             return 404
-        if error_message.lower().startswith('forbidden'):
+        if error_message.lower().startswith("forbidden"):
             return 403
-        if error_message.lower().startswith('unauthorized'):
+        if error_message.lower().startswith("unauthorized"):
             return 403
-        if error_message.lower().startswith('unauthenticated'):
+        if error_message.lower().startswith("unauthenticated"):
             return 401
-        if error_message.lower().startswith('unprocessable'):
+        if error_message.lower().startswith("unprocessable"):
             return 422
-        if error_message.lower().startswith('invalid'):
+        if error_message.lower().startswith("invalid"):
             return 422
         return 500
 
@@ -50,5 +51,5 @@ class HTTPAPIException(HTTPException):
         self, original_headers: Optional[Mapping[str, Any]] = None
     ) -> Mapping[str, Any]:
         headers = {} if original_headers is None else dict(original_headers)
-        headers['api-error'] = 'yes'
+        headers["api-error"] = "yes"
         return headers

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/core/messagebus/__init__.py

@@ -1,10 +1,8 @@
-from core.messagebus.messagebus import (
-    Admin, Consumer, Publisher, MessageSerializer
-)
-from core.messagebus.mock import MockAdmin, MockConsumer, MockPublisher
 from core.messagebus.kafka.admin import KafkaAdmin
 from core.messagebus.kafka.consumer import KafkaConsumer
 from core.messagebus.kafka.publisher import KafkaPublisher
+from core.messagebus.messagebus import Admin, Consumer, MessageSerializer, Publisher
+from core.messagebus.mock import MockAdmin, MockConsumer, MockPublisher
 from core.messagebus.rabbitmq.admin import RMQAdmin
 from core.messagebus.rabbitmq.consumer import RMQConsumer
 from core.messagebus.rabbitmq.publisher import RMQPublisher

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/core/messagebus/kafka/admin.py

@@ -1,17 +1,15 @@
-from typing import List, Mapping, Optional
-from core.messagebus.messagebus import Admin
-from kafka.admin import KafkaAdminClient, NewTopic
-from kafka import __version__
 import asyncio
 import logging
+from typing import List, Mapping, Optional
 
+from aiokafka import __version__
+from aiokafka.admin import AIOKafkaAdminClient, NewTopic
+from core.messagebus.messagebus import Admin
 
-class KafkaEventConfig():
+
+class KafkaEventConfig:
     def __init__(
-        self,
-        topic_name: str,
-        num_partitions: int = 1,
-        replication_factor: int = 1
+        self, topic_name: str, num_partitions: int = 1, replication_factor: int = 1
     ):
         self.topic_name = topic_name
         self.num_partitions = num_partitions
@@ -24,12 +22,12 @@ class KafkaAdmin(Admin):
         logger: logging.Logger,
         bootstrap_servers: str,
         configs: Mapping[str, KafkaEventConfig],
-        client_id: str = 'kafka-admin-' + __version__,
-        security_protocol='PLAINTEXT',
+        client_id: str = "kafka-admin-" + __version__,
+        security_protocol="PLAINTEXT",
         sasl_mechanism="PLAIN",
         sasl_plain_password=None,
         sasl_plain_username=None,
-        sasl_kerberos_service_name='kafka',
+        sasl_kerberos_service_name="kafka",
         sasl_kerberos_domain_name=None,
         sasl_oauth_token_provider=None,
     ):
@@ -49,26 +47,27 @@ class KafkaAdmin(Admin):
     async def create_events(self, event_names: List[str]):
         # Only handle non-existing events
         event_names = [
-            event_name for event_name in event_names
+            event_name
+            for event_name in event_names
             if event_name not in self._existing_events
         ]
         if len(event_names) == 0:
             return
         # Create topics
-        topics = [
-            self.get_new_topic(event_name) for event_name in event_names
-        ]
+        topics = [self.get_new_topic(event_name) for event_name in event_names]
         try:
             admin_client = self._create_connection()
             admin_client.create_topics(topics)
             admin_client.close()
         except (asyncio.CancelledError, GeneratorExit, Exception):
             self.logger.error(
-                ' '.join([
-                    '🐼 [kafka-admin] Something wrong when ',
-                    f'creating topics: {topics}'
-                ]),
-                exc_info=True
+                " ".join(
+                    [
+                        "🐼 [kafka-admin] Something wrong when ",
+                        f"creating topics: {topics}",
+                    ]
+                ),
+                exc_info=True,
             )
         for event_name in event_names:
             self._existing_events[event_name] = True
@@ -76,14 +75,16 @@ class KafkaAdmin(Admin):
     async def delete_events(self, event_names: List[str]):
         # Only handle existing events
         event_names = [
-            event_name for event_name in event_names
+            event_name
+            for event_name in event_names
             if event_name in self._existing_events
         ]
         if len(event_names) == 0:
             return
         # Create topic names
         topic_names = [
-            self.get_topic_name(event_name) for event_name in event_names
+            self.get_topic_name(event_name)
+            for event_name in event_names
             if event_name in self._existing_events
         ]
         try:
@@ -94,11 +95,13 @@ class KafkaAdmin(Admin):
                 del self._existing_events[event_name]
         except (asyncio.CancelledError, GeneratorExit, Exception):
             self.logger.error(
-                ' '.join([
-                    '🐼 [kafka-admin] Something wrong when ',
-                    f'deleting topics: {topic_names}'
-                ]),
-                exc_info=True
+                " ".join(
+                    [
+                        "🐼 [kafka-admin] Something wrong when ",
+                        f"deleting topics: {topic_names}",
+                    ]
+                ),
+                exc_info=True,
             )
 
     def get_config(self, event_name: str) -> KafkaEventConfig:
@@ -115,12 +118,12 @@ class KafkaAdmin(Admin):
         topic = NewTopic(
             name=event_config.topic_name,
             num_partitions=event_config.num_partitions,
-            replication_factor=event_config.replication_factor
+            replication_factor=event_config.replication_factor,
         )
         return topic
 
-    def _create_connection(self) -> KafkaAdminClient:
-        return KafkaAdminClient(
+    def _create_connection(self) -> AIOKafkaAdminClient:
+        return AIOKafkaAdminClient(
             bootstrap_servers=self.bootstrap_servers,
             client_id=self.client_id,
             security_protocol=self.security_protocol,
@@ -129,7 +132,7 @@ class KafkaAdmin(Admin):
             sasl_plain_username=self.sasl_plain_username,
             sasl_kerberos_service_name=self.sasl_kerberos_service_name,
             sasl_kerberos_domain_name=self.sasl_kerberos_domain_name,
-            sasl_oauth_token_provider=self.sasl_oauth_token_provider
+            sasl_oauth_token_provider=self.sasl_oauth_token_provider,
         )
 
 
@@ -137,12 +140,12 @@ def must_get_kafka_admin(
     logger: logging.Logger,
     kafka_admin: Optional[KafkaAdmin],
     bootstrap_servers: str,
-    client_id='kafka-admin-' + __version__,
-    security_protocol='PLAINTEXT',
+    client_id="kafka-admin-" + __version__,
+    security_protocol="PLAINTEXT",
     sasl_mechanism="PLAIN",
     sasl_plain_password=None,
     sasl_plain_username=None,
-    sasl_kerberos_service_name='kafka',
+    sasl_kerberos_service_name="kafka",
     sasl_kerberos_domain_name=None,
     sasl_oauth_token_provider=None,
 ) -> KafkaAdmin:

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/core/messagebus/kafka/consumer.py

@@ -1,17 +1,17 @@
-from typing import Any, Callable, Mapping, Optional
-from core.messagebus.messagebus import (
-    Consumer, TEventHandler, MessageSerializer,
-    must_get_message_serializer
-)
-from core.messagebus.kafka.admin import (
-    KafkaAdmin, must_get_kafka_admin
-)
-from aiokafka import AIOKafkaConsumer, __version__
-from aiokafka.consumer.consumer import RoundRobinPartitionAssignor
-
 import asyncio
 import inspect
 import logging
+from typing import Any, Callable, Mapping, Optional
+
+from aiokafka import AIOKafkaConsumer, __version__
+from aiokafka.consumer.consumer import RoundRobinPartitionAssignor
+from core.messagebus.kafka.admin import KafkaAdmin, must_get_kafka_admin
+from core.messagebus.messagebus import (
+    Consumer,
+    MessageSerializer,
+    TEventHandler,
+    must_get_message_serializer,
+)
 
 
 class KafkaConsumer(Consumer):
@@ -19,7 +19,7 @@ class KafkaConsumer(Consumer):
         self,
         logger: logging.Logger,
         bootstrap_servers: str,
-        client_id='aiokafka-' + __version__,
+        client_id="aiokafka-" + __version__,
         group_id: Optional[str] = None,
         key_deserializer=None,
         value_deserializer=None,
@@ -29,7 +29,7 @@ class KafkaConsumer(Consumer):
         max_partition_fetch_bytes=1 * 1024 * 1024,
         request_timeout_ms=40 * 1000,
         retry_backoff_ms=100,
-        auto_offset_reset='latest',
+        auto_offset_reset="latest",
         enable_auto_commit=True,
         auto_commit_interval_ms=5000,
         check_crcs=True,
@@ -42,22 +42,22 @@ class KafkaConsumer(Consumer):
         consumer_timeout_ms=200,
         max_poll_records=None,
         ssl_context=None,
-        security_protocol='PLAINTEXT',
-        api_version='auto',
+        security_protocol="PLAINTEXT",
+        api_version="auto",
         exclude_internal_topics=True,
         connections_max_idle_ms=540000,
         isolation_level="read_uncommitted",
         sasl_mechanism="PLAIN",
         sasl_plain_password=None,
         sasl_plain_username=None,
-        sasl_kerberos_service_name='kafka',
+        sasl_kerberos_service_name="kafka",
         sasl_kerberos_domain_name=None,
         sasl_oauth_token_provider=None,
         serializer: Optional[MessageSerializer] = None,
         kafka_admin: Optional[KafkaAdmin] = None,
         retry: int = 3,
-        retry_interval: int = 3,
-        identifier='kafka-consumer'
+        retry_interval: int = 10,
+        identifier="kafka-consumer",
     ):
         self.logger = logger
         self.serializer = must_get_message_serializer(serializer)
@@ -124,6 +124,7 @@ class KafkaConsumer(Consumer):
             )
             self._handlers[event_name] = handler
             return handler
+
         return wrapper
 
     async def start(self):
@@ -144,37 +145,33 @@ class KafkaConsumer(Consumer):
                 await self._connect()
             await self._init_topics()
             topics = list(self._topic_to_event_map.keys())
-            self.logger.warning(
-                f'🐼 [{self.identifier}] Subscribe to topics: {topics}'
-            )
+            self.logger.warning(f"🐼 [{self.identifier}] Subscribe to topics: {topics}")
             self.consumer.subscribe(topics=topics)
             async for message in self.consumer:
                 topic_name = message.topic
                 event_name = self._topic_to_event_map[topic_name]
                 message_handler = self._handlers.get(event_name)
-                decoded_value = self.serializer.decode(
-                    event_name, message.value
-                )
+                decoded_value = self.serializer.decode(event_name, message.value)
                 self.logger.info(
-                    f'🐼 [{self.identifier}] Consume from "{topic_name}": ' +
-                    f'{decoded_value}'
+                    f'🐼 [{self.identifier}] Consume from "{topic_name}": '
+                    + f"{decoded_value}"
                 )
                 await self._run_handler(message_handler, decoded_value)
             retry = self.retry
         except (asyncio.CancelledError, GeneratorExit, Exception) as e:
             if retry > 0:
-                self.logger.error(f'🐼 [{self.identifier}]', exc_info=True)
+                self.logger.error(f"🐼 [{self.identifier}]", exc_info=True)
             if retry == 0:
                 self.logger.error(
-                    f'🐼 [{self.identifier}] Failed to consume message after ' +
-                    f'{self.retry} attempts'
+                    f"🐼 [{self.identifier}] Failed to consume message after "
+                    + f"{self.retry} attempts"
                 )
-                self.logger.fatal(f'🐼 [{self.identifier}] Cannot retry')
+                self.logger.fatal(f"🐼 [{self.identifier}] Cannot retry")
                 raise e
-            self.logger.warning(f'🐼 [{self.identifier}] Retry to consume')
+            self.logger.warning(f"🐼 [{self.identifier}] Retry to consume")
             await self._disconnect()
             await asyncio.sleep(self.retry_interval)
-            await self._start(retry-1)
+            await self._start(retry - 1)
         finally:
             await self._disconnect()
 
@@ -187,7 +184,7 @@ class KafkaConsumer(Consumer):
         }
 
     async def _connect(self):
-        self.logger.info(f'🐼 [{self.identifier}] Create kafka consumer')
+        self.logger.info(f"🐼 [{self.identifier}] Create kafka consumer")
         self.consumer = AIOKafkaConsumer(
             bootstrap_servers=self.bootstrap_servers,
             client_id=self.client_id,
@@ -225,30 +222,26 @@ class KafkaConsumer(Consumer):
             sasl_kerberos_domain_name=self.sasl_kerberos_domain_name,
             sasl_oauth_token_provider=self.sasl_oauth_token_provider,
         )
-        self.logger.info(f'🐼 [{self.identifier}] Start kafka consumer')
+        self.logger.info(f"🐼 [{self.identifier}] Start kafka consumer")
         await self.consumer.start()
-        self.logger.info(f'🐼 [{self.identifier}] Kafka consumer started')
+        self.logger.info(f"🐼 [{self.identifier}] Kafka consumer started")
 
     async def _disconnect(self):
         if self.consumer is not None:
             try:
                 self.logger.info(
-                    f'🐼 [{self.identifier}] Unsubscribe kafka consumer ' +
-                    'from all topics'
+                    f"🐼 [{self.identifier}] Unsubscribe kafka consumer "
+                    + "from all topics"
                 )
                 self.consumer.unsubscribe()
-                self.logger.info(f'🐼 [{self.identifier}] Stop kafka consumer')
+                self.logger.info(f"🐼 [{self.identifier}] Stop kafka consumer")
                 await self.consumer.stop()
-                self.logger.info(
-                    f'🐼 [{self.identifier}] Kafka consumer stopped'
-                )
+                self.logger.info(f"🐼 [{self.identifier}] Kafka consumer stopped")
             except (asyncio.CancelledError, GeneratorExit, Exception):
-                self.logger.error(f'🐼 [{self.identifier}]', exc_info=True)
+                self.logger.error(f"🐼 [{self.identifier}]", exc_info=True)
         self.consumer = None
 
-    async def _run_handler(
-        self, message_handler: TEventHandler, decoded_value: Any
-    ):
+    async def _run_handler(self, message_handler: TEventHandler, decoded_value: Any):
         if inspect.iscoroutinefunction(message_handler):
             return asyncio.create_task(message_handler(decoded_value))
         return message_handler(decoded_value)