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

build/lib/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'

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

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

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

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

build/lib/ka_uts_com/com.py

@@ -1,222 +1,121 @@
 # coding=utf-8
+from typing import Any
 
+import os
+import time
 import calendar
+import importlib.resources as resources
 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
-
-T_Any = Any
-T_Arr = List[Any]
-T_Bool = bool
-T_Dic = Dict[Any, Any]
-
-TN_Arr = None | T_Arr
-TN_Bool = None | bool
-TN_Dic = None | T_Dic
-TN_DT = None | datetime
+from ka_uts_com.utils.aoeqstmt import AoEqStmt
+from ka_uts_com.utils.pacmod import PacMod
+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_
+
+TyAny = Any
+TyDateTime = datetime
+TyTimeStamp = int
+TyArr = list[Any]
+TyBool = bool
+TyDic = dict[Any, Any]
+TyLogger = Logger
+
+TnAny = None | Any
+TnArr = None | TyArr
+TnDic = None | TyDic
+TnTimeStamp = None | TyTimeStamp
+TnDateTime = None | TyDateTime
+TnStr = None | str
 
 
-class LogStandard:
-    """Standard Logging
+class Com:
+    """Communication Class
     """
     sw_init: bool = False
-    cfg: T_Dic = {}
-    log: Logger = logging.getLogger('dummy_logger')
-    logfile: str = 'log.standard.yml'
+    dir_dat: TnStr = None
+    tenant: TnStr = None
+    log_type: TnStr = None
+    cmd: TnStr = None
+    d_com_pacmod: TyDic = {}
+    d_app_pacmod: TyDic = {}
+    path_bin = None
+    path_log_cfg = None
 
-    @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
+    pid = None
 
-    @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
+    ts: TnTimeStamp
+    ts_start: TnDateTime = None
+    ts_end: TnDateTime = None
+    ts_etime: TnDateTime = None
+    d_timer: TyDic = {}
 
-    @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')
+    cfg: TnDic = None
+    Log = logging.getLogger('dummy_logger')
+    App: Any = None
+    Exit: Any = None
 
     @classmethod
-    def sh(cls, **kwargs) -> Any:
+    def init(cls, app_cls, kwargs: TyDic):
+        """ set log and application (module) configuration
+        """
         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')
+            return
+        cls.sw_init = True
+        cls.dir_dat = kwargs.get('dir_dat', '/data')
+        cls.tenant = kwargs.get('tenant')
+        cls.log_type = kwargs.get('log_type', 'std')
+        cls.cmd = kwargs.get('cmd')
+        cls.d_com_pacmod = PacMod.sh_d_pacmod(cls)
+        cls.d_app_pacmod = PacMod.sh_d_pacmod(app_cls)
+
+        cls.ts = calendar.timegm(time.gmtime())
+        cls.pid = os.getpid()
 
-    @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)
+        # print(f"Com.init cls.tenanat = {cls.tenant}")
+        # print(f"Com.init cls.cmd = {cls.cmd}")
+        # print(f"Com.init kwargs = {kwargs}")
 
-    @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
+        cls.set_path_bin()
+        cls.set_path_log_cfg()
 
-    @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)
+        cls.Log = Log_.sh(cls, **kwargs)
+        cls.cfg = Cfg_.sh(cls, **kwargs)
+        cls.App = App_.sh(cls, **kwargs)
+        cls.Exit = Exit_.sh(**kwargs)
 
     @classmethod
-    def sh(cls, **kwargs) -> Any:
-        if cls.sw_init:
-            return cls.log
-        cls.init(**kwargs)
-        return cls.log
-
+    def sh_kwargs(cls, app_cls, d_parms, *args) -> TyDic:
+        _kwargs: TyDic = AoEqStmt.sh_d_eq(*args, d_parms=d_parms)
+        cls.init(app_cls, _kwargs)
+        _kwargs['com'] = cls
+        return _kwargs
 
-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
+    def set_path_bin(cls):
+        """ show directory
         """
-        _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
-
-
-class Com:
-    """Communication Class
-    """
-    sw_init: bool = False
-    cfg: TN_Dic = None
-    pid = None
-    pacmod_curr: T_Dic = {}
-
-    ts_start: None | datetime = None
-    ts_end: None | datetime = None
-    ts_etime: None | datetime = None
-    d_timer: Dict = {}
-
-    # Log = None
-    Log: Logger = logging.getLogger('dummy_logger')
-    App = None
-    Exit = Exit
+        package = cls.d_app_pacmod['package']
+        path = resources.files(package).joinpath("bin")
+        if path.is_file():
+            cls.path_bin = path
+        # raise ModuleNotFoundError
 
     @classmethod
-    def init(cls, **kwargs):
-        """ set log and application (module) configuration
+    def set_path_log_cfg(cls):
+        """ show directory
         """
