holado 0.13.22__py3-none-any.whl

holado_core/common/resource/persisted_method_to_call_manager.py

@@ -0,0 +1,263 @@
+
+#################################################
+# 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 json
+from holado_core.common.resource.persisted_data_manager import PersistedDataManager
+from holado_python.standard_library.typing import Typing
+from holado_core.common.exceptions.technical_exception import TechnicalException
+from holado_core.common.tools.tools import Tools
+from holado.common.handlers.undefined import undefined_value, undefined_argument,\
+    any_value
+from holado_python.common.tools.datetime import DateTime
+from holado_db.tools.db.query.base.query_builder import DBCompareOperator
+from holado.common.handlers.enums import AutoNumber
+
+logger = logging.getLogger(__name__)
+
+
+class MethodCallStatus(AutoNumber):
+    Ready = ()
+    Completed = ()
+    Failed = ()
+    Expired = ()
+    
+
+class PersistedMethodToCallManager(PersistedDataManager):
+    def __init__(self, scope_name, delete_on_success=True, delete_on_fail=False, delete_on_success_after_fail=False, expiration_try_counter=10, data_name="method", table_name="method_to_call", db_name="default"):
+        """ Constructor
+        @param scope_name: Scope of this manager
+        
+        Note: if scope_name is any_value, it is possible to call all methods persisted with any scope, but it is not possible to add new methods.
+        """
+        super().__init__(data_name=data_name, table_name=table_name, 
+                         table_sql_create=self._get_default_table_sql_create(table_name), 
+                         db_name=db_name)
+        self.__scope_name = scope_name
+        self.__delete_on_success = delete_on_success
+        self.__delete_on_fail = delete_on_fail
+        self.__delete_on_success_after_fail = delete_on_fail
+        self.__expiration_try_counter = expiration_try_counter
+    
+    def initialize(self, resource_manager, expression_evaluator):
+        super().initialize(resource_manager)
+        self.__expression_evaluator = expression_evaluator
+    
+    def _get_default_table_sql_create(self, table_name):
+        return f"""CREATE TABLE {table_name} (
+                id INTEGER PRIMARY KEY,
+                scope_name text NOT NULL,
+                function_qualname text NOT NULL,
+                self_getter TEXT,
+                args TEXT,
+                kwargs TEXT,
+                use text NOT NULL,
+                use_index integer NOT NULL,
+                created_at TEXT,
+                changed_at TEXT,
+                status TEXT,
+                try_counter INTEGER,
+                error TEXT,
+                do_delete_on_success INTEGER,
+                do_delete_on_fail INTEGER,
+                do_delete_on_success_after_fail INTEGER
+            )"""
+    
+    def add_function_to_call(self, function_qualname, args_list=None, kwargs_dict=None, use="default", use_index=0, add_if_exists=False, delete_on_success=undefined_argument, delete_on_fail=undefined_argument, delete_on_success_after_fail=undefined_argument):
+        """Add a function to call.
+        @param function_qualname: Qualified name of function
+        @param args_list: List of function args (default: None)
+        @param kwargs_dict: Dict of function kwargs (default: None)
+        @param use: Define persistent usage. It usually corresponds to a specific scope.
+        @param use_index: use index, useable to order the functions to call. By default all are 0. If set to None, it is automatically set to max(use_index)+1.
+        @param delete_on_success: If True, delete function after its success
+        @param delete_on_fail: If True, delete function after its fail
+        @param delete_on_success_after_fail: If True, delete function after its success even if it has previously failed
+        """
+        self.add_method_to_call(function_qualname, None, args_list, kwargs_dict, use, use_index, add_if_exists, delete_on_success, delete_on_fail, delete_on_success_after_fail)
+    
+    def add_method_to_call(self, function_qualname, self_getter_eval_str, args_list=None, kwargs_dict=None, use="default", use_index=0, add_if_exists=False, delete_on_success=undefined_argument, delete_on_fail=undefined_argument, delete_on_success_after_fail=undefined_argument):
+        """Add a method to call.
+        @param function_qualname: Qualified name of function
+        @param self_getter_eval_str: String to eval in order to get the self instance to use when calling method 
+        @param args_list: List of function args (default: None)
+        @param kwargs_dict: Dict of function kwargs (default: None)
+        @param use: Define persistent usage. It usually corresponds to a specific scope.
+        @param use_index: Use index, useable to order the functions to call. By default all are 0. If set to None, it is automatically set to max(use_index)+1.
+        @param add_if_exists: Add if method already exists (default: False)
+        @param delete_on_success: If True, delete method after its success
+        @param delete_on_fail: If True, delete method after its fail
+        @param delete_on_success_after_fail: If True, delete method after its success even if it has previously failed
+        """
+        if self.__scope_name is any_value:
+            raise TechnicalException("To add a method to call, the scope name must be specified")
+        
+        # Define persisted data that can define if method is already persisted
+        data = {
+            'scope_name': self.__scope_name,
+            'function_qualname': function_qualname,
+            'self_getter': self_getter_eval_str,
+            'use': use,
+            }
+        if args_list is not None:
+            data['args'] = json.dumps(args_list)
+        if kwargs_dict is not None:
+            data['kwargs'] = json.dumps(kwargs_dict)
+        
+        # Return if data is already persisted and add_if_exists==True
+        filter_compare_data = [('status', DBCompareOperator.In, [MethodCallStatus.Ready.name, MethodCallStatus.Failed.name])]
+        if not add_if_exists and self.has_persisted_data(filter_data=data, filter_compare_data=filter_compare_data):
+            return
+        
+        # Persist data
+        if use_index is None:
+            use_index = self.__get_use_next_index(use)
+        now_str = DateTime.datetime_2_str(DateTime.utcnow())
+        data.update({
+            'use_index': use_index,
+            'created_at': now_str,
+            'changed_at': now_str,
+            'status': MethodCallStatus.Ready.name,
+            'try_counter': 0,
+            'do_delete_on_success': self.__get_db_on_delete_after_when_add_method(delete_on_success, self.__delete_on_success),
+            'do_delete_on_fail': self.__get_db_on_delete_after_when_add_method(delete_on_fail, self.__delete_on_fail),
+            'do_delete_on_success_after_fail': self.__get_db_on_delete_after_when_add_method(delete_on_success_after_fail, self.__delete_on_success_after_fail)
+            })
+        
+        self.add_persisted_data(data)
+    
+    def get_number_of_functions_and_method_to_call(self, use=undefined_argument):
+        methods_data = self.__get_functions_and_methods_to_call(use=use)
+        return len(methods_data)
+    
+    def __get_db_on_delete_after_when_add_method(self, method_delete, default_delete):
+        if method_delete is not undefined_argument:
+            if method_delete is undefined_value:
+                return -1
+            else:
+                return method_delete
+        else:
+            if default_delete is undefined_value:
+                return -1
+            else:
+                return default_delete
+        
+    def __get_do_delete_after_call(self, db_delete, default_delete):
+        if db_delete != -1:
+            return db_delete
+        else:
+            if default_delete is undefined_value:
+                return False
+            else:
+                return default_delete
+        
+    def __get_use_next_index(self, use):
+        datas = self.get_persisted_datas({'scope_name':self.__scope_name, 'use':use})
+        if datas:
+            return max(map(lambda x:x['use_index'], datas)) + 1
+        else:
+            return 0
+    
+    def __get_functions_and_methods_to_call(self, use=undefined_argument, use_index=None):
+        filter_data = {}
+        if self.__scope_name is not any_value:
+            filter_data['scope_name'] = self.__scope_name
+        if use is not undefined_argument:
+            filter_data['use'] = use
+            if use_index is not None:
+                filter_data['use_index'] = use_index
+        filter_compare_data = [('status', DBCompareOperator.In, [MethodCallStatus.Ready.name, MethodCallStatus.Failed.name])]
+        return self.get_persisted_datas(filter_data, filter_compare_data=filter_compare_data)
+    
+    def call_functions_and_methods(self, use="default", use_index=None):
+        """Call methods of given use
+        @param use: Define persistent usage. It usually corresponds to a specific scope.
+        @param use_index: If defined, call only functions and methods of given index.
+        """
+        # Get functions and methods to call
+        methods_data = self.__get_functions_and_methods_to_call(use=use)
+        
+        # Call methods
+        if methods_data:
+            for meth_index, meth_data in enumerate(methods_data):
+                status, do_delete, error = None, None, ''
+                try:
+                    self._call_function_or_method(meth_data)
+                except Exception as exc:
+                    error = Tools.represent_exception(exc, indent=8)
+                    msg_list = [f"Error while calling following method (use: '{use}' ; use index: {use_index} ; method index: {meth_index}):"]
+                    msg_list.append(Tools.represent_object(meth_data, 8))
+                    msg_list.append("    Error:")
+                    msg_list.append(error)
+                    msg_list.append("  => Continue to process persisted methods")
+                    msg_list.append("     WARNING: this method is removed from persisted methods to avoid recursive and blocking errors")
+                    logger.error("\n".join(msg_list))
+                    status = MethodCallStatus.Failed
+                    do_delete = self.__get_do_delete_after_call(meth_data['do_delete_on_fail'], self.__delete_on_fail)
+                else:
+                    status = MethodCallStatus.Completed
+                    if meth_data['try_counter'] == 0:
+                        do_delete = self.__get_do_delete_after_call(meth_data['do_delete_on_success'], self.__delete_on_success)
+                    else:
+                        do_delete = self.__get_do_delete_after_call(meth_data['do_delete_on_success_after_fail'], self.__delete_on_success_after_fail)
+                
+                self.__update_persisted_data_after_call(do_delete, meth_data, status, error)
+                
+    def __update_persisted_data_after_call(self, do_delete, meth_data, status, error):
+        if do_delete:
+            self.__delete_function_or_method(meth_data)
+        else:
+            self.__update_function_or_method_status(meth_data, status, error)
+    
+    def __delete_function_or_method(self, function_or_method_data):
+        filter_data = {'id':function_or_method_data['id']}
+        self.delete_persisted_data(filter_data)
+    
+    def __update_function_or_method_status(self, function_or_method_data, status, error):
+        filter_data = {'id':function_or_method_data['id']}
+        try_counter = function_or_method_data['try_counter'] + 1
+        if try_counter >= self.__expiration_try_counter and status == MethodCallStatus.Failed:
+            status = MethodCallStatus.Expired
+        
+        data = {
+            'status': status.name,
+            'try_counter': try_counter,
+            'error': error,
+            'changed_at': DateTime.datetime_2_str(DateTime.utcnow()),
+            }
+        self.update_persisted_data(data, filter_data=filter_data)
+    
+    def _call_function_or_method(self, function_or_method_data):
+        _, func = self.__expression_evaluator.evaluate_python_expression(function_or_method_data['function_qualname'])
+        if not Typing.is_function(func):
+            raise TechnicalException(f"Failed to evaluate python expression '{function_or_method_data['function_qualname']}' as a function (obtained: {func} [type: {Typing.get_object_class_fullname(func)}] ; function data: {function_or_method_data})")
+        
+        func_self = None
+        if function_or_method_data['self_getter'] is not None:
+            _, func_self = self.__expression_evaluator.evaluate_python_expression(function_or_method_data['self_getter'])
+        
+        if function_or_method_data['args'] is not None:
+            args = json.loads(function_or_method_data['args'])
+        else:
+            args = []
+        if function_or_method_data['kwargs'] is not None:
+            kwargs = json.loads(function_or_method_data['kwargs'])
+        else:
+            kwargs = {}
+        
+        if func_self is not None:
+            func(func_self, *args, **kwargs)
+        else:
+            func(*args, **kwargs)
+        
+    

