holado 0.13.22__py3-none-any.whl

holado_core/common/tables/comparators/internal_table_cell_comparator.py

@@ -0,0 +1,30 @@
+
+#################################################
+# 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.table_cell_comparator import TableCellComparator
+from holado_core.common.tools.comparators.comparator import CompareOperator
+
+
+class InternalTableCellComparator(TableCellComparator):
+    def __init__(self, internal_comparator):
+        super().__init__()
+        self.__internal_comparator = internal_comparator
+        
+    def _compare_by_operator(self, obj_1, operator: CompareOperator, obj_2, is_obtained_vs_expected = True, raise_exception = True, redirect_to_equals=True):
+        # Note: redirect_to_equals is not passed to internal comparator
+        return self.__internal_comparator.compare(obj_1, operator, obj_2, is_obtained_vs_expected, raise_exception)
+    
+    

holado_core/common/tables/comparators/string_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 StringTableCellComparator(InternalTableCellComparator):
+    def __init__(self):
+        from holado_python.common.tools.comparators.string_comparator import StringComparator
+        super().__init__(StringComparator())
+    

holado_core/common/tables/comparators/string_table_comparator.py

@@ -0,0 +1,29 @@
+
+#################################################
+# 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
+import logging
+from holado_core.common.tables.comparators.table_comparator import TableComparator
+from holado_core.common.tables.comparators.string_table_row_comparator import StringTableRowComparator
+
+logger = logging.getLogger(__name__)
+
+
+class StringTableComparator(TableComparator):
+    def __init__(self, row_comparator=None, cell_comparator=None):
+        if row_comparator is None and cell_comparator is None:
+            row_comparator = StringTableRowComparator()
+        super().__init__(row_comparator=row_comparator, cell_comparator=cell_comparator)
+        

holado_core/common/tables/comparators/string_table_row_comparator.py

@@ -0,0 +1,29 @@
+
+#################################################
+# 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
+import logging
+from holado_core.common.tables.comparators.string_table_cell_comparator import StringTableCellComparator
+from holado_core.common.tables.comparators.table_row_comparator import TableRowComparator
+
+logger = logging.getLogger(__name__)
+
+
+class StringTableRowComparator(TableRowComparator):
+    def __init__(self, cell_comparator = StringTableCellComparator()):
+        super().__init__(cell_comparator=cell_comparator)
+        
+        
+

holado_core/common/tables/comparators/table_cell_comparator.py

@@ -0,0 +1,40 @@
+
+#################################################
+# 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.table_cell import TableCell
+from holado_core.common.tools.comparators.comparator import Comparator
+import abc
+from holado_core.common.exceptions.technical_exception import TechnicalException
+from holado_value.common.tables.value_table_cell import ValueTableCell
+from holado_python.standard_library.typing import Typing
+
+
+class TableCellComparator(Comparator):
+    __metaclass__ = abc.ABCMeta    
+
+    def __init__(self):
+        super().__init__("table cell")
+    
+    def _convert_input(self, obj, name):
+        if isinstance(obj, ValueTableCell):
+            res = obj.value
+        elif isinstance(obj, TableCell):
+            res = obj.content
+        else:
+            raise TechnicalException(f"Unexpected input of type {Typing.get_object_class_fullname(obj)} (expected: TableCell or any sub-type)")
+        return res
+        
+    

holado_core/common/tables/comparators/table_comparator.py

