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

build/lib/ka_uts_com/data/{log.standard.yml → log.usr.yml}

@@ -1,5 +1,4 @@
 version: 1
-
 disable_existing_loggers: False
 
 # root:
@@ -10,25 +9,27 @@ disable_existing_loggers: False
 
 loggers:
 
-    # main logger
-    main:
+    # user logger
+    usr:
         # level: NOTSET
         level: DEBUG
         handlers:
-            - main_debug_console
-            - main_debug_file
-            - main_info_file
-            - main_error_file
+            - usr_debug_console
+            - usr_error_file
+            - usr_warning_file
+            - usr_debug_file
+            - usr_info_file
+            - usr_log_file
 
 handlers:
 
-    main_debug_console:
+    usr_debug_console:
         class: 'logging.StreamHandler'
         level: DEBUG
-        formatter: main_debug
+        formatter: usr_debug
         stream: 'ext://sys.stderr'
 
-#   main_info_rotating_file_handler:
+#   person_info_rotating_file_handler:
 #       class: 'logging.handlers.RotatingFileHandler'
 #       level: INFO
 #       formatter: info
@@ -38,31 +39,45 @@ handlers:
 #       backupCount: 10
 #       encoding: utf8
 
-    main_debug_file:
+    usr_error_file:
+        class: 'logging.FileHandler'
+        level: ERROR
+        formatter: usr_error
+        filename: '{{dir_run_errs}}/errs_{{pid}}_{{ts}}.log'
+        mode: 'a'
+
+    usr_warning_file:
+        class: 'logging.FileHandler'
+        level: ERROR
+        formatter: usr_warning
+        filename: '{{dir_run_wrns}}/wrns_{{pid}}_{{ts}}.log'
+        mode: 'a'
+
+    usr_debug_file:
         class: 'logging.FileHandler'
         level: DEBUG
-        formatter: main_error
-        filename: '/data/{{tenant}}/RUN/{{package}}/{{module}}/debs/debs_{{pid}}_{{ts}}.log'
+        formatter: usr_debug
+        filename: '{{dir_run_debs}}/debs_{{pid}}_{{ts}}.log'
         mode: 'a'
 
-    main_info_file:
+    usr_info_file:
         class: 'logging.FileHandler'
         level: INFO
-        formatter: main_info
-        filename: '/data/{{tenant}}/RUN/{{package}}/{{module}}/logs/logs_{{pid}}_{{ts}}.log'
+        formatter: usr_info
+        filename: '{{dir_run_infs}}/infs_{{pid}}_{{ts}}.log'
         mode: 'a'
 
-    main_error_file:
+    usr_log_file:
         class: 'logging.FileHandler'
-        level: ERROR
-        formatter: main_error
-        filename: '/data/{{tenant}}/RUN/{{package}}/{{module}}/errs/errs_{{pid}}_{{ts}}.log'
+        level: INFO
+        formatter: usr_log
+        filename: '{{dir_run_logs}}/logs_{{pid}}_{{ts}}.log'
         mode: 'a'
 
-    main_critical_mail:
+    usr_critical_mail:
         class: 'logging.handlers.SMTPHandler'
         level: CRITICAL
-        formatter: main_critical
+        formatter: usr_critical
         mailhost : localhost
         fromaddr: 'monitoring@domain.com'
         toaddrs:
@@ -73,14 +88,19 @@ handlers:
 
 formatters:
 
-    main_info:
-        format: '%(asctime)s-%(levelname)s-%(name)s::%(module)s|%(lineno)s:: %(message)s'
-    main_debug:
+    usr_errs:
         format: '%(asctime)-15s %(levelname)s-%(name)s-%(process)d::%(module)s.%(funcName)s|%(lineno)s:: %(message)s'
         datefmt: '%Y-%m-%d %H:%M:%S'
-    main_error:
+    usr_wrns:
         format: '%(asctime)-15s %(levelname)s-%(name)s-%(process)d::%(module)s.%(funcName)s|%(lineno)s:: %(message)s'
         datefmt: '%Y-%m-%d %H:%M:%S'
-    main_critical:
+    usr_debs:
+        format: '%(asctime)-15s %(levelname)s-%(name)s-%(process)d::%(module)s.%(funcName)s|%(lineno)s:: %(message)s'
+        datefmt: '%Y-%m-%d %H:%M:%S'
+    usr_infs:
+        format: '%(asctime)s-%(levelname)s-%(name)s::%(module)s|%(lineno)s:: %(message)s'
+    usr_logs:
+        format: '%(asctime)s-%(levelname)s-%(name)s::%(module)s|%(lineno)s:: %(message)s'
+    usr_critical:
         format: '%(asctime)-15s %(levelname)s-%(name)s-%(process)d::%(module)s.%(funcName)s|%(lineno)s:: %(message)s'
         datefmt: '%Y-%m-%d %H:%M:%S'

build/lib/ka_uts_com/decorators/dec.py

@@ -0,0 +1,13 @@
+"""
+Decorators
+"""
+# coding=utf-8
+from ka_uts_com.timer import Timer
+
+
+def timer(fnc):
+    def wrapper(*args, **kwargs):
+        Timer.start(fnc)
+        fnc(*args, **kwargs)
+        Timer.end(fnc)
+    return wrapper

build/lib/ka_uts_com/fnc.py

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

build/lib/ka_uts_com/ioc/jinja2_.py

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

