atk-common 2.1.0__py3-none-any.whl → 3.0.0__py3-none-any.whl

atk_common/__init__.py

@@ -1,67 +1 @@
 # __init__.py
-from atk_common.bo_logger import BoLogger
-from atk_common.consumer_retry_handler import create_retry_handler
-from atk_common.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.db_utils import sql, sql_with_record, convert_none_to_null, date_time_utc_column
-from atk_common.default_should_retry import default_should_retry
-from atk_common.docker_utils import get_current_container_info, set_container_metadata
-from atk_common.env_utils import get_env_value
-from atk_common.error_utils import get_message, create_error_log, get_error_entity, resend_error_entity, handle_error, get_response_error, get_error_type
-from atk_common.http_response_utils import http_response
-from atk_common.hash_utils import create_enforcement_hash
-from atk_common.http_utils import is_http_status_ok, is_http_status_internal, get_test_response
-from atk_common.internal_response_utils import create_response, is_response_ok, is_response_http, is_response_internal
-from atk_common.file_utils import get_image_file_type
-from atk_common.log_utils import add_log_item, add_log_item_http
-from atk_common.mq_utils import decode_message
-from atk_common.rabbitmq_consumer import RabbitMQConsumer
-
-__all__ = [
-    'BoLogger',
-    '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_current_container_info',
-    'set_container_metadata',
-    'get_env_value',
-    'get_message',
-    'create_error_log',
-    'get_error_entity',
-    'resend_error_entity',
-    'handle_error',
-    'get_response_error',
-    'get_error_type',
-    'create_enforcement_hash',
-    'http_response',
-    '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',
-    'add_log_item',
-    'add_log_item_http',
-    'decode_message',
-    'RabbitMQConsumer',
-]

atk_common/bo_logger.py

@@ -5,7 +5,10 @@ from atk_common.enums.log_level_enum import LogLevel
 
 class BoLogger:
     def __init__(self, log_level: LogLevel, log_url):
-        self.log_level = log_level
+        if log_level is None:
+            self.log_level = LogLevel.INFO.value
+        else:
+            self.log_level = log_level
         self.log_url = log_url
 
     def set_level(self, log_level):
@@ -28,16 +31,16 @@ class BoLogger:
             # Send log_json to self.log_url via HTTP POST request (Grafana Loki or similar)
 
     def debug(self, message: str):
-        self._log(LogLevel.DEBUG, message)
+        self._log(LogLevel.DEBUG.value, message)
 
     def info(self, message: str):
-        self._log(LogLevel.INFO, message)
+        self._log(LogLevel.INFO.value, message)
 
     def warning(self, message: str):
-        self._log(LogLevel.WARNING, message)
+        self._log(LogLevel.WARNING.value, message)
 
     def error(self, message: str):
-        self._log(LogLevel.ERROR, message)
+        self._log(LogLevel.ERROR.value, message)
 
     def critical(self, message: str):
-        self._log(LogLevel.CRITICAL, message)
+        self._log(LogLevel.CRITICAL.value, message)

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/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/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/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/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/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/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/http_response_utils.py

@@ -2,7 +2,7 @@ import json
 from flask import Response
 from http import HTTPStatus
 from atk_common.enums.api_error_type_enum import ApiErrorType
-from atk_common.error_utils import get_error_entity, resend_error_entity
+from atk_common.utils.error_utils import get_error_entity, resend_error_entity
 from atk_common.http_utils import is_http_status_internal, is_http_status_ok
 from atk_common.internal_response_utils import is_response_http
 

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/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/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/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/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/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/mq_utils.py

@@ -1,5 +1,5 @@
 import json
-from atk_common.error_utils import get_message
+from atk_common.utils.error_utils import get_message
 from atk_common.log_utils import add_log_item
 
 def decode_message(body, message):

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/utils/consumer_retry_handler.py

