ka-uts-com 1.0.1.250131__py3-none-any.whl → 2.0.0.250407__py3-none-any.whl

build/lib/ka_uts_com/__version__.py

@@ -1,7 +1,7 @@
 __title__ = 'ka_uts_com'
 __description__ = 'Communication Utilities.'
 __url__ = 'https://ka-ut-com.readthedocs.io/en/latest'
-__version__ = '1.0.1.250131'
+__version__ = '2.0.0.250407'
 __build__ = 0x022200
 __author__ = 'Bernd Stroehle'
 __author_email__ = 'bernd.stroehle@gmail.com'

build/lib/ka_uts_com/base/app_.py

@@ -22,30 +22,29 @@ class App_:
     """Aplication Class
     """
     sw_init: TyBool = False
-    httpmod: TyAny = None
     sw_replace_keys: TnBool = None
     keys: TnArr = None
+    httpmod: TyAny = None
     reqs: TyDic = {}
     app: TyDic = {}
 
     @classmethod
-    def init(cls, log: TyLogger, **kwargs) -> None:
+    def init(cls, com, **kwargs) -> None:
         if cls.sw_init:
             return
         cls.sw_init = True
         cls.httpmod = kwargs.get('httpmod')
         cls.sw_replace_keys = kwargs.get('sw_replace_keys', False)
-        try:
-            if cls.sw_replace_keys:
-                d_pacmod: TyDic = kwargs.get('d_pacmod', {})
-                cls.keys = Yaml_.read(PacMod.sh_path_keys_yaml(d_pacmod), log)
-        except Exception as exc:
-            log.error(exc, exc_info=True)
-            raise
+        if cls.sw_replace_keys:
+            try:
+                cls.keys = Yaml_.read(PacMod.sh_path_keys(com), com.Log)
+            except Exception as exc:
+                com.Log.error(exc, exc_info=True)
+                raise
 
     @classmethod
-    def sh(cls, log: TyLogger, **kwargs) -> Any:
+    def sh(cls, com, **kwargs) -> Any:
         if cls.sw_init:
             return cls
-        cls.init(log, **kwargs)
+        cls.init(com, **kwargs)
         return cls

build/lib/ka_uts_com/base/cfg_.py

@@ -17,11 +17,19 @@ TyLogger = Logger
 class Cfg_:
     """Configuration Class
     """
+    sw_init: TyBool = False
     cfg: Any = None
 
     @classmethod
-    def sh(cls, log: TyLogger, d_pacmod: TyDic) -> Any:
-        """ show configuration
-        """
-        cls.cfg = Yaml_.read(PacMod.sh_path_cfg_yaml(d_pacmod), log)
+    def init(cls, com, **kwargs) -> None:
+        if cls.sw_init:
+            return
+        cls.sw_init = True
+        cls.cfg = Yaml_.read(PacMod.sh_path_cfg(com), com.Log)
+
+    @classmethod
+    def sh(cls, com, **kwargs) -> Any:
+        if cls.sw_init:
+            return cls
+        cls.init(com, **kwargs)
         return cls.cfg

build/lib/ka_uts_com/base/log_.py

@@ -9,7 +9,7 @@ from logging import Logger
 from datetime import datetime
 import psutil
 
-from ka_uts_com.utils.pacmod import PacMod
+# from ka_uts_com.com import Com
 from ka_uts_com.ioc.jinja2_ import Jinja2_
 
 TyAny = Any
@@ -20,6 +20,7 @@ TyArr = list[Any]
 TyBool = bool
 TyDic = dict[Any, Any]
 TyDir = str
+TyPath = str
 TyLogger = Logger
 
 TnAny = None | Any
@@ -30,11 +31,6 @@ TnTimeStamp = None | TyTimeStamp
 TnDateTime = None | TyDateTime
 
 
-class LogStandard:
-    """Standard Logging
-    """
-
-
 class Log_:
 
     sw_init: bool = False
@@ -42,70 +38,90 @@ class Log_:
     username: str = psutil.Process().username()
 
     @classmethod
-    def sh_run_dir(cls, com, **kwargs) -> TyDir:
+    def sh_dir_run(cls, com) -> TyDir:
         """Show run_dir
         """
