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

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__ = '1.0.1.250131'
 __build__ = 0x022200
 __author__ = 'Bernd Stroehle'
 __author_email__ = 'bernd.stroehle@gmail.com'

ka_uts_com/base/app_.py

@@ -0,0 +1,51 @@
+# 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
+    httpmod: TyAny = None
+    sw_replace_keys: TnBool = None
+    keys: TnArr = None
+    reqs: TyDic = {}
+    app: TyDic = {}
+
+    @classmethod
+    def init(cls, log: TyLogger, **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)
+        try:
+            if cls.sw_replace_keys:
+                d_pacmod: TyDic = kwargs.get('d_pacmod', {})
+                cls.keys = Yaml_.read(PacMod.sh_path_keys_yaml(d_pacmod), log)
+        except Exception as exc:
+            log.error(exc, exc_info=True)
+            raise
+
+    @classmethod
+    def sh(cls, log: TyLogger, **kwargs) -> Any:
+        if cls.sw_init:
+            return cls
+        cls.init(log, **kwargs)
+        return cls

ka_uts_com/base/cfg_.py

@@ -0,0 +1,27 @@
+# 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
+    """
+    cfg: Any = None
+
+    @classmethod
+    def sh(cls, log: TyLogger, d_pacmod: TyDic) -> Any:
+        """ show configuration
+        """
+        cls.cfg = Yaml_.read(PacMod.sh_path_cfg_yaml(d_pacmod), log)
+        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,115 @@
+# 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.utils.pacmod import PacMod
+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
+TyLogger = Logger
+
+TnAny = None | Any
+TnArr = None | TyArr
+TnBool = None | bool
+TnDic = None | TyDic
+TnTimeStamp = None | TyTimeStamp
+TnDateTime = None | TyDateTime
+
+
+class LogStandard:
+    """Standard Logging
+    """
+
+
+class Log_:
+
+    sw_init: bool = False
+    log: TyLogger = logging.getLogger('dummy_logger')
+    username: str = psutil.Process().username()
+
+    @classmethod
+    def sh_run_dir(cls, com, **kwargs) -> TyDir:
+        """Show run_dir
+        """
+        tenant: str = com.d_pacmod['tenant']
+        package: str = com.d_pacmod['package']
+        module: str = com.d_pacmod['module']
+        log_type: str = kwargs.get('log_type', 'std')
+        if log_type == "std":
+            return f"/data/{tenant}/RUN/{package}/{module}"
+        return f"/data/{tenant}/RUN/{package}/{module}/{cls.username}"
+
+    @classmethod
+    def sh_cfg(cls, com, **kwargs) -> TyDic:
+        """Read log file path with jinja2
+        """
+        run_dir = kwargs.get('run_dir', cls.sh_run_dir(com, **kwargs))
+        run_dir_debug: str = kwargs.get('run_dir_debug', f"{run_dir}/debs")
+        run_dir_info: str = kwargs.get('run_dir_info', f"{run_dir}/logs")
+        run_dir_error: str = kwargs.get('run_dir_error', f"{run_dir}/errs")
+
+        if kwargs.get('sw_mklogdirs', True):
+            os.makedirs(run_dir_debug, exist_ok=True)
+            os.makedirs(run_dir_info, exist_ok=True)
+            os.makedirs(run_dir_error, exist_ok=True)
+
+        log_type = kwargs.get('log_type', 'std')
+        logcfg_file = f'log.{log_type}.yml'
+        logcfg_path: str = PacMod.sh_path_cfg_log(filename=logcfg_file)
+        cfg: TyDic = Jinja2_.read(
+                logcfg_path,
+                com.Log,
+                debug_dir=run_dir_debug,
+                info_dir=run_dir_info,
+                error_dir=run_dir_error,
+                module=com.d_pacmod['module'],
+                pid=com.pid,
+                ts=com.ts)
+        # ts=com.ts_start)
+        sw_debug: TyBool = kwargs.get('sw_debug', False)
+        if sw_debug:
+            level = logging.DEBUG
+        else:
+            level = logging.INFO
+        if log_type == 'std':
+            logger_name = 'main'
+        else:
+            logger_name = 'person'
+        cfg['handlers'][f"{logger_name}_debug_console"]['level'] = level
+        cfg['handlers'][f"{logger_name}_debug_file"]['level'] = level
+
+        return cfg
+
+    @classmethod
+    def init(cls, com, **kwargs) -> None:
+        """Set static variable log level in log configuration handlers
+        """
+        log_type = kwargs.get('log_type', 'std')
+        cls.sw_init = True
+        cfg = cls.sh_cfg(com, **kwargs)
+        logging.config.dictConfig(cfg)
+        if log_type == "std":
+            cls.log = logging.getLogger('main')
+        else:
+            cls.log = logging.getLogger(log_type)
+
+    @classmethod
+    def sh(cls, com, **kwargs) -> TyLogger:
+        if cls.sw_init:
+            return cls.log
+        cls.init(com, **kwargs)
+        return cls.log