holado 0.13.22__py3-none-any.whl

holado_core/common/tools/path_manager.py

@@ -0,0 +1,238 @@
+
+#################################################
+# 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
+from pathlib import Path
+from holado_python.common.tools.datetime import DateTime
+from holado.holado_config import Config
+
+logger = logging.getLogger(__name__)
+
+
+class PathManager(object):
+
+    def __init__(self):
+        pass
+    
+    def get_user_group(self, path):
+        p = Path(path)
+        return p.owner(), p.group()
+    
+    def get_mode(self, path):
+        return os.stat(path).st_mode & 0o777
+    
+    def makedirs(self, path, mode = None, is_directory = False, user = None, group = 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, user, group)
+            
+    def makefile(self, path, mode = None, user = None, group = None):
+        if not os.path.exists(path):
+            self.makedirs(path, mode, False, user, group)
+            open(path, 'a').close()
+            
+            if mode:
+                os.chmod(path, mode)
+            self.chown(path, user, group)
+            
+    def remove_path(self, path, ignore_errors=False):
+        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 remove_paths(self, glob_pattern, ignore_errors=False):
+        paths = glob(glob_pattern)
+        for path in paths:
+            self.remove_path(path, ignore_errors)
+                
+    def copy_path_recursively(self, src_path, dst_path, filter_patterns = None, ignore_patterns = None, do_log = False, log_prefix = "", user = None, group = 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, user=user, group=group)
+                shutil.copy2(src_path, dst_path)
+                self.chown(dst_path, user, group)
+        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, user=user, group=group)
+    
+    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_user_home_path(self):
+        import pathlib
+        return str(pathlib.Path.home())
+    
+    def get_local_resources_path(self, name=None):
+        base_path = os.getenv('HOLADO_LOCAL_RESOURCES_BASEDIR')
+        if base_path is None:
+            base_path = os.path.join(self.get_user_home_path(), '.holado', 'resources')
+        
+        if name is not None:
+            return os.path.join(base_path, name)
+        else:
+            return base_path
+    
+    def get_reports_path(self, name=None, with_application_group=True):
+        base_path = os.getenv('HOLADO_OUTPUT_BASEDIR')
+        if base_path is None:
+            base_path = os.path.join(self.get_user_home_path(), '.holado', 'output')
+        
+        res = os.path.join(base_path, "reports")
+        if with_application_group and Config.application_group is not None:
+            res = os.path.join(res, Config.application_group)
+        if name is not None:
+            res = os.path.join(res, name)
+        return res
+    
+    def chown(self, path, user = None, group = None):
+        if user is not None or group is not None:
+            if user is None or group is None:
+                raise TechnicalException(f"User and group (name or ID) cannot be None (user={user} ; group={group})")
+            shutil.chown(path, user, group)
+    
+    def check_file_exists(self, path, do_exist=True, raise_exception=True):
+        """
+        @param path Path
+        @param do_exist Define to check if file exists or not
+        @param raise_exception If True, raises an exception rather than returning False
+        @return True if given path is an existing file
+        """
+        res = (do_exist == os.path.exists(path))
+        
+        if not res and raise_exception:
+            raise FunctionalException(f"File '{path}' " + "doesn't exist" if do_exist else "exists")
+        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(self, dir_path, prefix=None, subdir_relative_path=None, since_datetime=None):
+        res = []
+        for filename in os.listdir(dir_path):
+            file_path = os.path.join(dir_path, filename)
+            
+            if subdir_relative_path is not None:
+                # Filter directories that doesn't contain expected sub-file
+                if not os.path.isdir(file_path):
+                    continue
+                file_path = os.path.join(file_path, subdir_relative_path)
+                if not os.path.exists(file_path):
+                    continue
+            else:
+                # Filter paths that are not files
+                if not os.path.isfile(file_path):
+                    continue
+            
+            # Filter on prefix
+            if prefix is not None and not filename.startswith(prefix):
+                continue
+            
+            # Filter on file modification datetime
+            if since_datetime is not None:
+                dt_last_modif = DateTime.timestamp_to_datetime(os.path.getmtime(file_path))
+                if dt_last_modif < since_datetime:
+                    continue
+            
+            # File is matching criteria
+            res.append(file_path)
+        return res
+    
+    def find_file(self, dir_path, prefix=None, since_datetime=None):
+        files = self.find_files(dir_path, prefix=prefix, since_datetime=since_datetime)
+        
+        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,144 @@
+
+#################################################
+# 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
+    
+    @classmethod
+    def to_string(cls, src):
+        if isinstance(src, bytes):
+            return src.decode('utf-8')
+        elif isinstance(src, str):
+            return src
+        else:
+            return str(src)
+
+

holado_core/common/tools/tools.py

@@ -0,0 +1,197 @@
+
+#################################################
+# 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
+from holado.common.handlers.undefined import default_value
+
+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=default_value, is_length_with_suffix=False, is_suffix_with_truncated_length=True):
+        """Truncate text if needed.
+        Default truncate suffix is '[...(xxx)]' if is_suffix_with_truncated_length=True else '[...]'
+        Note: length can be None, meaning no truncate to do
+        """
+        if length is not None and len(text) > length:
+            if truncated_suffix is default_value:
+                truncated_suffix = f"[...({len(text)-length})]" if is_suffix_with_truncated_length else "[...]"
+            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, indent=0):
+        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 Tools.indent_string(indent, "".join(list_format))
+    
+    @classmethod
+    def represent_object(cls, obj, indent=0, *, do_indent_first_line=True, full_details=False, access_type=AccessType.Public, max_level=3):
+        return cls.__represent_object(obj, indent, do_indent_first_line, full_details, access_type, max_level, [])
+    
+    @classmethod
+    def __represent_object(cls, obj, indent, do_indent_first_line, full_details, access_type, max_level, _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}")
+                        val_str = cls.__represent_object(obj[key], 0, True, full_details, access_type, max_level-1, _internal)
+                        if '\n' in val_str:
+                            res_list.append(f"    {key}:")
+                            res_list.append(Tools.indent_string(4, val_str))
+                        else:
+                            res_list.append(f"    {key}: {val_str}")
+                    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}")
+                        el_str = cls.__represent_object(el, 0, True, full_details, access_type, max_level-1, _internal)
+                        if '\n' in el_str:
+                            res_list.append("    {")
+                            res_list.append(Tools.indent_string(4, el_str))
+                            res_list.append("    }")
+                        else:
+                            res_list.append(f"    {el_str}")
+                    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))}"]
+                        if max_level > 0:
+                            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, max_level-1, _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_level(cls, log_level, max_log_level):
+        """Define the log level to use: if log_level is greater than max_log_level, return max_log_level.
+        """
+        return min(log_level, max_log_level)
+    
+    @classmethod
+    def do_log(cls, logger, log_level, max_log_level=logging.CRITICAL):
+        return logger.isEnabledFor(cls.do_log_level(log_level, max_log_level))
+    
+    @classmethod
+    def do_log_if_objects_are_different(cls, logger, log_level, obj1, obj2, max_log_level=logging.CRITICAL):
+        try:
+            return cls.do_log(logger, log_level, max_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/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 *
+