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

build/lib/ka_uts_com/ioc/yaml_.py

@@ -1,30 +0,0 @@
-# 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,86 +0,0 @@
-from ka_uts_com.com import Com
-from typing import Any
-TyDic = dict[Any, Any]
-
-
-class Log:
-    """Logging Class
-    """
-    class Eq:
-
-        @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(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 error(*args, **kwargs) -> None:
-        if kwargs is None:
-            kwargs = {}
-        kwargs['stacklevel'] = kwargs.get('stacklevel', 2)
-        Com.Log.error(*args, **kwargs)
-
-    @staticmethod
-    def warning(*args, **kwargs) -> None:
-        if kwargs is None:
-            kwargs = {}
-        kwargs['stacklevel'] = kwargs.get('stacklevel', 2)
-        Com.Log.warning(*args, **kwargs)
-
-    @staticmethod
-    def info(*args, **kwargs) -> None:
-        if kwargs is None:
-            kwargs = {}
-        kwargs['stacklevel'] = kwargs.get('stacklevel', 2)
-        Com.Log.info(*args, **kwargs)
-
-    @staticmethod
-    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)
-        Com.Log.debug(*args, **kwargs)

build/lib/ka_uts_com/timer.py

@@ -1,69 +0,0 @@
-# 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
-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: TnAny) -> TnAny:
-        if start is None:
-            return None
-        return end.timestamp()-start.timestamp()
-
-
-class Timer:
-    """ Timer Management
-    """
-    @staticmethod
-    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')
-        if isinstance(class_id, str):
-            class_name = class_id
-        else:
-            class_name = class_id.__qualname__
-        if not parms:
-            parms = ""
-        else:
-            parms = f" {parms}"
-        arr: TyArr = []
-        for item in [package, module, class_name, parms]:
-            if not item:
-                continue
-            arr.append(item)
-        return sep.join(arr)
-
-    @classmethod
-    def start(cls, class_id: TyAny, parms: TnAny = None, sep: TyStr = ".") -> None:
-        """ Start Timer
-        """
-        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
-        """
-        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)
-        msg = f"{task_id} elapse time [sec] = {elapse_time_sec}"
-        Log.info(msg, stacklevel=2)

build/lib/ka_uts_com/utils/aoeqstmt.py

@@ -1,37 +0,0 @@
-# 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

build/lib/ka_uts_com/utils/date.py

@@ -1,15 +0,0 @@
-from datetime import datetime
-from datetime import date
-
-TyDate = date
-TnDate = None | TyDate
-TnStr = None | str
-
-
-class Date:
-
-    @staticmethod
-    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

@@ -1,99 +0,0 @@
-# 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/utils/pacmod.py

@@ -1,123 +0,0 @@
-# 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