build/lib/ka_uts_com/ioc/yaml_.py

@@ -0,0 +1,30 @@
+# 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,6 +1,6 @@
 from ka_uts_com.com import Com
-
-from typing import Any, Callable
+from typing import Any
+TyDic = dict[Any, Any]
 
 
 class Log:
@@ -8,56 +8,79 @@ class Log:
     """
     class Eq:
 
-        @staticmethod
-        def sh(key: Any, value: Any) -> str:
-            """ Show Key, Value as Equate
-            """
-            return f"{key} = {value}"
+        @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(cls.sh(key, value), stacklevel=3)
+            Log.debug(f"{key} = {value}", stacklevel=3)
+
+    class Dic:
 
         @classmethod
-        def error(cls, key: Any, value: Any) -> None:
-            Log.error(cls.sh(key, value), stacklevel=3)
+        def debug(cls, dic: TyDic) -> None:
+            for key, value in dic.items():
+                Log.debug(f"{key} = {value}", stacklevel=3)
 
         @classmethod
-        def info(cls, key: Any, value: Any) -> None:
-            Log.info(cls.sh(key, value), stacklevel=3)
+        def error(cls, dic: TyDic) -> None:
+            for key, value in dic.items():
+                Log.error(f"{key} = {value}", stacklevel=3)
 
         @classmethod
-        def warning(cls, key: Any, value: Any) -> None:
-            Log.warning(cls.sh(key, value), stacklevel=3)
+        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 debug(*args, **kwargs) -> None:
+    def error(*args, **kwargs) -> None:
         if kwargs is None:
             kwargs = {}
         kwargs['stacklevel'] = kwargs.get('stacklevel', 2)
-        fnc_debug: Callable = Com.Log.debug
-        fnc_debug(*args, **kwargs)
+        Com.Log.error(*args, **kwargs)
 
     @staticmethod
-    def error(*args, **kwargs) -> None:
+    def warning(*args, **kwargs) -> None:
         if kwargs is None:
             kwargs = {}
         kwargs['stacklevel'] = kwargs.get('stacklevel', 2)
-        fnc_error: Callable = Com.Log.error
-        fnc_error(*args, **kwargs)
+        Com.Log.warning(*args, **kwargs)
 
     @staticmethod
     def info(*args, **kwargs) -> None:
         if kwargs is None:
             kwargs = {}
         kwargs['stacklevel'] = kwargs.get('stacklevel', 2)
-        fnc_info: Callable = Com.Log.info
-        fnc_info(*args, **kwargs)
+        Com.Log.info(*args, **kwargs)
 
     @staticmethod
-    def warning(*args, **kwargs) -> None:
+    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)
-        fnc_warning: Callable = Com.Log.warning
-        fnc_warning(*args, **kwargs)
+        Com.Log.debug(*args, **kwargs)

build/lib/ka_uts_com/timer.py

@@ -1,25 +1,22 @@
 # 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, List
-
-T_Any = Any
-T_Arr = List[Any]
-T_Str = str
-
-TN_Any = None | T_Any
-TN_Str = None | T_Str
+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: TN_Any) -> TN_Any:
+    def sh_elapse_time_sec(end: Any, start: TnAny) -> TnAny:
         if start is None:
             return None
         return end.timestamp()-start.timestamp()
@@ -29,12 +26,15 @@ class Timer:
     """ Timer Management
     """
     @staticmethod
-    def sh_task_id(
-            class_id: Any, parms: TN_Any, separator: T_Str) -> T_Str:
-        """ start Timer
+    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 = Com.pacmod_curr['package']
-        module = Com.pacmod_curr['module']
+        package = d_pacmod.get('package')
+        module = d_pacmod.get('module')
         if isinstance(class_id, str):
             class_name = class_id
         else:
@@ -43,28 +43,25 @@ class Timer:
             parms = ""
         else:
             parms = f" {parms}"
-        arr: T_Arr = []
+        arr: TyArr = []
         for item in [package, module, class_name, parms]:
             if not item:
                 continue
             arr.append(item)
-        return separator.join(arr)
+        return sep.join(arr)
 
     @classmethod
-    def start(
-            cls, class_id: T_Any,
-            parms: TN_Any = None, separator: T_Str = ".") -> None:
-        """ start Timer
+    def start(cls, class_id: TyAny, parms: TnAny = None, sep: TyStr = ".") -> None:
+        """ Start Timer
         """
-        task_id = cls.sh_task_id(class_id, parms, separator)
+        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: T_Any,
-            parms: TN_Any = None, separator: T_Str = ".") -> None:
-        """ end Timer
+    def end(cls, class_id: TyAny, parms: TnAny = None, sep: TyStr = ".") -> None:
+        """ End Timer
         """
-        task_id = cls.sh_task_id(class_id, parms, separator)
+        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)

build/lib/ka_uts_com/utils/aoeqstmt.py

@@ -0,0 +1,37 @@
+# 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/{date.py → utils/date.py}

@@ -1,15 +1,15 @@
 from datetime import datetime
 from datetime import date
 
-T_Date = date
-TN_Date = None | T_Date
-TN_Str = None | str
+TyDate = date
+TnDate = None | TyDate
+TnStr = None | str
 
 
 class Date:
 
     @staticmethod
-    def sh(datestring: TN_Str, fmt: str) -> TN_Date:
+    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

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