holado_core/common/resource/resource_manager.py

@@ -0,0 +1,126 @@
+
+#################################################
+# 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 os
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+
+class ResourceManager():
+    """
+    Manage local resources, ie resources stored on disk during and through sessions.
+    For example, it can be used to persist data through sessions, so that a session can adapt its behavior according previous sessions.
+    """
+    def __init__(self, local_resource_path):
+        self.__local_resource_path = local_resource_path
+        
+        self.__func_db_manager = None
+        self.__func_path_manager = None
+        self.__db_connect_kwargs_by_name = {}
+        
+    def initialize(self, func_db_manager, func_path_manager):
+        self.__func_db_manager = func_db_manager
+        self.__func_path_manager = func_path_manager
+        
+        self.__path_manager.makedirs(self.__local_resource_path, is_directory=True)
+        
+    @property
+    def __db_manager(self):
+        return self.__func_db_manager()
+    
+    @property
+    def __path_manager(self):
+        return self.__func_path_manager()
+        
+    @property
+    def local_resource_path(self):
+        return self.__local_resource_path
+    
+    def get_path(self, *args):
+        return os.path.join(self.__local_resource_path, *args)
+    
+    def get_db_client(self, name, is_persistent=False):
+        """ Return a SQLite3 DB client to the resource DB of given name
+        @param is_persistent If True, name is prefixed with 'persistent/db/'
+        """
+        full_name = os.path.join("persistent", "db", name) if is_persistent else name
+        _, res = self.__db_manager.get_or_create(full_name, 'sqlite3', self.__get_db_connect_kwargs(full_name))
+        return res
+    
+    def __get_db_connect_kwargs(self, full_name):
+        if full_name not in self.__db_connect_kwargs_by_name:
+            db_filepath = self.get_path(f"{full_name}.sqlite3")
+            self.__path_manager.makedirs(db_filepath)
+            
+            uri = f"file:{db_filepath}?mode=rwc"
+            connect_kwargs = {'database': uri,
+                              'uri': True}
+            self.__db_connect_kwargs_by_name[full_name] = connect_kwargs
+        return self.__db_connect_kwargs_by_name[full_name]
+        
+    def persist_pair(self, key, value, db_name="default", table_name="pair", do_commit=True):
+        client = self.get_db_client(db_name, is_persistent=True)
+        client.execute(f"create table if not exists {table_name} (key, value)", do_commit=do_commit)
+        
+        client.execute(f"insert into {table_name} values (?, ?)", key, value, do_commit=do_commit)
+        
+    def has_data_table(self, table_name, db_name="default", is_persistent=False):
+        client = self.get_db_client(db_name, is_persistent=is_persistent)
+        return client.exist_table(table_name)
+        
+    def create_data_table(self, table_name, create_sql, db_name="default", is_persistent=False, raise_if_exist=False, do_commit=True, do_audit=False):
+        client = self.get_db_client(db_name, is_persistent=is_persistent)
+        client.create_table(table_name, create_sql, raise_if_exist=raise_if_exist, do_commit=do_commit, do_audit=do_audit)
+        
+    def delete_data_table(self, table_name, db_name="default", is_persistent=False, raise_if_not_exist=False, do_commit=True):
+        client = self.get_db_client(db_name, is_persistent=is_persistent)
+        client.drop_table(table_name, raise_if_not_exist=raise_if_not_exist, do_commit=do_commit)
+        
+    def check_data_table_schema(self, table_name, create_sql, db_name="default", is_persistent=False):
+        client = self.get_db_client(db_name, is_persistent=is_persistent)
+        result = client.select("sqlite_schema", where_data={'name':table_name}, sql_return='sql')
+        if not result:
+            return False
+        
+        sql = result[0][0].content
+        return sql == create_sql
+        
+    def count_data(self, table_name, where_data: dict=None, where_compare_data: list=None, db_name="default", is_persistent=False):
+        client = self.get_db_client(db_name, is_persistent=is_persistent)
+        return client.count(table_name, where_data=where_data, where_compare_data=where_compare_data)
+        
+    def has_data(self, table_name, where_data: dict=None, where_compare_data: list=None, db_name="default", is_persistent=False):
+        count = self.count_data(table_name, where_data=where_data, where_compare_data=where_compare_data, db_name=db_name, is_persistent=is_persistent)
+        return count > 0
+        
+    def get_data(self, table_name, where_data: dict=None, where_compare_data: list=None, db_name="default", is_persistent=False, result_as_dict_list=False, as_generator=False):
+        client = self.get_db_client(db_name, is_persistent=is_persistent)
+        result = client.select(table_name, where_data=where_data, where_compare_data=where_compare_data, result_as_dict_list=result_as_dict_list, as_generator=as_generator)
+        return result
+        
+    def add_data(self, table_name, data: dict, db_name="default", is_persistent=False, do_commit=True):
+        client = self.get_db_client(db_name, is_persistent=is_persistent)
+        result = client.insert(table_name, data, do_commit=do_commit)
+        return result
+        
+    def update_data(self, table_name, data: dict, where_data: dict=None, where_compare_data: list=None, db_name="default", is_persistent=False, do_commit=True):
+        client = self.get_db_client(db_name, is_persistent=is_persistent)
+        result = client.update(table_name, data=data, where_data=where_data, where_compare_data=where_compare_data, do_commit=do_commit)
+        return result
+        
+    def delete_data(self, table_name, where_data: dict=None, where_compare_data: list=None, db_name="default", is_persistent=False, do_commit=True):
+        client = self.get_db_client(db_name, is_persistent=is_persistent)
+        client.delete(table_name, where_data=where_data, where_compare_data=where_compare_data, do_commit=do_commit)
+        

