atk-common 2.1.0__tar.gz → 3.0.0__tar.gz

{atk_common-2.1.0 → atk_common-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atk_common
-Version: 2.1.0
+Version: 3.0.0
 Summary: ATK common methods
 Home-page: https://github.com/pypa/atk_common
 Author: Roger

{atk_common-2.1.0 → atk_common-3.0.0}/setup.py

@@ -36,7 +36,7 @@ setup(
     # For a discussion on single-sourcing the version across setup.py and the
     # project code, see
     # https://packaging.python.org/guides/single-sourcing-package-version/
-    version="2.1.0",  # Required
+    version="3.0.0",  # Required
     # This is a one-line description or tagline of what your project does. This
     # corresponds to the "Summary" metadata field:
     # https://packaging.python.org/specifications/core-metadata/#summary

atk_common-3.0.0/src/atk_common/__init__.py

@@ -0,0 +1 @@
+# __init__.py

atk_common-3.0.0/src/atk_common/classes/__init__.py

@@ -0,0 +1,16 @@
+# __init__.py
+from atk_common.classes.bo_logger import BoLogger
+from atk_common.classes.docker_handler import DockerHandler
+from atk_common.classes.env_handler import EnvHandler
+from atk_common.classes.error_handler import ErrorHandler
+from atk_common.classes.http_response_handler import HttpResponseHandler
+from atk_common.classes.rabbitmq_consumer import RabbitMQConsumer
+
+__all__ = [
+    'BoLogger',
+    'DockerHandler',
+    'EnvHandler',
+    'ErrorHandler',
+    'HttpResponseHandler',
+    'RabbitMQConsumer',
+]

atk_common-3.0.0/src/atk_common/classes/bo_logger.py

@@ -0,0 +1,62 @@
+import json
+from typing import Optional
+from opentelemetry.trace import get_current_span
+from atk_common.interfaces import ILogger  # for type hints only
+from atk_common.enums import LogLevel
+from atk_common.utils.datetime_utils import get_utc_date_time_str
+from atk_common.enums.log_level_enum import LogLevel
+
+class BoLogger(ILogger):
+    def __init__(self, log_level: LogLevel, component, version):
+        if log_level is None:
+            self.log_level = LogLevel.INFO
+        else:
+            self.log_level = log_level
+        self.component = component
+        self.version = version
+
+    def _get_trace_context(self):
+        span = get_current_span()
+        ctx = span.get_span_context()
+        if ctx.is_valid:
+            return {
+                "trace_id": f"{ctx.trace_id:032x}",
+                "span_id": f"{ctx.span_id:016x}",
+            }
+        return {"trace_id": None, "span_id": None}
+
+    def _create_log_json(self, timestamp, level: LogLevel, message: str):
+        log_entry = {
+            "timestamp": timestamp,
+            "severity": level.name,
+            "message": message,
+            "component": self.component,
+            "version": self.version,
+        }
+        log_entry.update(self._get_trace_context())
+        return log_entry
+
+    def _log(self, level: LogLevel, message: str):
+        if level.value >= self.log_level.value:
+            timestamp = get_utc_date_time_str()
+            log_json = self._create_log_json(timestamp, level, message)
+            print(json.dumps(log_json))
+
+    def debug(self, message: str):
+        self._log(LogLevel.DEBUG, message)
+
+    def info(self, message: str):
+        self._log(LogLevel.INFO, message)
+
+    def warning(self, message: str):
+        self._log(LogLevel.WARNING, message)
+
+    def error(self, message: str):
+        self._log(LogLevel.ERROR, message)
+
+    def critical(self, message: str):
+        self._log(LogLevel.CRITICAL, message)
+
+    def set_level(self, log_level: LogLevel):
+        self.log_level = log_level
+

atk_common-3.0.0/src/atk_common/classes/docker_handler.py

@@ -0,0 +1,76 @@
+import docker
+import socket
+from atk_common.interfaces import IDockerHandler
+from atk_common.interfaces import ILogger
+
+class DockerHandler(IDockerHandler):
+    def __init__(self, logger: ILogger, image_name, image_version):
+        self.logger = logger
+        self.image_name = image_name
+        self.image_version = image_version
+        self.set_container_metadata()
+
+    def get_image_name_and_version(self, tags):
+        if tags:
+            # Use the first tag (usually only one)
+            full_tag = tags[0]  # e.g., 'bo-crypto-wrapper-api:latest'
+
+            if ":" in full_tag:
+                image_name, image_version = full_tag.split(":", 1)
+            else:
+                image_name = full_tag
+                image_version = "<none>"
+            return image_name, image_version
+        else:
+            return None, None
+        
+    def create_port_item(self, port, binding):
+        data = {}
+        data['port'] = port
+        data['binding'] = binding
+        return data
+
+    def create_container_log(self, container_data):
+        image_name = container_data.get('imageName') or 'Unknown'
+        image_version = container_data.get('imageVersion') or 'Unknown'
+        
+        log_str = f'Image name: {image_name}, image version: {image_version}'
+        self.logger.info(log_str)
+
+    def get_current_container_info(self):
+        try:
+            data = {}
+            client = docker.from_env()
+
+            # Get current container's hostname (usually the container ID)
+            container_id = socket.gethostname()
+
+            # Fetch container object using partial ID
+            container = client.containers.get(container_id)
+
+            tags_info = self.get_image_name_and_version(container.image.tags)
+            data['imageName'] = tags_info[0]
+            data['imageVersion'] = tags_info[1]
+            data['containerName'] = container.name
+            ports = container.attrs['NetworkSettings']['Ports']
+            data['ports'] = []
+            if ports:
+                for container_port, host_bindings in ports.items():
+                    if host_bindings:
+                        for binding in host_bindings:
+                            data['ports'].append(self.create_port_item(container_port, f"{binding['HostIp']}:{binding['HostPort']}"))
+                    else:
+                        data['ports'].append(self.create_port_item(container_port, None))
+            self.create_container_log(data)
+            return data
+        except Exception as e:
+            self.logger.error("Error getting container data:" + str(e))
+            return None
+
+    def set_container_metadata(self):
+        data = {}
+        data['imageName'] = self.image_name
+        data['imageVersion'] = self.image_version
+        data['containerName'] = self.image_name
+        self.create_container_log(data)
+        return data

atk_common-3.0.0/src/atk_common/classes/env_handler.py

@@ -0,0 +1,38 @@
+import os
+from typing import Optional
+from atk_common.interfaces import IEnvHandler
+from atk_common.interfaces import ILogger
+
+class EnvHandler(IEnvHandler):
+    def __init__(self, logger: Optional(ILogger)): # type: ignore
+        self.logger = logger
+
+    def val_str(self, value):
+        if value is None:
+            return '<Empty>'
+        if isinstance(value, str):
+            if value.strip() == '' or value.lower() == 'null':
+                return '<Null>'
+            return value
+        return str(value)
+
+    def is_value_null_or_empty(self, value):
+        if isinstance(value, str):
+            return value.strip() == '' or value.lower() == 'null'
+        return False
+
+    def get_env_value(self, key, abort_on_error=True):
+        val = os.environ.get(key)
+        if self.logger:
+            self.logger.info(key + ':' + self.val_str(val))
+        if val is None and abort_on_error:
+            err_msg = f"Environment variable '{key}' is not set."
+            if self.logger:
+                self.logger.critical(err_msg)
+            raise ValueError(err_msg)
+        if self.is_value_null_or_empty(val):
+            return None
+        return val
+    
+    def set_logger(self, logger: ILogger):
+        self.logger = logger

atk_common-3.0.0/src/atk_common/classes/error_handler.py

@@ -0,0 +1,81 @@
+from http import HTTPStatus
+from flask import Response
+from enum import Enum
+import json
+from typing import Optional
+from atk_common.utils.datetime_utils import get_utc_date_time_str
+from atk_common.enums.api_error_type_enum import ApiErrorType
+from atk_common.utils.http_utils import is_http_status_internal
+from atk_common.utils.internal_response_utils import create_response
+from atk_common.interfaces import IErrorHandler
+from atk_common.interfaces import ILogger
+from atk_common.interfaces import IDockerHandler
+
+class ErrorHandler(IErrorHandler):
+    def __init__(self, logger: ILogger, docker_handler: IDockerHandler):
+        self.logger = logger
+        self.docker_handler = docker_handler
+
+    def get_message(self, error):
+        if hasattr(error, 'message'):
+            return str(error.message)
+        else:
+            return str(error)
+        
+    def create_error_log(self, data):
+        err_str = data['message'] + ', statusCode: ' + str(data['statusCode']) + ', method: ' + data['method']
+        if data['containerInfo'] is not None:
+            err_str += ', imageName: ' + data['containerInfo']['imageName']
+            err_str += ', imageVersion: ' + data['containerInfo']['imageVersion']
+            err_str += ', containerName: ' + data['containerInfo']['containerName']
+        else:
+            err_str += ', imageName: <none>'
+            err_str += ', imageVersion: <none>'
+            err_str += ', containerName: <none>'
+        self.logger.critical(err_str)
+
+    def get_error_entity(self, error, method, error_type, status_code, container_info):
+        data = {}
+        data['statusCode'] = status_code
+        data['exceptionType'] = str(type(error))
+        data['errorType'] = error_type.value if isinstance(error_type, Enum) else error_type
+        data['message'] = self.get_message(error)
+        data['method'] = method
+        data['timestamp'] = get_utc_date_time_str()
+        data['containerInfo'] = container_info
+        self.create_error_log(data)
+        return Response(
+            response=json.dumps(data),
+            status=HTTPStatus.INTERNAL_SERVER_ERROR,
+            mimetype='application/json'
+        )
+
+    def resend_error_entity(self, error_entity):
+        self.create_error_log(error_entity)
+        return Response(
+            response=json.dumps(error_entity),
+            status=HTTPStatus.INTERNAL_SERVER_ERROR,
+            mimetype='application/json'
+        )
+
+    def handle_error(self, resp, status):
+        if is_http_status_internal(resp.status_code):
+            self.logger.info(resp.json().get('message'))
+            return create_response(status, resp.status_code, resp.json())
+        else:
+            self.logger.info(resp.text)
+            return create_response(status, resp.status_code, resp.text)
+
+    def get_response_error(self, resp):
+        if is_http_status_internal(resp.status_code):
+            return resp.json()
+        else:
+            return resp.text
+
+    # Return values:
+    # 1 - Connection error
+    # 2 - Internal error
+    def get_error_type(self, conn):
+        if conn is None:
+            return ApiErrorType.CONNECTION
+        return ApiErrorType.INTERNAL

atk_common-3.0.0/src/atk_common/classes/http_response_handler.py

@@ -0,0 +1,42 @@
+import json
+from flask import Response
+from http import HTTPStatus
+from atk_common.enums.api_error_type_enum import ApiErrorType
+from atk_common.utils.http_utils import is_http_status_internal, is_http_status_ok
+from atk_common.utils.internal_response_utils import is_response_http
+from atk_common.interfaces import IErrorHandler
+from atk_common.interfaces import IHttpResponseHandler
+
+class HttpResponseHandler(IHttpResponseHandler):
+    def __init__(self, error_handler: IErrorHandler):
+        self.error_handler = error_handler
+
+    def _convert_response_data(self, data):
+        if isinstance(data, dict):
+            return json.dumps(data)
+        elif isinstance(data, list):
+            return json.dumps(data)
+        elif isinstance(data, str):
+            json_data = json.loads(data)
+            return json.dumps(json_data)
+        else:
+            return data
+
+    # If response['status'] == 0 (OK, http status = 200): create Response and return response['responseMsg']   
+    # If http status == 500: 
+    #   If response['status'] == 1 (HTTP): resend received error entity
+    #   If response['status'] == 2 (INTERNAL): create new error entity and return as response
+    # If http status other value: create new error entity and return as response
+    def http_response(self, method, response, container_info):
+        if is_http_status_ok(response['statusCode']):
+            return Response(
+                response=self._convert_response_data(response['responseMsg']),
+                status=HTTPStatus.OK,
+                mimetype=response['contentType'],
+                headers=response['httpHeaders']
+            )
+        elif is_http_status_internal(response['statusCode']):
+            if is_response_http(response):
+                return self.error_handler.resend_error_entity(response['responseMsg'])
+            return self.error_handler.get_error_entity(response['responseMsg'], method, ApiErrorType.INTERNAL, response['statusCode'], container_info)
+        return self.error_handler.get_error_entity(response['responseMsg'], method, ApiErrorType.CONNECTION, response['statusCode'], container_info)

atk_common-3.0.0/src/atk_common/classes/rabbitmq_consumer.py

@@ -0,0 +1,72 @@
+from kombu import Connection, Queue, Consumer
+from kombu.exceptions import ConnectionError, ChannelError # Import relevant exceptions
+import socket
+import time
+from atk_common.interfaces import ILogger
+CONNECTION_ERRORS = (
+    ConnectionError,
+    ChannelError,
+    OSError,
+)
+
+class RabbitMQConsumer:
+    def __init__(self, queue_name, user, pwd, host, vhost, dlx, dlq, content_type, message_handler, logger: ILogger):
+        self.logger = logger
+
+        rabbit_url = 'amqp://' + user + ':' + pwd + '@' + host + '/' + vhost
+        self.logger.info(f"Initializing connection to RabbitMQ {queue_name} at {host}")
+
+        self.connection = Connection(rabbit_url, heartbeat=10)
+        if dlx is not None and dlq is not None:
+            queue = Queue(name=queue_name,
+                        queue_arguments={
+                            'x-dead-letter-exchange': dlx, 
+                            'x-dead-letter-routing-key': dlq},
+                        )
+        else:
+            queue = Queue(name=queue_name)
+        self.queue = queue
+        self.content_type = content_type  # Optional content type for message handling
+        self.message_handler = message_handler  # Custom message handler
+    
+    def consume(self):
+        conn = self.establish_connection()
+        self.logger.info("Begin consuming messages...")
+
+        while True:
+            try:
+                conn.drain_events(timeout=2)
+                self.logger.debug("Drained event or heartbeat.")
+            except socket.timeout:
+                self.logger.debug("Socket timeout, checking heartbeat...")
+                conn.heartbeat_check()
+            except CONNECTION_ERRORS as e:
+                self.logger.critical(f"Connection lost: {e}. Reconnecting...")
+                return  # break loop and re-establish connection
+            except Exception as e:
+                self.logger.critical(f"Top-level exception in consume loop: {e}. Restarting after delay...")
+                return
+
+    def establish_connection(self):
+        revived_connection = self.connection.clone()
+        revived_connection.ensure_connection(max_retries=3)
+        channel = revived_connection.channel()
+
+        consumer = Consumer(
+            revived_connection, 
+            queues=self.queue, 
+            callbacks=[self.message_handler], 
+            accept=[self.content_type] if self.content_type else None)
+        consumer.revive(channel)
+        consumer.consume()
+        self.logger.info("Connection revived!")
+        return revived_connection
+        
+    def run(self):
+        self.logger.info("Starting RabbitMQ consumer run loop...")
+        while True:
+            try:
+                self.consume()
+            except Exception as e:
+                self.logger.critical(f"Top-level exception in run loop: {e}. Restarting after delay...")
+                time.sleep(5)

atk_common-3.0.0/src/atk_common/interfaces/__init__.py

@@ -0,0 +1,14 @@
+# __init__.py
+from atk_common.interfaces.docker_handler_interface import IDockerHandler
+from atk_common.interfaces.env_handler_interface import IEnvHandler
+from atk_common.interfaces.error_handler_interface import IErrorHandler
+from atk_common.interfaces.http_response_handler_interface import IHttpResponseHandler
+from atk_common.interfaces.logger_interface import ILogger
+
+__all__ = [
+    'IDockerHandler',
+    'IEnvHandler',
+    'IErrorHandler',
+    'ILogger',
+    'IHttpResponseHandler',
+]

atk_common-3.0.0/src/atk_common/interfaces/docker_handler_interface.py

@@ -0,0 +1,9 @@
+# interfaces/logger_interface.py
+from typing import Protocol
+
+class IDockerHandler(Protocol):
+    def get_image_name_and_version(self, tags) -> None: ...
+    def create_port_item(port, binding) -> None: ...
+    def create_container_log(container_data) -> None: ...
+    def get_current_container_info() -> None: ...
+    def set_container_metadata(image_name_env_key, image_version_env_key) -> None: ...

atk_common-3.0.0/src/atk_common/interfaces/env_handler_interface.py

@@ -0,0 +1,8 @@
+# interfaces/env_handler_interface.py
+from typing import Protocol
+
+class IEnvHandler(Protocol):
+    def val_str(self, value) -> None: ...
+    def is_value_null_or_empty(self, value) -> None: ...
+    def get_env_value(self, msg: str) -> None: ...
+    def set_logger(self, logger) -> None: ...

atk_common-3.0.0/src/atk_common/interfaces/error_handler_interface.py

@@ -0,0 +1,11 @@
+# interfaces/error_handler_interface.py
+from typing import Protocol
+
+class IErrorHandler(Protocol):
+    def get_message(self, error) -> None: ...
+    def create_error_log(self, data) -> None: ...
+    def get_error_entity(self, error, method, error_type, status_code, container_info) -> None: ...
+    def resend_error_entity(self, error_entity) -> None: ...
+    def handle_error(self, resp, status) -> None: ...
+    def get_response_error(self, resp) -> None: ...
+    def get_error_type(self, conn) -> None: ...

atk_common-3.0.0/src/atk_common/interfaces/http_response_handler_interface.py

@@ -0,0 +1,5 @@
+# interfaces/env_handler_interface.py
+from typing import Protocol
+
+class IHttpResponseHandler(Protocol):
+    def http_response(self, method, response, container_info) -> None: ...

atk_common-3.0.0/src/atk_common/interfaces/logger_interface.py

@@ -0,0 +1,9 @@
+# interfaces/logger_interface.py
+from typing import Protocol
+
+class ILogger(Protocol):
+    def debug(self, msg: str) -> None: ...
+    def info(self, msg: str) -> None: ...
+    def warning(self, msg: str) -> None: ...
+    def error(self, msg: str) -> None: ...
+    def critical(self, msg: str) -> None: ...

atk_common-3.0.0/src/atk_common/utils/__init__.py

@@ -0,0 +1,47 @@
+# __init__.py
+from atk_common.utils.consumer_retry_handler import create_retry_handler
+from atk_common.utils.datetime_utils import \
+    get_utc_date_time, \
+    get_utc_date_time_str, \
+    get_utc_date_time_str_with_z, \
+    seconds_to_utc_timestamp, \
+    get_utc_date_from_iso, \
+    adjust_millisescond, \
+    convert_to_utc, \
+    convert_to_utc_image_dt
+from atk_common.utils.db_utils import sql, sql_with_record, convert_none_to_null, date_time_utc_column
+from atk_common.utils.default_should_retry import default_should_retry
+from atk_common.utils.error_utils import get_message
+from atk_common.utils.hash_utils import create_enforcement_hash
+from atk_common.utils.http_utils import is_http_status_ok, is_http_status_internal, get_test_response
+from atk_common.utils.internal_response_utils import create_response, is_response_ok, is_response_http, is_response_internal
+from atk_common.utils.file_utils import get_image_file_type
+from atk_common.utils.mq_utils import decode_message
+
+__all__ = [
+    'create_retry_handler',
+    'get_utc_date_time',
+    'get_utc_date_time_str',
+    'get_utc_date_time_str_with_z',
+    'seconds_to_utc_timestamp',
+    'get_utc_date_from_iso',
+    'adjust_millisescond',
+    'convert_to_utc',
+    'convert_to_utc_image_dt',
+    'sql',
+    'sql_with_record',
+    'convert_none_to_null',
+    'date_time_utc_column',
+    'default_should_retry',
+    'get_message',
+    'create_enforcement_hash',
+    'is_http_status_ok',
+    'is_http_status_internal',
+    'get_test_response',
+    'create_response',
+    'is_response_ok',
+    'is_response_http',
+    'is_response_internal',
+    'get_image_file_type',
+    'decode_message',
+]

{atk_common-2.1.0/src/atk_common → atk_common-3.0.0/src/atk_common/utils}/consumer_retry_handler.py

@@ -1,13 +1,17 @@
 from kombu import Producer
-from atk_common.internal_response_utils import is_response_ok
+from atk_common.classes.bo_logger import BoLogger
+from atk_common.utils.internal_response_utils import is_response_ok
 
-def create_retry_handler(process_func, connection, exchange, routing_key, should_retry, log, declare=None):
-    """
-    process_func: your original handler function (body, message)
-    retry_queue: kombu.Queue instance to republish to
-    should_retry: function(message_status) -> bool
-    log: function for logging
-    """
+"""
+process_func: your original handler function (body, message)
+connection: kombu.Connection instance to use for retrying (nullable)
+exchange: kombu.Exchange instance to publish to (nullable)
+routing_key: routing key for the exchange (nullable)
+should_retry: function(message_status) -> bool
+bo_logger: BoLogger instance for logging
+declare: optional kombu.DeclarativeExchange or Queue to declare before publishing
+"""
+def create_retry_handler(process_func, connection, exchange, routing_key, should_retry, bo_logger: BoLogger, declare=None):
 
     def handler(body, message):
         try:
@@ -18,7 +22,7 @@ def create_retry_handler(process_func, connection, exchange, routing_key, should
                 if connection is not None:
                     # Use retry queue
                     if should_retry(process_response):
-                        log("Retrying after delay...")
+                        bo_logger.info("Retrying after delay...")
                         with connection.Producer() as producer:
                             producer.publish(
                                 message.body,
@@ -33,17 +37,19 @@ def create_retry_handler(process_func, connection, exchange, routing_key, should
                             )
                         message.ack()
                     else:
-                        log("Sending to DLQ...")
+                        bo_logger.critical("Sending to DLQ...")
                         message.reject(requeue=False)
                 else:
                     if should_retry(process_response):
-                        log("Requing...")
-                        message.requeue()
-                    else:
-                        log("Sending to DLQ...")
+                        bo_logger.critical("Sending to DLQ...")
                         message.reject(requeue=False)
+                        # bo_logger.critical("Requing...")
+                        # message.requeue()
+                    else:
+                        bo_logger.critical("Discarding message...")
+                        message.ack()
         except Exception as e:
-            log(f"Error during processing: {e}")
+            bo_logger.critical(f"Error during processing: {e}, sending to DLQ...")
             message.reject(requeue=False)
 
     return handler

{atk_common-2.1.0/src/atk_common → atk_common-3.0.0/src/atk_common/utils}/default_should_retry.py

@@ -1,6 +1,6 @@
 from atk_common.enums.api_error_type_enum import ApiErrorType
 from atk_common.enums.response_status_type_enum import ResponseStatusType
-from atk_common.http_utils import is_http_status_internal, is_http_status_ok
+from atk_common.utils.http_utils import is_http_status_internal, is_http_status_ok
 
 def default_should_retry(message_status):
     if message_status['status'] == ResponseStatusType.HTTP:

atk_common-3.0.0/src/atk_common/utils/error_utils.py

@@ -0,0 +1,5 @@
+def get_message(error):
+    if hasattr(error, 'message'):
+        return str(error.message)
+    else:
+        return str(error)

{atk_common-2.1.0/src/atk_common → atk_common-3.0.0/src/atk_common/utils}/http_utils.py

@@ -1,5 +1,5 @@
 from http import HTTPStatus
-from atk_common.datetime_utils import get_utc_date_time_str
+from atk_common.utils.datetime_utils import get_utc_date_time_str
 
 def is_http_status_ok(status_code):
     return status_code >= HTTPStatus.OK.value and status_code < HTTPStatus.MULTIPLE_CHOICES.value

atk_common-3.0.0/src/atk_common/utils/mq_utils.py

@@ -0,0 +1,30 @@
+import json
+from http import HTTPStatus
+from atk_common.classes.bo_logger import BoLogger
+from atk_common.enums.response_status_type_enum import ResponseStatusType
+from atk_common.utils.error_utils import get_message
+from atk_common.utils.internal_response_utils import create_response
+
+def decode_message(body, message, bo_logger: BoLogger):
+    import gzip
+    import msgpack
+    try:
+        content_encoding = message.headers.get('content_encoding')
+        if content_encoding is not None and content_encoding == 'gzip':
+            body = gzip.decompress(body)
+        if message.content_type is None or message.content_type == '':
+            return create_response(ResponseStatusType.OK, HTTPStatus.OK, body)
+        elif message.content_type == 'application/json':
+            return create_response(ResponseStatusType.OK, HTTPStatus.OK, body)
+        elif message.content_type == 'application/octet-stream':
+            return create_response(ResponseStatusType.OK, HTTPStatus.OK, body)
+        elif message.content_type == 'application/x-msgpack' or message.content_type == 'application/msgpack':
+            return create_response(ResponseStatusType.OK, HTTPStatus.OK, msgpack.unpackb(body, raw=False))
+        elif message.content_type.startswith('text/'):
+            return create_response(ResponseStatusType.OK, HTTPStatus.OK, body.decode('utf-8'))
+        else:
+            bo_logger.critical(f"Unknown message content type {message.content_type}. Cannot decode message.")
+            return create_response(ResponseStatusType.INTERNAL, HTTPStatus.INTERNAL_SERVER_ERROR, get_message(error))
+    except Exception as error:
+        bo_logger.critical('Error decoding message: ' + get_message(error))
+        return create_response(ResponseStatusType.INTERNAL, HTTPStatus.INTERNAL_SERVER_ERROR, get_message(error))

{atk_common-2.1.0 → atk_common-3.0.0}/src/atk_common.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atk_common
-Version: 2.1.0
+Version: 3.0.0
 Summary: ATK common methods
 Home-page: https://github.com/pypa/atk_common
 Author: Roger