Renamed project

src/cpl_core/logging/__init__.py

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+
+"""
+sh_cpl-core sh-edraft Common Python library
+~~~~~~~~~~~~~~~~~~~
+
+sh-edraft Common Python library
+
+:copyright: (c) 2020 - 2021 sh-edraft.de
+:license: MIT, see LICENSE for more details.
+
+"""
+
+__title__ = 'cpl_core.logging'
+__author__ = 'Sven Heidemann'
+__license__ = 'MIT'
+__copyright__ = 'Copyright (c) 2020 - 2021 sh-edraft.de'
+__version__ = '2021.10.6'
+
+from collections import namedtuple
+
+# imports:
+from .logger_service import Logger
+from .logger_abc import LoggerABC
+from .logging_level_enum import LoggingLevelEnum
+from .logging_settings import LoggingSettings
+from .logging_settings_name_enum import LoggingSettingsNameEnum
+
+VersionInfo = namedtuple('VersionInfo', 'major minor micro')
+version_info = VersionInfo(major='2021', minor='10', micro='6')

src/cpl_core/logging/logger_abc.py

@@ -0,0 +1,102 @@
+from abc import abstractmethod, ABC
+
+
+class LoggerABC(ABC):
+    r"""ABC for :class:`cpl.logging.logger_service.Logger`"""
+
+    @abstractmethod
+    def __init__(self):
+        ABC.__init__(self)
+
+    @abstractmethod
+    def header(self, string: str):
+        r"""Writes a header message
+
+        Parameter
+        ---------
+            string: :class:`str`
+                String to write as header
+        """
+        pass
+
+    @abstractmethod
+    def trace(self, name: str, message: str):
+        r"""Writes a trace message
+
+        Parameter
+        ---------
+            name: :class:`str`
+                Message name
+            message: :class:`str`
+                Message string
+        """
+        pass
+
+    @abstractmethod
+    def debug(self, name: str, message: str):
+        r"""Writes a debug message
+
+        Parameter
+        ---------
+            name: :class:`str`
+                Message name
+            message: :class:`str`
+                Message string
+        """
+        pass
+
+    @abstractmethod
+    def info(self, name: str, message: str):
+        r"""Writes an information
+
+        Parameter
+        ---------
+            name: :class:`str`
+                Message name
+            message: :class:`str`
+                Message string
+        """
+        pass
+
+    @abstractmethod
+    def warn(self, name: str, message: str):
+        r"""Writes an warning
+
+        Parameter
+        ---------
+            name: :class:`str`
+                Message name
+            message: :class:`str`
+                Message string
+        """
+        pass
+
+    @abstractmethod
+    def error(self, name: str, message: str, ex: Exception = None):
+        r"""Writes an error
+
+        Parameter
+        ---------
+            name: :class:`str`
+                Error name
+            message: :class:`str`
+                Error message
+            ex: :class:`Exception`
+                Thrown exception
+        """
+        pass
+
+    @abstractmethod
+    def fatal(self, name: str, message: str, ex: Exception = None):
+        r"""Writes an error and ends the program
+
+        Parameter
+        ---------
+            name: :class:`str`
+                Error name
+            message: :class:`str`
+                Error message
+            ex: :class:`Exception`
+                Thrown exception
+        """
+        pass

src/cpl_core/logging/logger_service.py

