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

ka_uts_com/ioc/yaml_.py

@@ -0,0 +1,30 @@
+# coding=utf-8
+import yaml
+
+from typing import Any
+TyAny = Any
+TyArr = list[Any]
+TyDic = dict[Any, Any]
+
+TnAny = None | Any
+
+
+class Yaml_:
+    """ Manage Object to Yaml file affilitation
+    """
+    @staticmethod
+    def read(path: str, log) -> TnAny:
+        try:
+            with open(path) as fd:
+                # The Loader parameter handles the conversion from YAML
+                # scalar values to Python object format
+                obj = yaml.load(fd, Loader=yaml.SafeLoader)
+                return obj
+        except FileNotFoundError:
+            log.error(f"No such file or directory: {path}")
+        except IOError:
+            # if Com.Log is not None:
+            #     fnc_error = Com.Log.error
+            #     fnc_error(exc, exc_info=True)
+            raise
+        return None

ka_uts_com/log.py

@@ -1,6 +1,6 @@
 from ka_uts_com.com import Com
-
-from typing import Any, Callable
+from typing import Any
+TyDic = dict[Any, Any]
 
 
 class Log:
@@ -8,56 +8,79 @@ class Log:
     """
     class Eq:
 
-        @staticmethod
-        def sh(key: Any, value: Any) -> str:
-            """ Show Key, Value as Equate
-            """
-            return f"{key} = {value}"
+        @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 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(cls.sh(key, value), stacklevel=3)
+            Log.debug(f"{key} = {value}", stacklevel=3)
+
+    class Dic:
 
         @classmethod
-        def error(cls, key: Any, value: Any) -> None:
-            Log.error(cls.sh(key, value), stacklevel=3)
+        def debug(cls, dic: TyDic) -> None:
+            for key, value in dic.items():
+                Log.debug(f"{key} = {value}", stacklevel=3)
 
         @classmethod
-        def info(cls, key: Any, value: Any) -> None:
-            Log.info(cls.sh(key, value), stacklevel=3)
+        def error(cls, dic: TyDic) -> None:
+            for key, value in dic.items():
+                Log.error(f"{key} = {value}", stacklevel=3)
 
         @classmethod
-        def warning(cls, key: Any, value: Any) -> None:
-            Log.warning(cls.sh(key, value), stacklevel=3)
+        def info(cls, dic: TyDic) -> None:
+            for key, value in dic.items():
+                Log.info(f"{key} = {value}", stacklevel=3)
+
+        @classmethod
+        def warning(cls, dic: TyDic) -> None:
+            for key, value in dic.items():
+                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)
-        fnc_debug: Callable = Com.Log.debug
-        fnc_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)
-        fnc_error: Callable = Com.Log.error
-        fnc_error(*args, **kwargs)
+        Com.Log.warning(*args, **kwargs)
 
     @staticmethod
     def info(*args, **kwargs) -> None:
         if kwargs is None:
             kwargs = {}
         kwargs['stacklevel'] = kwargs.get('stacklevel', 2)
-        fnc_info: Callable = Com.Log.info
-        fnc_info(*args, **kwargs)
+        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.log(*args, **kwargs)
+
+    @staticmethod
+    def debug(*args, **kwargs) -> None:
         if kwargs is None:
             kwargs = {}
         kwargs['stacklevel'] = kwargs.get('stacklevel', 2)
-        fnc_warning: Callable = Com.Log.warning
-        fnc_warning(*args, **kwargs)
+        Com.Log.debug(*args, **kwargs)

ka_uts_com/timer.py

@@ -1,25 +1,22 @@
 # coding=utf-8
-
 from datetime import datetime
 
 from ka_uts_com.com import Com
 from ka_uts_com.log import Log
 
-from typing import Any, List
-
-T_Any = Any
-T_Arr = List[Any]
-T_Str = str
-
-TN_Any = None | T_Any
-TN_Str = None | T_Str
+from typing import Any
+TyAny = Any
+TyArr = list[Any]
+TyDic = dict[Any, Any]
+TyStr = str
+TnAny = None | TyAny
+TnStr = None | TyStr
 
 
 class Timestamp:
 
     @staticmethod
-    def sh_elapse_time_sec(
-            end: Any, start: TN_Any) -> TN_Any:
+    def sh_elapse_time_sec(end: Any, start: TnAny) -> TnAny:
         if start is None:
             return None
         return end.timestamp()-start.timestamp()
@@ -29,12 +26,15 @@ class Timer:
     """ Timer Management
     """
     @staticmethod
-    def sh_task_id(
-            class_id: Any, parms: TN_Any, separator: T_Str) -> T_Str:
-        """ 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 = Com.pacmod_curr['package']
-        module = Com.pacmod_curr['module']
+        package = d_pacmod.get('package')
+        module = d_pacmod.get('module')
         if isinstance(class_id, str):
             class_name = class_id
         else:
