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

ka_uts_com/com.py

@@ -10,6 +10,8 @@ from logging import Logger
 from datetime import datetime
 
 from ka_uts_com.utils.aoeqstmt import AoEqStmt
+from ka_uts_com.utils.pac import Pac
+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,62 @@ 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()
 
+        cls.path_bin = cls.sh_path_bin()
+        cls.path_log_cfg = cls.sh_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 sh_path_bin(cls) -> Any:
+        """ show directory
+        """
+        package = cls.d_app_pacmod['package']
+        path = "bin"
+        return Pac.sh_path_by_package(package, path)
+
+    @classmethod
+    def sh_path_log_cfg(cls) -> Any:
+        """ show directory
+        """
+        _packages = [cls.d_app_pacmod['package'], cls.d_com_pacmod['package']]
+        _path = f"data/log.{cls.log_type}.yml"
+        return Pac.sh_path_by_packages(_packages, _path)
+
+    @classmethod
+    def sh_path_cfg(cls) -> Any:
+        """ show directory
+        """
+        package = cls.d_app_pacmod['package']
+        path = 'data/cfg.yml'
+        return Pac.sh_path_by_package(package, path)

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/ioc/jinja2_.py

@@ -38,5 +38,5 @@ class Jinja2_:
             return obj
         except IOError as exc:
             log.error(exc, exc_info=True)
-            # log.error(f"No such file or directory: {path}")
+            # log.error(f"No such file or directory: path='{path'}")
             raise

ka_uts_com/ioc/yaml_.py

@@ -21,7 +21,8 @@ class Yaml_:
                 obj = yaml.load(fd, Loader=yaml.SafeLoader)
                 return obj
         except FileNotFoundError:
-            log.error(f"No such file or directory: {path}")
+            log.error(f"No such file or directory: path='{path}'")
+            raise
         except IOError:
             # if Com.Log is not None:
             #     fnc_error = Com.Log.error

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/pac.py

@@ -0,0 +1,35 @@
+# coding=utf-8
+from typing import Any
+
+import os
+import importlib.resources as resources
+
+TyArr = list[Any]
+TyDic = dict[Any, Any]
+TyPackage = str
+TyPackages = list[str]
+TyPath = str
+
+
+class Pac:
+
+    @staticmethod
+    def sh_path_by_package(package: TyPackage, path: TyPath) -> Any:
+        """ show directory
+        """
+        _path = str(resources.files(package).joinpath(path))
+        # if _path.is_file():
+        if _path is not None and _path != '':
+            if os.path.exists(_path):
+                return _path
+        return ''
+
+    @classmethod
+    def sh_path_by_packages(cls, packages: TyPackages, path: TyPath) -> Any:
+        """ show directory
+        """
+        for _package in packages:
+            _path = cls.sh_path_by_package(_package, path)
+            if _path:
+                return _path
+        return ''