-        tenant: str = com.d_pacmod['tenant']
-        package: str = com.d_pacmod['package']
-        module: str = com.d_pacmod['module']
-        log_type: str = kwargs.get('log_type', 'std')
-        if log_type == "std":
-            return f"/data/{tenant}/RUN/{package}/{module}"
-        return f"/data/{tenant}/RUN/{package}/{module}/{cls.username}"
+        # print(f"sh_dir_run com.dir_dat = {com.dir_dat}")
+        # print(f"sh_dir_run com.cmd = {com.cmd}")
+        # print(f"sh_dir_run com.tenant = {com.tenant}")
+        # print(f"sh_dir_run com = {com}")
+        dir_dat: str = com.dir_dat
+        tenant: str = com.tenant
+        cmd: str = com.cmd
+        package: str = com.d_app_pacmod['package']
+        # module: str = com.d_app_pacmod['module']
+        if tenant is not None:
+            path = f"{dir_dat}/{tenant}/RUN/{package}"
+        else:
+            path = f"{dir_dat}/RUN/{package}"
+        if com.log_type == "usr":
+            path = f"{path}/{cls.username}"
+        if cmd is not None:
+            path = f"{path}/{cmd}"
+        # print(f"sh_dir_run path = {path}")
+        # print("==================================")
+        return path
 
     @classmethod
-    def sh_cfg(cls, com, **kwargs) -> TyDic:
+    def sh_d_log_cfg(cls, com, **kwargs) -> TyDic:
         """Read log file path with jinja2
         """