@@ -0,0 +1,256 @@
+import datetime
+import os
+import traceback
+from string import Template
+
+from cpl.console.console import Console
+from cpl.console.foreground_color_enum import ForegroundColorEnum
+from cpl.environment.application_environment_abc import ApplicationEnvironmentABC
+from cpl.logging.logger_abc import LoggerABC
+from cpl.logging.logging_level_enum import LoggingLevelEnum
+from cpl.logging.logging_settings import LoggingSettings
+from cpl.time.time_format_settings import TimeFormatSettings
+
+
+class Logger(LoggerABC):
+    r"""Service for logging
+
+    Parameter
+    ---------
+        logging_settings: :class:`cpl.logging.logging_settings.LoggingSettings`
+            Settings for the logger
+        time_format: :class:`cpl.time.time_format_settings.TimeFormatSettings`
+            Time format settings
+        env: :class:`cpl.environment.application_environment_abc.ApplicationEnvironmentABC`
+            Environment of the application
+    """
+
+    def __init__(self, logging_settings: LoggingSettings, time_format: TimeFormatSettings, env: ApplicationEnvironmentABC):
+        LoggerABC.__init__(self)
+
+        self._env = env
+        self._log_settings: LoggingSettings = logging_settings
+        self._time_format_settings: TimeFormatSettings = time_format
+
+        self._log = Template(self._log_settings.filename).substitute(
+            date_time_now=self._env.date_time_now.strftime(self._time_format_settings.date_time_format),
+            start_time=self._env.start_time.strftime(self._time_format_settings.date_time_log_format)
+        )
+        self._path = self._log_settings.path
+        self._level = self._log_settings.level
+        self._console = self._log_settings.console
+
+        self.create()
+
+    def _get_datetime_now(self) -> str:
+        r"""Returns the date and time by given format
+
+        Returns
+        -------
+            Date and time in given format
+        """
+        try:
+            return datetime.datetime.now().strftime(self._time_format_settings.date_time_format)
+        except Exception as e:
+            self.error(__name__, 'Cannot get time', ex=e)
+
+    def _get_date(self) -> str:
+        r"""Returns the date by given format
+
+        Returns
+        -------
+            Date in given format
+        """
+        try:
+            return datetime.datetime.now().strftime(self._time_format_settings.date_format)
+        except Exception as e:
+            self.error(__name__, 'Cannot get date', ex=e)
+
+    def create(self) -> None:
+        r"""Creates path tree and logfile"""
+
+        """ path """
+        try:
+            # check if log file path exists
+            if not os.path.exists(self._path):
+                os.makedirs(self._path)
+        except Exception as e:
+            self._fatal_console(__name__, 'Cannot create log dir', ex=e)
+
+        """ create new log file """
+        try:
+            # open log file, create if not exists
+            path = f'{self._path}{self._log}'
+            permission = 'a+'
+            if not os.path.isfile(path):
+                permission = 'w+'
+
+            f = open(path, permission)
+            Console.write_line(f'[{__name__}]: Using log file: {path}')
+            f.close()
+        except Exception as e:
+            self._fatal_console(__name__, 'Cannot open log file', ex=e)
+
+    def _append_log(self, string: str):
+        r"""Writes to logfile
+
+        Parameter
+        ---------
+            string: :class:`str`
+        """
+        try:
+            # open log file and append always
+            if not os.path.isdir(self._path):
+                self._fatal_console(__name__, 'Log directory not found')
+
+            with open(self._path + self._log, "a+", encoding="utf-8") as f:
+                f.write(string + '\n')
+                f.close()
+        except Exception as e:
+            self._fatal_console(__name__, f'Cannot append log file, message: {string}', ex=e)
+
+    def _get_string(self, name: str, level: LoggingLevelEnum, message: str) -> str:
+        r"""Returns input as log entry format
+
+        Parameter
+        ---------
+            name: :class:`str`
+                Name of the message
+            level: :class:`cpl.logging.logging_level_enum.LoggingLevelEnum`
+                Logging level
+            message: :class:`str`
+                Log message
+
+        Returns
+        -------
+            Formatted string for logging
+        """
+        log_level = level.name
+        return f'<{self._get_datetime_now()}> [ {log_level} ] [ {name} ]: {message}'
+
+    def header(self, string: str):
+        # append log and print message
+        self._append_log(string)
+        Console.set_foreground_color(ForegroundColorEnum.default)
+        Console.write_line(string)
+        Console.set_foreground_color(ForegroundColorEnum.default)
+
+    def trace(self, name: str, message: str):
+        output = self._get_string(name, LoggingLevelEnum.TRACE, message)
+
+        # check if message can be written to log
+        if self._level.value >= LoggingLevelEnum.TRACE.value:
+            self._append_log(output)
+
+        # check if message can be shown in console_old
+        if self._console.value >= LoggingLevelEnum.TRACE.value:
+            Console.set_foreground_color(ForegroundColorEnum.green)
+            Console.write_line(output)
+            Console.set_foreground_color(ForegroundColorEnum.default)
+
+    def debug(self, name: str, message: str):
+        output = self._get_string(name, LoggingLevelEnum.DEBUG, message)
+
+        # check if message can be written to log
+        if self._level.value >= LoggingLevelEnum.DEBUG.value:
+            self._append_log(output)
+
+        # check if message can be shown in console_old
+        if self._console.value >= LoggingLevelEnum.DEBUG.value:
+            Console.set_foreground_color(ForegroundColorEnum.green)
+            Console.write_line(output)
+            Console.set_foreground_color(ForegroundColorEnum.default)
+
+    def info(self, name: str, message: str):
+        output = self._get_string(name, LoggingLevelEnum.INFO, message)
+
+        # check if message can be written to log
+        if self._level.value >= LoggingLevelEnum.INFO.value:
+            self._append_log(output)
+
+        # check if message can be shown in console_old
+        if self._console.value >= LoggingLevelEnum.INFO.value:
+            Console.set_foreground_color(ForegroundColorEnum.green)
+            Console.write_line(output)
+            Console.set_foreground_color(ForegroundColorEnum.default)
+
+    def warn(self, name: str, message: str):
+        output = self._get_string(name, LoggingLevelEnum.WARN, message)
+
+        # check if message can be written to log
+        if self._level.value >= LoggingLevelEnum.WARN.value:
+            self._append_log(output)
+
+        # check if message can be shown in console_old
+        if self._console.value >= LoggingLevelEnum.WARN.value:
+            Console.set_foreground_color(ForegroundColorEnum.yellow)
+            Console.write_line(output)
+            Console.set_foreground_color(ForegroundColorEnum.default)
+
+    def error(self, name: str, message: str, ex: Exception = None):
+        output = ''
+        if ex is not None:
+            tb = traceback.format_exc()
+            self.error(name, message)
+            output = self._get_string(name, LoggingLevelEnum.ERROR, f'{ex} -> {tb}')
+        else:
+            output = self._get_string(name, LoggingLevelEnum.ERROR, message)
+
+        # check if message can be written to log
+        if self._level.value >= LoggingLevelEnum.ERROR.value:
+            self._append_log(output)
+
+        # check if message can be shown in console_old
+        if self._console.value >= LoggingLevelEnum.ERROR.value:
+            Console.set_foreground_color(ForegroundColorEnum.red)
+            Console.write_line(output)
+            Console.set_foreground_color(ForegroundColorEnum.default)
+
+    def fatal(self, name: str, message: str, ex: Exception = None):
+        output = ''
+        if ex is not None:
+            tb = traceback.format_exc()
+            self.error(name, message)
+            output = self._get_string(name, LoggingLevelEnum.FATAL, f'{ex} -> {tb}')
+        else:
+            output = self._get_string(name, LoggingLevelEnum.FATAL, message)
+
+        # check if message can be written to log
+        if self._level.value >= LoggingLevelEnum.FATAL.value:
+            self._append_log(output)
+
+        # check if message can be shown in console_old
+        if self._console.value >= LoggingLevelEnum.FATAL.value:
+            Console.set_foreground_color(ForegroundColorEnum.red)
+            Console.write_line(output)
+            Console.set_foreground_color(ForegroundColorEnum.default)
+
+        exit()
+
+    def _fatal_console(self, name: str, message: str, ex: Exception = None):
+        r"""Writes an error to console only
+
+        Parameter
+        ---------
+            name: :class:`str`
+                Error name
+            message: :class:`str`
+                Error message
+            ex: :class:`Exception`
+                Thrown exception
+        """
+        output = ''
+        if ex is not None:
+            tb = traceback.format_exc()
+            self.error(name, message)
+            output = self._get_string(name, LoggingLevelEnum.ERROR, f'{ex} -> {tb}')
+        else:
+            output = self._get_string(name, LoggingLevelEnum.ERROR, message)
+
+        # check if message can be shown in console_old
+        if self._console.value >= LoggingLevelEnum.FATAL.value:
+            Console.set_foreground_color(ForegroundColorEnum.red)
+            Console.write_line(output)
+            Console.set_foreground_color(ForegroundColorEnum.default)
+
+        exit()

