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

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)

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

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

{build/lib/ka_uts_com → 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
         )

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

@@ -1,37 +1,36 @@
 # coding=utf-8
+from typing import Any
+import traceback
 
 from datetime import datetime
 import re
 import orjson
 import simplejson
-import traceback
 
-from typing import Any, List, Dict
+TyArr = list[Any]
+TyDic = dict[Any, Any]
+TyAoA = list[TyArr]
 
-T_Arr = List[Any]
-T_Dic = Dict[Any, Any]
-T_AoA = List[T_Arr]
-
-TN_Int = None | int
-TN_Float = None | float
-TN_Str = None | str
-TN_AoA = None | T_AoA
-TN_Arr = None | T_Arr
-TN_Dic = None | T_Dic
-TN_Datetime = None | datetime
+TnInt = None | int
+TnFloat = None | float
+TnStr = None | str
+TnAoA = None | TyAoA
+TnArr = None | TyArr
+TnDic = None | TyDic
+TnDatetime = None | datetime
 
 
 class Str:
     """ Manage String Class
     """
     @staticmethod
-    def sh_date(string: str, fmt: TN_Str = None) -> TN_Datetime:
+    def sh_date(string: str, fmt: TnStr = None) -> TnDatetime:
         """ show string as date using the format string
         """
         try:
             if fmt is None:
                 fmt = "%m/%d/%Y"
-            _date: TN_Datetime = datetime.strptime(string, fmt)
+            _date: TnDatetime = datetime.strptime(string, fmt)
             return _date
         except Exception:
             print(traceback.format_exc())
@@ -69,8 +68,7 @@ class Str:
             if int(string) % 2 == 0:
                 return False
             return True
-        else:
-            return False
+        return False
 
     @staticmethod
     def is_integer(string: str) -> bool:
@@ -89,7 +87,7 @@ class Str:
         return False
 
     @staticmethod
-    def is_undefined(string: TN_Str) -> bool:
+    def is_undefined(string: TnStr) -> bool:
         """ check if string is undefined (None or empty)
         """
         if string is None or string == '':
@@ -97,7 +95,7 @@ class Str:
         return False
 
     @staticmethod
-    def nvl(string: TN_Str) -> TN_Str:
+    def nvl(string: TnStr) -> TnStr:
         """ nvl function similar to SQL NVL function
         """
         if string is None:
@@ -111,7 +109,7 @@ class Str:
         return string.replace('\n', ' ').strip()
 
     @staticmethod
-    def remove(string: str, a_to_remove: T_Arr) -> str:
+    def remove(string: str, a_to_remove: TyArr) -> str:
         """ remove all character of a list
         """
         for to_remove in a_to_remove:
@@ -122,15 +120,16 @@ class Str:
     def sh_boolean(string: str) -> bool:
         """ Show string as boolean if string is a boolean
         """
-        if string.lower() == 'true':
-            return True
-        elif string.lower() == 'false':
-            return False
-        else:
-            raise ValueError
+        match string.lower():
+            case 'true':
+                return True
+            case 'false':
+                return False
+            case _:
+                raise ValueError
 
     @staticmethod
-    def sh_float(string: str) -> TN_Float:
+    def sh_float(string: str) -> TnFloat:
         """ Returns Float if string is of Type Float
             otherwise None
         """
@@ -141,7 +140,7 @@ class Str:
             return None
 
     @staticmethod
-    def sh_int(string: str) -> TN_Int:
+    def sh_int(string: str) -> TnInt:
         """ Returns Int if string is of Type Int
             otherwise None
         """
@@ -151,23 +150,21 @@ class Str:
             return None
 
     @staticmethod
-    def sh_dic(string: str, sw_decimal=False) -> TN_Dic:
+    def sh_dic(string: str, sw_decimal=False) -> Any:
         """ Returns Dic if string is of Type Json-String
             otherwise None
         """
         try:
             if sw_decimal:
-                dic = simplejson.loads(string, use_decimal=True)
+                return simplejson.loads(string, use_decimal=True)
             else:
-                dic = orjson.loads(string)
-            return dic
+                return orjson.loads(string)
         except Exception:
-            # print(f"string = {string}")
             print(traceback.format_exc())
             return None
 
     @staticmethod
-    def sh_arr(string: str) -> TN_Arr:
+    def sh_arr(string: str) -> Any:
         """ Show valid Array string as Array
         """
         try:
@@ -177,7 +174,7 @@ class Str:
             return None
 
     @staticmethod
-    def sh_aoa(string: str) -> TN_AoA:
+    def sh_aoa(string: str) -> Any:
         """ Show valid Array string as Array
         """
         try:
@@ -193,7 +190,7 @@ class Str:
         return string.split()[0]
 
     @classmethod
-    def sh_a_int(cls, string: str, sep: str) -> T_Arr:
+    def sh_a_int(cls, string: str, sep: str) -> TyArr:
         """ Show first substring of string
         """
         # arr = string.split(sep)
@@ -210,7 +207,7 @@ class Str:
 
     @classmethod
     def sh_a_str(
-            cls, string: str, sep: str, a_exclude: TN_Arr = None) -> Any:
+            cls, string: str, sep: str, a_exclude: TnArr = None) -> Any:
         """ Show first substring of string
         """
         # arr = string.split(sep)
@@ -238,7 +235,7 @@ class Str:
 
     @classmethod
     def sh_a_obj(
-            cls, string: str, sep: str, a_exclude: TN_Arr = None) -> Any:
+            cls, string: str, sep: str, a_exclude: TnArr = None) -> Any:
         """ Show first substring of string
         """
         # arr = string.split(sep)
@@ -253,7 +250,7 @@ class Str:
                 if _item not in a_exclude:
                     _arr.append(_item)
 
-        arr_new: T_Arr = []
+        arr_new: TyArr = []
         for item in _arr:
             if isinstance(item, str):
                 _item = item.strip()