-        if cls.sw_init:
+        package = cls.d_app_pacmod['package']
+        path = resources.files(package).joinpath(f"data/log.{cls.log_type}.yml")
+        if path.is_file():
+            cls.path_log_cfg = path
             return
-        cls.sw_init = True
-
-        cls.pacmod_curr = kwargs.get('pacmod_curr')
-        cls.ts_start = 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)
+        package = cls.d_com_pacmod['package']
+        path = resources.files(package).joinpath(f"data/log.{cls.log_type}.yml")
+        if path.is_file():
+            cls.path_log_cfg = path
+        # raise ModuleNotFoundError

build/lib/ka_uts_com/data/log.std.yml

@@ -0,0 +1,107 @@
+version: 1
+
+disable_existing_loggers: False
+
+# root:
+#     level: DEBUG
+#     handlers:
+#         - debug_console
+#         - debug_file
+
+loggers:
+
+    # standard logger
+    std:
+        # level: NOTSET
+        level: DEBUG
+        handlers:
+            - std_debug_console
+            - std_error_file
+            - std_warning_file
+            - std_debug_file
+            - std_info_file
+            - std_log_file
+
+handlers:
+
+    std_debug_console:
+        class: 'logging.StreamHandler'
+        level: DEBUG
+        formatter: std_debug
+        stream: 'ext://sys.stderr'
+
+#   std_info_rotating_file_handler:
+#       class: 'logging.handlers.RotatingFileHandler'
+#       level: INFO
+#       formatter: info
+#       filename: 'info.rotating.log'
+#       mode: 'a'
+#       maxBytes: 1048576  # 1MB
+#       backupCount: 10
+#       encoding: utf8
+
+    std_error_file:
+        class: 'logging.FileHandler'
+        level: ERROR
+        formatter: std_error
+        filename: '{{dir_run_errs}}/errs_{{pid}}_{{ts}}.log'
+        mode: 'a'
+
+    std_warning_file:
+        class: 'logging.FileHandler'
+        level: WARNING
+        formatter: std_warning
+        filename: '{{dir_run_wrns}}/wrns_{{pid}}_{{ts}}.log'
+        mode: 'a'
+
+    std_debug_file:
+        class: 'logging.FileHandler'
+        level: DEBUG
+        formatter: std_debug
+        filename: '{{dir_run_debs}}/debs_{{pid}}_{{ts}}.log'
+        mode: 'a'
+
+    std_info_file:
+        class: 'logging.FileHandler'
+        level: INFO
+        formatter: std_info
+        filename: '{{dir_run_infs}}/infs_{{pid}}_{{ts}}.log'
+        mode: 'a'
+
+    std_log_file:
+        class: 'logging.FileHandler'
+        level: INFO
+        formatter: std_log
+        filename: '{{dir_run_logs}}/logs_{{pid}}_{{ts}}.log'
+        mode: 'a'
+
+    std_critical_mail:
+        class: 'logging.handlers.SMTPHandler'
+        level: CRITICAL
+        formatter: std_critical
+        mailhost : localhost
+        fromaddr: 'monitoring@domain.com'
+        toaddrs:
+            - 'dev@domain.com'
+            - 'qa@domain.com'
+        subject: 'Critical error with application name'
+
+
+formatters:
+
+    std_warning:
+        format: '%(asctime)-15s %(levelname)s-%(name)s-%(process)d::%(module)s.%(funcName)s|%(lineno)s:: %(message)s'
+        datefmt: '%Y-%m-%d %H:%M:%S'
+    std_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'
+    std_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'
+    std_info:
+        format: '%(asctime)s-%(levelname)s-%(name)s::%(module)s|%(lineno)s:: %(message)s'
+    std_log:
+        format: '%(asctime)s-%(levelname)s-%(name)s::%(module)s|%(lineno)s:: %(message)s'
+    std_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'