src/cpl_core/logging/logging_level_enum.py

@@ -0,0 +1,12 @@
+from enum import Enum
+
+
+class LoggingLevelEnum(Enum):
+
+    OFF = 0         # Nothing
+    FATAL = 1       # Error that cause exit
+    ERROR = 2       # Non fatal error
+    WARN = 3        # Error that can later be fatal
+    INFO = 4        # Normal information's
+    DEBUG = 5       # Detailed app state
+    TRACE = 6       # Detailed app information's

src/cpl_core/logging/logging_settings.py

@@ -0,0 +1,63 @@
+import traceback
+from typing import Optional
+
+from cpl.configuration.configuration_model_abc import ConfigurationModelABC
+from cpl.console.console import Console
+from cpl.console.foreground_color_enum import ForegroundColorEnum
+from cpl.logging.logging_level_enum import LoggingLevelEnum
+from cpl.logging.logging_settings_name_enum import LoggingSettingsNameEnum
+
+
+class LoggingSettings(ConfigurationModelABC):
+    r"""Representation of logging settings"""
+
+    def __init__(self):
+        ConfigurationModelABC.__init__(self)
+        self._path: Optional[str] = None
+        self._filename: Optional[str] = None
+        self._console: Optional[LoggingLevelEnum] = None
+        self._level: Optional[LoggingLevelEnum] = None
+
+    @property
+    def path(self) -> str:
+        return self._path
+
+    @path.setter
+    def path(self, path: str) -> None:
+        self._path = path
+
+    @property
+    def filename(self) -> str:
+        return self._filename
+
+    @filename.setter
+    def filename(self, filename: str) -> None:
+        self._filename = filename
+
+    @property
+    def console(self) -> LoggingLevelEnum:
+        return self._console
+
+    @console.setter
+    def console(self, console: LoggingLevelEnum) -> None:
+        self._console = console
+
+    @property
+    def level(self) -> LoggingLevelEnum:
+        return self._level
+
+    @level.setter
+    def level(self, level: LoggingLevelEnum) -> None:
+        self._level = level
+
+    def from_dict(self, settings: dict):
+        try:
+            self._path = settings[LoggingSettingsNameEnum.path.value]
+            self._filename = settings[LoggingSettingsNameEnum.filename.value]
+            self._console = LoggingLevelEnum[settings[LoggingSettingsNameEnum.console_level.value]]
+            self._level = LoggingLevelEnum[settings[LoggingSettingsNameEnum.file_level.value]]
+        except Exception as e:
+            Console.set_foreground_color(ForegroundColorEnum.red)
+            Console.write_line(f'[ ERROR ] [ {__name__} ]: Reading error in {self.__name__} settings')
+            Console.write_line(f'[ EXCEPTION ] [ {__name__} ]: {e} -> {traceback.format_exc()}')
+            Console.set_foreground_color(ForegroundColorEnum.default)

src/cpl_core/logging/logging_settings_name_enum.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class LoggingSettingsNameEnum(Enum):
+
+    path = 'Path'
+    filename = 'Filename'
+    console_level = 'ConsoleLogLevel'
+    file_level = 'FileLogLevel'