turintech_logging 2.0.1__py3-none-any.whl

core_logging/__init__.py

@@ -0,0 +1,23 @@
+# ───────────────────────────────────────────────────── imports ────────────────────────────────────────────────────── #
+from core_logging.logger_conf import EnableLoggerConf, FileLoggerConf, LoggerConf
+from core_logging.logger_handler import InterceptHandler
+from core_logging.logger_service import LoggerService
+from core_logging.logger_utils import LoggerType, get_logger
+
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────── #
+#         Defines the public interface of the module that will be imported when using 'from package import *'.         #
+#    This helps control what is exposed to the global namespace, limiting imports to only those listed in __all__.     #
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────── #
+
+__all__ = [
+    "EnableLoggerConf",
+    "FileLoggerConf",
+    "LoggerConf",
+    "InterceptHandler",
+    "LoggerService",
+    "get_logger",
+    "LoggerType",
+    "logger",
+]
+
+logger = get_logger()

core_logging/logger_conf.py

@@ -0,0 +1,184 @@
+# ───────────────────────────────────────────────────── imports ────────────────────────────────────────────────────── #
+import sys
+from datetime import time, timedelta
+from pathlib import Path
+from typing import Any, Callable, Dict, Optional, Union
+
+from pydantic import Field, field_validator
+
+from core_common_configuration.base_conf_env import BaseConfEnv
+
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────── #
+#                           specifies all modules that shall be loaded and imported into the                           #
+#                                current namespace when we use 'from package import *'                                 #
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────── #
+
+__all__ = [
+    "EnableLoggerConf",
+    "LoggerConf",
+    "FileLoggerConf",
+    "logger_conf_factory",
+    "file_logger_conf_factory",
+    "enable_logger_conf_factory",
+]
+
+
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────── #
+#                                                Logging Configuration                                                 #
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────── #
+
+
+class EnableLoggerConf(BaseConfEnv):
+    """Configuration to enable or disable different types of logging."""
+
+    enable: bool = Field(
+        True,
+        description=(
+            "Flag indicating whether the logging configuration should be initialized (True) or if this configuration "
+            "is already initialized (False)."
+        ),
+    )
+    enable_file: bool = Field(True, description="Flag to enable (True) or disable (False) logging to a file.")
+    enable_stderr: bool = Field(False, description="Flag to enable (True) or disable (False) logging to stderr output.")
+
+
+class LoggerConf(BaseConfEnv):
+    """Configuration attributes for application logs.
+
+    Attributes:
+        sink: An object responsible for receiving formatted logging messages and propagating them
+            to an appropriate endpoint.
+        level: The minimum severity level from which logged messages should be sent to the sink.
+        format: The template used to format logged messages before being sent to the sink.
+        colorize: Whether the color markups contained in the formatted message should be converted
+            to ANSI codes for terminal coloration, or stripped otherwise.
+        serialize: Whether the logged message and its records should be first converted to a JSON string
+            before being sent to the sink.
+        backtrace: Whether the exception trace formatted should be extended upward, beyond the catching point,
+            to show the full stack trace which generated the error.
+        diagnose: Whether the exception trace should display the variables' values to ease debugging.
+            This should be set to False in production to avoid leaking sensitive data.
+        enqueue: Whether the messages to be logged should first pass through a multiprocess-safe queue
+            before reaching the sink. This is useful while logging to a file through multiple processes
+            and also has the advantage of making logging calls non-blocking.
+    """
+
+    sink: Union[Path, object]
+
+    level: str = "INFO"
+    format: Union[str, Callable] = (
+        "<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green>"
+        " <r>-</r> <level>{level: <8}</level>"
+        " <r>-</r> <cyan>{name}</cyan>.<cyan>{function}</cyan>:<cyan>{line}</cyan>"
+        " <r>-</r> <level>{message}</level>"
+    )
+    colorize: Optional[bool] = True
+    serialize: Optional[bool] = False
+    backtrace: Optional[bool] = True
+    diagnose: Optional[bool] = False
+    enqueue: Optional[bool] = True
+
+    @field_validator("level")
+    def upper_validator(cls, value: str) -> str:
+        return value.upper() if value else value
+
+    @field_validator("sink", mode="before")
+    def sink_validator(cls, value: str):
+        return {
+            "sys.stdout": sys.stdout,
+            "sys.stderr": sys.stderr,
+        }.get(value, value)
+
+    def model_dump(self, **kwargs) -> dict[str, Any]:
+        """Override Pydantic's `model_dump` to exclude the `sink` field when dumping.
+
+        After obtaining the clean dump, re-attach the actual `sink` object (e.g., sys.stdout, file path,
+        logging handler) so that `logger.add()` receives a supported sink type.
+        """
+        dump = super().model_dump(**kwargs, exclude={"sink"})
+        return {**dump, "sink": self.sink}
+
+
+class FileLoggerConf(LoggerConf):
+    """Configuration attributes for application file logs."""
+
+    colorize: Optional[bool] = False
+    rotation: Union[str, int, time, timedelta] = "12:00"  # New file is created each day at noon
+    retention: Union[str, int, time, timedelta] = "1 month"
+    compression: Optional[str] = "zip"
+    delay: bool = True
+
+
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────── #
+#                                            Logging Configuration Factory                                             #
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────── #
+
+
+def enable_logger_conf_factory(
+    _env_file: Optional[str] = None, prefix: Optional[str] = None, defaults: Optional[Dict] = None, **kwargs
+) -> EnableLoggerConf:
+    """This is a factory generating a EnableLoggerConf class specific to a service, loading every value from a generic
+    .env file storing variables in uppercase with a service prefix.
+
+    example .env:
+       PREFIX_ENABLE=true
+       ...
+
+    Args:
+        _env_file (str, optional): Configuration file of the environment variables from where to load the values.
+        prefix (str, optional): Prefix that the class attributes must have in the environment variables.
+        defaults (Dict, optional): New values to override the default field values for the configuration model.
+        kwargs (**Dict): Arguments passed to the Settings class initializer.
+
+    Returns:
+        conf (EnableLoggerConf): Object of the required configuration class
+
+    """
+    return EnableLoggerConf.with_defaults(env_file=_env_file, env_prefix=prefix, defaults=defaults, **kwargs)
+
+
+def logger_conf_factory(
+    _env_file: Optional[str] = None, prefix: Optional[str] = None, defaults: Optional[Dict] = None, **kwargs
+) -> LoggerConf:
+    """This is a factory generating a LoggerConf class specific to a service, loading every value from a generic .env
+    file storing variables in uppercase with a service prefix.
+
+    example .env:
+       PREFIX_LEVEL=INFO
+       ...
+
+    Args:
+        _env_file (str, optional): Configuration file of the environment variables from where to load the values.
+        prefix (str, optional): Prefix that the class attributes must have in the environment variables.
+        defaults (Dict, optional): New values to override the default field values for the configuration model.
+        kwargs (**Dict): Arguments passed to the Settings class initializer.
+
+    Returns:
+        conf (LoggerConf): Object of the required configuration class
+
+    """
+    return LoggerConf.with_defaults(env_file=_env_file, env_prefix=prefix, defaults=defaults, **kwargs)
+
+
+def file_logger_conf_factory(
+    _env_file: Optional[str] = None, prefix: Optional[str] = None, defaults: Optional[Dict] = None, **kwargs
+) -> FileLoggerConf:
+    """This is a factory generating a FileLoggerConf class specific to a service, loading every value from a generic
+    .env file storing variables in uppercase with a service prefix.
+
+    example .env:
+       PREFIX_LEVEL=INFO
+       PREFIX_COLORIZE=true
+       ...
+
+    Args:
+        _env_file (str, optional): Configuration file of the environment variables from where to load the values.
+        prefix (str, optional): Prefix that the class attributes must have in the environment variables.
+        defaults (Dict, optional): New values to override the default field values for the configuration model.
+        kwargs (**Dict): Arguments passed to the Settings class initializer.
+
+    Returns:
+        conf (FileLoggerConf): Object of the required configuration class
+
+    """
+    return FileLoggerConf.with_defaults(env_file=_env_file, env_prefix=prefix, defaults=defaults, **kwargs)