@@ -0,0 +1,209 @@
+
+#################################################
+# 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 range
+from builtins import super
+from holado_core.common.tools.comparators.comparator import Comparator
+from holado_core.common.exceptions.verify_exception import VerifyException
+from holado_core.common.exceptions.technical_exception import TechnicalException
+from holado_core.common.exceptions.functional_exception import FunctionalException
+import logging
+from holado_core.common.tables.comparators.string_table_row_comparator import StringTableRowComparator
+from holado_core.common.exceptions.exceptions import Exceptions
+from holado_core.common.tools.tools import Tools
+from holado_core.common.tables.comparators.table_row_comparator import TableRowComparator
+
+logger = logging.getLogger(__name__)
+
+
+class TableComparator(Comparator):
+    def __init__(self, row_comparator=None, cell_comparator=None):
+        super().__init__("table")
+        
+        if row_comparator is not None:
+            self.__row_comparator = row_comparator
+        elif cell_comparator is not None:
+            self.__row_comparator = TableRowComparator(cell_comparator)
+        else:
+            self.__row_comparator = StringTableRowComparator()
+
+    @property
+    def row_comparator(self):
+        return self.__row_comparator
+    
+    def equals(self, table_1, table_2, is_obtained_vs_expected = True, raise_exception = True):
+        try:
+            res = True
+            
+            # Verify number of rows
+            if table_1.nb_rows != table_2.nb_rows:
+                if raise_exception:
+                    raise VerifyException("Tables have not same number of rows (table {name1}: {nb1} rows ; table {name2}: {nb2} rows):\n  table {name1}:\n{repr1}\n  table {name2}:\n{repr2})".format(
+                                                  name1=self._get_name_1(is_obtained_vs_expected), nb1=table_1.nb_rows, repr1=table_1.represent(4),
+                                                  name2=self._get_name_2(is_obtained_vs_expected), nb2=table_2.nb_rows, repr2=table_2.represent(4)))
+                else:
+                    return False
+                
+            # Compare rows content
+            for i in range(table_1.nb_rows):
+                try:
+                    res = self.__row_comparator.equals(table_1.get_row(i),
+                                                       table_2.get_row(i),
+                                                       is_obtained_vs_expected=is_obtained_vs_expected,
+                                                       raise_exception=raise_exception)
+                except FunctionalException as exc:
+                    msg = "Difference exists at line of index {}:\n----------------------------------\n -> {}\n----------------------------------\n  table {}:\n{}\n  table {}:\n{}".format(
+                            i, Exceptions.exception_message(exc), self._get_name_1(is_obtained_vs_expected), self._represent_table(table_1, 4), self._get_name_2(is_obtained_vs_expected), self._represent_table(table_2, 4))
+                    raise VerifyException(msg) from exc
+                except Exception as exc:
+                    msg = "Error while comparing line of index {}:\n----------------------------------\n -> {}\n----------------------------------\n  table {}:\n{}\n  table {}:\n{}".format(
+                            i, Exceptions.exception_message(exc), self._get_name_1(is_obtained_vs_expected), self._represent_table(table_1, 4), self._get_name_2(is_obtained_vs_expected), self._represent_table(table_2, 4))
+                    raise TechnicalException(msg) from exc
+                
+                if not res:
+                    if raise_exception:
+                        raise TechnicalException("This case should have already raised an exception")
+                    else:
+                        if Tools.do_log(logger, logging.DEBUG):
+                            logger.debug("Difference exists at line of index {}:\n  table {}:\n{}\n  table {}:\n{}".format(
+                                       i, self._get_name_1(is_obtained_vs_expected), self._represent_table(table_1, 4), self._get_name_2(is_obtained_vs_expected), self._represent_table(table_2, 4)))
+                        break
+                    
+            return res
+        except (FunctionalException, TechnicalException) as exc:
+            raise exc
+        except Exception as exc:
+            msg = "Error while comparing tables:\n{}\n  table {}:\n{}\n  table {}:\n{}".format(
+                    Tools.indent_string(4, Exceptions.exception_message(exc)), 
+                    self._get_name_1(is_obtained_vs_expected), self._represent_table(table_1, 4), 
+                    self._get_name_2(is_obtained_vs_expected), self._represent_table(table_2, 4))
+            raise TechnicalException(msg) from exc
+    
+    def contains_rows(self, table_1, table_2, check_row_order = True, is_obtained_vs_expected = True, raise_exception = True):
+        try:
+            res = True
+            
+            # Compare rows content
+            start_index = 0
+            for i in range(table_2.nb_rows):
+                try:
+                    res, row_index = self.contains_row(table_1, table_2.get_row(i), start_row_index = start_index,
+                                                       is_obtained_vs_expected=is_obtained_vs_expected, raise_exception=raise_exception)
+                    if check_row_order:
+                        start_index = row_index + 1
+                except FunctionalException as exc:
+                    msg = "Table {} doesn't contain row {} of index {}:\n----------------------------------\n -> {}\n----------------------------------\n  table {}:\n{}\n  table {}:\n{}".format(
+                            self._get_name_1(is_obtained_vs_expected), self._get_name_2(is_obtained_vs_expected), i, Exceptions.exception_message(exc), self._get_name_1(is_obtained_vs_expected), self._represent_table(table_1, 4), self._get_name_2(is_obtained_vs_expected), self._represent_table(table_2, 4))
+                    raise VerifyException(msg) from exc
+                except Exception as exc:
+                    msg = "Error while checking if table {} contains row {} of index {}:\n----------------------------------\n -> {}\n----------------------------------\n  table {}:\n{}\n  table {}:\n{}".format(
+                            self._get_name_1(is_obtained_vs_expected), self._get_name_2(is_obtained_vs_expected), i, Exceptions.exception_message(exc), self._get_name_1(is_obtained_vs_expected), self._represent_table(table_1, 4), self._get_name_2(is_obtained_vs_expected), self._represent_table(table_2, 4))
+                    raise TechnicalException(msg) from exc
+                
+                if not res:
+                    break
+                    
+            return res
+        except (FunctionalException, TechnicalException) as exc:
+            raise exc
+        except Exception as exc:
+            msg = "Error while checking if table {} contains rows of table {}:\n{}\n  table {}:\n{}\n  table {}:\n{}".format(
+                    self._get_name_1(is_obtained_vs_expected), self._get_name_2(is_obtained_vs_expected), 
+                    Tools.indent_string(4, Exceptions.exception_message(exc)), 
+                    self._get_name_1(is_obtained_vs_expected), self._represent_table(table_1, 4), 
+                    self._get_name_2(is_obtained_vs_expected), self._represent_table(table_2, 4))
+            raise TechnicalException(msg) from exc
+    
+    def doesnt_contain_rows(self, table_1, table_2, is_obtained_vs_expected = True, raise_exception = True):
+        try:
+            res = True
+            
+            # Compare rows content
+            for i in range(table_2.nb_rows):
+                try:
+                    row_res, _ = self.contains_row(table_1, table_2.get_row(i),
+                                                       is_obtained_vs_expected=is_obtained_vs_expected, raise_exception=False)
+                except Exception as exc:
+                    msg = "Error while checking if table {} contains row {} of index {}:\n----------------------------------\n -> {}\n----------------------------------\n  table {}:\n{}\n  table {}:\n{}".format(
+                            self._get_name_1(is_obtained_vs_expected), self._get_name_2(is_obtained_vs_expected), i, Exceptions.exception_message(exc), self._get_name_1(is_obtained_vs_expected), self._represent_table(table_1, 4), self._get_name_2(is_obtained_vs_expected), self._represent_table(table_2, 4))
+                    raise TechnicalException(msg) from exc
+                
+                if row_res:
+                    if raise_exception:
+                        msg = "Table {} contains row {} of index {}:\n  table {}:\n{}\n  table {}:\n{}".format(
+                                self._get_name_1(is_obtained_vs_expected), self._get_name_2(is_obtained_vs_expected), i, self._get_name_1(is_obtained_vs_expected), self._represent_table(table_1, 4), self._get_name_2(is_obtained_vs_expected), self._represent_table(table_2, 4))
+                        raise VerifyException(msg)
+                    else:
+                        res = False
+                        break
+                
+            return res
+        except (FunctionalException, TechnicalException) as exc:
+            raise exc
+        except Exception as exc:
+            msg = "Error while checking if table {} contains rows of table {}:\n{}\n  table {}:\n{}\n  table {}:\n{}".format(
+                    self._get_name_1(is_obtained_vs_expected), self._get_name_2(is_obtained_vs_expected), 
+                    Tools.indent_string(4, Exceptions.exception_message(exc)), 
+                    self._get_name_1(is_obtained_vs_expected), self._represent_table(table_1, 4), 
+                    self._get_name_2(is_obtained_vs_expected), self._represent_table(table_2, 4))
+            raise TechnicalException(msg) from exc
+    
+    def contains_row(self, table_1, row_2, start_row_index = 0, is_obtained_vs_expected = True, raise_exception = True):
+        try:
+            res = True
+            res_index = -1
+            
+            # Compare rows content
+            for i in range(start_row_index, table_1.nb_rows):
+                try:
+                    res = self.__row_comparator.equals(table_1.get_row(i),
+                                                       row_2,
+                                                       is_obtained_vs_expected=is_obtained_vs_expected,
+                                                       raise_exception=False)
+                except Exception as exc:
+                    msg = "Error while comparing line of index {}:\n----------------------------------\n -> {}\n----------------------------------\n  table {}:\n{}\n  table {}:\n{}".format(
+                            i, Exceptions.exception_message(exc), self._get_name_1(is_obtained_vs_expected), self._represent_table(table_1, 4), self._get_name_2(is_obtained_vs_expected), self._represent_row(row_2, 4))
+                    raise TechnicalException(msg) from exc
+                
+                if res:
+                    res_index = i
+                    break
+                
+            if not res and raise_exception:
+                msg = "Table doesn't contain the row:\n  table {}:\n{}\n  row {}:\n{}".format(
+                               self._get_name_1(is_obtained_vs_expected), self._represent_table(table_1, 4), self._get_name_2(is_obtained_vs_expected), self._represent_row(row_2, 4))
+                raise VerifyException(msg)
+                    
+            return (res, res_index)
+        except (FunctionalException, TechnicalException) as exc:
+            raise exc
+        except Exception as exc:
+            msg = "Error while searching row in table:\n{}\n  table {}:\n{}\n  row {}:\n{}".format(
+                    Tools.indent_string(4, Exceptions.exception_message(exc)), 
+                    self._get_name_1(is_obtained_vs_expected), self._represent_table(table_1, 4), 
+                    self._get_name_2(is_obtained_vs_expected), self._represent_row(row_2, 4))
+            raise TechnicalException(msg) from exc
+    
+    def _represent_table(self, table, indent):
+        try:
+            return table.represent(indent)
+        except Exception as exc:
+            return f"[ERROR while representing table: {Exceptions.exception_message(exc)}]"
+    
+    def _represent_row(self, row, indent):
+        try:
+            return row.represent(indent)
+        except Exception as exc:
+            return f"[ERROR while representing table row: {Exceptions.exception_message(exc)}]"

