adapta 3.3.22a532.dev6__py3-none-any.whl → 3.5.13__py3-none-any.whl

adapta/__init__.py

@@ -2,7 +2,7 @@
  Global index.
 """
 
-#  Copyright (c) 2023-2024. ECCO Sneaks & Data
+#  Copyright (c) 2023-2026. ECCO Data & AI and other project contributors.
 #
 #  Licensed under the Apache License, Version 2.0 (the "License");
 #  you may not use this file except in compliance with the License.

adapta/_version.py

@@ -1 +1 @@
-__version__ = 'v3.3.22a532.dev6'
+__version__ = '3.5.13'

adapta/connectors/__init__.py

@@ -1,4 +1,4 @@
-#  Copyright (c) 2023-2024. ECCO Sneaks & Data
+#  Copyright (c) 2023-2026. ECCO Data & AI and other project contributors.
 #
 #  Licensed under the Apache License, Version 2.0 (the "License");
 #  you may not use this file except in compliance with the License.

adapta/connectors/service_bus/__init__.py

@@ -1,6 +1,6 @@
 """init file"""
 
-#  Copyright (c) 2023-2024. ECCO Sneaks & Data
+#  Copyright (c) 2023-2026. ECCO Data & AI and other project contributors.
 #
 #  Licensed under the Apache License, Version 2.0 (the "License");
 #  you may not use this file except in compliance with the License.

adapta/connectors/service_bus/_connector.py

@@ -1,7 +1,7 @@
 """
     Connector for Azure Service Bus.
 """
-#  Copyright (c) 2023-2024. ECCO Sneaks & Data
+#  Copyright (c) 2023-2026. ECCO Data & AI and other project contributors.
 #
 #  Licensed under the Apache License, Version 2.0 (the "License");
 #  you may not use this file except in compliance with the License.
@@ -16,7 +16,6 @@
 #  limitations under the License.
 #
 
-from typing import Optional
 import os
 from azure.servicebus import (
     ServiceBusSender,
@@ -31,7 +30,7 @@ class AzureServiceBusConnector:
     Connector for Azure Service Bus.
     """
 
-    def __init__(self, conn_str: Optional[str] = None, queue_name: Optional[str] = None):
+    def __init__(self, conn_str: str | None = None, queue_name: str | None = None):
         self.service_bus_client: ServiceBusClient = ServiceBusClient.from_connection_string(
             conn_str=conn_str if conn_str is not None else os.environ["SERVICE_BUS_CONNECTION_STRING"],
             transport_type=TransportType.Amqp,

adapta/logs/__init__.py

@@ -1,7 +1,7 @@
 """
  Module index.
 """
-#  Copyright (c) 2023-2024. ECCO Sneaks & Data
+#  Copyright (c) 2023-2026. ECCO Data & AI and other project contributors.
 #
 #  Licensed under the Apache License, Version 2.0 (the "License");
 #  you may not use this file except in compliance with the License.

adapta/logs/_async_logger.py

@@ -3,7 +3,7 @@
 """
 import asyncio
 
-#  Copyright (c) 2023-2024. ECCO Sneaks & Data
+#  Copyright (c) 2023-2026. ECCO Data & AI and other project contributors.
 #
 #  Licensed under the Apache License, Version 2.0 (the "License");
 #  you may not use this file except in compliance with the License.
@@ -19,11 +19,12 @@ import asyncio
 #
 
 import logging
+import sys
 import threading
 from contextlib import asynccontextmanager
 from logging.handlers import QueueHandler, QueueListener
-from multiprocessing import Queue
-from typing import final, TypeVar, Generic, Type, List, Optional, Dict
+from queue import Queue
+from typing import final, TypeVar, Generic
 
 from adapta.logs._internal import MetadataLogger
 from adapta.logs._internal_logger import _InternalLogger
@@ -38,11 +39,11 @@ class _AsyncLogger(Generic[TLogger], _InternalLogger):
     Asyncio-safe wrapper for MetadataLogger
     """
 
-    def redirect(self, tags: Optional[Dict[str, str]] = None, **kwargs):
+    def redirect(self, tags: dict[str, str] | None = None, **kwargs):
         return self._redirect(logger=self._logger, tags=tags)
 
     @asynccontextmanager
-    async def redirect_async(self, tags: Optional[Dict[str, str]] = None, **kwargs):
+    async def redirect_async(self, tags: dict[str, str] | None = None, **kwargs):
         is_active = False
         tmp_symlink_out = b""
         tmp_symlink_err = b""
@@ -57,16 +58,26 @@ class _AsyncLogger(Generic[TLogger], _InternalLogger):
             # externally control the flushing process
             while is_active:
                 start_position_out = self._flush_and_log(
-                    pos=start_position_out, tmp_symlink=tmp_symlink_out, logger=self._logger, tags=tags
+                    pos=start_position_out,
+                    tmp_symlink=tmp_symlink_out,
+                    logger=self._logger,
+                    tags=tags,
+                    channel=sys.stdout,
                 )
                 start_position_err = self._flush_and_log(
-                    pos=start_position_err, tmp_symlink=tmp_symlink_err, logger=self._logger, tags=tags
+                    pos=start_position_err,
+                    tmp_symlink=tmp_symlink_err,
+                    logger=self._logger,
+                    tags=tags,
+                    channel=sys.stderr,
                 )
                 await asyncio.sleep(0.1)
 
             return self._flush_and_log(
-                pos=start_position_out, tmp_symlink=tmp_symlink_out, logger=self._logger, tags=tags
-            ), self._flush_and_log(pos=start_position_err, tmp_symlink=tmp_symlink_err, logger=self._logger, tags=tags)
+                pos=start_position_out, tmp_symlink=tmp_symlink_out, logger=self._logger, tags=tags, channel=sys.stdout
+            ), self._flush_and_log(
+                pos=start_position_err, tmp_symlink=tmp_symlink_err, logger=self._logger, tags=tags, channel=sys.stderr
+            )
 
         self._handle_unsupported_redirect(tags)
         libc, saved_stdout, saved_stderr, tmp_file_out, tmp_file_err = self._prepare_redirect()
