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

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}")
-            raise

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

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

ka_uts_com/utils/str.py

@@ -1,265 +0,0 @@
-# coding=utf-8
-from typing import Any
-import traceback
-
-from datetime import datetime
-import re
-import orjson
-import simplejson
-
-TyArr = list[Any]
-TyDic = dict[Any, Any]
-TyAoA = list[TyArr]
-
-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: TnStr = None) -> TnDatetime:
-        """ show string as date using the format string
-        """
-        try:
-            if fmt is None:
-                fmt = "%m/%d/%Y"
-            _date: TnDatetime = 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
-        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: TnStr) -> bool:
-        """ check if string is undefined (None or empty)
-        """
-        if string is None or string == '':
-            return True
-        return False
-
-    @staticmethod
-    def nvl(string: TnStr) -> TnStr:
-        """ 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: TyArr) -> 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
-        """
-        match string.lower():
-            case 'true':
-                return True
-            case 'false':
-                return False
-            case _:
-                raise ValueError
-
-    @staticmethod
-    def sh_float(string: str) -> TnFloat:
-        """ 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) -> TnInt:
-        """ 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) -> Any:
-        """ Returns Dic if string is of Type Json-String
-            otherwise None
-        """
-        try:
-            if sw_decimal:
-                return simplejson.loads(string, use_decimal=True)
-            else:
-                return orjson.loads(string)
-        except Exception:
-            print(traceback.format_exc())
-            return None
-
-    @staticmethod
-    def sh_arr(string: str) -> Any:
-        """ 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) -> Any:
-        """ 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) -> TyArr:
-        """ 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: TnArr = 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: TnArr = 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: TyArr = []
-        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