holado 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

holado_core/common/tools/path_manager.py

@@ -0,0 +1,185 @@
+
+#################################################
+# HolAdo (Holistic Automation do)
+#
+# (C) Copyright 2021-2025 by Eric Klumpp
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+# The Software is provided “as is”, without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the software or the use or other dealings in the Software.
+#################################################
+
+import logging
+import os
+from glob import glob
+import shutil
+import re
+from holado_core.common.exceptions.technical_exception import TechnicalException
+from holado_core.common.exceptions.functional_exception import FunctionalException
+from datetime import datetime
+from holado_core.common.tools.tools import Tools
+
+logger = logging.getLogger(__name__)
+
+
+class PathManager(object):
+
+    def __init__(self):
+        pass
+
+    def makedirs(self, path, mode = None, is_directory = False, uid = None, gid = None):
+        if not is_directory:
+            path = os.path.dirname(path)
+        if not os.path.exists(path):
+            if mode:
+                os.makedirs(path, mode)
+            else:
+                os.makedirs(path)
+            self.chown(path, uid, gid)
+            
+    def remove_paths(self, glob_pattern, ignore_errors=False):
+        paths = glob(glob_pattern)
+        for path in paths:
+            if os.path.isfile(path):
+                try:
+                    os.remove(path)
+                except Exception as exc:
+                    if not ignore_errors:
+                        raise exc
+            elif os.path.isdir(path):
+                shutil.rmtree(path, ignore_errors=ignore_errors)
+                
+    def copy_path_recursively(self, src_path, dst_path, filter_patterns = None, ignore_patterns = None, do_log = False, log_prefix = "", uid = None, gid = None):
+    #         logging.debug("Copying path '{}' -> '{}' (ignoring {})".format(src_path, dst_path, ignore_patterns))
+        # Copy path
+        if os.path.isfile(src_path):
+            if self.__filter_path(src_path, filter_patterns=filter_patterns, ignore_patterns=ignore_patterns, do_log=do_log, log_prefix=log_prefix):
+                if do_log:
+                    logger.debug("{}Copy file '{}' -> '{}".format(log_prefix, src_path, dst_path))
+                self.makedirs(dst_path, uid=uid, gid=gid)
+                shutil.copy2(src_path, dst_path)
+                self.chown(dst_path, uid, gid)
+        elif os.path.isdir(src_path):
+            lp = os.listdir(src_path)
+            for cp in lp:
+                cur_src_path = os.path.join(src_path, cp)
+                cur_dst_path = os.path.join(dst_path, cp)
+                self.copy_path_recursively(cur_src_path, cur_dst_path, filter_patterns=filter_patterns, ignore_patterns=ignore_patterns, do_log=do_log, log_prefix=log_prefix, uid=uid, gid=gid)
+    
+    def __filter_paths(self, paths, filter_patterns = None, ignore_patterns = None, do_log = False, log_prefix = ""):
+        if filter_patterns is not None and not isinstance(filter_patterns, list):
+            raise TechnicalException("Parameter 'filter_patterns' must be None or a list of patterns")
+        if ignore_patterns is not None and not isinstance(ignore_patterns, list):
+            raise TechnicalException("Parameter 'ignore_patterns' must be None or a list of patterns")
+        
+        res = []
+        for path in paths:
+            if self.__filter_path(path, filter_patterns, ignore_patterns, do_log, log_prefix):
+                res.append(path)
+                
+        return res
+    
+    def __filter_path(self, path, filter_patterns = None, ignore_patterns = None, do_log = False, log_prefix = ""):
+        if filter_patterns is not None and not isinstance(filter_patterns, list):
+            raise TechnicalException("Parameter 'filter_patterns' must be None or a list of patterns")
+        if ignore_patterns is not None and not isinstance(ignore_patterns, list):
+            raise TechnicalException("Parameter 'ignore_patterns' must be None or a list of patterns")
+        
+        if filter_patterns is not None and len(filter_patterns) > 0:
+            is_matching_a_filter = False
+            for pattern in filter_patterns:
+                if re.match(pattern, path):
+                    if do_log:
+                        if Tools.do_log(logger, logging.DEBUG):
+                            logger.debug(f"{log_prefix}File '{path}' is matching filter '{pattern}'")
+                    is_matching_a_filter = True
+                    break
+            if not is_matching_a_filter:
+                if do_log:
+                    if Tools.do_log(logger, logging.DEBUG):
+                        logger.debug(f"{log_prefix}File '{path}' is excluded by filters {filter_patterns}")
+                return False
+
+        if ignore_patterns is not None and len(ignore_patterns) > 0:
+            is_ignored = False
+            for pattern in ignore_patterns:
+                if re.match(pattern, path):
+                    if do_log:
+                        if Tools.do_log(logger, logging.DEBUG):
+                            logger.debug(f"{log_prefix}File '{path}' is ignored since it matches pattern '{pattern}'")
+                    is_ignored = True
+                    break
+            if is_ignored:
+                return False
+
+        return True
+    
+    def rename(self, src, dst, raise_if_exists=True):
+        if raise_if_exists:
+            os.rename(src, dst)
+        else:
+            os.replace(src, dst)
+    
+    def get_local_resources_path(self, name=None):
+        base_path = os.getenv('HOLADO_TEST_LOCAL_RESOURCES_BASEDIR')
+        if base_path is None:
+            raise Exception("Missing environment variable HOLADO_TEST_LOCAL_RESOURCES_BASEDIR with HolAdo local resources base path")
+        
+        if name is not None:
+            return os.path.join(base_path, name)
+        else:
+            return base_path
+    
+    def get_reports_path(self, name=None):
+        base_path = os.getenv('HOLADO_TEST_OUTPUT_BASEDIR')
+        if base_path is None:
+            raise Exception("Missing environment variable HOLADO_TEST_OUTPUT_BASEDIR with HolAdo output base path")
+        
+        if name is not None:
+            return os.path.join(base_path, "reports", name)
+        else:
+            return os.path.join(base_path, "reports")
+    
+    def chown(self, path, uid = None, gid = None):
+        if uid is not None or gid is not None:
+            if uid is None or gid is None:
+                raise TechnicalException(f"User and group ID cannot be None (uid={uid} ; gid={gid})")
+            os.chown(path, uid, gid)
+    
+    def check_file_exists(self, path, raise_exception=True):
+        """
+         * @param path Path
+         * @param throwException If True, raises an exception rather than returning False
+         * @return True if given path is an existing file
+        """
+        res = os.path.exists(path)
+        
+        if not res and raise_exception:
+            raise FunctionalException(f"File '{path}' doesn't exist")
+        return res
+    
+    def get_timestamped_path(self, prefix, ext, dt=None, dt_format="%Y%m%d-%H%M%S"):
+        ext = ext.strip('.')
+        if dt is None:
+            dt = datetime.now()
+        now_str = datetime.strftime(dt, dt_format)
+        return f"{prefix}_{now_str}.{ext}"
+    
+    def find_files_starting_with(self, dir_path, prefix):
+        res = []
+        for filename in os.listdir(dir_path):
+            if os.path.isfile(os.path.join(dir_path, filename)) and filename.startswith(prefix):
+                res.append(os.path.join(dir_path, filename))
+        return res
+    
+    def find_file_starting_with(self, dir_path, prefix):
+        files = self.find_files_starting_with(dir_path, prefix)
+        
+        if len(files) == 0:
+            raise FunctionalException(f"Unable to find a file starting with '{prefix}' in folder '{dir_path}'")
+        elif len(files) > 1:
+            raise FunctionalException(f"Found many ({len(files)}) files starting with '{prefix}' in folder '{dir_path}': {files}")
+        return files[0]
+    