@@ -86,8 +97,8 @@ class _AsyncLogger(Generic[TLogger], _InternalLogger):
         self,
         name: str,
         min_log_level: LogLevel,
-        log_handlers: List[logging.Handler],
-        fixed_template: Optional[Dict[str, Dict[str, str]]] = None,
+        log_handlers: list[logging.Handler],
+        fixed_template: dict[str, dict[str, str]] | None = None,
         fixed_template_delimiter=", ",
         global_tags: dict[str, str] | None = None,
     ):
@@ -98,14 +109,14 @@ class _AsyncLogger(Generic[TLogger], _InternalLogger):
         self._logger_queue_handler = QueueHandler(self._logger_message_queue)
         self._logger.addHandler(self._logger_queue_handler)
         self._log_handlers = log_handlers
-        self._listener: Optional[QueueListener] = None
+        self._listener: QueueListener | None = None
         self._is_active: bool = False
         self._lock = threading.RLock()
 
     def info(
         self,
         template: str,
-        tags: Optional[Dict[str, str]] = None,
+        tags: dict[str, str] | None = None,
         **kwargs,
     ) -> None:
         """
@@ -121,8 +132,8 @@ class _AsyncLogger(Generic[TLogger], _InternalLogger):
     def warning(
         self,
         template: str,
-        exception: Optional[BaseException] = None,
-        tags: Optional[Dict[str, str]] = None,
+        exception: BaseException | None = None,
+        tags: dict[str, str] | None = None,
         **kwargs,
     ) -> None:
         """
@@ -139,8 +150,8 @@ class _AsyncLogger(Generic[TLogger], _InternalLogger):
     def error(
         self,
         template: str,
-        exception: Optional[BaseException] = None,
-        tags: Optional[Dict[str, str]] = None,
+        exception: BaseException | None = None,
+        tags: dict[str, str] | None = None,
         **kwargs,
     ) -> None:
         """
@@ -157,9 +168,9 @@ class _AsyncLogger(Generic[TLogger], _InternalLogger):
     def debug(
         self,
         template: str,
-        exception: Optional[BaseException] = None,
-        diagnostics: Optional[str] = None,  # pylint: disable=R0913
-        tags: Optional[Dict[str, str]] = None,
+        exception: BaseException | None = None,
+        diagnostics: str | None = None,  # pylint: disable=R0913
+        tags: dict[str, str] | None = None,
         **kwargs,
     ) -> None:
         """
