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

build/lib/ka_uts_com/fnc.py

@@ -1,37 +1,42 @@
 # coding=utf-8
+from collections.abc import Callable
+from typing import Any
 
-from typing import Any, Callable, Dict
+TyArr = list[Any]
+TyCallable = Callable[..., Any]
+TyDic = dict[Any, Any]
+TyArrDic = TyArr | TyDic
+TyDoC = dict[str, TyCallable]
+TyMsg = str
 
-T_Dic = Dict[Any, Any]
-T_DicStr2Callable = Dict[str, Callable]
-
-TN_Str = None | str
-TN_Callable = None | Callable
+TnStr = None | str
+TnDoC = None | TyDoC
+TnCallable = None | TyCallable
 
 
 class Fnc:
-    """ Manage Functions
+    """
+    Functions
     """
     @staticmethod
-    def sh(d_key2fnc: T_DicStr2Callable, key: TN_Str) -> Callable:
-        if not key:
-            msg = f"key {key} is None or empty string"
-            raise Exception(msg)
-        _fnc: TN_Callable = d_key2fnc.get(key)
-        if not _fnc:
-            msg = f"key {key} is not defined in function table {d_key2fnc}"
-            raise Exception(msg)
-        else:
-            return _fnc
+    def identity(obj: Any) -> Any:
+        return obj
 
     @staticmethod
-    def ex(d_key2fnc: T_DicStr2Callable, key: TN_Str, kwargs: T_Dic) -> None:
+    def sh(doc: TnDoC, key: TnStr) -> TyCallable:
+        if not doc:
+            msg = f"function table: {doc} is not defined"
+            raise Exception(msg)
         if not key:
-            msg = f"key {key} is None or empty string"
+            msg = f"key: {key} is not defined"
             raise Exception(msg)
-        _fnc: TN_Callable = d_key2fnc.get(key)
-        if not _fnc:
-            msg = f"key {key} is not defined in function table {d_key2fnc}"
+        fnc: TnCallable = doc.get(key)
+        if not fnc:
+            msg = f"key: {key} is not defined in function table: {doc}"
             raise Exception(msg)
-        else:
-            _fnc(kwargs)
+        return fnc
+
+    @classmethod
+    def ex(cls, doc: TnDoC, key: TnStr, args_kwargs: TyArrDic) -> Any:
+        fnc: TyCallable = cls.sh(doc, key)
+        return fnc(args_kwargs)

build/lib/ka_uts_com/ioc/jinja2_.py

@@ -0,0 +1,42 @@
+# coding=utf-8
+# from collections.abc import Callable
+from typing import Any
+
+import os
+import yaml
+import jinja2
+# import logging
+# import logging.config
+from logging import Logger
+
+TyAny = Any
+TyDic = dict[Any, Any]
+TyLogger = Logger
+
+TnDic = None | TyDic
+
+
+class Jinja2_:
+
+    """ Manage Object to Json file affilitation
+    """
+    @staticmethod
+    def read_template(path: str) -> Any:
+        directory, file = os.path.split(path)
+        env = jinja2.Environment(loader=jinja2.FileSystemLoader(directory))
+        return env.get_template(file)
+
+    @classmethod
+    def read(cls, path: str, log: TyLogger, **kwargs) -> Any:
+        try:
+            # read jinja template from file
+            template = cls.read_template(path)
+            # render template as yaml string
+            template_rendered = template.render(kwargs)
+            # load yaml string into object
+            obj: Any = yaml.safe_load(template_rendered)
+            return obj
+        except IOError as exc:
+            log.error(exc, exc_info=True)
+            # log.error(f"No such file or directory: {path}")
+            raise

build/lib/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

build/lib/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,68 @@ class Log:
     """
     class Eq:
 
-        @staticmethod
-        def sh(key: Any, value: Any) -> str:
-            """ Show Key, Value as Equate
-            """
-            return f"{key} = {value}"
-
         @classmethod
         def debug(cls, key: Any, value: Any) -> None:
-            Log.debug(cls.sh(key, value), stacklevel=3)
+            Log.debug(f"{key} = {value}", stacklevel=3)
 
         @classmethod
         def error(cls, key: Any, value: Any) -> None:
-            Log.error(cls.sh(key, value), stacklevel=3)
+            Log.error(f"{key} = {value}", stacklevel=3)
 
         @classmethod
         def info(cls, key: Any, value: Any) -> None:
-            Log.info(cls.sh(key, value), stacklevel=3)
+            Log.info(f"{key} = {value}", stacklevel=3)
 
         @classmethod
         def warning(cls, key: Any, value: Any) -> None:
-            Log.warning(cls.sh(key, value), stacklevel=3)
+            Log.warning(f"{key} = {value}", stacklevel=3)
+
+    class Dic:
+
+        @classmethod
+        def debug(cls, dic: TyDic) -> None:
+            for key, value in dic.items():
+                Log.debug(f"{key} = {value}", stacklevel=3)
+
+        @classmethod
+        def error(cls, dic: TyDic) -> None:
+            for key, value in dic.items():
+                Log.error(f"{key} = {value}", stacklevel=3)
+
+        @classmethod
+        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:
         if kwargs is None:
             kwargs = {}
         kwargs['stacklevel'] = kwargs.get('stacklevel', 2)
