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

build/lib/ka_uts_com/timer.py

@@ -26,8 +26,12 @@ class Timer:
     """ Timer Management
     """
     @staticmethod
-    def sh_task_id(d_pacmod: TyDic, class_id: Any, parms: TnAny, sep: TyStr) -> TyStr:
-        """ start Timer
+    def sh_task_id(d_pacmod: TyDic, class_id: TyAny, parms: TnAny, sep: TyStr) -> TyStr:
+        """
+        Show task id, which is created by the concationation of the following items:
+        package, module, class_name and parms if they are defined; the items package
+        and module are get from the package-module directory; the item class_name is
+        the class_id if its a string, otherwise the attribute __qualname__ is used.
         """
         package = d_pacmod.get('package')
         module = d_pacmod.get('module')
@@ -48,16 +52,16 @@ class Timer:
 
     @classmethod
     def start(cls, class_id: TyAny, parms: TnAny = None, sep: TyStr = ".") -> None:
-        """ start Timer
+        """ Start Timer
         """
-        task_id = cls.sh_task_id(Com.d_pacmod, class_id, parms, sep)
+        task_id = cls.sh_task_id(Com.d_app_pacmod, class_id, parms, sep)
         Com.d_timer[task_id] = datetime.now()
 
     @classmethod
     def end(cls, class_id: TyAny, parms: TnAny = None, sep: TyStr = ".") -> None:
-        """ end Timer
+        """ End Timer
         """
-        task_id = cls.sh_task_id(Com.d_pacmod, class_id, parms, sep)
+        task_id = cls.sh_task_id(Com.d_app_pacmod, class_id, parms, sep)
         start = Com.d_timer.get(task_id)
         end = datetime.now()
         elapse_time_sec = Timestamp.sh_elapse_time_sec(end, start)

build/lib/ka_uts_com/utils/aoeqstmt.py

@@ -29,11 +29,9 @@ class AoEqStmt:
     def sh_d_eq(cls, a_eqstmt: TyArr, **kwargs) -> TyDic:
         """ show equates dictionary
         """
-        root_cls = kwargs.get('root_cls')
         d_parms: TnDic = kwargs.get('d_parms')
         _sh_prof = kwargs.get('sh_prof')
         d_eq: TyDic = cls.init_d_eq(a_eqstmt)
         d_eq_new: TyDic = DoEq.verify(d_eq, d_parms)
-        DoEq._set_d_pacmod(d_eq_new, root_cls)
         DoEq._set_sh_prof(d_eq_new, _sh_prof)
         return d_eq_new

build/lib/ka_uts_com/utils/doeq.py

@@ -2,7 +2,7 @@
 from collections.abc import Callable
 from typing import Any
 
-from ka_uts_com.utils.pacmod import PacMod
+# from ka_uts_com.utils.pacmod import PacMod
 from ka_uts_com.utils.str import Str
 from ka_uts_com.utils.date import Date
 
@@ -55,12 +55,12 @@ class DoEq:
         # print(f"value = {value}, type(value) = {type(value)}")
         return value
 
-    @staticmethod
-    def _set_d_pacmod(d_eq: TyDic, root_cls) -> None:
-        """ set current pacmod dictionary
-        """
-        tenant = d_eq.get('tenant')
-        d_eq['d_pacmod'] = PacMod.sh_d_pacmod(root_cls, tenant)
+    # @staticmethod
+    # def _set_d_pacmod(d_eq: TyDic, root_cls) -> None:
+    #   """ set current pacmod dictionary
+    #   """
+    #   tenant = d_eq.get('tenant')
+    #   d_eq['d_pacmod'] = PacMod.sh_d_pacmod(root_cls, tenant)
 
     @staticmethod
     def _set_sh_prof(d_eq: TyDic, sh_prof: TyCall | Any) -> None:

build/lib/ka_uts_com/utils/pacmod.py

@@ -2,106 +2,122 @@
 from typing import Any
 
 from os import path as os_path
-import pkg_resources
+# import pkg_resources
+import importlib.resources as resources
 
 TyArr = list[Any]
 TyDic = dict[Any, Any]
+TyPath = str
+
 TnDic = None | TyDic
+TnPath = None | TyPath
 
 
 class PacMod:
     """ Package Module Management
     """
     @staticmethod
-    def sh_d_pacmod(root_cls, tenant: Any) -> TyDic:
+    def sh_d_pacmod(cls) -> TyDic:
         """ Show Pacmod Dictionary
         """
-        a_pacmod: TyArr = root_cls.__module__.split(".")
-        package = a_pacmod[0]
-        module = a_pacmod[1]
-        d_pacmod: TyDic = {}
-        d_pacmod['tenant'] = tenant
-        d_pacmod['package'] = package
-        d_pacmod['module'] = module
-        return d_pacmod
+        a_pacmod: TyArr = cls.__module__.split(".")
+        return {'package': a_pacmod[0], 'module': a_pacmod[1]}
 
-    # class Cfg:
-    #    """ Configuration Sub Class of Package Module Class
-    #    """
     @staticmethod
-    def sh_path_cfg_yaml(d_pacmod: TyDic) -> str:
+    def sh_path_module_yaml(d_pacmod: TyDic) -> str:
         """ show directory
         """
+        # def sh_path_cfg_yaml(d_pacmod: TyDic) -> str:
         package = d_pacmod['package']
         module = d_pacmod['module']
