ka-uts-com 2.1.0.250408__py3-none-any.whl → 2.2.0.250427__py3-none-any.whl

ka_uts_com/fnc.py

@@ -1,42 +0,0 @@
-# coding=utf-8
-from collections.abc import Callable
-from typing import Any
-
-TyArr = list[Any]
-TyCallable = Callable[..., Any]
-TyDic = dict[Any, Any]
-TyArrDic = TyArr | TyDic
-TyDoC = dict[str, TyCallable]
-TyMsg = str
-
-TnStr = None | str
-TnDoC = None | TyDoC
-TnCallable = None | TyCallable
-
-
-class Fnc:
-    """
-    Functions
-    """
-    @staticmethod
-    def identity(obj: Any) -> Any:
-        return obj
-
-    @staticmethod
-    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 not defined"
-            raise Exception(msg)
-        fnc: TnCallable = doc.get(key)
-        if not fnc:
-            msg = f"key: {key} is not defined in function table: {doc}"
-            raise Exception(msg)
-        return fnc
-
-    @classmethod
-    def ex(cls, doc: TnDoC, key: TnStr, args_kwargs: TyArrDic) -> Any:
-        fnc: TyCallable = cls.sh(doc, key)
-        return fnc(args_kwargs)

ka_uts_com/ioc/jinja2_.py

@@ -1,42 +0,0 @@
-# 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='{path'}")
-            raise

ka_uts_com/ioc/yaml_.py

@@ -1,31 +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='{path}'")
-            raise
-        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,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)

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

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()

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

ka_uts_com/utils/pac.py

@@ -1,35 +0,0 @@
-# coding=utf-8
-from typing import Any
-
-import os
-import importlib.resources as resources
-
-TyArr = list[Any]
-TyDic = dict[Any, Any]
-TyPackage = str
-TyPackages = list[str]
-TyPath = str
-
-
-class Pac:
-
-    @staticmethod
-    def sh_path_by_package(package: TyPackage, path: TyPath) -> Any:
-        """ show directory
-        """
-        _path = str(resources.files(package).joinpath(path))
-        # if _path.is_file():
-        if _path is not None and _path != '':
-            if os.path.exists(_path):
-                return _path
-        return ''
-
-    @classmethod
-    def sh_path_by_packages(cls, packages: TyPackages, path: TyPath) -> Any:
-        """ show directory
-        """
-        for _package in packages:
-            _path = cls.sh_path_by_package(_package, path)
-            if _path:
-                return _path
-        return ''

ka_uts_com/utils/pacmod.py

@@ -1,109 +0,0 @@
-# coding=utf-8
-from typing import Any
-
-from os import path as os_path
-
-from ka_uts_com.utils.pac import Pac
-
-TyArr = list[Any]
-TyDic = dict[Any, Any]
-TyPath = str
-
-
-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) -> Any:
-        """ show directory
-        """
-        package = d_pacmod['package']
-        module = d_pacmod['module']
-        path = f"{module}/data/{module}.yml"
-        return Pac.sh_path_by_package(package, path)
-
-    @staticmethod
-    def sh_path_keys(d_pacmod: TyDic) -> Any:
-        """ show directory
-        """
-        package = d_pacmod['package']
-        path = 'data/keys.yml'
-        return Pac.sh_path_by_package(package, 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(d_pacmod: TyDic) -> Any:
-    #     """ show directory
-    #     """
-    #     package = com.d_app_pacmod['package']
-    #     path = 'dat/cfg.yml'
-    #     return Pac.sh_path(package, 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) -> TyPath:
-        """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) -> TyPath:
-        """ show type specific path
-        """
-        _dir: str = cls.sh_dir_type(com, type_)
-        return os_path.join(_dir, f"{filename}*.{suffix}")