holado_core/common/tables/comparators/table_comparator_manager.py

@@ -0,0 +1,60 @@
+
+#################################################
+# 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 builtins import object
+from holado_core.common.tables.comparators.string_table_cell_comparator import StringTableCellComparator
+import re
+from holado_core.common.exceptions.functional_exception import FunctionalException
+from holado_core.common.tables.comparators.integer_table_cell_comparator import IntegerTableCellComparator
+from holado_core.common.tables.comparators.float_table_cell_comparator import FloatTableCellComparator
+from holado_core.common.tables.comparators.bytes_table_cell_comparator import BytesTableCellComparator
+from holado_core.common.tables.comparators.datetime_table_cell_comparator import DatetimeTableCellComparator
+from holado_core.common.tables.comparators.boolean_table_cell_comparator import BooleanTableCellComparator
+from holado_core.common.tools.converters.converter import Converter
+from holado_core.common.tools.tools import Tools
+
+logger = logging.getLogger(__name__)
+
+
+class TableComparatorManager(object):
+    
+    @classmethod
+    def convert_compare_method_2_TableCellComparator(cls, compare_method):
+        if Tools.do_log(logger, logging.DEBUG):
+            logger.debug("Converting compare method name to associated TableCellComparator")
+
+        if compare_method == "Boolean":
+            return BooleanTableCellComparator()
+        elif compare_method == "Bytes":
+            return BytesTableCellComparator()
+        elif compare_method == "Datetime":
+            return DatetimeTableCellComparator()
+        elif compare_method.startswith("Float"):
+            regex = re.compile(r"Float\((.*)\)")
+            r_match = regex.match(compare_method)
+            if r_match:
+                precision_str = r_match.group(1)
+                if Converter.is_float(precision_str):
+                    precision = float(precision_str)
+                    return FloatTableCellComparator(diff_precision=precision, relative_precision=None)
+                else:
+                    raise FunctionalException("The parameter of compare method 'Float' is a precision that must be a float")
+            else:
+                return FloatTableCellComparator()
+        elif compare_method == "Integer":
+            return IntegerTableCellComparator()
+        elif compare_method == "String":
+            return StringTableCellComparator()
+        
+        