@@ -206,10 +217,10 @@ class _AsyncLogger(Generic[TLogger], _InternalLogger):
 
 
 def create_async_logger(
-    logger_type: Type[TLogger],
-    log_handlers: List[logging.Handler],
+    logger_type: type[TLogger],
+    log_handlers: list[logging.Handler],
     min_log_level: LogLevel = LogLevel.INFO,
-    fixed_template: Optional[Dict[str, Dict[str, str]]] = None,
+    fixed_template: dict[str, dict[str, str]] | None = None,
     fixed_template_delimiter=", ",
     global_tags: dict[str, str] = None,
 ) -> _AsyncLogger[TLogger]:

adapta/logs/_base.py

@@ -1,7 +1,7 @@
 """
  Adapta Logging Interface.
 """
-#  Copyright (c) 2023-2024. ECCO Sneaks & Data
+#  Copyright (c) 2023-2026. ECCO Data & AI and other project contributors.
 #
 #  Licensed under the Apache License, Version 2.0 (the "License");
 #  you may not use this file except in compliance with the License.
@@ -18,7 +18,7 @@
 
 import logging
 from logging import Handler, StreamHandler
-from typing import List, Optional, Dict, final
+from typing import final
 
 from adapta.logs._internal_logger import _InternalLogger
 from adapta.logs.models import LogLevel
@@ -31,10 +31,10 @@ class SemanticLogger(_InternalLogger):
     Proxy for a collection of python loggers that use the same formatting interface.
     """
 
-    async def redirect_async(self, tags: Optional[Dict[str, str]] = None, **kwargs):
+    async def redirect_async(self, tags: dict[str, str] | None = None, **kwargs):
         raise NotImplementedError("Async operations are not supported by this logger")
 
-    def redirect(self, tags: Optional[Dict[str, str]] = None, log_source_name: Optional[str] = None, **kwargs):
+    def redirect(self, tags: dict[str, str] | None = None, log_source_name: str | None = None, **kwargs):
         return self._redirect(logger=self._get_logger(log_source_name), tags=tags)
 
     def start(self) -> None:
@@ -43,7 +43,7 @@ class SemanticLogger(_InternalLogger):
     def stop(self) -> None:
         pass
 
-    def __init__(self, fixed_template: Optional[Dict[str, Dict[str, str]]] = None, fixed_template_delimiter=", "):
+    def __init__(self, fixed_template: dict[str, dict[str, str]] | None = None, fixed_template_delimiter=", "):
         """
           Creates a new instance of a SemanticLogger
 
@@ -51,7 +51,7 @@ class SemanticLogger(_InternalLogger):
         :param fixed_template_delimiter: Optional delimiter to use when appending fixed templates.
         """
         super().__init__(fixed_template, fixed_template_delimiter)
-        self._loggers: Dict[str, logging.Logger] = {}
+        self._loggers: dict[str, logging.Logger] = {}
         self._default_log_source = None
         self._fixed_template = fixed_template
         self._fixed_template_delimiter = fixed_template_delimiter
@@ -62,7 +62,7 @@ class SemanticLogger(_InternalLogger):
         *,
         log_source_name: str,
         min_log_level: LogLevel,
-        log_handlers: Optional[List[Handler]] = None,
+        log_handlers: list[Handler] | None = None,
         is_default=False,
     ) -> "SemanticLogger":
         """
@@ -90,13 +90,13 @@ class SemanticLogger(_InternalLogger):
 
         return self
 
-    def __getattr__(self, log_source) -> Optional[logging.Logger]:
+    def __getattr__(self, log_source) -> logging.Logger | None:
         if log_source in self._loggers:
             return self._loggers[log_source]
 
         return None
 
-    def _get_logger(self, log_source_name: Optional[str] = None) -> MetadataLogger:
+    def _get_logger(self, log_source_name: str | None = None) -> MetadataLogger:
         """
           Retrieves a logger by log source name, or a default logger is log source name is not provided.
 
@@ -117,8 +117,8 @@ class SemanticLogger(_InternalLogger):
     def info(
         self,
         template: str,
-        tags: Optional[Dict[str, str]] = None,
-        log_source_name: Optional[str] = None,
+        tags: dict[str, str] | None = None,
+        log_source_name: str | None = None,
         **kwargs,
     ) -> None:
         """
@@ -136,9 +136,9 @@ class SemanticLogger(_InternalLogger):
     def warning(
         self,
         template: str,
-        exception: Optional[BaseException] = None,
-        tags: Optional[Dict[str, str]] = None,
-        log_source_name: Optional[str] = None,
+        exception: BaseException | None = None,
+        tags: dict[str, str] | None = None,
+        log_source_name: str | None = None,
         **kwargs,
     ) -> None:
         """
@@ -157,9 +157,9 @@ class SemanticLogger(_InternalLogger):
     def error(
         self,
         template: str,
-        exception: Optional[BaseException] = None,
-        tags: Optional[Dict[str, str]] = None,
-        log_source_name: Optional[str] = None,
+        exception: BaseException | None = None,
+        tags: dict[str, str] | None = None,
+        log_source_name: str | None = None,
         **kwargs,
     ) -> None:
         """
