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

ka_uts_com/com.py

@@ -1,205 +1,52 @@
 # coding=utf-8
+from typing import Any
 
+import os
+import time
 import calendar
 import logging
 import logging.config
 from logging import Logger
-
-import os
-import time
 from datetime import datetime
 
-from ka_uts_com.ioc import Yaml
-from ka_uts_com.ioc import Jinja2
-from ka_uts_com.pacmod import Pacmod
-
-from typing import Any, Callable, List, Dict
+from ka_uts_com.utils.aoeqstmt import AoEqStmt
+from ka_uts_com.base.app_ import App_
+from ka_uts_com.base.cfg_ import Cfg_
+from ka_uts_com.base.exit_ import Exit_
+from ka_uts_com.base.log_ import Log_
 
-T_Any = Any
-T_Arr = List[Any]
-T_Bool = bool
-T_Dic = Dict[Any, Any]
+TyAny = Any
+TyDateTime = datetime
+TyTimeStamp = int
+TyArr = list[Any]
+TyBool = bool
+TyDic = dict[Any, Any]
+TyLogger = Logger
 
-TN_Arr = None | T_Arr
-TN_Bool = None | bool
-TN_Dic = None | T_Dic
-TN_DT = None | datetime
-
-
-class LogStandard:
-    """Standard Logging
-    """
-    sw_init: bool = False
-    cfg: T_Dic = {}
-    log: Logger = logging.getLogger('dummy_logger')
-    logfile: str = 'log.standard.yml'
-
-    @staticmethod
-    def read(pacmod: T_Dic, filename: str) -> Any:
-        """Read log file path with jinja2
-        """
-        # path: str = Pacmod.Path.Log.sh_cfg(filename=filename)
-        path: str = Pacmod.sh_path_cfg_log(filename=filename)
-        tenant: str = pacmod['tenant']
-        package: str = pacmod['package']
-        module: str = pacmod['module']
-        pid = Com.pid
-        ts: TN_DT = Com.ts_start
-        cfg = Jinja2.read(
-            path, tenant=tenant,
-            package=package, module=module,
-            pid=pid, ts=ts)
-        return cfg
-
-    @classmethod
-    def set_level(cls, sw_debug: bool) -> None:
-        """Set static variable log level in log configuration handlers
-        """
-        if sw_debug:
-            level = logging.DEBUG
-        else:
-            level = logging.INFO
-        cls.cfg['handlers']['main_debug_console']['level'] = level
-        cls.cfg['handlers']['main_debug_file']['level'] = level
-
-    @classmethod
-    def init(
-            cls, **kwargs) -> None:
-        cls.sw_init = True
-        cls.cfg = cls.read(Com.pacmod_curr, cls.logfile)
-        sw_debug: Any = kwargs.get('sw_debug')
-        cls.set_level(sw_debug)
-        logging.config.dictConfig(cls.cfg)
-        cls.log = logging.getLogger('main')
-
-    @classmethod
-    def sh(cls, **kwargs) -> Any:
-        if cls.sw_init:
-            return cls.log
-        cls.init(**kwargs)
-        return cls.log
-
-
-class LogPersonal:
-    """Personal Logging
-    """
-    sw_init: bool = False
-    cfg: T_Dic = {}
-    logfile = 'log.person.yml'
-    log: Logger = logging.getLogger('dummy_logger')
-
-    @classmethod
-    def read(cls, pacmod: T_Dic, person: Any, filename: str) -> Any:
-        path: str = Pacmod.sh_path_cfg_log(filename=filename)
-        package: str = pacmod['package']
-        module: str = pacmod['module']
-        return Jinja2.read(
-            path, package=package, module=module, person=person,
-            pid=Com.pid, ts=Com.ts_start)
-
-    @classmethod
-    def set_level(cls, person: str, sw_debug: bool) -> None:
-        if sw_debug:
-            level = logging.DEBUG
-        else:
-            level = logging.INFO
-        cls.cfg['handlers'][f'{person}_debug_console']['level'] = level
-        cls.cfg['handlers'][f'{person}_debug_file']['level'] = level
-
-    @classmethod
-    def init(cls, pacmod: T_Dic, person: str, sw_debug: bool) -> None:
-        cls.cfg = cls.read(pacmod, person, cls.logfile)
-        cls.set_level(person, sw_debug)
-        logging.config.dictConfig(cls.cfg)
-        cls.log = logging.getLogger(person)
-
-    @classmethod
-    def sh(cls, **kwargs) -> Any:
-        if cls.sw_init:
-            return cls.log
-        cls.init(**kwargs)
-        return cls.log
-
-
-class Cfg:
-    """Configuration Class
-    """
-    @classmethod
-    def init(cls, pacmod: T_Dic) -> TN_Dic:
-        """ the package data directory has to contain a __init__.py
-            file otherwise the objects notation {package}.data to
-            locate the package data directory is invalid
-        """
-        _dic: TN_Dic = Yaml.read(Pacmod.sh_path_cfg_yaml(pacmod))
-        return _dic
-
-
-class Mgo:
-    """Mongo DB Class
-    """
-    client = None
-
-
-class App:
-    """Aplication Class
-    """
-    sw_init: T_Bool = False
-    httpmod: T_Any = None
-    sw_replace_keys: TN_Bool = None
-    keys: TN_Arr = None
-    reqs: T_Dic = {}
-    app: T_Dic = {}
-
-    @classmethod
-    def init(cls, **kwargs) -> Any:
-        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:
-                pacmod = kwargs.get('pacmod_curr')
-                # cls.keys = Yaml.read(Pacmod.Pmd.sh_path_keys(pacmod))
-                cls.keys = Yaml.read(Pacmod.sh_path_keys_yaml(pacmod))
-        except Exception as e:
-            if Com.Log is not None:
-                fnc_error: Callable = Com.Log.error
-                fnc_error(e, exc_info=True)
-            raise
-        return cls
-
-    @classmethod
-    def sh(cls, **kwargs) -> Any:
-        if cls.sw_init:
-            return cls
-        cls.init(**kwargs)
-        return cls
-
-
-class Exit:
-    """Exit Class
-    """
-    sw_critical: bool = False
-    sw_stop: bool = False
-    sw_interactive: bool = False
+TnAny = None | Any
+TnArr = None | TyArr
+TnDic = None | TyDic
+TnTimeStamp = None | TyTimeStamp
+TnDateTime = None | TyDateTime
 
 
 class Com:
     """Communication Class
     """
     sw_init: bool = False
