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

build/lib/ka_uts_com/log.py

@@ -0,0 +1,63 @@
+from ka_uts_com.com import Com
+
+from typing import Any, Callable
+
+
+class Log:
+    """Logging Class
+    """
+    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)
+
+        @classmethod
+        def error(cls, key: Any, value: Any) -> None:
+            Log.error(cls.sh(key, value), stacklevel=3)
+
+        @classmethod
+        def info(cls, key: Any, value: Any) -> None:
+            Log.info(cls.sh(key, value), stacklevel=3)
+
+        @classmethod
+        def warning(cls, key: Any, value: Any) -> None:
+            Log.warning(cls.sh(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)
+
+    @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)
+
+    @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)
+
+    @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)

build/lib/ka_uts_com/pacmod.py

@@ -0,0 +1,111 @@
+# coding=utf-8
+
+from os import path as os_path
+import pkg_resources
+
+from typing import Any, Dict, List
+
+T_Arr = List[Any]
+T_Dic = Dict[Any, Any]
+
+TN_Dic = None | T_Dic
+
+
+class Pacmod:
+    """ Package Module Management
+    """
+    def sh_d_pacmod(root_cls, tenant: Any) -> T_Dic:
+        """ Show Pacmod Dictionary
+        """
+        a_pacmod: T_Arr = root_cls.__module__.split(".")
+        package = a_pacmod[0]
+        module = a_pacmod[1]
+        d_pacmod: T_Dic = {}
+        d_pacmod['tenant'] = tenant
+        d_pacmod['package'] = package
+        d_pacmod['module'] = module
+        return d_pacmod
+
+    # class Cfg:
+    #    """ Configuration Sub Class of Package Module Class
+    #    """
+    @staticmethod
+    def sh_path_cfg_yaml(pacmod: T_Dic) -> str:
+        """ show directory
+        """
+        package = pacmod['package']
+        module = pacmod['module']
+
+        dir: 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")
+        return path
+
+    @staticmethod
+    def sh_path_keys_yaml(
+            pacmod: Any, filename: str = 'keys.yml') -> str:
+        """ show directory
+        """
+        package = pacmod['package']
+        dir = f"{package}.data"
+        path = pkg_resources.resource_filename(dir, filename)
+        return path
+
+    @staticmethod
+    def sh_pacmod_type(pacmod: Dict, type_: str) -> str:
+        """ show Data File Path
+        """
+        package = pacmod['package']
+        module = pacmod['module']
+        return f"/data/{package}/{module}/{type_}"
+
+    @classmethod
+    def sh_file_path(
+            cls, pacmod: T_Dic, 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_
+
+        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.Data.Dir.sh(pacmod, type)
+        _dir: str = cls.sh_pacmod_type(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:
+            file_path = os_path.join(_dir, f"{filename_}.{suffix}")
+        return file_path
+
+    @classmethod
+    def sh_pattern(
+            cls, pacmod: T_Dic, 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}")
+        return path
+
+    @staticmethod
+    def sh_path_cfg_log(pacmod: TN_Dic = None, filename: str = 'log.yml'):
+        """ show directory
+        """
+        if pacmod is None:
+            pacmod = {'package': 'ka_uts_com', 'module': 'com'}
+        return pkg_resources.resource_filename(
+            f"{pacmod['package']}.data", filename
+        )

build/lib/ka_uts_com/str.py

@@ -0,0 +1,268 @@
+# coding=utf-8
+
+from datetime import datetime
+import re
+import orjson
+import simplejson
+import traceback
+
+from typing import Any, List, Dict
+
+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
+
+
+class Str:
+    """ Manage String Class
+    """
+    @staticmethod
+    def sh_date(string: str, fmt: TN_Str = None) -> TN_Datetime:
+        """ show string as date using the format string
+        """
+        try:
+            if fmt is None:
+                fmt = "%m/%d/%Y"
+            _date: TN_Datetime = datetime.strptime(string, fmt)
+            return _date
+        except Exception:
+            print(traceback.format_exc())
+            return None
+
+    @staticmethod
+    def lchop(string: str, prefix: str) -> str:
+        """ return substring of string which starts at the
+            end of the contained prefix
+        """
+        if string.startswith(prefix):
+            return string[len(prefix):]
+        return string
+
+    @staticmethod
+    def rchop(string: str, suffix: str) -> str:
+        """ return substring of string which ends at the
+            beginning of the contained suffix
+        """
+        if suffix and string.endswith(suffix):
+            return string[:-len(suffix)]
+        return string
+
+    @staticmethod
+    def strip_multiple_chars(string: str, chars: str) -> str:
+        """ replace multiple characters in string
+        """
+        return string.translate(str.maketrans("", "", chars))
+
+    @staticmethod
+    def is_odd(string: str) -> bool:
+        """ check if string is odd number
+        """
+        if string.isnumeric():
+            if int(string) % 2 == 0:
+                return False
+            return True
+        else:
+            return False
+
+    @staticmethod
+    def is_integer(string: str) -> bool:
+        """ check if string is integer
+        """
+        if string[0] in ('-', '+'):
+            return string[1:].isdigit()
+        return string.isdigit()
+
+    @staticmethod
+    def is_boolean(string: str) -> bool:
+        """ check if string is boolean
+        """
+        if string.strip().lower() in ['true', 'false']:
+            return True
+        return False
+
+    @staticmethod
+    def is_undefined(string: TN_Str) -> bool:
+        """ check if string is undefined (None or empty)
+        """
+        if string is None or string == '':
+            return True
+        return False
+
+    @staticmethod
+    def nvl(string: TN_Str) -> TN_Str:
+        """ nvl function similar to SQL NVL function
+        """
+        if string is None:
+            return ''
+        return string
+
+    @staticmethod
+    def strip_n(string: str) -> str:
+        """ Replace new line characters by Blanks and strip Blanks
+        """
+        return string.replace('\n', ' ').strip()
+
+    @staticmethod
+    def remove(string: str, a_to_remove: T_Arr) -> str:
+        """ remove all character of a list
+        """
+        for to_remove in a_to_remove:
+            string = string.replace(to_remove, '')
+        return string
+
+    @staticmethod
+    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
+
+    @staticmethod
+    def sh_float(string: str) -> TN_Float:
+        """ Returns Float if string is of Type Float
+            otherwise None
+        """
+        try:
+            return float(string)
+        except Exception:
+            print(traceback.format_exc())
+            return None
+
+    @staticmethod
+    def sh_int(string: str) -> TN_Int:
+        """ Returns Int if string is of Type Int
+            otherwise None
+        """
+        try:
+            return int(string)
+        except ValueError:
+            return None
+
+    @staticmethod
+    def sh_dic(string: str, sw_decimal=False) -> TN_Dic:
+        """ Returns Dic if string is of Type Json-String
+            otherwise None
+        """
+        try:
+            if sw_decimal:
+                dic = simplejson.loads(string, use_decimal=True)
+            else:
+                dic = orjson.loads(string)
+            return dic
+        except Exception:
+            # print(f"string = {string}")
+            print(traceback.format_exc())
+            return None
+
+    @staticmethod
+    def sh_arr(string: str) -> TN_Arr:
+        """ Show valid Array string as Array
+        """
+        try:
+            return orjson.loads(string)
+        except Exception:
+            print(traceback.format_exc())
+            return None
+
+    @staticmethod
+    def sh_aoa(string: str) -> TN_AoA:
+        """ Show valid Array string as Array
+        """
+        try:
+            return orjson.loads(string)
+        except Exception:
+            print(traceback.format_exc())
+            return None
+
+    @staticmethod
+    def sh_first_item(string: str) -> Any:
+        """ Show first substring of string
+        """
+        return string.split()[0]
+
+    @classmethod
+    def sh_a_int(cls, string: str, sep: str) -> T_Arr:
+        """ Show first substring of string
+        """
+        # arr = string.split(sep)
+        arr = re.split(sep, string)
+        arr_new = []
+        for item in arr:
+            _item = item.strip()
+            if not isinstance(_item, str):
+                continue
+            if not _item.isdigit():
+                continue
+            arr_new.append(cls.sh_int(_item))
+        return arr_new
+
+    @classmethod
+    def sh_a_str(
+            cls, string: str, sep: str, a_exclude: TN_Arr = None) -> Any:
+        """ Show first substring of string
+        """
+        # arr = string.split(sep)
+        arr = re.split(sep, string)
+
+        if a_exclude is None:
+            _arr = arr
+        else:
+            _arr = []
+            for item in arr:
+                _item = item.strip()
+                if _item not in a_exclude:
+                    _arr.append(_item)
+
+        arr_new = []
+        for item in _arr:
+            if isinstance(item, str):
+                arr_new.append(item.strip())
+            elif isinstance(item, int):
+                arr_new.append(str(item))
+            else:
+                arr_new.append(item)
+
+        return arr_new
+
+    @classmethod
+    def sh_a_obj(
+            cls, string: str, sep: str, a_exclude: TN_Arr = None) -> Any:
+        """ Show first substring of string
+        """
+        # arr = string.split(sep)
+        arr = re.split(sep, string)
+
+        if a_exclude is None:
+            _arr = arr
+        else:
+            _arr = []
+            for item in arr:
+                _item = item.strip()
+                if _item not in a_exclude:
+                    _arr.append(_item)
+
+        arr_new: T_Arr = []
+        for item in _arr:
+            if isinstance(item, str):
+                _item = item.strip()
+                if _item.isdigit():
+                    _item = cls.sh_int(_item)
+                    arr_new.append(_item)
+                else:
+                    arr_new.append(_item)
+            else:
+                arr_new.append(item)
+
+        return arr_new

build/lib/ka_uts_com/timer.py

@@ -0,0 +1,72 @@
+# 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
+
+
+class Timestamp:
+
+    @staticmethod
+    def sh_elapse_time_sec(
+            end: Any, start: TN_Any) -> TN_Any:
+        if start is None:
+            return None
+        return end.timestamp()-start.timestamp()
+
+
+class Timer:
+    """ Timer Management
+    """
+    @staticmethod
+    def sh_task_id(
+            class_id: Any, parms: TN_Any, separator: T_Str) -> T_Str:
+        """ start Timer
+        """
+        package = Com.pacmod_curr['package']
+        module = Com.pacmod_curr['module']
+        if isinstance(class_id, str):
+            class_name = class_id
+        else:
+            class_name = class_id.__qualname__
+        if not parms:
+            parms = ""
+        else:
+            parms = f" {parms}"
+        arr: T_Arr = []
+        for item in [package, module, class_name, parms]:
+            if not item:
+                continue
+            arr.append(item)
+        return separator.join(arr)
+
+    @classmethod
+    def start(
+            cls, class_id: T_Any,
+            parms: TN_Any = None, separator: T_Str = ".") -> None:
+        """ start Timer
+        """
+        task_id = cls.sh_task_id(class_id, parms, separator)
+        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
+        """
+        task_id = cls.sh_task_id(class_id, parms, separator)
+        start = Com.d_timer.get(task_id)
+        end = datetime.now()
+        elapse_time_sec = Timestamp.sh_elapse_time_sec(end, start)
+        msg = f"{task_id} elapse time [sec] = {elapse_time_sec}"
+        Log.info(msg, stacklevel=2)

ka_uts_com/__version__.py

@@ -0,0 +1,10 @@
+__title__ = 'ka_uts_com'
+__description__ = 'Communication Utilities.'
+__url__ = 'https://ka-ut-com.readthedocs.io/en/latest'
+__version__ = '1.0.0.240823'
+__build__ = 0x022200
+__author__ = 'Bernd Stroehle'
+__author_email__ = 'bernd.stroehle@gmail.com'
+__license__ = 'Apache-2.0'
+__copyright__ = 'Copyright 2024 Bernd Stroehle'
+__cake__ = u'\u2728 \U0001f370 \u2728'

ka_uts_com/aeq.py

@@ -0,0 +1,87 @@
+# coding=utf-8
+
+# import orjson
+# import traceback
+
+from ka_uts_com.date import Date
+from ka_uts_com.str import Str
+
+from typing import Any, Dict, List
+
+TN_Date = None | Any
+
+T_Arr = List[Any]
+T_Dic = Dict[Any, Any]
+
+TN_Arr = None | T_Arr
+TN_Dic = None | T_Dic
+TN_Str = None | str
+
+
+class Aeq:
+    """ Dictionary of Equates
+    """
+    @classmethod
+    def sh_value(cls, key: str, value: Any, d_valid_parms: TN_Dic) -> 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: TN_Str = 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
+
+    @classmethod
+    def sh_d_eq(cls, a_s_eq: T_Arr, d_valid_parms: TN_Dic) -> T_Dic:
+
+        d_eq = {}
+        _d_valid_parms = d_valid_parms
+        for s_eq in a_s_eq[1:]:
+            a_eq = s_eq.split('=')
+            if len(a_eq) == 1:
+                key = 'cmd'
+                value = a_eq[0]
+                if _d_valid_parms is not None:
+                    if value in _d_valid_parms:
+                        _d_valid_parms = _d_valid_parms[value]
+                    else:
+                        _valid_commands = list(_d_valid_parms.keys())
+                        msg = (f"Wrong command: {value}; "
+                               f"valid commands are: {_valid_commands}")
+            else:
+                key = a_eq[0]
+                value = a_eq[1]
+
+                if _d_valid_parms is not None:
+                    if key not in _d_valid_parms:
+                        msg = (f"Wrong parameter: {key}; "
+                               f"valid parameters are: {_d_valid_parms}")
+                        raise Exception(msg)
+                    value = cls.sh_value(key, value, _d_valid_parms)
+            d_eq[key] = value
+        return d_eq

ka_uts_com/argv.py

@@ -0,0 +1,49 @@
+# coding=utf-8
+
+from ka_uts_com.pacmod import Pacmod
+from ka_uts_com.aeq import Aeq
+
+from typing import Any, Callable, Dict, List
+
+T_Arr = List[Any]
+T_Dic = Dict[Any, Any]
+
+TN_Arr = None | T_Arr
+TN_Dic = None | T_Dic
+
+
+class Argv:
+    """ Manage Commandline Arguments
+    """
+    @staticmethod
+    def set_by_pacmod(d_eq: T_Dic, root_cls) -> None:
+        """ set current pacmod dictionary
+        """
+        tenant = d_eq.get('tenant')
+        d_eq['pacmod_curr'] = Pacmod.sh_d_pacmod(root_cls, tenant)
+
+    @staticmethod
+    def set_by_prof(d_eq: T_Dic, sh_prof: Callable | 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 sh(cls, a_s_eq: T_Arr, **kwargs) -> T_Dic:
+        """ show equates dictionary
+        """
+        # print(f"DoEq sh kwargs = {kwargs}")
+        root_cls = kwargs.get('root_cls')
+        d_valid_parms: TN_Dic = kwargs.get('d_parms')
+        # print(f"DoEq sh d_valid_parms = {d_valid_parms}")
+
+        d_eq = Aeq.sh_d_eq(a_s_eq, d_valid_parms)
+
+        cls.set_by_pacmod(d_eq, root_cls)
+        _sh_prof = kwargs.get('sh_prof')
+        cls.set_by_prof(d_eq, _sh_prof)
+
+        return d_eq