-        run_dir = kwargs.get('run_dir', cls.sh_run_dir(com, **kwargs))
-        run_dir_debug: str = kwargs.get('run_dir_debug', f"{run_dir}/debs")
-        run_dir_info: str = kwargs.get('run_dir_info', f"{run_dir}/logs")
-        run_dir_error: str = kwargs.get('run_dir_error', f"{run_dir}/errs")
-
-        if kwargs.get('sw_mklogdirs', True):
-            os.makedirs(run_dir_debug, exist_ok=True)
-            os.makedirs(run_dir_info, exist_ok=True)
-            os.makedirs(run_dir_error, exist_ok=True)
-
-        log_type = kwargs.get('log_type', 'std')
-        logcfg_file = f'log.{log_type}.yml'
-        logcfg_path: str = PacMod.sh_path_cfg_log(filename=logcfg_file)
-        cfg: TyDic = Jinja2_.read(
-                logcfg_path,
-                com.Log,
-                debug_dir=run_dir_debug,
-                info_dir=run_dir_info,
-                error_dir=run_dir_error,
-                module=com.d_pacmod['module'],
+        dir_run = cls.sh_dir_run(com)
+        if kwargs.get('sw_single_dir_run', True):
+            # print("---sw_single_dir_run = True --------------")
+            dir_run_errs = f"{dir_run}/logs"
+            dir_run_wrns = f"{dir_run}/logs"
+            dir_run_infs = f"{dir_run}/logs"
+            dir_run_logs = f"{dir_run}/logs"
+            dir_run_debs = f"{dir_run}/logs"
+            if kwargs.get('sw_mk_dir_run', True):
+                os.makedirs(dir_run_logs, exist_ok=True)
+        else:
+            # print("---sw_single_dir_run = False -------------")
+            dir_run_errs = f"{dir_run}/errs"
+            dir_run_wrns = f"{dir_run}/wrns"
+            dir_run_infs = f"{dir_run}/infs"
+            dir_run_logs = f"{dir_run}/logs"
+            dir_run_debs = f"{dir_run}/debs"
+            if kwargs.get('sw_mk_dir_run', True):
+                os.makedirs(dir_run_errs, exist_ok=True)
+                os.makedirs(dir_run_wrns, exist_ok=True)
+                os.makedirs(dir_run_infs, exist_ok=True)
+                os.makedirs(dir_run_logs, exist_ok=True)
+                os.makedirs(dir_run_debs, exist_ok=True)
+        # path_log_cfg: TyPath = PacMod.sh_path_log_cfg(com)
+        module = com.d_app_pacmod['module']
+        # print(f"sh_d_log_cfg cls.path_log_cfg = {cls.path_log_cfg}")
+        d_log_cfg: TyDic = Jinja2_.read(
+                com.path_log_cfg, com.Log,
+                dir_run_errs=dir_run_errs,
+                dir_run_wrns=dir_run_wrns,
+                dir_run_infs=dir_run_infs,
+                dir_run_logs=dir_run_logs,
+                dir_run_debs=dir_run_debs,
+                module=module,
                 pid=com.pid,
                 ts=com.ts)
-        # ts=com.ts_start)
+        # print(f"sh_d_log_cfg d_log_cfg = {d_log_cfg}")
         sw_debug: TyBool = kwargs.get('sw_debug', False)
         if sw_debug:
             level = logging.DEBUG
         else:
             level = logging.INFO
-        if log_type == 'std':
-            logger_name = 'main'
-        else:
-            logger_name = 'person'
-        cfg['handlers'][f"{logger_name}_debug_console"]['level'] = level
-        cfg['handlers'][f"{logger_name}_debug_file"]['level'] = level
+        logger_name = com.log_type
+        d_log_cfg['handlers'][f"{logger_name}_debug_console"]['level'] = level
+        d_log_cfg['handlers'][f"{logger_name}_debug_file"]['level'] = level
 
-        return cfg
+        return d_log_cfg
 
     @classmethod
     def init(cls, com, **kwargs) -> None:
         """Set static variable log level in log configuration handlers
         """
-        log_type = kwargs.get('log_type', 'std')
         cls.sw_init = True
-        cfg = cls.sh_cfg(com, **kwargs)
-        logging.config.dictConfig(cfg)
-        if log_type == "std":
-            cls.log = logging.getLogger('main')
-        else:
-            cls.log = logging.getLogger(log_type)
+        d_log_cfg = cls.sh_d_log_cfg(com, **kwargs)
+        logging.config.dictConfig(d_log_cfg)
+        cls.log = logging.getLogger(com.log_type)
 
     @classmethod
     def sh(cls, com, **kwargs) -> TyLogger:

build/lib/ka_uts_com/com.py

@@ -4,12 +4,14 @@ from typing import Any
 import os
 import time
 import calendar
+import importlib.resources as resources
 import logging
 import logging.config
 from logging import Logger
 from datetime import datetime
 
 from ka_uts_com.utils.aoeqstmt import AoEqStmt
+from ka_uts_com.utils.pacmod import PacMod
 from ka_uts_com.base.app_ import App_
 from ka_uts_com.base.cfg_ import Cfg_
 from ka_uts_com.base.exit_ import Exit_
@@ -28,15 +30,23 @@ TnArr = None | TyArr
 TnDic = None | TyDic
 TnTimeStamp = None | TyTimeStamp
 TnDateTime = None | TyDateTime
+TnStr = None | str
 
 
 class Com:
     """Communication Class
     """
     sw_init: bool = False
-    cfg: TnDic = None
+    dir_dat: TnStr = None
+    tenant: TnStr = None
+    log_type: TnStr = None
+    cmd: TnStr = None
+    d_com_pacmod: TyDic = {}
+    d_app_pacmod: TyDic = {}
+    path_bin = None
+    path_log_cfg = None
+
     pid = None
-    d_pacmod: TyDic = {}
 
     ts: TnTimeStamp
     ts_start: TnDateTime = None
@@ -44,29 +54,68 @@ class Com:
     ts_etime: TnDateTime = None
     d_timer: TyDic = {}
 
-    Log: Logger = logging.getLogger('dummy_logger')
+    cfg: TnDic = None
+    Log = logging.getLogger('dummy_logger')
     App: Any = None
     Exit: Any = None
 
     @classmethod
-    def init(cls, **kwargs):
+    def init(cls, app_cls, kwargs: TyDic):
         """ set log and application (module) configuration
         """
         if cls.sw_init:
             return
         cls.sw_init = True
-        cls.d_pacmod = kwargs.get('d_pacmod', {})
+        cls.dir_dat = kwargs.get('dir_dat', '/data')
+        cls.tenant = kwargs.get('tenant')
+        cls.log_type = kwargs.get('log_type', 'std')
+        cls.cmd = kwargs.get('cmd')
+        cls.d_com_pacmod = PacMod.sh_d_pacmod(cls)
+        cls.d_app_pacmod = PacMod.sh_d_pacmod(app_cls)
+
         cls.ts = calendar.timegm(time.gmtime())
         cls.pid = os.getpid()
 
+        # print(f"Com.init cls.tenanat = {cls.tenant}")
+        # print(f"Com.init cls.cmd = {cls.cmd}")
+        # print(f"Com.init kwargs = {kwargs}")
+
+        cls.set_path_bin()
+        cls.set_path_log_cfg()
+
         cls.Log = Log_.sh(cls, **kwargs)
-        cls.cfg = Cfg_.sh(cls.Log, cls.d_pacmod)
-        cls.App = App_.sh(cls.Log, **kwargs)
+        cls.cfg = Cfg_.sh(cls, **kwargs)
+        cls.App = App_.sh(cls, **kwargs)
         cls.Exit = Exit_.sh(**kwargs)
 
     @classmethod
-    def sh_kwargs(cls, root_cls, d_parms, *args) -> TyDic:
-        _kwargs: TyDic = AoEqStmt.sh_d_eq(
-                *args, d_parms=d_parms, root_cls=root_cls)
-        cls.init(**_kwargs)
+    def sh_kwargs(cls, app_cls, d_parms, *args) -> TyDic:
+        _kwargs: TyDic = AoEqStmt.sh_d_eq(*args, d_parms=d_parms)
+        cls.init(app_cls, _kwargs)
+        _kwargs['com'] = cls
         return _kwargs
+
+    @classmethod
+    def set_path_bin(cls):
+        """ show directory
+        """
+        package = cls.d_app_pacmod['package']
+        path = resources.files(package).joinpath("bin")
+        if path.is_file():
+            cls.path_bin = path
+        # raise ModuleNotFoundError
+
+    @classmethod
+    def set_path_log_cfg(cls):
+        """ show directory
+        """
+        package = cls.d_app_pacmod['package']
+        path = resources.files(package).joinpath(f"data/log.{cls.log_type}.yml")
+        if path.is_file():
+            cls.path_log_cfg = path
+            return
+        package = cls.d_com_pacmod['package']
+        path = resources.files(package).joinpath(f"data/log.{cls.log_type}.yml")
+        if path.is_file():
+            cls.path_log_cfg = path
+        # raise ModuleNotFoundError

build/lib/ka_uts_com/data/log.std.yml

@@ -10,25 +10,27 @@ disable_existing_loggers: False
 
 loggers:
 
-    # main logger
-    main:
+    # standard logger
+    std:
         # level: NOTSET
         level: DEBUG
         handlers:
-            - main_debug_console
-            - main_debug_file
-            - main_info_file
-            - main_error_file
+            - std_debug_console
+            - std_error_file
+            - std_warning_file
+            - std_debug_file
+            - std_info_file
+            - std_log_file
 
 handlers:
 
-    main_debug_console:
+    std_debug_console:
         class: 'logging.StreamHandler'
         level: DEBUG
-        formatter: main_debug
+        formatter: std_debug
         stream: 'ext://sys.stderr'
 
-#   main_info_rotating_file_handler:
+#   std_info_rotating_file_handler:
 #       class: 'logging.handlers.RotatingFileHandler'
 #       level: INFO
 #       formatter: info
@@ -38,31 +40,45 @@ handlers:
 #       backupCount: 10
 #       encoding: utf8
 
-    main_debug_file:
+    std_error_file:
+        class: 'logging.FileHandler'
+        level: ERROR
+        formatter: std_error
+        filename: '{{dir_run_errs}}/errs_{{pid}}_{{ts}}.log'
+        mode: 'a'
+
+    std_warning_file:
+        class: 'logging.FileHandler'
+        level: WARNING
+        formatter: std_warning
+        filename: '{{dir_run_wrns}}/wrns_{{pid}}_{{ts}}.log'
+        mode: 'a'
+
+    std_debug_file:
         class: 'logging.FileHandler'
         level: DEBUG
-        formatter: main_error
-        filename: '{{debug_dir}}/debs_{{pid}}_{{ts}}.log'
+        formatter: std_debug
+        filename: '{{dir_run_debs}}/debs_{{pid}}_{{ts}}.log'
         mode: 'a'
 
-    main_info_file:
+    std_info_file:
         class: 'logging.FileHandler'
         level: INFO
-        formatter: main_info
-        filename: '{{info_dir}}/logs_{{pid}}_{{ts}}.log'
+        formatter: std_info
+        filename: '{{dir_run_infs}}/infs_{{pid}}_{{ts}}.log'
         mode: 'a'
 
-    main_error_file:
+    std_log_file:
         class: 'logging.FileHandler'
-        level: ERROR
-        formatter: main_error
-        filename: '{{error_dir}}/errs_{{pid}}_{{ts}}.log'
+        level: INFO
+        formatter: std_log
+        filename: '{{dir_run_logs}}/logs_{{pid}}_{{ts}}.log'
         mode: 'a'
 
-    main_critical_mail:
+    std_critical_mail:
         class: 'logging.handlers.SMTPHandler'
         level: CRITICAL
-        formatter: main_critical
+        formatter: std_critical
         mailhost : localhost
         fromaddr: 'monitoring@domain.com'
         toaddrs:
@@ -73,14 +89,19 @@ handlers:
 
 formatters:
 
-    main_info:
-        format: '%(asctime)s-%(levelname)s-%(name)s::%(module)s|%(lineno)s:: %(message)s'
-    main_debug:
+    std_warning:
         format: '%(asctime)-15s %(levelname)s-%(name)s-%(process)d::%(module)s.%(funcName)s|%(lineno)s:: %(message)s'
         datefmt: '%Y-%m-%d %H:%M:%S'
-    main_error:
+    std_error:
         format: '%(asctime)-15s %(levelname)s-%(name)s-%(process)d::%(module)s.%(funcName)s|%(lineno)s:: %(message)s'
         datefmt: '%Y-%m-%d %H:%M:%S'
-    main_critical:
+    std_debug:
+        format: '%(asctime)-15s %(levelname)s-%(name)s-%(process)d::%(module)s.%(funcName)s|%(lineno)s:: %(message)s'
+        datefmt: '%Y-%m-%d %H:%M:%S'
+    std_info:
+        format: '%(asctime)s-%(levelname)s-%(name)s::%(module)s|%(lineno)s:: %(message)s'
+    std_log:
+        format: '%(asctime)s-%(levelname)s-%(name)s::%(module)s|%(lineno)s:: %(message)s'
+    std_critical:
         format: '%(asctime)-15s %(levelname)s-%(name)s-%(process)d::%(module)s.%(funcName)s|%(lineno)s:: %(message)s'
         datefmt: '%Y-%m-%d %H:%M:%S'

build/lib/ka_uts_com/data/log.usr.yml

@@ -9,22 +9,24 @@ disable_existing_loggers: False
 
 loggers:
 
-    # person logger
-    person:
+    # user logger
+    usr:
         # level: NOTSET
         level: DEBUG
         handlers:
-            - person_debug_console
-            - person_debug_file
-            - person_info_file
-            - person_error_file
+            - usr_debug_console
+            - usr_error_file
+            - usr_warning_file
+            - usr_debug_file
+            - usr_info_file
+            - usr_log_file
 
 handlers:
 
-    person_debug_console:
+    usr_debug_console:
         class: 'logging.StreamHandler'
         level: DEBUG
-        formatter: person_debug
+        formatter: usr_debug
         stream: 'ext://sys.stderr'
 
 #   person_info_rotating_file_handler:
@@ -37,31 +39,45 @@ handlers:
 #       backupCount: 10
 #       encoding: utf8
 
-    person_debug_file:
+    usr_error_file:
+        class: 'logging.FileHandler'
+        level: ERROR
+        formatter: usr_error
+        filename: '{{dir_run_errs}}/errs_{{pid}}_{{ts}}.log'
+        mode: 'a'
+
+    usr_warning_file:
+        class: 'logging.FileHandler'
+        level: ERROR
+        formatter: usr_warning
+        filename: '{{dir_run_wrns}}/wrns_{{pid}}_{{ts}}.log'
+        mode: 'a'
+
+    usr_debug_file:
         class: 'logging.FileHandler'
         level: DEBUG
-        formatter: person_error
-        filename: '{{debug_dir}}/debs_{{pid}}_{{ts}}.log'
+        formatter: usr_debug
+        filename: '{{dir_run_debs}}/debs_{{pid}}_{{ts}}.log'
         mode: 'a'
 
-    person_info_file:
+    usr_info_file:
         class: 'logging.FileHandler'
         level: INFO
-        formatter: person_info
-        filename: '{{info_dir}}/logs_{{pid}}_{{ts}}.log'
+        formatter: usr_info
+        filename: '{{dir_run_infs}}/infs_{{pid}}_{{ts}}.log'
         mode: 'a'
 
-    person_error_file:
+    usr_log_file:
         class: 'logging.FileHandler'
-        level: ERROR
-        formatter: person_error
-        filename: '{{error_dir}}/errs_{{pid}}_{{ts}}.log'
+        level: INFO
+        formatter: usr_log
+        filename: '{{dir_run_logs}}/logs_{{pid}}_{{ts}}.log'
         mode: 'a'
 
-    person_critical_mail:
+    usr_critical_mail:
         class: 'logging.handlers.SMTPHandler'
         level: CRITICAL
-        formatter: person_critical
+        formatter: usr_critical
         mailhost : localhost
         fromaddr: 'monitoring@domain.com'
         toaddrs:
@@ -72,14 +88,19 @@ handlers:
 
 formatters:
 
-    person_info:
-        format: '%(asctime)s-%(levelname)s-%(name)s::%(module)s|%(lineno)s:: %(message)s'
-    person_debug:
+    usr_errs:
         format: '%(asctime)-15s %(levelname)s-%(name)s-%(process)d::%(module)s.%(funcName)s|%(lineno)s:: %(message)s'
         datefmt: '%Y-%m-%d %H:%M:%S'
-    person_error:
+    usr_wrns:
         format: '%(asctime)-15s %(levelname)s-%(name)s-%(process)d::%(module)s.%(funcName)s|%(lineno)s:: %(message)s'
         datefmt: '%Y-%m-%d %H:%M:%S'
-    person_critical:
+    usr_debs:
+        format: '%(asctime)-15s %(levelname)s-%(name)s-%(process)d::%(module)s.%(funcName)s|%(lineno)s:: %(message)s'
+        datefmt: '%Y-%m-%d %H:%M:%S'
+    usr_infs:
+        format: '%(asctime)s-%(levelname)s-%(name)s::%(module)s|%(lineno)s:: %(message)s'
+    usr_logs:
+        format: '%(asctime)s-%(levelname)s-%(name)s::%(module)s|%(lineno)s:: %(message)s'
+    usr_critical:
         format: '%(asctime)-15s %(levelname)s-%(name)s-%(process)d::%(module)s.%(funcName)s|%(lineno)s:: %(message)s'
         datefmt: '%Y-%m-%d %H:%M:%S'

build/lib/ka_uts_com/log.py

@@ -8,21 +8,25 @@ class Log:
     """
     class Eq:
 
-        @classmethod
-        def debug(cls, key: Any, value: Any) -> None:
-            Log.debug(f"{key} = {value}", stacklevel=3)
-
         @classmethod
         def error(cls, key: Any, value: Any) -> None:
             Log.error(f"{key} = {value}", stacklevel=3)
 
+        @classmethod
+        def warning(cls, key: Any, value: Any) -> None:
+            Log.warning(f"{key} = {value}", stacklevel=3)
+
         @classmethod
         def info(cls, key: Any, value: Any) -> None:
             Log.info(f"{key} = {value}", stacklevel=3)
 
         @classmethod
-        def warning(cls, key: Any, value: Any) -> None:
-            Log.warning(f"{key} = {value}", stacklevel=3)
+        def log(cls, key: Any, value: Any) -> None:
+            Log.log(f"{key} = {value}", stacklevel=3)
+
+        @classmethod
+        def debug(cls, key: Any, value: Any) -> None:
+            Log.debug(f"{key} = {value}", stacklevel=3)
 
     class Dic:
 
@@ -47,18 +51,18 @@ class Log:
                 Log.warning(f"{key} = {value}", stacklevel=3)
 
     @staticmethod
-    def debug(*args, **kwargs) -> None:
+    def error(*args, **kwargs) -> None:
         if kwargs is None:
             kwargs = {}
         kwargs['stacklevel'] = kwargs.get('stacklevel', 2)
-        Com.Log.debug(*args, **kwargs)
+        Com.Log.error(*args, **kwargs)
 
     @staticmethod
-    def error(*args, **kwargs) -> None:
+    def warning(*args, **kwargs) -> None:
         if kwargs is None:
             kwargs = {}
         kwargs['stacklevel'] = kwargs.get('stacklevel', 2)
-        Com.Log.error(*args, **kwargs)
+        Com.Log.warning(*args, **kwargs)
 
     @staticmethod
     def info(*args, **kwargs) -> None:
@@ -68,8 +72,15 @@ class Log:
         Com.Log.info(*args, **kwargs)
 
     @staticmethod
-    def warning(*args, **kwargs) -> None:
+    def log(*args, **kwargs) -> None:
         if kwargs is None:
             kwargs = {}
         kwargs['stacklevel'] = kwargs.get('stacklevel', 2)
-        Com.Log.warning(*args, **kwargs)
+        Com.Log.log(*args, **kwargs)
+
+    @staticmethod
+    def debug(*args, **kwargs) -> None:
+        if kwargs is None:
+            kwargs = {}
+        kwargs['stacklevel'] = kwargs.get('stacklevel', 2)
+        Com.Log.debug(*args, **kwargs)