-    cfg: TN_Dic = None
+    cfg: TnDic = None
     pid = None
-    pacmod_curr: T_Dic = {}
+    d_pacmod: TyDic = {}
 
-    ts_start: None | datetime = None
-    ts_end: None | datetime = None
-    ts_etime: None | datetime = None
-    d_timer: Dict = {}
+    ts: TnTimeStamp
+    ts_start: TnDateTime = None
+    ts_end: TnDateTime = None
+    ts_etime: TnDateTime = None
+    d_timer: TyDic = {}
 
-    # Log = None
     Log: Logger = logging.getLogger('dummy_logger')
-    App = None
-    Exit = Exit
+    App: Any = None
+    Exit: Any = None
 
     @classmethod
     def init(cls, **kwargs):
@@ -208,15 +55,18 @@ class Com:
         if cls.sw_init:
             return
         cls.sw_init = True
-
-        cls.pacmod_curr = kwargs.get('pacmod_curr')
-        cls.ts_start = calendar.timegm(time.gmtime())
+        cls.d_pacmod = kwargs.get('d_pacmod', {})
+        cls.ts = calendar.timegm(time.gmtime())
         cls.pid = os.getpid()
 
-        cls.cfg = Cfg.init(cls.pacmod_curr)
-        log_type = kwargs.get('log_type', 'standard')
-        if log_type == 'standard':
-            cls.Log = LogStandard.sh(**kwargs)
-        else:
-            cls.Log = LogPersonal.sh(**kwargs)
-        cls.App = App.sh(**kwargs)
+        cls.Log = Log_.sh(cls, **kwargs)
+        cls.cfg = Cfg_.sh(cls.Log, cls.d_pacmod)
+        cls.App = App_.sh(cls.Log, **kwargs)
+        cls.Exit = Exit_.sh(**kwargs)
+
+    @classmethod
+    def sh_kwargs(cls, root_cls, d_parms, *args) -> TyDic:
+        _kwargs: TyDic = AoEqStmt.sh_d_eq(
+                *args, d_parms=d_parms, root_cls=root_cls)
+        cls.init(**_kwargs)
+        return _kwargs

ka_uts_com/data/{log.standard.yml → log.std.yml}

@@ -42,21 +42,21 @@ handlers:
         class: 'logging.FileHandler'
         level: DEBUG
         formatter: main_error
-        filename: '/data/{{tenant}}/RUN/{{package}}/{{module}}/debs/debs_{{pid}}_{{ts}}.log'
+        filename: '{{debug_dir}}/debs_{{pid}}_{{ts}}.log'
         mode: 'a'
 
     main_info_file:
         class: 'logging.FileHandler'
         level: INFO
         formatter: main_info
-        filename: '/data/{{tenant}}/RUN/{{package}}/{{module}}/logs/logs_{{pid}}_{{ts}}.log'
+        filename: '{{info_dir}}/logs_{{pid}}_{{ts}}.log'
         mode: 'a'
 
     main_error_file:
         class: 'logging.FileHandler'
         level: ERROR
         formatter: main_error
-        filename: '/data/{{tenant}}/RUN/{{package}}/{{module}}/errs/errs_{{pid}}_{{ts}}.log'
+        filename: '{{error_dir}}/errs_{{pid}}_{{ts}}.log'
         mode: 'a'
 
     main_critical_mail:

