adapta 2.11.9__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__ = '2.11.9'
+__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,25 +97,26 @@ 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,
     ):
-        super().__init__(fixed_template, fixed_template_delimiter)
+        super().__init__(fixed_template, fixed_template_delimiter, global_tags)
         self._logger: MetadataLogger = logging.getLogger(name)
         self._logger.setLevel(min_log_level.value)
         self._logger_message_queue = Queue(-1)
         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:
         """
@@ -120,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:
         """
@@ -138,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:
         """
@@ -156,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:
         """
@@ -205,11 +217,12 @@ 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]:
     """
     Factory method to create an async-io safe logger.
@@ -222,4 +235,5 @@ def create_async_logger(
         log_handlers=log_handlers,
         fixed_template=fixed_template,
         fixed_template_delimiter=fixed_template_delimiter,
+        global_tags=global_tags,
     )

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
     """