holado_core/common/resource/table_data_manager.py

@@ -0,0 +1,110 @@
+
+#################################################
+# 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
+from holado_core.common.exceptions.technical_exception import TechnicalException
+from holado_core.common.tools.tools import Tools
+import copy
+from holado.common.handlers.undefined import undefined_argument
+
+logger = logging.getLogger(__name__)
+
+
+
+class TableDataManager():
+    """
+    Manage data stored in a dedicated resource table.
+    """
+    def __init__(self, data_name, table_name, table_sql_create, db_name="default", is_persistent=False, do_audit=False):
+        self.__data_name = data_name
+        self.__table_name = table_name
+        self.__table_sql_create = table_sql_create
+        self.__db_name = db_name
+        self.__is_persistent = is_persistent
+        self.__do_audit = do_audit
+        
+        self.__resource_manager = None
+    
+    def initialize(self, resource_manager):
+        self.__resource_manager = resource_manager
+        
+    @property
+    def table_name(self):
+        return self.__table_name
+    
+    def ensure_db_exists(self):
+        if self.__resource_manager.has_data_table(self.__table_name, db_name=self.__db_name, is_persistent=self.__is_persistent):
+            if self.__resource_manager.check_data_table_schema(self.__table_name, self.__table_sql_create, db_name=self.__db_name, is_persistent=self.__is_persistent):
+                # Table already exists with the right schema
+                return
+            else:
+                # Table already exists but with wrong schema => delete table before creating it again
+                self.__resource_manager.delete_data_table(self.__table_name, db_name=self.__db_name, is_persistent=self.__is_persistent, raise_if_not_exist=True, do_commit=True)
+        
+        # Create table
+        # Note: method create_data_table raise an exception if it doesn't succeed to create the table
+        self.__resource_manager.create_data_table(self.__table_name, self.__table_sql_create, db_name=self.__db_name, is_persistent=self.__is_persistent, raise_if_exist=True, do_commit=True, do_audit=self.__do_audit)
+    
+    def has_data(self, filter_data=None, filter_compare_data=None):
+        return self.__resource_manager.has_data(self.__table_name, where_data=filter_data, where_compare_data=filter_compare_data, db_name=self.__db_name, is_persistent=self.__is_persistent)
+        
+    def get_datas(self, filter_data=None, filter_compare_data=None, as_generator=False):
+        """
+        Note: Whereas 'data' is already a plural, a 's' is added in method name to be coherent with other method names
+        """
+        return self.__resource_manager.get_data(self.__table_name, where_data=filter_data, where_compare_data=filter_compare_data, db_name=self.__db_name, is_persistent=self.__is_persistent, result_as_dict_list=True, as_generator=as_generator)
+
+    def get_data(self, filter_data=None, filter_compare_data=None):
+        """
+        Note: Whereas 'datum' should be the right word in method name since method returns only one datum, method is named with 'data' in its usual singular meaning for most people.
+        """
+        data = self.get_datas(filter_data=filter_data, filter_compare_data=filter_compare_data)
+        if len(data) > 1:
+            raise TechnicalException(f"Too many ({len(data)}) {self.__data_name} found for filter {filter_data}.")
+        elif len(data) == 1:
+            return data[0]
+        else:
+            return None
+        
+    def count_data(self, filter_data=None, filter_compare_data=None):
+        return self.__resource_manager.count_data(self.__table_name, where_data=filter_data, where_compare_data=filter_compare_data, db_name=self.__db_name, is_persistent=self.__is_persistent)
+
+    def update_data(self, data, filter_data=None, filter_compare_data=None):
+        if Tools.do_log(logger, logging.DEBUG):
+            logger.debug(f"Update {self.__data_name} for {filter_data} and {filter_compare_data}: {data}")
+        self.__resource_manager.update_data(self.__table_name, data, where_data=filter_data, where_compare_data=filter_compare_data, db_name=self.__db_name, is_persistent=self.__is_persistent)
+
+    def add_data(self, data, filter_data=None):
+        if Tools.do_log(logger, logging.DEBUG):
+            logger.debug(f"Add {self.__data_name} for {filter_data}: {data}")
+        data = copy.copy(data)
+        if filter_data:
+            data.update(filter_data)
+        self.__resource_manager.add_data(self.__table_name, data, db_name=self.__db_name, is_persistent=self.__is_persistent)
+        
+    def update_or_add_data(self, filter_data, data, existing_data=undefined_argument):
+        if existing_data is undefined_argument:
+            has_data = self.has_data(filter_data)
+        else:
+            has_data = existing_data is not None
+        
+        if has_data:
+            self.update_data(data, filter_data=filter_data)
+        else:
+            self.add_data(data, filter_data)
+        
+    def delete_data(self, filter_data):
+        self.__resource_manager.delete_data(self.__table_name, where_data=filter_data, db_name=self.__db_name, is_persistent=self.__is_persistent)
+
+
+