@@ -178,10 +178,10 @@ class SemanticLogger(_InternalLogger):
     def debug(
         self,
         template: str,
-        exception: Optional[BaseException] = None,
-        diagnostics: Optional[str] = None,  # pylint: disable=R0913
-        tags: Optional[Dict[str, str]] = None,
-        log_source_name: Optional[str] = None,
+        exception: BaseException | None = None,
+        diagnostics: str | None = None,  # pylint: disable=R0913
+        tags: dict[str, str] | None = None,
+        log_source_name: str | None = None,
         **kwargs,
     ) -> None:
         """

adapta/logs/_internal.py

@@ -1,5 +1,5 @@
 """Classes for internal use by `adapta.logs` module. Should not be imported outside this module"""
-#  Copyright (c) 2023-2024. ECCO Sneaks & Data
+#  Copyright (c) 2023-2026. ECCO Data & AI and other project contributors.
 #
 #  Licensed under the Apache License, Version 2.0 (the "License");
 #  you may not use this file except in compliance with the License.
@@ -15,7 +15,6 @@
 #
 
 import logging
-from typing import Optional, Dict
 
 from adapta.logs.models import CompositeLogMetadata, LogLevel
 
@@ -39,11 +38,11 @@ class MetadataLogger(logging.Logger):
         log_level: int,
         msg: str,
         template: str,
-        tags: Optional[Dict[str, str]],
-        diagnostics: Optional[str],
+        tags: dict[str, str] | None,
+        diagnostics: str | None,
         stack_info: bool,
-        metadata_fields: Optional[Dict[str, str]],
-        exception: Optional[BaseException],
+        metadata_fields: dict[str, str] | None,
+        exception: BaseException | None,
     ):
         """
         Creates log entry with metadata from Composite Logger
@@ -77,7 +76,7 @@ class MetadataLogger(logging.Logger):
         )
 
 
-def from_log_level(log_level: Optional[LogLevel]) -> Optional[int]:
+def from_log_level(log_level: LogLevel | None) -> int | None:
     """
     Converts adapta log level to logging log level
     """

adapta/logs/_internal_logger.py

@@ -3,7 +3,7 @@
 """
 import ctypes
 
-#  Copyright (c) 2023-2024. ECCO Sneaks & Data
+#  Copyright (c) 2023-2026. ECCO Data & AI and other project contributors.
 #
 #  Licensed under the Apache License, Version 2.0 (the "License");
 #  you may not use this file except in compliance with the License.
@@ -28,7 +28,7 @@ from abc import ABC
 from contextlib import contextmanager
 from threading import Thread
 from time import sleep
-from typing import Any
+from typing import Any, TextIO
 
 from adapta.logs._internal import MetadataLogger, from_log_level
 from adapta.logs._logger_interface import LoggerInterface
@@ -65,6 +65,17 @@ class _InternalLogger(LoggerInterface, ABC):
 
         return fixed_args
 
+    def _get_format_args(self, **kwargs) -> tuple[dict, dict]:
+        base_args = self._get_fixed_args()
+        duplicates = {}
+        for arg_name, arg_value in kwargs.items():
+            if arg_name in base_args:
+                duplicates[arg_name] = arg_value
+            else:
+                base_args[arg_name] = arg_value
+
+        return base_args, duplicates
+
     def _get_template(self, template) -> str:
         return (
             self._fixed_template_delimiter.join([template, ", ".join(self._fixed_template.keys())])
@@ -72,6 +83,30 @@ class _InternalLogger(LoggerInterface, ABC):
             else template
         )
 
+    def _log_malformed_template(
+        self,
+        logger: MetadataLogger,
+        duplicates: dict[str, str],
+        tags: dict[str, str] = None,
+        **kwargs,
+    ) -> None:
+        dup_template = " ".join(
+            [
+                "Duplicated log properties provided:",
+                ", ".join(map(lambda key: "".join(["{", key, "}"]), duplicates.keys())),
+            ]
+        )
+        logger.log_with_metadata(
+            logging.WARN,
+            msg=dup_template.format(**duplicates),
+            template=dup_template,
+            tags=(tags or {}) | self._global_tags,
+            diagnostics=None,
+            stack_info=False,
+            exception=None,
+            metadata_fields=self._get_metadata_fields(kwargs),
+        )
+
     def _meta_info(
         self,
         template: str,
@@ -88,7 +123,8 @@ class _InternalLogger(LoggerInterface, ABC):
         :param kwargs: Templated arguments (key=value).
         :return:
         """