holado_core/common/tables/comparators/table_row_comparator.py

@@ -0,0 +1,116 @@
+
+#################################################
+# 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 range
+from builtins import super
+from holado_core.common.tools.comparators.comparator import Comparator
+from holado_core.common.tools.tools import Tools
+from holado_core.common.exceptions.verify_exception import VerifyException
+from holado_core.common.exceptions.technical_exception import TechnicalException
+from holado_core.common.exceptions.functional_exception import FunctionalException
+import logging
+from holado_core.common.exceptions.exceptions import Exceptions
+
+logger = logging.getLogger(__name__)
+
+
+class TableRowComparator(Comparator):
+    def __init__(self, cell_comparator=None, cells_comparators=None):
+        """
+        Define the method used to compare cells.
+        Implementation tests first if cells_comparators is defined, else it uses cell_comparator 
+        """
+        super().__init__("table row")
+        
+        self.__cell_comparator = cell_comparator
+        self.__cells_comparators = cells_comparators
+        if self.__cell_comparator is None and self.__cells_comparators is None:
+            raise TechnicalException("No cell comparator is defined")
+        
+    def equals(self, row_1, row_2, is_obtained_vs_expected = True, raise_exception = True):
+        try:
+            res = True
+            
+            # Verify number of cells
+            if row_1.nb_cells != row_2.nb_cells:
+                if raise_exception:
+                    raise VerifyException("Rows have not same number of cells (row {name1}: {nb1} cells ; row {name2}: {nb2} cells):\n  row {name1}:\n{repr1}\n  row {name2}:\n{repr2})".format(
+                                                   name1=self._get_name_1(is_obtained_vs_expected), nb1=row_1.nb_cells, repr1=row_1.represent(0), 
+                                                   name2=self._get_name_2(is_obtained_vs_expected), nb2=row_2.nb_cells, repr2=row_2.represent(0)))
+                else:
+                    return False
+            if self.__cells_comparators is not None and row_1.nb_cells > len(self.__cells_comparators):
+                raise TechnicalException("Rows have more cells than defined in list of cells comparators")
+                
+                
+            # Compare cells content
+            for i in range(row_1.nb_cells):
+                # Define cell comparator to use
+                if self.__cells_comparators is not None:
+                    cell_comp = self.__cells_comparators[i]
+                else:
+                    cell_comp = self.__cell_comparator
+                
+                # Manage case where the cell comparator is None, meaning the cells mustn't be compared
+                if cell_comp is None:
+                    continue
+                
+                # Compare cells
+                try:
+                    res = cell_comp.equals(row_1.get_cell(i),
+                                           row_2.get_cell(i),
+                                           is_obtained_vs_expected = is_obtained_vs_expected,
+                                           raise_exception = raise_exception)
+                except FunctionalException as exc:
+                    msg = "Difference exists in row at cells of index {}:\n{}\n  row {}: {}\n  row {}: {}\n  cell comparator: {}".format(
+                            i, Tools.indent_string(4, Exceptions.exception_message(exc)), 
+                            self._get_name_1(is_obtained_vs_expected), self.__represent_row(row_1), 
+                            self._get_name_2(is_obtained_vs_expected), self.__represent_row(row_2),
+                            cell_comp)
+                    raise VerifyException(msg) from exc
+                except Exception as exc:
+                    msg = "Error while comparing cells of index {}:\n{}\n  row {}: {}\n  row {}: {}\n  cell comparator: {}".format(
+                            i, Tools.indent_string(4, Exceptions.exception_message(exc)), 
+                            self._get_name_1(is_obtained_vs_expected), self.__represent_row(row_1), 
+                            self._get_name_2(is_obtained_vs_expected), self.__represent_row(row_2),
+                            cell_comp)
+                    raise TechnicalException(msg) from exc
+                
+                if not res:
+                    if raise_exception:
+                        raise TechnicalException("This case should have already raised an exception")
+                    else:
+                        if Tools.do_log(logger, logging.DEBUG):
+                            logger.debug("Difference exists in row at cells of index {}:\n  row {}:\n{}\n  row {}:\n{}".format(
+                                         i, self._get_name_1(is_obtained_vs_expected), self.__represent_row(row_1, 4), self._get_name_2(is_obtained_vs_expected), self.__represent_row(row_2, 4)))
+                        break
+                    
+            return res
+        except (FunctionalException, TechnicalException) as exc:
+            raise exc
+        except Exception as exc:
+            msg = "Error while comparing rows:\n{}\n  row {}: {}\n  row {}: {}".format(
+                    Tools.indent_string(4, Exceptions.exception_message(exc)), 
+                    self._get_name_1(is_obtained_vs_expected), self.__represent_row(row_1), 
+                    self._get_name_2(is_obtained_vs_expected), self.__represent_row(row_2))
+            raise TechnicalException(msg) from exc
+    
+    def __represent_row(self, row, indent=0):
+        try:
+            return row.represent(indent)
+        except Exception as exc:
+            return f"[ERROR while representing row: {Exceptions.exception_message(exc)}]"
+        
+