@@ -0,0 +1,55 @@
+from kombu import Producer
+from atk_common.classes.bo_logger import BoLogger
+from atk_common.utils.internal_response_utils import is_response_ok
+
+"""
+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:
+            process_response = process_func(body, message)
+            if is_response_ok(process_response):
+                message.ack()
+            else:
+                if connection is not None:
+                    # Use retry queue
+                    if should_retry(process_response):
+                        bo_logger.info("Retrying after delay...")
+                        with connection.Producer() as producer:
+                            producer.publish(
+                                message.body,
+                                exchange=exchange,
+                                routing_key=routing_key,
+                                retry=True,
+                                declare=declare,
+                                content_type=message.content_type,
+                                content_encoding=message.content_encoding,
+                                headers=message.headers,
+                                timestamp=message.properties.get("timestamp")
+                            )
+                        message.ack()
+                    else:
+                        bo_logger.critical("Sending to DLQ...")
+                        message.reject(requeue=False)
+                else:
+                    if should_retry(process_response):
+                        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:
+            bo_logger.critical(f"Error during processing: {e}, sending to DLQ...")
+            message.reject(requeue=False)
+
+    return handler

atk_common/utils/datetime_utils.py

@@ -0,0 +1,106 @@
+from datetime import datetime, timezone, timedelta
+from zoneinfo import ZoneInfo
+
+def get_utc_date_time():
+    return datetime.now(timezone.utc)
+
+def get_utc_date_time_str():
+    return str(datetime.now(timezone.utc))
+
+def get_utc_date_time_str_with_z():
+    return datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ')
+
+def seconds_to_utc_timestamp(seconds):
+    return str(datetime.fromtimestamp(seconds, tz=timezone.utc))
+
+def get_utc_date_from_iso(date_time):
+    dt = datetime.fromisoformat(date_time)
+    dt_utc = dt.astimezone(timezone.utc)
+    return str(dt_utc.date())
+
+def adjust_millisescond(dt_str):
+    if '.' in dt_str:
+        dt_part, frac = dt_str.split('.')
+        frac = frac[:6]  # keep only the first 6 digits
+        dt_str_clean = f"{dt_part}.{frac}"
+        return dt_str_clean
+    else:
+        dt_str_clean = dt_str
+        return dt_str_clean
+
+# Original datetime string, handles:
+# dt_str = '2023-02-01T14:13:08.653133+01:00'
+# dt_str = '2023-02-01T14:13:08.653133 01:00'
+# dt_str = '2024-01-03T08:13:52.705474147'
+def convert_to_utc(dt_str):
+    # Split datetime and offset
+    if '+' in dt_str:
+        parts = dt_str.split('+')
+    else:
+        parts = dt_str.split(' ')
+    if len(parts) == 2:
+        dt_part, offset_part = parts
+    else:
+        dt_part = parts[0]
+        offset_part = None  # or set a default if needed
+
+    dt_part = adjust_millisescond(dt_part)
+    dt_naive  = datetime.fromisoformat(dt_part)
+
+    if offset_part is None:
+        dt_aware = dt_naive.replace(tzinfo=ZoneInfo("Europe/Berlin"))
+        dt_utc = dt_aware.astimezone(ZoneInfo("UTC"))
+        return dt_utc.strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]
+    else:
+        # Create a timezone object using the offset
+        hours_offset = int(offset_part.split(':')[0])
+        minutes_offset = int(offset_part.split(':')[1])
+        tzinfo = timezone(timedelta(hours=hours_offset, minutes=minutes_offset))
+
+        # Assign the timezone to the datetime
+        dt_with_tz = dt_naive.replace(tzinfo=tzinfo)
+
+        # Convert to UTC
+        dt_utc =dt_with_tz.astimezone(timezone.utc)
+        return dt_utc.strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]
+
+# Original datetime string, handles:
+# dt_str = '2023-02-01 14:13:08.653133 +01:00'
+def convert_to_utc_image_dt(dt_str):
+    dt_str = dt_str.strip()
+    # Detect offset
+    if '+' in dt_str:
+        parts = dt_str.split('+')
+        sign = '+'
+    elif '-' in dt_str[10:]:  # avoid confusion with date part
+        parts = dt_str.split('-')
+        sign = '-'
+    else:
+        parts = [dt_str]
+        sign = None
+
+    if len(parts) == 2:
+        dt_part = parts[0].strip()
+        offset_part = parts[1].strip()
+        if sign == '-':
+            offset_part = '-' + offset_part
+        else:
+            offset_part = '+' + offset_part
+    else:
+        dt_part = parts[0].strip()
+        offset_part = None
+
+    dt_part = adjust_millisescond(dt_part)
+    dt_naive = datetime.fromisoformat(dt_part)
+
+    if offset_part is None:
+        dt_aware = dt_naive.replace(tzinfo=ZoneInfo("Europe/Berlin"))
+        dt_utc = dt_aware.astimezone(ZoneInfo("UTC"))
+    else:
+        offset_hours, offset_minutes = map(int, offset_part.split(':'))
+        delta = timedelta(hours=offset_hours, minutes=offset_minutes)
+        tz = timezone(delta)
+        dt_aware = dt_naive.replace(tzinfo=tz)
+        dt_utc = dt_aware.astimezone(timezone.utc)
+
+    return dt_utc.strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]

atk_common/utils/db_utils.py

@@ -0,0 +1,25 @@
+def sql(connection, sql, get_one):
+    from psycopg2.extras import RealDictCursor
+    with connection:
+        with connection.cursor(cursor_factory=RealDictCursor) as cursor:
+            cursor.execute(sql)
+            if get_one:
+                return cursor.fetchone()
+            return cursor.fetchall()
+
+def sql_with_record(connection, sql, record):
+    from psycopg2.extras import RealDictCursor
+    with connection:
+        with connection.cursor(cursor_factory=RealDictCursor) as cursor:
+            cursor.execute(sql, record)
+            return cursor.fetchone()
+
+def convert_none_to_null(value):
+    if value is None or value == '':
+        return 'null'
+    if type(value) is str:
+        return '\'' + value + '\''
+    return value
+
+def date_time_utc_column(column):
+    return 'TO_CHAR({0} at time zone \'UTC\', \'yyyy-mm-dd hh24:mi:ss.ms"Z"\')'.format(column)

atk_common/utils/default_should_retry.py

@@ -0,0 +1,19 @@
+from atk_common.enums.api_error_type_enum import ApiErrorType
+from atk_common.enums.response_status_type_enum import ResponseStatusType
+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:
+        status_code = message_status['statusCode']
+        if is_http_status_ok(status_code):
+            return False
+        elif is_http_status_internal(status_code):
+            #errorType = 1: connection error
+            #errorType = 2: api internal error (database, etc)
+            if message_status['responseMsg']['errorType'] == ApiErrorType.CONNECTION.value:
+                return True
+            else:
+                return False
+        else:
+            return True
+    return True

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/utils/file_utils.py

@@ -0,0 +1,4 @@
+def get_image_file_type(encoding):
+    if (encoding == 'Raw'):
+        return '.ATKIMAGE'
+    return '.jpg'

atk_common/utils/hash_utils.py

@@ -0,0 +1,21 @@
+import hashlib
+import json
+
+def create_enforcement_hash(request_json, created_on):
+    data = {}
+    data['commandTypeId'] = request_json['commandTypeId']
+    data['controlGroupId'] = request_json['controlGroupId']
+    data['controlSiteId'] = request_json['controlSiteId']
+    data['numberOfImages'] = request_json['numberOfImages']
+    data['startDatetime'] = request_json['startDatetime']
+    data['stopDatetime'] = request_json['stopDatetime']
+    data['speedLimit'] = request_json['speedLimit']
+    data['photoLimit'] = request_json['photoLimit']
+    data['heavyVehicleSpeedLimit'] = request_json['heavyVehicleSpeedLimit']
+    data['heavyVehiclePhotoLimit'] = request_json['heavyVehiclePhotoLimit']
+    data['testSeries'] = request_json['testSeries']
+    data['comment'] = request_json['comment']
+    data['commandCreatedBy'] = request_json['commandCreatedBy']
+    data['commandCreatedOn'] = created_on
+    json_to_hash = json.dumps(data, sort_keys = True).encode("utf-8")
+    return hashlib.md5(json_to_hash).hexdigest()

atk_common/utils/http_utils.py

@@ -0,0 +1,18 @@
+from http import HTTPStatus
+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
+
+def is_http_status_internal(status_code):
+    return status_code >= HTTPStatus.INTERNAL_SERVER_ERROR.value
+
+def get_test_response(docker_container_data, component):
+    data = {}
+    data['utcDateTime'] = get_utc_date_time_str()
+    if docker_container_data is None:
+        data['containerData'] = None
+        data['component'] = component
+    else:
+        data['containerData'] = docker_container_data
+    return data

atk_common/utils/internal_response_utils.py

@@ -0,0 +1,20 @@
+from atk_common.enums.response_status_type_enum import ResponseStatusType
+
+def create_response(status, status_code, response_msg, http_headers=None, content_type='application/json'):
+    data = {}
+    data['status'] = status
+    data['statusCode'] = status_code
+    data['responseMsg'] = response_msg
+    data['httpHeaders'] = http_headers
+    data['contentType'] = content_type
+    return data
+
+def is_response_ok(response):
+    return response['status'] == ResponseStatusType.OK
+
+def is_response_http(response):
+    return response['status'] == ResponseStatusType.HTTP
+
+def is_response_internal(response):
+    return response['status'] == ResponseStatusType.INTERNAL
+    

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.dist-info → atk_common-3.0.0.dist-info}/METADATA

@@ -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.dist-info → atk_common-3.0.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
-atk_common/__init__.py,sha256=YSwim0faSNsJ8G__eIc2QoD4P8KygxfQxF8Y2tgk_6Q,2465
-atk_common/bo_logger.py,sha256=Ac7Xzs24AWR6erYGgp8YZw5zNkSY1NSwbOZNq-OMrVU,1453
+atk_common/__init__.py,sha256=c3aje-XkwrJBNF2NZnBV2SMj28J5F2Ha5Y86JwbPlcc,15
+atk_common/bo_logger.py,sha256=lzaXwLO1REIbKoFIEa5hEZZXkF4wqTZV6wl4T5DF6uo,1583
 atk_common/consumer_retry_handler.py,sha256=H_s9COWmjuvbzcjWxe2XpxrwfZB0j1Ns6-NO5iaxFtM,2119
 atk_common/datetime_utils.py,sha256=0SC5-Nai4RJH9B0VzvGKUQts_QeRXGb7tJLlsh73LJw,3556
 atk_common/db_utils.py,sha256=odUtXcS7Mumw5eGyVyVimL_U_lP7TqMX9v8nWO5nMvg,902
@@ -9,13 +9,20 @@ atk_common/env_utils.py,sha256=VCXEaAEGWFdQr5x7pKmks1Xs_g6gyrcwikqSz2XfETo,813
 atk_common/error_utils.py,sha256=kO-VQlajD8SO9MBxj8MHZRTK_uBXgPa09hy6pfjqZBY,2622
 atk_common/file_utils.py,sha256=UDwcRquO9IrqRrlUM0t-_g4R1-FKt8ZqQinSEqXOAk8,112
 atk_common/hash_utils.py,sha256=S_9o89CdI4lUQbVaqc85TDcqyDNuo30_E3VBaOrZKko,1047
-atk_common/http_response_utils.py,sha256=xS3d3AkfpNDkvRRGSfdGhSaIR6MM0ZIC5N9ZoJs4cNo,1794
+atk_common/http_response_utils.py,sha256=pjTBoWceRowsgmtazkm2iI1oTpR8ips9mwXqJu6dnH4,1800
 atk_common/http_utils.py,sha256=Av6wMa9984zQqXSrU3jndxLQO1xwv9U7YDFvJqZQAuo,664
 atk_common/internal_response_utils.py,sha256=2X9eLFEy1pO3Aesj1IRXg2yprwNcBDM5_dXaA5vfmMI,694
 atk_common/log_utils.py,sha256=tw6Ph8oTpxrGYe_BcDTYkgrYmFAb1IxTXTodqctAIiY,504
-atk_common/mq_utils.py,sha256=IDni2Y2AVezsJGTwPY9QPZ95b8RT8osBKHhbYcWbp_U,1131
+atk_common/mq_utils.py,sha256=6z4l7LsZWCzldsCZPsWnCtN4lIQ3gyoSuywQoQOh5Ak,1137
 atk_common/rabbitmq_consumer.py,sha256=4MhuwZs47Jt1fX4sUxr1MKRe7o2QRbPe9_utXEsa8QE,1907
 atk_common/response_utils.py,sha256=AxlmwkFoDU5XcFOzBQiuZxAQgswihpKXHSo1T0JJw3Q,556
+atk_common/classes/__init__.py,sha256=O_VHYxAilmoz3i9L6jkwS-JZ4UaTezdhFiA5liNl1lY,532
+atk_common/classes/bo_logger.py,sha256=DKEVtdm_ikMT3fbEEyWS3zsWvKn86Cckby2lTBm1mkM,2088
+atk_common/classes/docker_handler.py,sha256=73WiebIT_RwGgwyvIed_Q5p8Tsb1b22JChBDyUmf1IU,2949
+atk_common/classes/env_handler.py,sha256=sFx5dNiZZVOfIdvahOiDUG5LdHLIz4gAqGQGz2dqVgo,1286
+atk_common/classes/error_handler.py,sha256=PrQ3njxYrqVCJzwdS2cSyshNktT_AHFMMRaC9vKtjyg,3257
+atk_common/classes/http_response_handler.py,sha256=B83UW-W6pE5BcUaoYcIb1RS-TzZEeZ22vgWmvB7xT30,2176
+atk_common/classes/rabbitmq_consumer.py,sha256=aPMF5H50k__a1HEy8GGwNdhSqu-wjbw2L3TESyd1cEg,2941
 atk_common/enums/__init__.py,sha256=hOSoKWIBUpRFaMN2tNJiel6iGI1MHj229OYnU1J8Jg0,2636
 atk_common/enums/api_error_type_enum.py,sha256=9oW6ZaZ3lhMwR8r2sVNWGliS9C_jV-otiOYdezAuTp0,91
 atk_common/enums/camera_cabinet_type_enum.py,sha256=U2NVrsTCBgaMRwYJamnjshAW8Y7xlOVjvUzakdgVH9A,90
@@ -56,8 +63,25 @@ atk_common/enums/speed_control_status_type_enum.py,sha256=qpURh0K1L1tSpbrzVnckoe
 atk_common/enums/speed_control_stop_reason.py,sha256=pvLS6fpDhsCiIDAmiQBsHctxZnq-Dl2BOgJOxQnT5Hc,200
 atk_common/enums/test_image_type_enum.py,sha256=HUjxJorehnzRXMNF2uHk2DrAJ3Y_ajQvp0jW-mtlOhU,140
 atk_common/enums/violation_type_enum.py,sha256=01qTHOj-O8bOc-nwIHVnxLosm4cusD_YuqXM3ZsiRRk,86
-atk_common-2.1.0.dist-info/licenses/license.txt,sha256=_0O6fWM00-wTurDjnZhUP_N5QiwGhItaQZqHq5eqadA,1063
-atk_package/__init__.py,sha256=NcsmwFadivgIeWV0-5ACZxqmfo4EzTkJX0r4N6DFAdg,820
+atk_common/interfaces/__init__.py,sha256=HynEg28Uy3msO7qd__VxajTasSe9-Evpj9yi3Uw2NTo,508
+atk_common/interfaces/docker_handler_interface.py,sha256=aCJ6cELRlrbZC-sB-RQEpKhChCMEiYNclcfr62YjSCo,411
+atk_common/interfaces/env_handler_interface.py,sha256=yrmtTplH5tnuOAs7CW5RtzLMTE5q9sdzTYjiS2naNQQ,300
+atk_common/interfaces/error_handler_interface.py,sha256=H43hSeeThT_7EbNzh-rygAJWNAmyzFetodiXdmqKshU,522
+atk_common/interfaces/http_response_handler_interface.py,sha256=QjDmhVj4AnUyoRtSHk_sfFPI-cto6TV7Mx2_87tiOrs,185
+atk_common/interfaces/logger_interface.py,sha256=w9bhheJFCQ76qpoO_o0N-F6KVKf4HaHOKLRx_c7Jgsk,315
+atk_common/utils/__init__.py,sha256=HPqGmoNy6y1Bgu3Um_o1g0R5DnS-UZv1_ueC4i0uP30,1708
+atk_common/utils/consumer_retry_handler.py,sha256=TxlcX7JzU7XBXxGrpWHyisrpouItU0cLisVgTwO0boc,2601
+atk_common/utils/datetime_utils.py,sha256=0SC5-Nai4RJH9B0VzvGKUQts_QeRXGb7tJLlsh73LJw,3556
+atk_common/utils/db_utils.py,sha256=odUtXcS7Mumw5eGyVyVimL_U_lP7TqMX9v8nWO5nMvg,902
+atk_common/utils/default_should_retry.py,sha256=qghFbU71ygC8ARc0jkbDlxwZtwEPUqO8vGhIhGJX-Ao,838
+atk_common/utils/error_utils.py,sha256=i6AAW7g0CJJYRgnyruoTI6jujuC2vAH5938fb4mjeCw,133
+atk_common/utils/file_utils.py,sha256=UDwcRquO9IrqRrlUM0t-_g4R1-FKt8ZqQinSEqXOAk8,112
+atk_common/utils/hash_utils.py,sha256=S_9o89CdI4lUQbVaqc85TDcqyDNuo30_E3VBaOrZKko,1047
+atk_common/utils/http_utils.py,sha256=eSRuQeDgN0ISQdByZqE6cIGXoorcAXz7PEtVntHUKAo,670
+atk_common/utils/internal_response_utils.py,sha256=2X9eLFEy1pO3Aesj1IRXg2yprwNcBDM5_dXaA5vfmMI,694
+atk_common/utils/mq_utils.py,sha256=W4EVbM9FMPEwk7QJGksTqPN_of3yL1kBIhWpQNi6v_I,1859
+atk_common-3.0.0.dist-info/licenses/license.txt,sha256=_0O6fWM00-wTurDjnZhUP_N5QiwGhItaQZqHq5eqadA,1063
+atk_package/__init__.py,sha256=okIFEefQhQrw6DZg6oCEVWsEdkVCk-57VXBW0IUG_wU,834
 atk_package/datetime_utils.py,sha256=qsVF7l90P1-xukG2tV_jLqG9J_Yfl5wTpyfrdPBlyMo,239
 atk_package/env_utils.py,sha256=bXOrxM3fZUslqfmZt75iphbEJHbG4riJa8XOVzPwIII,313
 atk_package/error_utils.py,sha256=C-1GPo4hXHd0reW1gMEqyTjLMt257adGDjdYIyftiRE,1430
@@ -69,7 +93,7 @@ atk_package/enums/__init__.py,sha256=EtUr_--MQj1Rc_R0sF_ELXIThmhpfmhDWq3YaK9oQMk
 atk_package/enums/command_status_enum.py,sha256=M2Nln27a_DbzI07-gfytWQk2X087JhkU6Fmard5qVHs,127
 atk_package/enums/speed_control_status_enum.py,sha256=qpURh0K1L1tSpbrzVnckoe4hUn1illIkbo7k4mLfzIM,182
 shared_python_atk_enforcement/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-atk_common-2.1.0.dist-info/METADATA,sha256=bNqGgMP6r26lVwpyb-ABHeLbAQ0oFedLpwI8emqz7ms,1760
-atk_common-2.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-atk_common-2.1.0.dist-info/top_level.txt,sha256=4CwRjkLnheIdI4jQwc4tK3dbRc58WqUmoqjkdDTWlME,41
-atk_common-2.1.0.dist-info/RECORD,,
+atk_common-3.0.0.dist-info/METADATA,sha256=axS2RZluWJzOwXZT_YcnbIez7lAmxGLaXjEvVmaE-80,1760
+atk_common-3.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+atk_common-3.0.0.dist-info/top_level.txt,sha256=4CwRjkLnheIdI4jQwc4tK3dbRc58WqUmoqjkdDTWlME,41
+atk_common-3.0.0.dist-info/RECORD,,

atk_package/__init__.py

@@ -1,10 +1,10 @@
 # __init__.py
 from atk_common.datetime_utils import date_time_utc, get_utc_date_time
 from atk_common.env_utils import get_env_value
-from atk_common.error_utils import get_message, get_error_entity, handle_error, get_response_error, get_error_type
+from atk_common.utils.error_utils import get_message, get_error_entity, handle_error, get_response_error, get_error_type
 from atk_common.http_utils import is_status_code_ok
 from atk_common.log_utils import add_log_item, add_log_item_http
-from atk_common.rabbitmq_consumer import RabbitMQConsumer
+from atk_common.classes.rabbitmq_consumer import RabbitMQConsumer
 from atk_common.internal_response_utils import create_save_resp
 
 __all__ = [