@@ -43,28 +43,25 @@ class Timer:
             parms = ""
         else:
             parms = f" {parms}"
-        arr: T_Arr = []
+        arr: TyArr = []
         for item in [package, module, class_name, parms]:
             if not item:
                 continue
             arr.append(item)
-        return separator.join(arr)
+        return sep.join(arr)
 
     @classmethod
-    def start(
-            cls, class_id: T_Any,
-            parms: TN_Any = None, separator: T_Str = ".") -> None:
-        """ start Timer
+    def start(cls, class_id: TyAny, parms: TnAny = None, sep: TyStr = ".") -> None:
+        """ Start Timer
         """
-        task_id = cls.sh_task_id(class_id, parms, separator)
+        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: T_Any,
-            parms: TN_Any = None, separator: T_Str = ".") -> None:
-        """ end Timer
+    def end(cls, class_id: TyAny, parms: TnAny = None, sep: TyStr = ".") -> None:
+        """ End Timer
         """
-        task_id = cls.sh_task_id(class_id, parms, separator)
+        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

@@ -0,0 +1,37 @@
+# coding=utf-8
+from ka_uts_com.utils.doeq import DoEq
+
+from typing import Any
+TyArr = list[Any]
+TyDic = dict[Any, Any]
+
+TnArr = None | TyArr
+TnDic = None | TyDic
+TnStr = None | str
+
+
+class AoEqStmt:
+    """ Dictionary of Equates
+    """
+    @staticmethod
+    def init_d_eq(a_eqstmt: TyArr) -> TyDic:
+        d_eq = {}
+        for s_eq in a_eqstmt[1:]:
+            a_eq = s_eq.split('=')
+            if len(a_eq) == 1:
+                d_eq['cmd'] = a_eq[0]
+            else:
+                d_eq[a_eq[0]] = a_eq[1]
+                d_eq[a_eq[0]] = a_eq[1]
+        return d_eq
+
+    @classmethod
+    def sh_d_eq(cls, a_eqstmt: TyArr, **kwargs) -> TyDic:
+        """ show equates dictionary
+        """
+        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_sh_prof(d_eq_new, _sh_prof)
+        return d_eq_new

ka_uts_com/{date.py → utils/date.py}

@@ -1,15 +1,15 @@
 from datetime import datetime
 from datetime import date
 
-T_Date = date
-TN_Date = None | T_Date
-TN_Str = None | str
+TyDate = date
+TnDate = None | TyDate
+TnStr = None | str
 
 
 class Date:
 
     @staticmethod
-    def sh(datestring: TN_Str, fmt: str) -> TN_Date:
+    def sh(datestring: TnStr, fmt: str) -> TnDate:
         if not datestring:
             return None
         return datetime.strptime(datestring, fmt).date()

ka_uts_com/utils/doeq.py