holado_core/common/tools/string_tools.py

@@ -0,0 +1,135 @@
+
+#################################################
+# HolAdo (Holistic Automation do)
+#
+# (C) Copyright 2021-2025 by Eric Klumpp
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+# The Software is provided “as is”, without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the software or the use or other dealings in the Software.
+#################################################
+
+from holado_core.common.exceptions.technical_exception import TechnicalException
+import logging
+import string
+from holado_core.common.exceptions.functional_exception import FunctionalException
+import re
+from holado_python.standard_library.typing import Typing
+
+try:
+    from bitarray import bitarray
+    with_bitarray = True
+except:
+    with_bitarray = False
+
+logger = logging.getLogger(__name__)
+
+
+class StrTools(object):
+    
+    #TODO EKL: move following methods from Tools to this class
+    # @classmethod
+    # def get_indent_string(cls, indent):
+    #     return " " * indent
+    #
+    # @classmethod
+    # def indent_string(cls, indent, txt):
+    #     ind_str = StrTools.get_indent_string(indent)
+    #     lines = txt.split("\n") if txt else []
+    #     return ind_str + ("\n" + ind_str).join(lines)
+    #
+    # @classmethod
+    # def truncate_text(cls, text, length = Config.message_truncate_length, truncated_suffix = "[...]", is_length_with_suffix=False):
+    #     if len(text) > length:
+    #         if truncated_suffix:
+    #             if is_length_with_suffix:
+    #                 return text[0 : length - len(truncated_suffix)] + truncated_suffix
+    #             else:
+    #                 return text[0 : length] + truncated_suffix
+    #         else:
+    #             return text[0 : length]
+    #     else:
+    #         return text
+    
+    if with_bitarray:
+        @classmethod
+        def is_bitarray(cls, src):
+            # Convert source to str
+            if isinstance(src, bytes):
+                value_str = src.decode('utf-8')
+            elif isinstance(src, str):
+                value_str = src
+            else:
+                raise FunctionalException(f"Unexpected source type {Typing.get_object_class_fullname(src)} (allowed types: string, bytes)")
+            
+            try:
+                bitarray(value_str)
+            except:
+                return False
+            return True
+    
+    @classmethod
+    def is_hex(cls, src):
+        if not isinstance(src, str):
+            return False
+        
+        hex_digits = set(string.hexdigits)
+        return all(c in hex_digits for c in src)
+    
+    @classmethod
+    def hex_to_bytes(cls, src):
+        if not cls.is_hex(src):
+            raise FunctionalException(f"Source [{src}] (type: {Typing.get_object_class_fullname(src)}) is not an hexadecimal string")
+        
+        if len(src) % 2 != 0:
+            raise FunctionalException(f"Hex string must have a length multiple of 2. If not, a padding is usually applied with a 0 at left or right. Hex string: '{src}'")
+        
+        try:
+            res = bytes.fromhex(src)
+        except ValueError as exc:
+            raise TechnicalException(f"Error with hex string '{src}'") from exc
+        
+        # if len(res) * 2 != len(src):
+        #     raise TechnicalException(f"Failed to convert hex to bytes: hex length is {len(src)} ; bytes length is {len(res)}")
+        
+        return res
+    
+    @classmethod
+    def to_bytes(cls, src):
+        if isinstance(src, int):
+            signed = True if src < 0 else False
+        
+            length = 1
+            val = src
+            while val > 255:
+                length += 1
+                val = val / 256
+        
+            res = src.to_bytes(length, 'big', signed=signed)
+        elif isinstance(src, bytes):
+            res = src
+        elif isinstance(src, str):
+            if re.match(r"^b('|\").*\1$", src):
+                res = eval(src)
+                if not isinstance(res, bytes):
+                    raise TechnicalException(f"Failed to eval string [{src}] as bytes ; eval result: [{res}] (type: {Typing.get_object_class_fullname(res)})")
+            else:
+                res = src.encode('utf-8')
+        else:
+            raise FunctionalException(f"Unexpected source type {Typing.get_object_class_fullname(src)} (allowed types: int, string, bytes)")
+        
+        return res
+    
+    @classmethod
+    def to_hex(cls, src, do_upper=True):
+        src_bytes = cls.to_bytes(src)
+        
+        res = src_bytes.hex()
+        if do_upper:
+            res = res.upper()
+        
+        return res
+
+