ka_uts_com/data/{log.personal.yml → log.usr.yml}

@@ -1,49 +1,33 @@
 version: 1
-
 disable_existing_loggers: False
 
-root:
-    level: DEBUG
-    handlers:
-        - debug_console
-        - debug_file
+# root:
+#     level: DEBUG
+#     handlers:
+#         - debug_console
+#         - debug_file
 
 loggers:
 
-    # main logger
-    main:
-        level: 'NOTSET'
-        handlers:
-            - debug_console
-            - debug_file
-            - info_file
-            - error_file
-
     # person logger
     person:
-        level: NOTSET
+        # level: NOTSET
+        level: DEBUG
         handlers:
-            - debug_console
-            - debug_file
-            - info_file
-            - error_file
+            - person_debug_console
+            - person_debug_file
+            - person_info_file
+            - person_error_file
 
 handlers:
 
-    debug_console:
+    person_debug_console:
         class: 'logging.StreamHandler'
         level: DEBUG
-        formatter: debug
+        formatter: person_debug
         stream: 'ext://sys.stderr'
 
-    debug_file:
-        class: 'logging.FileHandler'
-        level: DEBUG
-        formatter: error
-        filename: 'debug.log'
-        mode: 'a'
-
-#   info_rotating_file_handler:
+#   person_info_rotating_file_handler:
 #       class: 'logging.handlers.RotatingFileHandler'
 #       level: INFO
 #       formatter: info
@@ -53,24 +37,31 @@ handlers:
 #       backupCount: 10
 #       encoding: utf8
 
-    info_file:
+    person_debug_file:
+        class: 'logging.FileHandler'
+        level: DEBUG
+        formatter: person_error
+        filename: '{{debug_dir}}/debs_{{pid}}_{{ts}}.log'
+        mode: 'a'
+
+    person_info_file:
         class: 'logging.FileHandler'
         level: INFO
-        formatter: info
-        filename: 'info.log'
+        formatter: person_info
+        filename: '{{info_dir}}/logs_{{pid}}_{{ts}}.log'
         mode: 'a'
 
-    error_file:
+    person_error_file:
         class: 'logging.FileHandler'
         level: ERROR
-        formatter: error
-        filename: 'error.log'
+        formatter: person_error
+        filename: '{{error_dir}}/errs_{{pid}}_{{ts}}.log'
         mode: 'a'
 
-    critical_mail:
+    person_critical_mail:
         class: 'logging.handlers.SMTPHandler'
         level: CRITICAL
-        formatter: critical
+        formatter: person_critical
         mailhost : localhost
         fromaddr: 'monitoring@domain.com'
         toaddrs:
@@ -78,16 +69,17 @@ handlers:
             - 'qa@domain.com'
         subject: 'Critical error with application name'
 
+
 formatters:
 
-    info:
+    person_info:
         format: '%(asctime)s-%(levelname)s-%(name)s::%(module)s|%(lineno)s:: %(message)s'
-    debug:
+    person_debug:
         format: '%(asctime)-15s %(levelname)s-%(name)s-%(process)d::%(module)s.%(funcName)s|%(lineno)s:: %(message)s'
         datefmt: '%Y-%m-%d %H:%M:%S'
-    error:
+    person_error:
         format: '%(asctime)-15s %(levelname)s-%(name)s-%(process)d::%(module)s.%(funcName)s|%(lineno)s:: %(message)s'
         datefmt: '%Y-%m-%d %H:%M:%S'
-    critical:
+    person_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'

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

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)

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

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

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,68 @@ class Log:
     """
     class Eq:
 
-        @staticmethod
-        def sh(key: Any, value: Any) -> str:
-            """ Show Key, Value as Equate
-            """
-            return f"{key} = {value}"
-
         @classmethod
         def debug(cls, key: Any, value: Any) -> None:
-            Log.debug(cls.sh(key, value), stacklevel=3)
+            Log.debug(f"{key} = {value}", stacklevel=3)
 
         @classmethod
         def error(cls, key: Any, value: Any) -> None:
-            Log.error(cls.sh(key, value), stacklevel=3)
+            Log.error(f"{key} = {value}", stacklevel=3)
 
         @classmethod
         def info(cls, key: Any, value: Any) -> None:
-            Log.info(cls.sh(key, value), stacklevel=3)
+            Log.info(f"{key} = {value}", stacklevel=3)
 
         @classmethod
         def warning(cls, key: Any, value: Any) -> None:
-            Log.warning(cls.sh(key, value), stacklevel=3)
+            Log.warning(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 debug(*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.debug(*args, **kwargs)
 
     @staticmethod
     def error(*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.error(*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:
         if kwargs is None:
             kwargs = {}
         kwargs['stacklevel'] = kwargs.get('stacklevel', 2)
-        fnc_warning: Callable = Com.Log.warning
-        fnc_warning(*args, **kwargs)
+        Com.Log.warning(*args, **kwargs)