core_logging/logger_handler.py

@@ -0,0 +1,54 @@
+# ───────────────────────────────────────────────────── imports ────────────────────────────────────────────────────── #
+import logging
+from types import FrameType
+from typing import Optional
+
+from core_logging.logger_utils import LoggerType
+
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────── #
+#         Defines the public interface of the module that will be imported when using 'from package import *'.         #
+#    This helps control what is exposed to the global namespace, limiting imports to only those listed in __all__.     #
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────── #
+
+__all__ = ["InterceptHandler"]
+
+
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────── #
+#                                                Module Implementation                                                 #
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────── #
+
+
+class InterceptHandler(logging.Handler):
+    """A logging handler that redirects standard logging messages to a structured logger."""
+
+    def __init__(self, logger: LoggerType, name: Optional[str] = None):
+        """Initializes the handler with a structured logger.
+
+        Args:
+            logger (LoggerType): The logger instance to intercept log messages.
+            name (str, optional): The name of the logging handler. Defaults to None.
+        """
+        super().__init__()
+        self.logger: LoggerType = logger
+        if name:
+            self.set_name(name)
+
+    def emit(self, record: logging.LogRecord):
+        """Processes and forwards log records to the structured logger.
+
+        Args:
+            record (logging.LogRecord): The log record to be handled.
+        """
+        try:
+            level = self.logger.level(record.levelname).name
+        except ValueError:
+            level = record.levelno  # type: ignore
+
+        # Find caller from where originated the logged message
+        frame: Optional[FrameType] = logging.currentframe()
+        depth: int = 2
+        while frame and frame.f_code.co_filename == logging.__file__:
+            frame = frame.f_back
+            depth += 1
+
+        self.logger.opt(depth=depth, exception=record.exc_info).log(level, record.getMessage())

