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

build/lib/ka_uts_com/__version__.py

@@ -0,0 +1,10 @@
+__title__ = 'ka_uts_com'
+__description__ = 'Communication Utilities.'
+__url__ = 'https://ka-ut-com.readthedocs.io/en/latest'
+__version__ = '1.0.0.240823'
+__build__ = 0x022200
+__author__ = 'Bernd Stroehle'
+__author_email__ = 'bernd.stroehle@gmail.com'
+__license__ = 'Apache-2.0'
+__copyright__ = 'Copyright 2024 Bernd Stroehle'
+__cake__ = u'\u2728 \U0001f370 \u2728'

build/lib/ka_uts_com/aeq.py

@@ -0,0 +1,87 @@
+# coding=utf-8
+
+# import orjson
+# import traceback
+
+from ka_uts_com.date import Date
+from ka_uts_com.str import Str
+
+from typing import Any, Dict, List
+
+TN_Date = None | Any
+
+T_Arr = List[Any]
+T_Dic = Dict[Any, Any]
+
+TN_Arr = None | T_Arr
+TN_Dic = None | T_Dic
+TN_Str = None | str
+
+
+class Aeq:
+    """ Dictionary of Equates
+    """
+    @classmethod
+    def sh_value(cls, key: str, value: Any, d_valid_parms: TN_Dic) -> 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: TN_Str = 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
+
+    @classmethod
+    def sh_d_eq(cls, a_s_eq: T_Arr, d_valid_parms: TN_Dic) -> T_Dic:
+
+        d_eq = {}
+        _d_valid_parms = d_valid_parms
+        for s_eq in a_s_eq[1:]:
+            a_eq = s_eq.split('=')
+            if len(a_eq) == 1:
+                key = 'cmd'
+                value = a_eq[0]
+                if _d_valid_parms is not None:
+                    if value in _d_valid_parms:
+                        _d_valid_parms = _d_valid_parms[value]
+                    else:
+                        _valid_commands = list(_d_valid_parms.keys())
+                        msg = (f"Wrong command: {value}; "
+                               f"valid commands are: {_valid_commands}")
+            else:
+                key = a_eq[0]
+                value = a_eq[1]
+
+                if _d_valid_parms is not None:
+                    if key not in _d_valid_parms:
+                        msg = (f"Wrong parameter: {key}; "
+                               f"valid parameters are: {_d_valid_parms}")
+                        raise Exception(msg)
+                    value = cls.sh_value(key, value, _d_valid_parms)
+            d_eq[key] = value
+        return d_eq

build/lib/ka_uts_com/argv.py

@@ -0,0 +1,49 @@
+# coding=utf-8
+
+from ka_uts_com.pacmod import Pacmod
+from ka_uts_com.aeq import Aeq
+
+from typing import Any, Callable, Dict, List
+
+T_Arr = List[Any]
+T_Dic = Dict[Any, Any]
+
+TN_Arr = None | T_Arr
+TN_Dic = None | T_Dic
+
+
+class Argv:
+    """ Manage Commandline Arguments
+    """
+    @staticmethod
+    def set_by_pacmod(d_eq: T_Dic, root_cls) -> None:
+        """ set current pacmod dictionary
+        """
+        tenant = d_eq.get('tenant')
+        d_eq['pacmod_curr'] = Pacmod.sh_d_pacmod(root_cls, tenant)
+
+    @staticmethod
+    def set_by_prof(d_eq: T_Dic, sh_prof: Callable | 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 sh(cls, a_s_eq: T_Arr, **kwargs) -> T_Dic:
+        """ show equates dictionary
+        """
+        # print(f"DoEq sh kwargs = {kwargs}")
+        root_cls = kwargs.get('root_cls')
+        d_valid_parms: TN_Dic = kwargs.get('d_parms')
+        # print(f"DoEq sh d_valid_parms = {d_valid_parms}")
+
+        d_eq = Aeq.sh_d_eq(a_s_eq, d_valid_parms)
+
+        cls.set_by_pacmod(d_eq, root_cls)
+        _sh_prof = kwargs.get('sh_prof')
+        cls.set_by_prof(d_eq, _sh_prof)
+
+        return d_eq

build/lib/ka_uts_com/com.py

@@ -0,0 +1,222 @@
+# coding=utf-8
+
+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
+
+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
+
+
+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
+
+
+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
+
+    @classmethod
+    def init(cls, **kwargs):
+        """ set log and application (module) configuration
+        """
+        if cls.sw_init:
+            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)

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