-        msg = self._get_template(template).format(**self._get_fixed_args(), **kwargs)
+        log_args, duplicates = self._get_format_args(**kwargs)
+        msg = self._get_template(template).format(**log_args)
         logger.log_with_metadata(
             logging.INFO,
             msg=msg,
@@ -99,6 +135,8 @@ class _InternalLogger(LoggerInterface, ABC):
             exception=None,
             metadata_fields=self._get_metadata_fields(kwargs),
         )
+        if len(duplicates) > 0:
+            self._log_malformed_template(logger, duplicates, tags, **kwargs)
 
     def _meta_warning(
         self,
@@ -118,7 +156,8 @@ class _InternalLogger(LoggerInterface, ABC):
         :param kwargs: Templated arguments (key=value).
         :return:
         """
-        msg = self._get_template(template).format(**self._get_fixed_args(), **kwargs)
+        log_args, duplicates = self._get_format_args(**kwargs)
+        msg = self._get_template(template).format(**log_args)
         logger.log_with_metadata(
             logging.WARN,
             msg=msg,
@@ -129,6 +168,8 @@ class _InternalLogger(LoggerInterface, ABC):
             exception=exception,
             metadata_fields=self._get_metadata_fields(kwargs),
         )
+        if len(duplicates) > 0:
+            self._log_malformed_template(logger, duplicates, tags, **kwargs)
 
     def _meta_error(
         self,
@@ -148,7 +189,8 @@ class _InternalLogger(LoggerInterface, ABC):
         :param kwargs: Templated arguments (key=value).
         :return:
         """
-        msg = self._get_template(template).format(**self._get_fixed_args(), **kwargs)
+        log_args, duplicates = self._get_format_args(**kwargs)
+        msg = self._get_template(template).format(**log_args)
         logger.log_with_metadata(
             logging.ERROR,
             msg=msg,
@@ -159,6 +201,8 @@ class _InternalLogger(LoggerInterface, ABC):
             exception=exception,
             metadata_fields=self._get_metadata_fields(kwargs),
         )
+        if len(duplicates) > 0:
+            self._log_malformed_template(logger, duplicates, tags, **kwargs)
 
     def _meta_debug(
         self,
@@ -179,7 +223,8 @@ class _InternalLogger(LoggerInterface, ABC):
         :param kwargs: Templated arguments (key=value).
         :return:
         """
-        msg = self._get_template(template).format(**self._get_fixed_args(), **kwargs)
+        log_args, duplicates = self._get_format_args(**kwargs)
+        msg = self._get_template(template).format(**log_args)
         logger.log_with_metadata(
             logging.DEBUG,
             msg=msg,
@@ -190,6 +235,8 @@ class _InternalLogger(LoggerInterface, ABC):
             exception=exception,
             metadata_fields=self._get_metadata_fields(kwargs),
         )
+        if len(duplicates) > 0:
+            self._log_malformed_template(logger, duplicates, tags, **kwargs)
 
     def _log_redirect_message(
         self,
@@ -255,20 +302,23 @@ class _InternalLogger(LoggerInterface, ABC):
         pos: int,
         tmp_symlink: bytes,
         logger: MetadataLogger,
+        channel: TextIO,
         tags: dict[str, str] | None = None,
         log_level: LogLevel | None = None,
     ) -> int:
-        sys.stdout.flush()
-        with open(tmp_symlink, "r", encoding="utf-8") as output:
+        channel.flush()
+        with open(tmp_symlink, encoding="utf-8") as output:
             output.seek(pos)
             for line in output.readlines():
-                self._log_redirect_message(
-                    logger,
-                    base_template="Redirected output: {message}",
-                    message=line,
-                    tags=(tags or {}) | self._global_tags,
-                    log_level=log_level,
-                )
+                clean_line = line.strip("\n")
+                if clean_line:
+                    self._log_redirect_message(
+                        logger,
+                        base_template="Redirected output: {message}",
+                        message=clean_line,
+                        tags=(tags or {}) | self._global_tags,
+                        log_level=log_level,
+                    )
             return output.tell()
 
     def _handle_unsupported_redirect(
@@ -309,6 +359,7 @@ class _InternalLogger(LoggerInterface, ABC):
                     logger=logger,
                     tags=(tags or {}) | self._global_tags,
                     log_level=log_level,
+                    channel=sys.stdout,
                 )
                 start_position_err = self._flush_and_log(
                     pos=start_position_err,
@@ -316,6 +367,7 @@ class _InternalLogger(LoggerInterface, ABC):
                     logger=logger,
                     tags=(tags or {}) | self._global_tags,
                     log_level=log_level,
+                    channel=sys.stderr,
                 )
                 sleep(0.1)
 
@@ -325,12 +377,14 @@ class _InternalLogger(LoggerInterface, ABC):
                 logger=logger,
                 tags=(tags or {}) | self._global_tags,
                 log_level=log_level,
+                channel=sys.stdout,
             ), self._flush_and_log(
                 pos=start_position_err,
                 tmp_symlink=tmp_symlink_err,
                 logger=logger,
                 tags=(tags or {}) | self._global_tags,
                 log_level=log_level,
+                channel=sys.stderr,
             )
 
         self._handle_unsupported_redirect(tags)

adapta/logs/_logger_interface.py

@@ -3,10 +3,9 @@
 """
 from abc import ABC, abstractmethod
 from contextlib import contextmanager, asynccontextmanager
-from typing import Optional, Dict
 
 
-#  Copyright (c) 2023-2024. ECCO Sneaks & Data
+#  Copyright (c) 2023-2026. ECCO Data & AI and other project contributors.
 #
 #  Licensed under the Apache License, Version 2.0 (the "License");
 #  you may not use this file except in compliance with the License.
@@ -28,14 +27,14 @@ class LoggerInterface(ABC):
     """
 
     @abstractmethod
-    def info(self, template: str, tags: Optional[Dict[str, str]] = None, **kwargs):
+    def info(self, template: str, tags: dict[str, str] | None = None, **kwargs):
         """
         Logs a message on INFO level
         """
 
     @abstractmethod
     def warning(
-        self, template: str, exception: Optional[BaseException] = None, tags: Optional[Dict[str, str]] = None, **kwargs
+        self, template: str, exception: BaseException | None = None, tags: dict[str, str] | None = None, **kwargs
     ):
         """
         Logs a message on WARN level
@@ -43,7 +42,7 @@ class LoggerInterface(ABC):
 
     @abstractmethod
     def error(
-        self, template: str, exception: Optional[BaseException] = None, tags: Optional[Dict[str, str]] = None, **kwargs
+        self, template: str, exception: BaseException | None = None, tags: dict[str, str] | None = None, **kwargs
     ):
         """
         Logs a message on ERROR level
@@ -53,9 +52,9 @@ class LoggerInterface(ABC):
     def debug(
         self,
         template: str,
-        exception: Optional[BaseException] = None,
-        diagnostics: Optional[str] = None,
-        tags: Optional[Dict[str, str]] = None,
+        exception: BaseException | None = None,
+        diagnostics: str | None = None,
+        tags: dict[str, str] | None = None,
         **kwargs
     ):
         """
@@ -76,7 +75,7 @@ class LoggerInterface(ABC):
 
     @contextmanager
     @abstractmethod
-    def redirect(self, tags: Optional[Dict[str, str]] = None, **kwargs):
+    def redirect(self, tags: dict[str, str] | None = None, **kwargs):
         """
          Redirects stdout to a temporary file and dumps its contents as INFO messages
          once the wrapped code block finishes execution. Stdout is restored after the block completes execution.
@@ -101,7 +100,7 @@ class LoggerInterface(ABC):
 
     @asynccontextmanager
     @abstractmethod
-    async def redirect_async(self, tags: Optional[Dict[str, str]] = None, **kwargs):
+    async def redirect_async(self, tags: dict[str, str] | None = None, **kwargs):
         """
         Async version of a redirect. Not supported in sync client
         """

adapta/logs/handlers/__init__.py

@@ -1,4 +1,4 @@
-#  Copyright (c) 2023-2024. ECCO Sneaks & Data
+#  Copyright (c) 2023-2026. ECCO Data & AI and other project contributors.
 #
 #  Licensed under the Apache License, Version 2.0 (the "License");
 #  you may not use this file except in compliance with the License.