holado_core/common/tools/tools.py

@@ -0,0 +1,172 @@
+
+#################################################
+# HolAdo (Holistic Automation do)
+#
+# (C) Copyright 2021-2025 by Eric Klumpp
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+# The Software is provided “as is”, without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the software or the use or other dealings in the Software.
+#################################################
+
+from holado.holado_config import Config
+import traceback
+import sys
+from holado_core.common.handlers.enums import AccessType
+import logging
+import time
+from holado_python.standard_library.typing import Typing
+
+logger = logging.getLogger(__name__)
+
+
+def reversed_enumerate(l):
+    return zip(range(len(l)-1, -1, -1), reversed(l))
+
+def reversed_range(min_, max_=None, step=-1):
+    if max_ is None:
+        min_, max_ = 0, min_
+    return range(max_-1, min_-1, step)
+
+
+class Tools(object):
+    
+    @classmethod
+    def get_indent_string(cls, indent):
+        return " " * indent
+    
+    @classmethod
+    def indent_string(cls, indent, txt, *, do_indent_first_line=True):
+        ind_str = Tools.get_indent_string(indent)
+        lines = txt.split("\n") if txt else []
+        if do_indent_first_line:
+            return ind_str + ("\n" + ind_str).join(lines)
+        else:
+            return ("\n" + ind_str).join(lines)
+
+    @classmethod
+    def truncate_text(cls, text, length = Config.message_truncate_length, truncated_suffix = "[...]", is_length_with_suffix=False):
+        if len(text) > length:
+            if truncated_suffix:
+                if is_length_with_suffix:
+                    return text[0 : length - len(truncated_suffix)] + truncated_suffix
+                else:
+                    return text[0 : length] + truncated_suffix
+            else:
+                return text[0 : length]
+        else:
+            return text
+    
+    @classmethod
+    def represent_exception(cls, exc, tb=None):
+        if sys.version_info >= (3,10):
+            if tb is not None:
+                list_format = traceback.format_exception(exc, value=exc, tb=tb)
+            else:
+                list_format = traceback.format_exception(exc)
+        else:
+            list_format = traceback.format_exception(type(exc), exc, exc.__traceback__)
+        return "".join(list_format)
+    
+    @classmethod
+    def represent_object(cls, obj, indent=0, *, do_indent_first_line=True, full_details=False, access_type=AccessType.Public):
+        return cls.__represent_object(obj, indent, do_indent_first_line, full_details, access_type, [])
+    
+    @classmethod
+    def __represent_object(cls, obj, indent, do_indent_first_line, full_details, access_type, _internal):
+        from holado_core.common.tools.converters.converter import Converter
+        
+        if Converter.is_primitive(obj) and not Converter.is_dict(obj) and not Converter.is_list(obj):
+            # logger.print(f"+++++ Tools.__represent_object: is primitive")
+            res = f"{obj} [{str(type(obj))}]" if full_details else f"{obj}"
+        else:
+            id_obj = id(obj)
+            if id_obj in _internal:
+                res = f"[RECURSION] (type: {str(type(obj))} ; id: {id_obj})" if full_details else f"[RECURSION]"
+            else:
+                _internal.append(id_obj)
+                
+                if Converter.is_dict(obj):
+                    # logger.print(f"+++++ Tools.__represent_object: is dict")
+                    res_list = [f"{str(type(obj))}({id_obj})"] if full_details else [""]
+                    # keys = sorted(value.keys())
+                    keys = list(obj.keys())
+                    for key in keys:
+                        # logger.print(f"+++++ Tools.__represent_object:     key: {key}")
+                        res_list.append(f"    {key}: {cls.__represent_object(obj[key], 4, False, full_details, access_type, _internal)}")
+                    res = "\n".join(res_list)
+                elif Converter.is_list(obj):
+                    # logger.print(f"+++++ Tools.__represent_object: is list")
+                    res_list = [f"{str(type(obj))}({id_obj})"] if full_details else ["["]
+                    # keys = sorted(value.keys())
+                    for el in obj:
+                    # for index, el in enumerate(obj):
+                    #     logger.print(f"+++++ Tools.__represent_object:     index: {index}")
+                        res_list.append(cls.__represent_object(el, 4, True, full_details, access_type, _internal))
+                    if not full_details:
+                        res_list.append("]")
+                    res = "\n".join(res_list)
+                else:
+                    if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+                        logger.trace(f"Representing object of type {Typing.get_object_class_fullname(obj)}")
+                    attributes = Typing.get_object_attributes(obj, access_type=access_type)
+                    # logger.print(f"+++++ Tools.__represent_object: {str(type(obj))} is object with {attributes=}")
+                    if attributes:
+                        res_list = [f"{str(type(obj))}({id_obj})"] if full_details else [f"{str(type(obj))}"]
+                        for name, value in attributes:
+                            # logger.print(f"+++++ Tools.__represent_object:     attribute '{name}'")
+                            res_list.append(f"    {name}: {cls.__represent_object(value, 4, False, full_details, access_type, _internal)}")
+                        res = "\n".join(res_list)
+                    else:
+                        res = f"{obj} [{str(type(obj))}({id_obj})]" if full_details else f"{obj}"
+                        # raise TechnicalException(f"Unmanaged representation of object of type '{Typing.get_object_class_fullname(obj)}'")
+        
+        return Tools.indent_string(indent, res, do_indent_first_line=do_indent_first_line)
+    
+    @classmethod
+    def has_sub_kwargs(cls, kwargs: dict, prefix: str):
+        for k in kwargs.keys():
+            if k.startswith(prefix):
+                return True
+        return False
+    
+    @classmethod    
+    def pop_sub_kwargs(cls, kwargs: dict, prefix: str):
+        res = {}
+        for k in list(kwargs.keys()):
+            if k.startswith(prefix):
+                res[k[len(prefix):]] = kwargs.pop(k)
+        return res
+    
+    @classmethod
+    def do_log(cls, logger, log_level):
+        return logger.isEnabledFor(log_level)
+    
+    @classmethod
+    def do_log_if_objects_are_different(cls, logger, log_level, obj1, obj2):
+        try:
+            return cls.do_log(logger, log_level) and (obj1 != obj2)
+        except Exception as exc:
+            if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+                logger.trace(f"Assume a log is needed since usually a comparison fails on mismatching types and thus objects are different. Obtained error: {exc}")
+            return True
+    
+    @classmethod
+    def raise_same_exception_type(cls, exception, new_message, add_from=True):
+        exc = type(exception)(new_message)
+        if add_from:
+            raise exc from exception
+        else:
+            raise exc
+    
+    @classmethod
+    def timer_s(cls):
+        return time.perf_counter()
+    
+    @classmethod
+    def timer_ns(cls):
+        return time.perf_counter_ns()
+    
+

