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

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'

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'

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)

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)

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

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:

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