holado_core/common/tables/comparators/table_with_header_comparator.py

@@ -0,0 +1,68 @@
+
+#################################################
+# 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.exceptions.verify_exception import VerifyException
+from holado_core.common.exceptions.technical_exception import TechnicalException
+from holado_core.common.exceptions.functional_exception import FunctionalException
+import logging
+from holado_core.common.tables.comparators.string_table_row_comparator import StringTableRowComparator
+from holado_core.common.exceptions.exceptions import Exceptions
+from holado_core.common.tools.tools import Tools
+from holado_core.common.tables.comparators.table_comparator import TableComparator
+
+logger = logging.getLogger(__name__)
+
+
+class TableWithHeaderComparator(TableComparator):
+    def __init__(self, header_comparator=None, row_comparator=None, cell_comparator=None):
+        super().__init__(row_comparator=row_comparator, cell_comparator=cell_comparator)
+        
+        self.__header_comparator = header_comparator if header_comparator is not None else StringTableRowComparator()
+
+    @property
+    def header_comparator(self):
+        return self.__header_comparator
+        
+    def equals(self, table_1, table_2, is_obtained_vs_expected = True, raise_exception = True):
+        return (self.equals_headers(table_1, table_2, is_obtained_vs_expected=is_obtained_vs_expected, raise_exception=raise_exception)
+                and super().equals(table_1, table_2, is_obtained_vs_expected=is_obtained_vs_expected, raise_exception=raise_exception))
+    
+    def contains_rows(self, table_1, table_2, check_row_order = True, is_obtained_vs_expected = True, raise_exception = True):
+        return (self.equals_headers(table_1, table_2, is_obtained_vs_expected=is_obtained_vs_expected, raise_exception=raise_exception)
+                and super().contains_rows(table_1, table_2, check_row_order=check_row_order, is_obtained_vs_expected=is_obtained_vs_expected, raise_exception=raise_exception))
+
+    def doesnt_contain_rows(self, table_1, table_2, is_obtained_vs_expected = True, raise_exception = True):
+        return (self.equals_headers(table_1, table_2, is_obtained_vs_expected=is_obtained_vs_expected, raise_exception=raise_exception)
+                and super().doesnt_contain_rows(table_1, table_2, is_obtained_vs_expected=is_obtained_vs_expected, raise_exception=raise_exception))
+
+    def equals_headers(self, table_1, table_2, is_obtained_vs_expected = True, raise_exception = True):
+        try:
+            return self.__header_comparator.equals(table_1.header, table_2.header, is_obtained_vs_expected=is_obtained_vs_expected, raise_exception=raise_exception);
+        except FunctionalException as exc:
+            msg = f"Table headers are not the same:\n -> {Exceptions.exception_message(exc)}"
+            if raise_exception:
+                raise VerifyException(msg) from exc
+            else:
+                if Tools.do_log(logger, logging.DEBUG):
+                    logger.debug(msg)
+                return False
+        except Exception as exc:
+            msg = "Error while comparing tables headers:\n{}\n  table {} header: {}\n  table {} header: {}".format(
+                    Tools.indent_string(4, Exceptions.exception_message(exc)), 
+                    self._get_name_1(is_obtained_vs_expected), self._represent_row(table_1.header, 0), 
+                    self._get_name_2(is_obtained_vs_expected), self._represent_row(table_2.header, 0))
+            raise TechnicalException(msg) from exc
+