core_logging/logger_service.py

@@ -0,0 +1,203 @@
+# ───────────────────────────────────────────────────── imports ────────────────────────────────────────────────────── #
+import logging
+import sys
+from os import PathLike
+from typing import Any, Optional
+
+from core_common_configuration import BaseConfManager
+from core_logging.logger_conf import EnableLoggerConf, FileLoggerConf, LoggerConf
+from core_logging.logger_handler import InterceptHandler
+from core_logging.logger_utils import LoggerType, get_logger
+
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────── #
+#         Defines the public interface of the module that will be imported when using 'from package import *'.         #
+#    This helps control what is exposed to the global namespace, limiting imports to only those listed in __all__.     #
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────── #
+
+__all__ = ["LoggerService"]
+
+
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────── #
+#                                                Service implementation                                                #
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────── #
+
+
+class LoggerService:
+    """Manages logging configurations and initialisation.
+
+    This class handles the configuration of logging settings, including enabling or disabling
+
+    Attributes:
+        _env_prefix (str): Prefix for environment variable names.
+        _conf_mgr (BaseConfManager): Configuration manager for handling environment variables.
+        _defaults_enable_logger_conf (Optional[dict[str, Any]]): Default configurations for enabling logging.
+        _defaults_logger_conf (Optional[dict[str, Any]]): Default configurations for logger settings.
+        _defaults_file_logger_conf (Optional[dict[str, Any]]): Default configurations for file logger settings.
+        _extra (Optional[dict[str, str]]): Additional parameters for the core logger.
+        _mandatory_logger_conf (dict[str, dict[str, Any]]): Mandatory logger configurations.
+    """
+
+    _env_prefix: str
+    _conf_mgr: BaseConfManager
+    _defaults_enable_logger_conf: Optional[dict[str, Any]]
+    _defaults_logger_conf: Optional[dict[str, Any]]
+    _defaults_file_logger_conf: Optional[dict[str, Any]]
+    _extra: Optional[dict[str, str]]
+    _mandatory_logger_conf: dict[str, dict[str, Any]]
+
+    def __init__(
+        self,
+        env_prefix: str = "LOGGER_",
+        env_file: Optional[PathLike] = None,
+        mandatory_logger_conf: Optional[dict[str, dict[str, Any]]] = None,
+        extra: Optional[dict[str, str]] = None,
+        **kwargs,
+    ):
+        """Initialises the LoggerService with specified configurations.
+
+        Args:
+            env_prefix (str): Prefix for environment variable names.
+            env_file (str | Path, optional): Path to the environment variable configuration file.
+            mandatory_logger_conf (dict[str, dict[str, Any]], optional): Mandatory logger configurations.
+            extra (dict[str, str], optional): Additional parameters for the core logger.
+            **kwargs: Additional keyword arguments, including:
+                - defaults_enable_logger_conf (dict[str, Any], optional): Default configurations for enabling logging.
+                - defaults_logger_conf (dict[str, Any], optional): Default configurations for logger settings.
+                - defaults_file_logger_conf (dict[str, Any], optional): Default configurations for file logger settings.
+        """
+        self._env_prefix = kwargs.get("prefix", env_prefix)
+        self._conf_mgr = BaseConfManager(env_file=env_file)
+        self._defaults_enable_logger_conf = kwargs.get("defaults_enable_logger_conf")
+        self._defaults_logger_conf = kwargs.get("defaults_logger_conf")
+        self._defaults_file_logger_conf = kwargs.get("defaults_file_logger_conf")
+        self._extra = extra
+        self._mandatory_logger_conf = (
+            mandatory_logger_conf
+            if mandatory_logger_conf is not None
+            else {"stdout": {"sink": sys.stdout}, "stderr": {"sink": sys.stderr, "level": "ERROR"}}
+        )
+
+    # ------------------------------------------------------------------------------------
+    # --- Configuration
+    # ------------------------------------------------------------------------------------
+
+    @property
+    def enable_logger_conf(self) -> EnableLoggerConf:
+        """Retrieve the configuration for enabling or disabling logging."""
+        return self._conf_mgr.get_conf(
+            conf_type=EnableLoggerConf,
+            conf_name="ENABLE_LOGGER_CONF",
+            env_prefix=self._env_prefix,
+            defaults=self._defaults_enable_logger_conf,
+        )
+
+    @property
+    def logger_conf(self) -> dict[str, LoggerConf]:
+        """Retrieve the logger configurations."""
+        return {
+            key: self._conf_mgr.get_conf(
+                conf_type=LoggerConf,
+                conf_name=f"LOGGER_CONF_{key.upper()}",
+                env_prefix=self._env_prefix,
+                defaults=self._defaults_logger_conf,
+                **mandatory,
+            )
+            for key, mandatory in self._mandatory_logger_conf.items()
+        }
+
+    @property
+    def file_logger_conf(self) -> FileLoggerConf:
+        """Retrieve the file logger configuration."""
+        return self._conf_mgr.get_conf(
+            conf_type=FileLoggerConf,
+            conf_name="FILE_LOGGER_CONF",
+            env_prefix=self._env_prefix,
+            defaults=self._defaults_file_logger_conf,
+        )
+
+    def get_configuration(self, mode: str = "json") -> dict[str, Any]:
+        """Returns the current logging configuration.
+
+        Args:
+            mode (str): Serialization mode (default: "json").
+
+        Returns:
+            dict[str, Any]: Full logging configuration.
+        """
+
+        def _serialized_conf(conf: Optional[dict[str, Any]]) -> dict[str, str]:
+            _conf = conf or {}
+            if mode == "json":
+                return {key: str(value) for key, value in _conf.items()}
+            return _conf
+
+        return {
+            "env_prefix": self._env_prefix,
+            "env_file": self._conf_mgr.env_file,
+            "defaults_enable_logger_conf": _serialized_conf(self._defaults_enable_logger_conf),
+            "defaults_file_logger_conf": _serialized_conf(self._defaults_file_logger_conf),
+            "mandatory_logger_conf": _serialized_conf(self._mandatory_logger_conf),
+            "extra": self._extra,
+            **{key: value.model_dump(mode=mode) for key, value in self._conf_mgr.config_map.items()},
+        }
+
+    # ------------------------------------------------------------------------------------
+    # --- Logging Initialisation
+    # ------------------------------------------------------------------------------------
+
+    def init_logging(self, logger: LoggerType, loggers_to_intercept: Optional[list[str]] = None) -> None:
+        """Initialises logging configuration and optionally intercepts specified loggers.
+
+        Args:
+            logger (LoggerType): The logger instance to configure.
+            loggers_to_intercept (list[str], optional): Optional list of loggers to intercept.
+        """
+        if loggers_to_intercept:
+            self.init_logging_handlers(logger, loggers_to_intercept)
+        self.init_logging_conf(logger)
+
+    def init_logging_conf(self, logger: Optional[LoggerType] = None) -> None:
+        """Configures the logging settings.
+
+        Args:
+            logger (LoggerType, optional): The logger instance to configure.
+                If not provided, the default logger obtained from the `get_logger` function will be used.
+        """
+        _logger: LoggerType = get_logger() if not logger else logger
+        enable_logger_conf: EnableLoggerConf = self.enable_logger_conf
+        if enable_logger_conf.enable:
+            _logger.configure(extra=self._extra)
+            _logger.remove()
+            _logger._core.handlers_count = 0
+
+            for key, config in self.logger_conf.items():
+                if key == "stdout" or (enable_logger_conf.enable_stderr and key == "stderr"):
+                    _logger.add(**config.model_dump())
+
+            if enable_logger_conf.enable_file:
+                _logger.add(**self.file_logger_conf.model_dump())
+
+            _logger.debug(f"Logger configured: {self.get_configuration()}")
+
+    @classmethod
+    def init_logging_handlers(cls, logger: LoggerType, loggers_to_intercept: list[str]) -> None:
+        """Intercepts and redirects specified loggers to a structured logger.
+
+        WARNING: If called in the startup event, logs before application start will use the old format.
+
+        Args:
+            logger (LoggerType): The structured logger instance.
+            loggers_to_intercept (list[str]): List of loggers to intercept.
+        """
+
+        for logger_name in loggers_to_intercept:
+            for intercepted_logger in (
+                logging.getLogger(name)
+                for name in logging.root.manager.loggerDict  # pylint:disable=no-member
+                if name.startswith(f"{logger_name}.")
+            ):
+                intercepted_logger.handlers = [InterceptHandler(logger, intercepted_logger.name)]
+                intercepted_logger.propagate = False  # Prevent duplicate log messages
+            log = logging.getLogger(logger_name)
+            log.handlers = [InterceptHandler(logger, logger_name)]
+            log.propagate = False  # Prevent duplicate log messages