holado_core/common/tables/__init__.py

@@ -0,0 +1 @@
+        

holado_core/common/tables/comparators/boolean_table_cell_comparator.py

@@ -0,0 +1,25 @@
+
+#################################################
+# 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 builtins import super
+from holado_core.common.tables.comparators.internal_table_cell_comparator import InternalTableCellComparator
+
+
+class BooleanTableCellComparator(InternalTableCellComparator):
+    def __init__(self):
+        from holado_python.common.tools.comparators.boolean_comparator import BooleanComparator
+        super().__init__(BooleanComparator())
+        
+    

holado_core/common/tables/comparators/bytes_table_cell_comparator.py

@@ -0,0 +1,25 @@
+
+#################################################
+# 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 builtins import super
+from holado_core.common.tables.comparators.internal_table_cell_comparator import InternalTableCellComparator
+
+
+class BytesTableCellComparator(InternalTableCellComparator):
+    def __init__(self):
+        from holado_python.common.tools.comparators.bytes_comparator import BytesComparator
+        super().__init__(BytesComparator())
+    
+    

holado_core/common/tables/comparators/datetime_table_cell_comparator.py

@@ -0,0 +1,24 @@
+
+#################################################
+# 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 builtins import super
+from holado_core.common.tables.comparators.internal_table_cell_comparator import InternalTableCellComparator
+
+
+class DatetimeTableCellComparator(InternalTableCellComparator):
+    def __init__(self):
+        from holado_python.common.tools.comparators.datetime_comparator import DatetimeComparator
+        super().__init__(DatetimeComparator())
+    