-
-        directory: str = f"{package}.data"
-
-        # print(f"dir = {dir}")
-        # print(f"package = {package}")
-        # print(f"module = {module}")
-
-        path: str = pkg_resources.resource_filename(directory, f"{module}.yml")
+        filename = f"{module}.yml"
+        file = resources.files(f"{package}.data")
+        print("sh_path_module_yaml files = {files}")
+        path: TyPath = file.joinpath(filename)
         return path
 
     @staticmethod
-    def sh_path_keys_yaml(
-            d_pacmod: TyDic, filename: str = 'keys.yml') -> str:
+    def sh_path_keys(
+            d_pacmod: TyDic, filename: str = 'keys.yml') -> TyPath:
         """ show directory
         """
         package = d_pacmod['package']
-        directory = f"{package}.data"
-        path: str = pkg_resources.resource_filename(directory, filename)
+        files = resources.files(f"{package}.data")
+        print("sh_path_keys files = {files}")
+        path: TyPath = files.joinpath(filename)
         return path
 
+    # @staticmethod
+    # def sh_path_log_cfg(com) -> TyPath:
+    #     """ show directory
+    #     """
+    #     package = com.d_app_pacmod['package']
+    #     path = resources.files(package).joinpath(f"data/log.{com.log_type}.yml")
+    #     if path.is_file():
+    #         return path
+    #     package = com.d_com_pacmod['package']
+    #     path = resources.files(package).joinpath(f"data/log.{com.log_type}.yml")
+    #     if path.is_file():
+    #         return path
+    #     raise ModuleNotFoundError
+
     @staticmethod
-    def sh_pacmod_type(d_pacmod: TyDic, type_: str) -> str:
-        """ show Data File Path
+    def sh_path_cfg(com) -> TyPath:
+        """ show directory
         """
-        package = d_pacmod['package']
-        module = d_pacmod['module']
-        return f"/data/{package}/{module}/{type_}"
+        filename = 'cfg.yml'
+        package = com.d_app_pacmod['package']
+        files = resources.files(f"{package}.data")
+        print(f"sh_path_cfg files = {files}")
+        path: TyPath = files.joinpath(filename)
+        return path
 
-    @classmethod
-    def sh_file_path(
-            cls, d_pacmod: TyDic, type_: str, suffix: str,
-            pid: Any, ts: Any, **kwargs) -> str:
-        """ show type specific path
-        """
-        filename = kwargs.get('filename')
-        if filename is not None:
-            filename_ = filename
-        else:
-            filename_ = type_
+    # @staticmethod
+    # def sh_path_type(d_pacmod: TyDic, type_: str) -> str:
+    #     """ show Data File Path
+    #     """
+    #     # def sh_pacmod_type(d_pacmod: TyDic, type_: str) -> str:
+    #     package = d_pacmod['package']
+    #     module = d_pacmod['module']
+    #     return f"/data/{package}/{module}/{type_}"
 
-        sw_run_pid_ts = kwargs.get('sw_run_pid_ts', True)
-        if sw_run_pid_ts is None:
-            sw_run_pid_ts = True
+    # @classmethod
+    # def sh_file_path(
+    #         cls, d_pacmod: TyDic, type_: str, suffix: str,
+    #         pid: Any, ts: Any, **kwargs) -> str:
+    #     """ show type specific path
+    #     """
+    #     filename_ = kwargs.get('filename', type_)
+    #     sw_run_pid_ts = kwargs.get('sw_run_pid_ts', True)
+    #     if sw_run_pid_ts is None:
+    #         sw_run_pid_ts = True
+    #
+    #   _dir: str = cls.sh_pacmod_type(d_pacmod, type_)
+    #   if sw_run_pid_ts:
+    #       file_path = os_path.join(
+    #           _dir, f"{filename_}_{pid}_{ts}.{suffix}")
+    #   else:
+    #       file_path = os_path.join(_dir, f"{filename_}.{suffix}")
+    #   return file_path
 
-        _dir: str = cls.sh_pacmod_type(d_pacmod, type_)
-        if sw_run_pid_ts:
-            file_path = os_path.join(
-                _dir, f"{filename_}_{pid}_{ts}.{suffix}")
+    @staticmethod
+    def sh_dir_type(com, type_: str) -> str:
+        """Show run_dir
+        """
+        dir_dat: str = com.dir_dat
+        tenant: str = com.tenant
+        package: str = com.d_app_pacmod['package']
+        module: str = com.d_app_pacmod['module']
+        if not tenant:
+            return f"{dir_dat}/{tenant}/{package}/{module}/{type_}"
         else:
-            file_path = os_path.join(_dir, f"{filename_}.{suffix}")
-        return file_path
+            return f"{dir_dat}/{package}/{module}/{type_}"
 
     @classmethod
-    def sh_pattern(
-            cls, d_pacmod: TyDic, type_: str, suffix: str, **kwargs) -> str:
+    def sh_path_pattern(
+            cls, com, filename, type_: str, suffix: str) -> str:
         """ show type specific path
         """
-        filename = kwargs.get('filename')
-        _directory: str = cls.sh_pacmod_type(d_pacmod, type_)
-        path = os_path.join(_directory, f"{filename}*.{suffix}")
+        _dir: str = cls.sh_dir_type(com, type_)
+        path: TyPath = os_path.join(_dir, f"{filename}*.{suffix}")
         return path
-
-    @staticmethod
-    def sh_path_cfg_log(d_pacmod: TnDic = None, filename: str = 'log.yml'):
-        """ show directory
-        """
-        if d_pacmod is None:
-            d_pacmod = {'package': 'ka_uts_com', 'module': 'com'}
-        return pkg_resources.resource_filename(
-            f"{d_pacmod['package']}.data", filename
-        )

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'

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

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

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:

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