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

build/lib/ka_uts_com/utils/pacmod.py

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

build/lib/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()

ka_uts_com/__version__.py

@@ -1,7 +1,7 @@
 __title__ = 'ka_uts_com'
 __description__ = 'Communication Utilities.'
 __url__ = 'https://ka-ut-com.readthedocs.io/en/latest'
-__version__ = '1.0.0.240823'
+__version__ = '2.0.0.250407'
 __build__ = 0x022200
 __author__ = 'Bernd Stroehle'
 __author_email__ = 'bernd.stroehle@gmail.com'

ka_uts_com/base/app_.py

@@ -0,0 +1,50 @@
+# coding=utf-8
+from typing import Any
+
+from logging import Logger
+
+from ka_uts_com.utils.pacmod import PacMod
+from ka_uts_com.ioc.yaml_ import Yaml_
+
+TyAny = Any
+TyArr = list[Any]
+TyBool = bool
+TyDic = dict[Any, Any]
+TyLogger = Logger
+
+TnAny = None | Any
+TnArr = None | TyArr
+TnBool = None | bool
+TnDic = None | TyDic
+
+
+class App_:
+    """Aplication Class
+    """
+    sw_init: TyBool = False
+    sw_replace_keys: TnBool = None
+    keys: TnArr = None
+    httpmod: TyAny = None
+    reqs: TyDic = {}
+    app: TyDic = {}
+
+    @classmethod
+    def init(cls, com, **kwargs) -> None:
+        if cls.sw_init:
+            return
+        cls.sw_init = True
+        cls.httpmod = kwargs.get('httpmod')
+        cls.sw_replace_keys = kwargs.get('sw_replace_keys', False)
+        if cls.sw_replace_keys:
+            try:
+                cls.keys = Yaml_.read(PacMod.sh_path_keys(com), com.Log)
+            except Exception as exc:
+                com.Log.error(exc, exc_info=True)
+                raise
+
+    @classmethod
+    def sh(cls, com, **kwargs) -> Any:
+        if cls.sw_init:
+            return cls
+        cls.init(com, **kwargs)
+        return cls

ka_uts_com/base/cfg_.py

@@ -0,0 +1,35 @@
+# coding=utf-8
+from typing import Any
+
+from logging import Logger
+
+from ka_uts_com.utils.pacmod import PacMod
+from ka_uts_com.ioc.yaml_ import Yaml_
+
+TyAny = Any
+TyTimeStamp = int
+TyArr = list[Any]
+TyBool = bool
+TyDic = dict[Any, Any]
+TyLogger = Logger
+
+
+class Cfg_:
+    """Configuration Class
+    """
+    sw_init: TyBool = False
+    cfg: Any = None
+
+    @classmethod
+    def init(cls, com, **kwargs) -> None:
+        if cls.sw_init:
+            return
+        cls.sw_init = True
+        cls.cfg = Yaml_.read(PacMod.sh_path_cfg(com), com.Log)
+
+    @classmethod
+    def sh(cls, com, **kwargs) -> Any:
+        if cls.sw_init:
+            return cls
+        cls.init(com, **kwargs)
+        return cls.cfg

ka_uts_com/base/exit_.py

@@ -0,0 +1,37 @@
+# coding=utf-8
+from typing import Any
+
+TyAny = Any
+TyArr = list[Any]
+TyBool = bool
+TyDic = dict[Any, Any]
+
+TnAny = None | Any
+TnArr = None | TyArr
+TnBool = None | bool
+TnDic = None | TyDic
+
+
+class Exit_:
+    """Exit Class
+    """
+    sw_init: TyBool = False
+    sw_critical: bool = False
+    sw_stop: bool = False
+    sw_interactive: bool = False
+
+    @classmethod
+    def init(cls, **kwargs) -> None:
+        if cls.sw_init:
+            return
+        cls.sw_init = True
+        cls.sw_critical = kwargs.get('sw_critical', False)
+        cls.sw_stop = kwargs.get('sw_stop', False)
+        cls.sw_interactive = kwargs.get('sw_interactive', False)
+
+    @classmethod
+    def sh(cls, **kwargs) -> Any:
+        if cls.sw_init:
+            return cls
+        cls.init(**kwargs)
+        return cls

ka_uts_com/base/log_.py