-        fnc_debug: Callable = Com.Log.debug
-        fnc_debug(*args, **kwargs)
+        Com.Log.debug(*args, **kwargs)
 
     @staticmethod
     def error(*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.error(*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:
         if kwargs is None:
             kwargs = {}
         kwargs['stacklevel'] = kwargs.get('stacklevel', 2)
-        fnc_warning: Callable = Com.Log.warning
-        fnc_warning(*args, **kwargs)
+        Com.Log.warning(*args, **kwargs)

build/lib/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,11 @@ class Timer:
     """ Timer Management
     """
     @staticmethod
-    def sh_task_id(
-            class_id: Any, parms: TN_Any, separator: T_Str) -> T_Str:
+    def sh_task_id(d_pacmod: TyDic, class_id: Any, parms: TnAny, sep: TyStr) -> TyStr:
         """ start Timer
         """
-        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 +39,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:
+    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_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:
+    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_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

@@ -0,0 +1,39 @@
+# 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
+        """
+        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/{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()

build/lib/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 → build/lib/ka_uts_com/utils}/pacmod.py

@@ -1,26 +1,25 @@
 # coding=utf-8
+from typing import Any
 
 from os import path as os_path
 import pkg_resources
 
-from typing import Any, Dict, List
+TyArr = list[Any]
+TyDic = dict[Any, Any]
+TnDic = None | TyDic
 
-T_Arr = List[Any]
-T_Dic = Dict[Any, Any]
 
-TN_Dic = None | T_Dic
-
-
-class Pacmod:
+class PacMod:
     """ Package Module Management
     """
-    def sh_d_pacmod(root_cls, tenant: Any) -> T_Dic:
+    @staticmethod
+    def sh_d_pacmod(root_cls, tenant: Any) -> TyDic:
         """ Show Pacmod Dictionary
         """
-        a_pacmod: T_Arr = root_cls.__module__.split(".")
+        a_pacmod: TyArr = root_cls.__module__.split(".")
         package = a_pacmod[0]
         module = a_pacmod[1]
-        d_pacmod: T_Dic = {}
+        d_pacmod: TyDic = {}
         d_pacmod['tenant'] = tenant
         d_pacmod['package'] = package
         d_pacmod['module'] = module
@@ -30,42 +29,42 @@ class Pacmod:
     #    """ Configuration Sub Class of Package Module Class
     #    """
     @staticmethod
-    def sh_path_cfg_yaml(pacmod: T_Dic) -> str:
+    def sh_path_cfg_yaml(d_pacmod: TyDic) -> str:
         """ show directory
         """
-        package = pacmod['package']
-        module = pacmod['module']
+        package = d_pacmod['package']
+        module = d_pacmod['module']
 
-        dir: str = f"{package}.data"
+        directory: str = f"{package}.data"
 
         # print(f"dir = {dir}")
         # print(f"package = {package}")
         # print(f"module = {module}")
 
-        path = pkg_resources.resource_filename(dir, f"{module}.yml")
+        path: str = pkg_resources.resource_filename(directory, f"{module}.yml")
         return path
 
     @staticmethod
     def sh_path_keys_yaml(
-            pacmod: Any, filename: str = 'keys.yml') -> str:
+            d_pacmod: TyDic, filename: str = 'keys.yml') -> str:
         """ show directory
         """
-        package = pacmod['package']
-        dir = f"{package}.data"
-        path = pkg_resources.resource_filename(dir, filename)
+        package = d_pacmod['package']
+        directory = f"{package}.data"
+        path: str = pkg_resources.resource_filename(directory, filename)
         return path
 
     @staticmethod
-    def sh_pacmod_type(pacmod: Dict, type_: str) -> str:
+    def sh_pacmod_type(d_pacmod: TyDic, type_: str) -> str:
         """ show Data File Path
         """
-        package = pacmod['package']
-        module = pacmod['module']
+        package = d_pacmod['package']
+        module = d_pacmod['module']
         return f"/data/{package}/{module}/{type_}"
 
     @classmethod
     def sh_file_path(
-            cls, pacmod: T_Dic, type_: str, suffix: str,
+            cls, d_pacmod: TyDic, type_: str, suffix: str,
             pid: Any, ts: Any, **kwargs) -> str:
         """ show type specific path
         """
@@ -79,11 +78,8 @@ class Pacmod:
         if sw_run_pid_ts is None:
             sw_run_pid_ts = True
 
-        # _dir: str = cls.Data.Dir.sh(pacmod, type)
-        _dir: str = cls.sh_pacmod_type(pacmod, type_)
+        _dir: str = cls.sh_pacmod_type(d_pacmod, type_)
         if sw_run_pid_ts:
-            # pid = str(Com.pid)
-            # ts = str(Com.ts_start)
             file_path = os_path.join(
                 _dir, f"{filename_}_{pid}_{ts}.{suffix}")
         else:
@@ -92,20 +88,20 @@ class Pacmod:
 
     @classmethod
     def sh_pattern(
-            cls, pacmod: T_Dic, type_: str, suffix: str, **kwargs) -> str:
+            cls, d_pacmod: TyDic, type_: str, suffix: str, **kwargs) -> str:
         """ show type specific path
         """
         filename = kwargs.get('filename')
-        _dir: str = cls.sh_pacmod_type(pacmod, type_)
-        path = os_path.join(_dir, f"{filename}*.{suffix}")
+        _directory: str = cls.sh_pacmod_type(d_pacmod, type_)
+        path = os_path.join(_directory, f"{filename}*.{suffix}")
         return path
 
     @staticmethod
-    def sh_path_cfg_log(pacmod: TN_Dic = None, filename: str = 'log.yml'):
+    def sh_path_cfg_log(d_pacmod: TnDic = None, filename: str = 'log.yml'):
         """ show directory
         """
-        if pacmod is None:
-            pacmod = {'package': 'ka_uts_com', 'module': 'com'}
+        if d_pacmod is None:
+            d_pacmod = {'package': 'ka_uts_com', 'module': 'com'}
         return pkg_resources.resource_filename(
-            f"{pacmod['package']}.data", filename
+            f"{d_pacmod['package']}.data", filename
         )