core_logging/logger_utils.py

@@ -0,0 +1,178 @@
+# ───────────────────────────────────────────────────── imports ────────────────────────────────────────────────────── #
+import logging
+from contextlib import contextmanager
+from typing import Any
+
+from typing_extensions import TypeAlias
+
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────── #
+#         Defines the public interface of the module that will be imported when using 'from package import *'.         #
+#    This helps control what is exposed to the global namespace, limiting imports to only those listed in __all__.     #
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────── #
+
+__all__ = [
+    "LoggerType",
+    "get_logger",
+    "get_logging_backup",
+    "set_logging_buckup",
+    "get_loguru_backup",
+    "set_loguru_buckup",
+    "preserve_logging_state",
+]
+
+
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────── #
+#                                                Module Implementation                                                 #
+# ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────── #
+
+
+def logger_type() -> type:
+    """Returns the Logger class from the specified logging module.
+
+    The import of the loguru.Logger class is performed inside this function
+    to avoid potential serialization issues.
+
+    Returns:
+        type: The Logger class from the specified logging module.
+    """
+    from loguru._logger import Logger  # pylint: disable=import-outside-toplevel
+
+    return Logger
+
+
+LoggerType: TypeAlias = logger_type()  # type: ignore
+
+
+def get_logger(**bind_args) -> LoggerType:
+    """Returns a logger instance, optionally binding extra context.
+
+    The import of the loguru logger instance is done inside this function to prevent
+    serialization issues.
+
+    Args:
+        **bind_args: The arguments to bind additional context to the logger.
+
+    Returns:
+        LoggerType: A logger instance with the provided context bound to it.
+    """
+    from loguru import logger  # pylint: disable=import-outside-toplevel
+
+    return logger.bind(**bind_args)
+
+
+# ------------------------------------------------------------------------------------
+# --- Preserve and restore the state of loggers
+# ------------------------------------------------------------------------------------
+
+
+def get_logging_backup() -> dict[str, dict[str, Any]]:
+    """Returns a dictionary containing the state of the logging module.
+
+    Returns:
+        dict[str, dict[str, Union[bool, list[logging.Handler]]]]: A dictionary containing the state
+            of the logging module.
+    """
+    return {
+        name: {
+            "handlers": list(logger.handlers),
+            "propagate": logger.propagate,
+        }
+        for name, logger in [(logging.root.name, logging.root.handlers)] + list(logging.root.manager.loggerDict.items())
+        if isinstance(logger, logging.Logger)
+    }
+
+
+def set_logging_buckup(logging_backup: dict[str, dict[str, Any]]) -> None:
+    """Restore the state of the logging module from a backup.
+
+    Args:
+        logging_backup (dict[str, dict[str, Union[bool, list[logging.Handler]]]]): The backup dictionary
+            created by get_logging_backup().
+    """
+    for name, logger in [(logging.root.name, logging.root.handlers)] + list(logging.root.manager.loggerDict.items()):
+        if isinstance(logger, logging.Logger):
+            if state := logging_backup.get(name):
+                logger.handlers = state["handlers"]
+                logger.propagate = state["propagate"]
+            else:
+                logging.root.manager.loggerDict.pop(name, None)
+
+
+def get_loguru_backup() -> dict[str, Any]:
+    """Returns a dictionary containing the state of the loguru logger.
+
+    Returns:
+        dict[str, Any]: A dictionary containing the state of the loguru logger.
+    """
+    from loguru import logger
+    from loguru._logger import Core
+
+    _core: Core = logger._core  # pyright: ignore[reportAttributeAccessIssue]
+    return {
+        **_core.__getstate__(),
+        "enabled": _core.enabled.copy(),
+        "handlers": _core.handlers.copy(),
+    }
+
+
+def set_loguru_buckup(loguru_backup: dict[str, Any]) -> None:
+    """Restore the state of loguru logger from a backup.
+
+    Args:
+        loguru_backup (dict[str, Any]): The backup dictionary created by get_loguru_backup().
+
+    Warning:
+        The colorize argument is not restored, so the color of the logger might not be the same as before.
+    """
+    from loguru import logger
+    from loguru._file_sink import FileSink
+    from loguru._logger import Core
+    from loguru._simple_sinks import StreamSink
+
+    _core: Core = logger._core  # pyright: ignore[reportAttributeAccessIssue]
+
+    # Remove all handlers currently added to the logger
+    logger.remove()
+    _core.handlers_count = 0
+
+    # Restore the internal state of the logger (except handlers)
+    handlers_backup = loguru_backup.get("handlers", {})
+    _core.__setstate__(
+        {key: value for key, value in loguru_backup.items() if key not in ["handlers", "handlers_count"]}
+    )
+
+    # Add each handler again using logger.add()
+    for _id, handler in handlers_backup.items():
+        fmt_with_exc = handler._formatter.strip()
+        fmt = fmt_with_exc[: -len("\n{exception}")] if fmt_with_exc.endswith("\n{exception}") else fmt_with_exc
+
+        sink = (
+            handler._sink._stream
+            if isinstance(handler._sink, StreamSink)
+            else handler._sink._path
+            if isinstance(handler._sink, FileSink)
+            else handler._sink
+        )
+
+        logger.add(
+            sink=sink,
+            level=handler._levelno,
+            format=fmt,
+            filter=handler._filter,
+            serialize=handler._serialize,
+            enqueue=handler._enqueue,
+            context=handler._multiprocessing_context,
+            catch=handler._error_interceptor._should_catch,
+        )
+
+
+@contextmanager
+def preserve_logging_state():
+    """Context manager to temporarily preserve and restore the state of loggers."""
+    logging_backup = get_logging_backup()
+    loguru_backup = get_loguru_backup()
+    try:
+        yield
+    finally:
+        set_logging_buckup(logging_backup)
+        set_loguru_buckup(loguru_backup)