@@ -0,0 +1,99 @@
+# coding=utf-8
+from collections.abc import Callable
+from typing import Any
+
+# from ka_uts_com.utils.pacmod import PacMod
+from ka_uts_com.utils.str import Str
+from ka_uts_com.utils.date import Date
+
+
+TyArr = list[Any]
+TyCall = Callable[..., Any]
+TyDic = dict[Any, Any]
+TyStr = str
+
+TnArr = None | TyArr
+TnDic = None | TyDic
+TnStr = None | TyStr
+
+
+class DoEq:
+    """ Manage Commandline Arguments
+    """
+    @classmethod
+    def sh_value(cls, key: str, value: Any, d_valid_parms: TnDic) -> Any:
+
+        # print(f"key = {key}, type(key) = {type(key)}")
+        # print(f"value = {value}, type(value) = {type(value)}")
+        if not d_valid_parms:
+            return value
+        _type: TnStr = d_valid_parms.get(key)
+        # print(f"_type = {_type}")
+        if not _type:
+            return value
+        if isinstance(_type, str):
+            match _type:
+                case 'int':
+                    value = int(value)
+                case 'bool':
+                    value = Str.sh_boolean(value)
+                case 'dict':
+                    value = Str.sh_dic(value)
+                case 'list':
+                    value = Str.sh_arr(value)
+                case '%Y-%m-%d':
+                    value = Date.sh(value, _type)
+                case '_':
+                    match _type[0]:
+                        case '[', '{':
+                            _obj = Str.sh_dic(_type)
+                            if value not in _obj:
+                                msg = (f"parameter={key} value={value} is invalid; "
+                                       f"valid values are={_obj}")
+                                raise Exception(msg)
+
+        # 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_sh_prof(d_eq: TyDic, sh_prof: TyCall | Any) -> None:
+        """ set current pacmod dictionary
+        """
+        if callable(sh_prof):
+            d_eq['sh_prof'] = sh_prof()
+        else:
+            d_eq['sh_prof'] = sh_prof
+
+    @classmethod
+    def verify(cls, d_eq: TyDic, d_parms: TnDic) -> TyDic:
+        if d_parms is None:
+            return d_eq
+        if 'cmd' in d_eq:
+            _d_valid_parms = d_parms
+            _cmd = d_eq['cmd']
+            _valid_commands = list(d_parms.keys())
+            if _cmd not in _valid_commands:
+                msg = (f"Wrong command: {_cmd}; "
+                       f"valid commands are: {_valid_commands}")
+                raise Exception(msg)
+            _d_valid_parms = d_parms[_cmd]
+        else:
+            _d_valid_parms = d_parms
+        if _d_valid_parms is None:
+            return d_eq
+
+        d_eq_new = {}
+        for key, value in d_eq.items():
+            if key not in _d_valid_parms:
+                msg = (f"Wrong parameter: {key}; "
+                       f"valid parameters are: {_d_valid_parms}")
+                raise Exception(msg)
+            d_eq_new[key] = cls.sh_value(key, value, _d_valid_parms)
+        return d_eq_new

ka_uts_com/utils/pacmod.py

@@ -0,0 +1,123 @@
+# coding=utf-8
+from typing import Any
+
+from os import path as os_path
+# 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(cls) -> TyDic:
+        """ Show Pacmod Dictionary
+        """
+        a_pacmod: TyArr = cls.__module__.split(".")
+        return {'package': a_pacmod[0], 'module': a_pacmod[1]}
+
+    @staticmethod
+    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']
+        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(
+            d_pacmod: TyDic, filename: str = 'keys.yml') -> TyPath:
+        """ show directory
+        """
+        package = d_pacmod['package']
+        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_path_cfg(com) -> TyPath:
+        """ show directory
+        """
+        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
+
+    # @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_}"
+
+    # @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
+
+    @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:
+            return f"{dir_dat}/{package}/{module}/{type_}"
+
+    @classmethod
+    def sh_path_pattern(
+            cls, com, filename, type_: str, suffix: str) -> str:
+        """ show type specific path
+        """
+        _dir: str = cls.sh_dir_type(com, type_)
+        path: TyPath = os_path.join(_dir, f"{filename}*.{suffix}")
+        return path