holado_core/common/tables/comparators/float_table_cell_comparator.py

@@ -0,0 +1,31 @@
+
+#################################################
+# 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 builtins import super
+from holado_core.common.tables.comparators.internal_table_cell_comparator import InternalTableCellComparator
+
+
+class FloatTableCellComparator(InternalTableCellComparator):
+    def __init__(self, diff_precision=None, relative_precision=1e-15):
+        """
+        Define the comparing method and its associated precision.
+        :see: holado_python.common.tools.comparators.float_comparator for more details on possible precisions.
+        :param diff_precision: If defined, a difference comparison is done with this precision
+        :param relative_precision: If defined, a relative comparison is done with this precision
+        """
+        from holado_python.common.tools.comparators.float_comparator import FloatComparator
+        super().__init__(FloatComparator(diff_precision=diff_precision, relative_precision=relative_precision))
+    
+    

holado_core/common/tables/comparators/integer_table_cell_comparator.py

@@ -0,0 +1,25 @@
+
+#################################################
+# 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 builtins import super
+from holado_core.common.tables.comparators.internal_table_cell_comparator import InternalTableCellComparator
+
+
+class IntegerTableCellComparator(InternalTableCellComparator):
+    def __init__(self):
+        from holado_python.common.tools.comparators.integer_comparator import IntegerComparator
+        super().__init__(IntegerComparator())
+    
+