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

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
+    

holado_core/common/tables/converters/table_converter.py

@@ -0,0 +1,194 @@
+#################################################
+# 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.tables.table_with_header import TableWithHeader
+from holado_core.common.tables.table_row import TableRow
+from holado_core.common.exceptions.technical_exception import TechnicalException
+from holado_core.common.tools.converters.converter import Converter
+from holado_python.standard_library.typing import Typing
+import logging
+from holado_json.ipc.json_converter import JsonConverter
+from holado_core.common.tables.table_manager import TableManager
+from holado_core.common.exceptions.functional_exception import FunctionalException
+import re
+from holado_core.common.tools.tools import Tools
+
+
+logger = logging.getLogger(__name__)
+
+
+
+class TableConverter(object):
+    
+    @classmethod
+    def convert_table_with_header_to_dict(cls, table):
+        res_list = cls.convert_table_with_header_to_dict_list(table)
+        if len(res_list) == 0:
+            return None
+        elif len(res_list) == 1:
+            return res_list[0]
+        else:
+            raise TechnicalException(f"Failed to convert table to dict, since table has more than one row.")
+    
+    @classmethod
+    def convert_table_with_header_to_dict_list(cls, table):
+        index_by_name = table.get_column_indexes_by_string_content()
+
+        res = []
+        for row in table.rows:
+            new_dict = {name: row.get_cell(index).content for name, index in index_by_name.items()}
+            res.append(new_dict)
+            
+        return res
+    
+    @classmethod
+    def convert_dict_list_to_table_with_header(cls, dict_list):
+        """
+        Builds a table with header from a list of dictionaries.
+        """
+        header = set()
+        for index, new_dict in enumerate(dict_list):
+            if not Converter.is_dict(new_dict):
+                raise TechnicalException(f"The list element of index {index} is not a dict (obtained type: {Typing.get_object_class_fullname(new_dict)})")
+            header = header.union(new_dict.keys())
+        header = sorted(header)
+
+        res = TableWithHeader()
+        res.header = TableRow(cells_content=header)
+        
+        for new_dict in dict_list:
+            res.add_row(contents_by_colname=new_dict)
+        
+        return res
+    
+    @classmethod
+    def convert_name_value_table_2_dict(cls, table):
+        if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+            logger.trace(f"Converting Name/Value table to dict (table = {table})")
+
+        # Verify table structure
+        TableManager.verify_table_is_name_value_table(table)
+        
+        res = {}
+        for row in table.rows:
+            if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+                logger.trace("Converting row (%s)", row)
+            
+            name = row.get_cell(0).content
+            value = row.get_cell(1).content
+            
+            if name in res:
+                raise FunctionalException("Name '{}' appears several times in table".format(name))
+            else:
+                res[name] = value
+                
+        if Tools.do_log(logger, logging.DEBUG):
+            logger.debug(f"Converting Name/Value table to dict (table = {table}) => {res}")
+        return res
+
+    @classmethod
+    def convert_name_value_table_2_json_object(cls, table, converter=None):
+        if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+            logger.trace(f"Converting Name/Value table to json object (table = {table})")
+        if converter is None:
+            converter = JsonConverter()
+        
+        # Verify table structure
+        TableManager.verify_table_is_name_value_table(table)
+        
+        res = {}
+        for row in table.rows:
+            if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+                logger.trace("Converting row (%s)", row)
+            
+            name = row.get_cell(0).content
+            value = row.get_cell(1).content
+            value = converter.to_json(value)
+            
+            if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+                logger.trace(f"Adding for name '{name}' json value [{value}] (type: {Typing.get_object_class_fullname(value)})")
+            cls._fill_json_dict(res, name, value)
+        
+        if Tools.do_log(logger, logging.DEBUG):
+            logger.debug(f"Converting Name/Value table to json object (table = {table}) => {res}")
+        return res
+ 
+    @classmethod
+    def extract_table_with_header_from_table(cls, table, row_first_index, row_last_index, col_first_index, col_last_index):
+        res = TableWithHeader()
+        
+        header_content = [c.content for c in table.rows[row_first_index].cells[col_first_index:col_last_index+1]]
+        res.header = TableRow(cells_content=header_content)
+        
+        for i in range(row_first_index+1, row_last_index+1):
+            row_content = [c.content for c in table.rows[i].cells[col_first_index:col_last_index+1]]
+            res.add_row(cells_content=row_content)
+        
+        return res
+        
+ 
+    @classmethod
+    def _fill_json_dict(cls, json_res, name, value):
+        if not isinstance(json_res, dict):
+            raise TechnicalException(f"Type '{Typing.get_object_class_fullname(json_res)}' is not a dict")
+        
+        names = name.split(".", maxsplit=1)
+        name0 = names[0]
+        name1 = names[1] if len(names) > 1 else None
+        
+        # manage lists
+        m = re.match(r"^([^[]+)\[(.*)\]$", name0)
+        if m:
+            li_name = m.group(1)
+            index = int(m.group(2))
+
+            if li_name not in json_res:
+                json_res[li_name] = []
+            cls._fill_json_list(json_res[li_name], index, name1, value)
+            return
+        
+        if name1 is None:
+            cls._fill_json_dict_entry(json_res, name0, value)
+        else:
+            if name0 not in json_res:
+                json_res[name0] = {}
+            cls._fill_json_dict(json_res[name0], name1, value)
+ 
+    @classmethod
+    def _fill_json_dict_entry(cls, json_res, name, value):
+        if name in json_res:
+            raise FunctionalException(f"Name '{name}' is already set")
+        else:
+            json_res[name] = value
+ 
+    @classmethod
+    def _fill_json_list(cls, json_res, index, name, value):
+        if not isinstance(json_res, list):
+            raise TechnicalException(f"Type '{Typing.get_object_class_fullname(json_res)}' is not a list")
+        
+        # Prepare list with missing elements
+        if index + 1 > len(json_res):
+            for _ in range(len(json_res), index + 1):
+                json_res.append(None)
+        
+        if name is None:
+            if json_res[index] is None:
+                json_res[index] = value
+            else:        
+                raise FunctionalException("List has already an element at index {}".format(index))
+        else:
+            if json_res[index] is None:
+                json_res[index] = {}
+            cls._fill_json_dict(json_res[index], name, value)
+            
+        
+