turintech_logging-2.0.1.dist-info/METADATA

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: turintech_logging
+Version: 2.0.1
+Summary: Core Libs files logging
+License-Expression: LicenseRef-Turing-Intelligence-Technology-EULA
+License-File: LICENSE
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: Other/Proprietary License
+Requires-Python: <3.14,>=3.8
+Requires-Dist: loguru<1.0.0,>=0.7.0
+Requires-Dist: pydantic<3.0.0,>=2
+Requires-Dist: python-dotenv<1.0.0,>=0.21.0
+Requires-Dist: turintech-configuration<3.0.0,>=2.0.0a0
+Requires-Dist: typing-extensions<5.0.0,>=4.5.0

turintech_logging-2.0.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+core_logging/__init__.py,sha256=fAXIgbY-RYCFiZUpp16dQjBwevIN_4xunjzVbNF4MEs,1735
+core_logging/logger_conf.py,sha256=8aYTJbK-ybN9Nz4xFsbxVxuepAJVwP49mUF6FgTampo,10098
+core_logging/logger_handler.py,sha256=h1ngFW5v5VSqVCFqXxeiLaNEZlCgzbLQocqUtaVt5Z4,3584
+core_logging/logger_service.py,sha256=_RXGm4W6IYIO_w1YPeddSikB487zggCziwXr_PE-WzA,10790
+core_logging/logger_utils.py,sha256=L-q97M5o2PvVwCp3EONtDYlPKC4n5EEwUoTj8fr1LKc,7545
+core_logging/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+turintech_logging-2.0.1.dist-info/METADATA,sha256=nngnLOiR1G7EYTZhxUzsUqkW_7sxNH1VLnRPW8Cn83g,533
+turintech_logging-2.0.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+turintech_logging-2.0.1.dist-info/licenses/LICENSE,sha256=1oiCRxRmKyfqDkVZDDGPl8W09ACBwaCJNUDYsW1aJB0,14103
+turintech_logging-2.0.1.dist-info/RECORD,,