holado_core/common/transport/crc.py

@@ -0,0 +1,40 @@
+
+import logging
+from holado_core.common.tools.tools import Tools
+
+logger = logging.getLogger(__name__)
+
+
+class Crc(object):
+    
+    @staticmethod
+    def crc(msg_bytes, offset, nb_bits, crc_size, polynomial, init_val, xor_val, reverse=False):
+        if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+            logger.trace(f"Computing CRC for:\n  {msg_bytes=}\n  {offset=}\n  {nb_bits=}\n  {crc_size=}\n  {polynomial=}\n  {init_val=}\n  {xor_val=}")
+        res = init_val
+        
+        # For each data bit in the data, process bits from left to right (or from right to left if reverse=True)
+        if reverse:
+            bits_range = range(offset+nb_bits-1, offset-1, -1)
+        else:
+            bits_range = range(offset, offset+nb_bits)
+        for i in bits_range:
+            bit = (msg_bytes[i // 8] >> (7 - (i % 8))) & 0x1
+            out = (res >> (crc_size - 1)) & 0x1
+            res = (res << 1) & (0xFFFFFFFF >> (32 - crc_size))
+            # Apply polynomial if the bit about to be shifted out of the crc is different than the processed bit
+            if bit ^ out == 1:
+                res ^= polynomial
+            if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+                logger.trace(f"Computing CRC: {i=}, {bit=} => {res}")
+        
+        res ^= xor_val
+        
+        # Be careful, for a crc-32, we can't make <<32, this should result to <<0
+        res &= 0xFFFFFFFF >> (32 - crc_size)
+        
+        if Tools.do_log(logger, logging.DEBUG):
+            logger.debug(f"CRC for:\n  {msg_bytes=}\n  {offset=}\n  {nb_bits=}\n  {crc_size=}\n  {polynomial=}\n  {init_val=}\n  {xor_val=}\n => {res}")
+        return res
+        
+        

holado_core/tests/behave/steps/__init__.py

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+
+#################################################
+# HolAdo (Holistic Automation do)
+#
+# (C) Copyright 2021-2025 by Eric Klumpp
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+# The Software is provided “as is”, without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the software or the use or other dealings in the Software.
+#################################################
+
+
+from .common.common_steps import *
+from .common.config_steps import *
+from .common.resource_steps import *
+from .common.tables_steps import *
+