@@ -0,0 +1,131 @@
+# coding=utf-8
+from collections.abc import Callable
+from typing import Any
+
+import os
+import logging
+import logging.config
+from logging import Logger
+from datetime import datetime
+import psutil
+
+# from ka_uts_com.com import Com
+from ka_uts_com.ioc.jinja2_ import Jinja2_
+
+TyAny = Any
+TyCallable = Callable[..., Any]
+TyDateTime = datetime
+TyTimeStamp = int
+TyArr = list[Any]
+TyBool = bool
+TyDic = dict[Any, Any]
+TyDir = str
+TyPath = str
+TyLogger = Logger
+
+TnAny = None | Any
+TnArr = None | TyArr
+TnBool = None | bool
+TnDic = None | TyDic
+TnTimeStamp = None | TyTimeStamp
+TnDateTime = None | TyDateTime
+
+
+class Log_:
+
+    sw_init: bool = False
+    log: TyLogger = logging.getLogger('dummy_logger')
+    username: str = psutil.Process().username()
+
+    @classmethod
+    def sh_dir_run(cls, com) -> TyDir:
+        """Show run_dir
+        """
+        # print(f"sh_dir_run com.dir_dat = {com.dir_dat}")
+        # print(f"sh_dir_run com.cmd = {com.cmd}")
+        # print(f"sh_dir_run com.tenant = {com.tenant}")
+        # print(f"sh_dir_run com = {com}")
+        dir_dat: str = com.dir_dat
+        tenant: str = com.tenant
+        cmd: str = com.cmd
+        package: str = com.d_app_pacmod['package']
+        # module: str = com.d_app_pacmod['module']
+        if tenant is not None:
+            path = f"{dir_dat}/{tenant}/RUN/{package}"
+        else:
+            path = f"{dir_dat}/RUN/{package}"
+        if com.log_type == "usr":
+            path = f"{path}/{cls.username}"
+        if cmd is not None:
+            path = f"{path}/{cmd}"
+        # print(f"sh_dir_run path = {path}")
+        # print("==================================")
+        return path
+
+    @classmethod
+    def sh_d_log_cfg(cls, com, **kwargs) -> TyDic:
+        """Read log file path with jinja2
+        """
+        dir_run = cls.sh_dir_run(com)
+        if kwargs.get('sw_single_dir_run', True):
+            # print("---sw_single_dir_run = True --------------")
+            dir_run_errs = f"{dir_run}/logs"
+            dir_run_wrns = f"{dir_run}/logs"
+            dir_run_infs = f"{dir_run}/logs"
+            dir_run_logs = f"{dir_run}/logs"
+            dir_run_debs = f"{dir_run}/logs"
+            if kwargs.get('sw_mk_dir_run', True):
+                os.makedirs(dir_run_logs, exist_ok=True)
+        else:
+            # print("---sw_single_dir_run = False -------------")
+            dir_run_errs = f"{dir_run}/errs"
+            dir_run_wrns = f"{dir_run}/wrns"
+            dir_run_infs = f"{dir_run}/infs"
+            dir_run_logs = f"{dir_run}/logs"
+            dir_run_debs = f"{dir_run}/debs"
+            if kwargs.get('sw_mk_dir_run', True):
+                os.makedirs(dir_run_errs, exist_ok=True)
+                os.makedirs(dir_run_wrns, exist_ok=True)
+                os.makedirs(dir_run_infs, exist_ok=True)
+                os.makedirs(dir_run_logs, exist_ok=True)
+                os.makedirs(dir_run_debs, exist_ok=True)
+        # path_log_cfg: TyPath = PacMod.sh_path_log_cfg(com)
+        module = com.d_app_pacmod['module']
+        # print(f"sh_d_log_cfg cls.path_log_cfg = {cls.path_log_cfg}")
+        d_log_cfg: TyDic = Jinja2_.read(
+                com.path_log_cfg, com.Log,
+                dir_run_errs=dir_run_errs,
+                dir_run_wrns=dir_run_wrns,
+                dir_run_infs=dir_run_infs,
+                dir_run_logs=dir_run_logs,
+                dir_run_debs=dir_run_debs,
+                module=module,
+                pid=com.pid,
+                ts=com.ts)
+        # print(f"sh_d_log_cfg d_log_cfg = {d_log_cfg}")
+        sw_debug: TyBool = kwargs.get('sw_debug', False)
+        if sw_debug:
+            level = logging.DEBUG
+        else:
+            level = logging.INFO
+        logger_name = com.log_type
+        d_log_cfg['handlers'][f"{logger_name}_debug_console"]['level'] = level
+        d_log_cfg['handlers'][f"{logger_name}_debug_file"]['level'] = level
+
+        return d_log_cfg
+
+    @classmethod
+    def init(cls, com, **kwargs) -> None:
+        """Set static variable log level in log configuration handlers
+        """
+        cls.sw_init = True
+        d_log_cfg = cls.sh_d_log_cfg(com, **kwargs)
+        logging.config.dictConfig(d_log_cfg)
+        cls.log = logging.getLogger(com.log_type)
+
+    @classmethod
+    def sh(cls, com, **kwargs) -> TyLogger:
+        if cls.sw_init:
+            return cls.log
+        cls.init(com, **kwargs)
+        return cls.log