turintech_logging-2.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

turintech_logging-2.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,146 @@
+TURING INTELLIGENCE TECHNOLOGY LIMITED END-USER LICENCE
+
+THIS LICENCE AGREEMENT (Licence) is made BETWEEN you (Licensee) and TURING INTELLIGENCE TECHNOLOGY LIMITED (business address at 1 Finsbury Avenue, London, EC2M 2PF, United Kingdom) (the Licensor), for TurinTech Artifacts(Code).
+
+The Licensor licenses the use of the Code to the Licensee on the basis of this Licence. The Licensor does not sell the Code to the Licensee. The Licensor remain the owner of the Code at all times, except for any Open Source third-party libraries (excluding any modifications or derivatives to that software, which shall be owned by the Licensor to the extent permitted under the terms of the open source software licence) (Open Source Software) are licensed on the applicable open source software licence.
+
+1. GRANT AND SCOPE OF LICENCE
+
+1.1. In consideration of the Licensee agreeing to abide by the terms of this Licence, the Licensor grants to Licensee a non-exclusive, non-transferable licence to use the Code on the terms of this Licence.
+
+1.2. The Licensee may:
+
+(a) download and use the Code for the Licensee's internal business purposes only in connection with the use of the "evoML" and / or "Artemis" software that the Licensor has made available to the Licensee under the terms of evoML and / or Artemis End-User License; and
+
+(b) provided the Licensee complies with the provisions in clause 2 *(Restrictions),* make up [1 (one)] copy of the Code for back-up purposes only.
+
+2. RESTRICTIONS
+
+2.1. Except as expressly set out in this Licence or as permitted by applicable law, the Licensee undertakes:
+
+(a) to comply with the applicable terms in respect of the Open Source Software;
+
+(b) not to copy the Code except where such copying is incidental to normal use of the Code, or where it is necessary for the purpose of back-up or operational security;
+
+(c) not to rent, lease, sub-license, loan, translate, merge, adapt, vary or modify the Code;
+
+(d) not to make alterations to, or modifications of, the whole or any part of the Code, nor permit the Code or any part of it to be combined with, or become incorporated in, any other programs;
+
+(e) not to disassemble, decompile, reverse-engineer or create derivative works based on the whole or any part of the Code nor attempt to do any such thing except to the extent that (by virtue of section 296A of the Copyright, Designs and Patents Act 1988) such actions cannot be prohibited because they are essential for the purpose of achieving inter-operability of the Code with another software program, and provided that the information obtained by the Licensee during such activities:
+  
+  (i) is used only for the purpose of achieving inter-operability of the Code with another software program; and
+  
+  (ii) is not unnecessarily disclosed or communicated without the Licensor's prior written consent to any third party; and
+  
+  (iii) is not used to create any software which is substantially similar to the Code;
+
+(f) to keep all copies of the Code secure and to maintain accurate and up-to-date records of the number and locations of all copies of the Code;
+
+(g) to supervise and control use of the Code and ensure that the Code is used by the Licensee, and its Personnel in accordance with the terms of this Licence;
+
+(h) to include the Licensor's copyright notice on all entire and partial copies the Licensee make of the Code on any medium;
+
+(i) not to provide or otherwise make available the Code in whole or in part, in any form to any person other than Licensee's Personnel without prior written consent from the Licensor.
+
+3. INTELLECTUAL PROPERTY RIGHTS
+
+3.1. The Licensee acknowledges that all Intellectual Property Rights in the Code anywhere in the world belong to the Licensor (except the Open Source Software but excluding any modifications or derivatives of the Open Source Software, which shall be owned by the Licensor to the extent permitted under the terms of the applicable Open Source Software licence), that rights in the Code are licensed (not sold) to the Licensee, and that the Licensee have no rights in, or to, the Code other than the right to use them in accordance with the terms of this Licence.
+
+3.2. The Licensee acknowledges that any output obtained using the Code is the sole responsibility of the Licensee. The Licensee is responsible for ensuring that the output obtained using the Code and any results and insights derived from such output are accurate, unbiased, and does not violate any applicable laws and regulations and / or the terms of this agreement.
+
+4. LIMITATION OF LIABILITY
+
+4.1. The Licensee acknowledge that the Code has not been developed to meet the Licensee's individual requirements, and that it is therefore the Licensee's responsibility to ensure that the facilities and functions of the Code as described in relevant user documentation meet the Licensee's requirements.
+
+4.2. The Licensor only supplies the Code for internal use by the Licensee's business, and the Licensee agrees not to use the Code for any re-sale purposes.
+
+4.3. Nothing in this Licence limits or excludes a Party's liability:
+
+(a) to the extent that it cannot be legally limited or excluded by law (including liability for fraud or fraudulent statements); or
+
+(b) for death or personal injury arising out of its negligence or that of its Personnel.
+4.4. Subject to clause 4.3, neither Party shall have any liability to the other Party, whether for breach of contract, in tort (including negligence), for breach of statutory duty, or otherwise, arising under or in connection with this Licence for:
+
+(a) loss of profits, sales, business, or revenue;
+
+(b) business interruption;
+
+(c) loss of anticipated savings;
+
+(d) wasted expenditure;
+
+(e) loss or corruption of data or information;
+
+(f) loss of business opportunity, goodwill or reputation; or
+
+(g) any indirect or consequential Losses.
+4.5. Subject to clause 4.3, the Licensor's total liability to the Licensee, whether for breach of contract, in tort (including negligence), for breach of statutory duty, or otherwise, arising under or in connection with this Licence for Losses incurred or suffered by the Licensee shall be limited for all claims in aggregate to £10,000.
+
+4.6. This Licence sets out the full extent of the Licensor's obligations and liabilities in respect of the supply of the Code. Except as expressly stated in this Licence, there are no conditions, warranties, representations or other terms, express or implied, that are binding on the Licensor. Any condition, warranty, representation or other term concerning the supply of the Code which might otherwise be implied into, or incorporated in, this Licence whether by statute, common law or otherwise, is excluded to the fullest extent permitted by law.
+
+5. TERMINATION
+
+5.1. The Licensor may terminate this Licence immediately by written notice to the Licensee either for (a) convenience, or (b) if the Licensee commit a material or persistent breach of this Licence which the Licensee fails to remedy (if remediable) within 14 days after the service of written notice requiring the Licensee to do so.
+
+5.2. On termination of this Licence for any reason:
+
+(a) all rights granted to the Licensee under this Licence shall cease;
+
+(b) the Licensee must immediately cease all activities authorised by this Licence; and
+
+(c) the Licensee must immediately and permanently delete or remove the Code from all computer equipment in its possession, and certify to the Licensor that the Licensee has done so.
+
+6. NOTICES
+
+6.1. Any notice:
+
+(a) given by the Licensor to the Licensee will be deemed received and properly served 24 hours after it is first posted on the Licensor's website, 24 hours after an email is sent to the Licensee, or three days after the date of posting of any letter; and
+
+(b) given by Licensee to the Licensor will be deemed received and properly served 24 hours after an email is sent to `legal@turintech.ai`, or three days after the date of posting of any letter.
+6.2. In proving the service of any notice, it will be sufficient to prove, in the case of posting on the Licensor's website, that the website was generally accessible to the public for a period of 24 hours after the first posting of the notice; in the case of a letter, that such letter was properly addressed, stamped and placed in the post to the address of the recipient given for these purposes; and, in the case of an email, that such email was sent to the email address of the recipient given for these purposes.
+
+7. FORCE MAJEURE
+
+7.1. Provided that it has promptly notify the other Party of the occurrence of a Force Majeure Event affecting it in connection with this Licence, if a Party is prevented from, hindered or delayed in performing any of its obligations under this Licence by a Force Majeure Event, it shall not be in breach of this Licence for any such failure or delay in performing such obligations.
+
+7.2. If a Force Majeure Event prevents the Licensor from making available or providing any of the Code for more than 30 (thirty) days, the Licensor may terminate this Licence immediately by notice to the Licensee.
+
+8. GENERAL
+
+8.1. A person who is not a Party to this Licence shall have no rights pursuant to the Contracts (Rights of Third Parties) Act 1999 to enforce rights or benefits under this Licence.
+
+8.2. The Licensee shall not assign, novate, transfer, mortgage, charge, subcontract, delegate or otherwise dispose of any or all of its rights and obligations under this Licence without the prior written consent of the Licensor. The Licensor may do all such things without the Licensee's consent.
+
+8.3. This Licence shall be binding on, and shall ensure for the benefit of, the successors and permitted assigns of a Party.
+
+8.4. Except as may otherwise be specifically provided for in this Licence, no right, power, privilege or remedy conferred by any provision of this Licence is intended to be exclusive of any other right, power, privilege or remedy (whether under any other provision of this Licence, at common law, equity, under statute or otherwise).
+
+8.5. A waiver of any right or remedy under this Licence or at law is only effective if given by notice. No failure or delay by a Party to exercise any right or remedy (nor a partial exercise of such right or remedy) provided under this Licence or at law constitutes a waiver of that or any other right or remedy, nor shall it prevent or restrict the further exercise of that or any other right or remedy.
+
+8.6. Nothing in this Licence shall be construed as constituting a partnership between the Parties, and nor shall it constitute a Party the agent of the other Party.
+
+8.7. If any provision of this Licence is invalid, illegal or unenforceable in connection with its performance, such provision shall be deemed deleted to the minimum extent necessary.
+
+8.8. The Licensor may update the terms of this Licence at any time on notice to Licensee. If the Licensee continues to use the Code following the deemed receipt and service of the notice under clause 6 (Notices) shall constitute the Licensee's acceptance to the terms of this Licence, as varied. If the Licensee does not wish to accept the terms of the Licence (as varied), the Licensee must immediately stop using and accessing the Code on the deemed receipt and service of the notice.
+
+8.9. For the purposes of this Licence:
+
+(a) **Force Majeure Event** means any event beyond a Party's reasonable control;
+
+(b) **Intellectual Property Rights** means rights in patents (including utility models), designs (whether or not capable of registration), semi-conductor topography rights, copyright, moral rights, database rights, trademarks, service marks, trade and business names, rights to sue for passing off, rights in the nature of unfair competition rights, trade secret, confidentiality and other proprietary rights including rights to know-how and other technical information, applications to register any of the foregoing, rights to take action for past infringements in respect of any of the foregoing, and all rights in the nature of any of the foregoing anywhere in the world;
+
+(c) **Losses** mean all losses, liabilities, damages, costs, charges, and expenses (including reputational loss or damage, management time, legal fees on a solicitor and own client basis, other professional advisers' fees, and costs and disbursements of investigation, litigation, settlement, judgment, interest, fines, penalties and remedial actions);
+
+(d) **Party** means a party to this Licence, and **Parties** means both of them;
+
+(e) **Personnel** means employees, agents, consultants, contractors and subcontractors.
+
+9. ENTIRE AGREEMENT
+
+9.1. This Licence constitutes the entire agreement between the Parties in relation to its subject matter. Nothing else has been agreed between the Parties in relation to that subject matter, and any earlier agreement or understanding between the Parties in relation to that subject matter has been superseded by this Licence. When entering into this Licence, no Party has relied on anything written, said or done by any person except to the extent that it is an express term of this Licence. No Party will have any non-contractual claim against any other Party for any representation made in connection with this Licence except to the extent that such claim cannot be excluded by contract. If a representation has become an express term of this Licence, it will only be enforceable as a contractual term in accordance with the terms of this Licence.
+
+10. GOVERNING LAW AND JURISDICTION
+
+10.1. This Licence, and any non-contractual obligations connected with it, shall be governed by the laws of England and Wales. The Parties irrevocably agree that all disputes, regardless of whether the dispute shall be regarded as contractual or not, shall be exclusively governed by and determined only in accordance with the laws of England and Wales.
+
+10.2. The Parties irrevocably agree that the courts of England and Wales have exclusive jurisdiction to determine any dispute and to grant interim remedies, or other provisional or protective relief.