@@ -0,0 +1,93 @@
+version: 1
+
+disable_existing_loggers: False
+
+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
+        handlers:
+            - debug_console
+            - debug_file
+            - info_file
+            - error_file
+
+handlers:
+
+    debug_console:
+        class: 'logging.StreamHandler'
+        level: DEBUG
+        formatter: debug
+        stream: 'ext://sys.stderr'
+
+    debug_file:
+        class: 'logging.FileHandler'
+        level: DEBUG
+        formatter: error
+        filename: 'debug.log'
+        mode: 'a'
+
+#   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
+
+    info_file:
+        class: 'logging.FileHandler'
+        level: INFO
+        formatter: info
+        filename: 'info.log'
+        mode: 'a'
+
+    error_file:
+        class: 'logging.FileHandler'
+        level: ERROR
+        formatter: error
+        filename: 'error.log'
+        mode: 'a'
+
+    critical_mail:
+        class: 'logging.handlers.SMTPHandler'
+        level: CRITICAL
+        formatter: critical
+        mailhost : localhost
+        fromaddr: 'monitoring@domain.com'
+        toaddrs:
+            - 'dev@domain.com'
+            - 'qa@domain.com'
+        subject: 'Critical error with application name'
+
+formatters:
+
+    info:
+        format: '%(asctime)s-%(levelname)s-%(name)s::%(module)s|%(lineno)s:: %(message)s'
+    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:
+        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:
+        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/data/log.standard.yml

@@ -0,0 +1,86 @@
+version: 1
+
+disable_existing_loggers: False
+
+# root:
+#     level: DEBUG
+#     handlers:
+#         - debug_console
+#         - debug_file
+
+loggers:
+
+    # main logger
+    main:
+        # level: NOTSET
+        level: DEBUG
+        handlers:
+            - main_debug_console
+            - main_debug_file
+            - main_info_file
+            - main_error_file
+
+handlers:
+
+    main_debug_console:
+        class: 'logging.StreamHandler'
+        level: DEBUG
+        formatter: main_debug
+        stream: 'ext://sys.stderr'
+
+#   main_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
+
+    main_debug_file:
+        class: 'logging.FileHandler'
+        level: DEBUG
+        formatter: main_error
+        filename: '/data/{{tenant}}/RUN/{{package}}/{{module}}/debs/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'
+        mode: 'a'
+
+    main_error_file:
+        class: 'logging.FileHandler'
+        level: ERROR
+        formatter: main_error
+        filename: '/data/{{tenant}}/RUN/{{package}}/{{module}}/errs/errs_{{pid}}_{{ts}}.log'
+        mode: 'a'
+
+    main_critical_mail:
+        class: 'logging.handlers.SMTPHandler'
+        level: CRITICAL
+        formatter: main_critical
+        mailhost : localhost
+        fromaddr: 'monitoring@domain.com'
+        toaddrs:
+            - 'dev@domain.com'
+            - 'qa@domain.com'
+        subject: 'Critical error with application name'
+
+
+formatters:
+
+    main_info:
+        format: '%(asctime)s-%(levelname)s-%(name)s::%(module)s|%(lineno)s:: %(message)s'
+    main_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'
+    main_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'
+    main_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/date.py

@@ -0,0 +1,15 @@
+from datetime import datetime
+from datetime import date
+
+T_Date = date
+TN_Date = None | T_Date
+TN_Str = None | str
+
+
+class Date:
+
+    @staticmethod
+    def sh(datestring: TN_Str, fmt: str) -> TN_Date:
+        if not datestring:
+            return None
+        return datetime.strptime(datestring, fmt).date()

build/lib/ka_uts_com/fnc.py

@@ -0,0 +1,37 @@
+# coding=utf-8
+
+from typing import Any, Callable, Dict
+
+T_Dic = Dict[Any, Any]
+T_DicStr2Callable = Dict[str, Callable]
+
+TN_Str = None | str
+TN_Callable = None | Callable
+
+
+class Fnc:
+    """ Manage 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
+
+    @staticmethod
+    def ex(d_key2fnc: T_DicStr2Callable, key: TN_Str, kwargs: T_Dic) -> None:
+        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:
+            _fnc(kwargs)

build/lib/ka_uts_com/ioc.py

@@ -0,0 +1,57 @@
+# coding=utf-8
+
+import jinja2
+import os
+import yaml
+
+from typing import Any, Dict
+
+T_Dic = Dict[Any, Any]
+
+TN_Any = None | Any
+
+
+class Yaml:
+
+    """ Manage Object to Yaml file affilitation
+    """
+    @staticmethod
+    def load_with_safeloader(string: str) -> None | Any:
+        _obj = yaml.load(string, Loader=yaml.SafeLoader)
+        return _obj
+
+    @staticmethod
+    def read(path: str) -> TN_Any:
+        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
+        return None
+
+
+class Jinja2:
+    """ Manage Object to Json file affilitation
+    """
+    @staticmethod
+    def read_template(
+            path: str) -> Any:
+        dir, file = os.path.split(path)
+        env = jinja2.Environment(loader=jinja2.FileSystemLoader(dir))
+        return env.get_template(file)
+
+    @classmethod
+    def read(
+            cls, path: str, **kwargs):
+        try:
+            # read jinja template from file
+            template = cls.read_template(path)
+
+            # render template as yaml string
+            template_rendered = template.render(**kwargs)
+
+            # parse yaml string as dictionary
+            dic = Yaml.load_with_safeloader(template_rendered)
+            return dic
+        except Exception:
+            raise