holado 0.13.22__py3-none-any.whl

holado_core/common/tables/converters/table_converter.py

@@ -0,0 +1,233 @@
+#################################################
+# 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
+from holado_data.data.generator.base import BaseGenerator
+
+
+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, as_generator=False)
+        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, as_generator=False):
+        if as_generator:
+            class TableWithHeader2DictGenerator(BaseGenerator):
+                def __init__(self, table):
+                    super().__init__(name="table with header to dict generator")
+                    self.__table = table
+                    self.__index_by_name = table.get_column_indexes_by_string_content()
+                    self.__table_rows_iter = iter(self.__table.rows)
+                
+                def __next__(self):
+                    row = next(self.__table_rows_iter)
+                    return {name: row.get_cell(index).content for name, index in self.__index_by_name.items()}
+            
+            return TableWithHeader2DictGenerator(table)
+        else:
+            # 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
+            gen = cls.convert_table_with_header_to_dict_list(table, as_generator=True)
+            return [e for e in gen]
+    
+    @classmethod
+    def convert_table_2_list_of_tuples(cls, table, as_generator=False):
+        if Tools.do_log(logger, logging.DEBUG):
+            logger.debug("Converting table to a list of tuples...")
+        if as_generator:
+            class Table2TupleGenerator(BaseGenerator):
+                def __init__(self, table):
+                    super().__init__(name="table with header to dict generator")
+                    self.__table = table
+                    self.__table_rows_iter = iter(self.__table.rows)
+                
+                def __next__(self):
+                    row = next(self.__table_rows_iter)
+                    return tuple((cell.content for cell in row.cells))
+            
+            return Table2TupleGenerator(table)
+        else:
+            # return [tuple((cell.content for cell in row.cells)) for row in table.rows]
+            gen = cls.convert_table_2_list_of_tuples(table, as_generator=True)
+            return [e for e in gen]
+    
+    @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})")
+
+        res = {}
+        if table is not None:
+            # Verify table structure
+            TableManager.verify_table_is_name_value_table(table)
+            
+            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)
+            
+        
+    

holado_core/common/tables/enums.py

@@ -0,0 +1,23 @@
+#################################################
+# 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.common.handlers.enums import AutoNumber
+
+
+class MergeTypes(AutoNumber):
+    """
+    Types of cell merge.
+    """
+    
+    LeftMerged = ()
+    TopMerged = ()
+    

holado_core/common/tables/table.py

@@ -0,0 +1,261 @@
+
+#################################################
+# 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_row import TableRow
+import copy
+from holado_core.common.exceptions.technical_exception import TechnicalException
+import logging
+from holado_core.common.exceptions.functional_exception import FunctionalException
+from holado_core.common.tools.tools import Tools
+from holado_python.standard_library.typing import Typing
+from holado_python.common.iterables import is_sorted
+
+logger = logging.getLogger(__name__)
+
+
+class Table(object):
+    def __init__(self):
+        super().__init__()
+        
+        self.__content = None
+        self.__parent = None
+        
+        self.__rows = []
+        
+    def __iter__(self):
+        return self.__rows.__iter__()
+
+    def __next__(self):
+        return self.__rows.__next__()
+    
+    def __getitem__(self, key):
+        if isinstance(key, int):
+            return self.__rows[key]
+        else:
+            raise TechnicalException(f"Unmanaged key: {key} (type: {Typing.get_object_class_fullname(key)})")
+    
+    def __copy__(self):
+        cls = self.__class__
+        res = cls()
+        
+        # Copy rows
+        for row in self.rows:
+            res.add_row(row=copy.copy(row))
+        
+        return res
+
+    def __deepcopy__(self, memo):
+        cls = self.__class__
+        result = cls.__new__(cls)
+        memo[id(self)] = result
+        for k, v in self.__dict__.items():
+            setattr(result, k, copy.deepcopy(v, memo))
+        return result
+    
+    def __repr__(self)->str:
+        if self.nb_rows < 10 or self.nb_rows * self.nb_columns < 100:
+            return f"<{self.__class__.__name__}>({self.nb_rows}x{self.nb_columns})\n{self.represent()}"
+        else:
+            return f"<{self.__class__.__name__}>({self.nb_rows}x{self.nb_columns})\n{self.represent(limit_rows=10)}[...]"
+    
+    @property
+    def content(self):
+        """ Content of whole table, relevant for some table types. """
+        return self.__content
+    
+    @content.setter
+    def content(self, content):
+        """ Set content of whole table, relevant for some table types. """
+        self.__content = content
+    
+    @property
+    def parent(self):
+        """ Parent, relevant for some table types. It's usually the origin of its creation. """
+        return self.__parent
+    
+    @parent.setter
+    def parent(self, parent):
+        """ Set parent. """
+        self.__parent = parent
+    
+    @property
+    def rows(self):
+        return self.__rows
+    
+    @property
+    def nb_columns(self):
+        if self.nb_rows > 0:
+            return len(self.rows[0])
+        else:
+            return 0
+    
+    @property
+    def nb_rows(self):
+        return len(self.__rows)
+            
+    def add_row(self, row=None, cells=None, cells_content=None, **kwargs):
+        if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+            logger.trace(f"add_row({row=}, {cells=}, {cells_content=})")
+        if row is not None:
+            self.__rows.append(row)
+            return row
+        else:
+            return self.add_row(row=self._new_row(cells=cells, cells_content=cells_content, **kwargs), **kwargs)
+        
+    def extend(self, table, copy_method=None, **kwargs):  # @UnusedVariable
+        for row in table.rows:
+            if copy_method is not None:
+                new_row = copy_method(row)
+            else:
+                new_row = row
+            self.add_row(row=new_row, **kwargs)
+        
+    def _new_row(self, cells=None, cells_content=None, **kwargs):  # @UnusedVariable
+        return TableRow(cells=cells, cells_content=cells_content)
+        
+    def get_row(self, index, **kwargs) -> TableRow :  # @UnusedVariable
+        return self.rows[index]
+    
+    def get_column(self, index, **kwargs):
+        res = self._new_row(**kwargs)
+        for row in self.rows:
+            res.add_cell(cell=row[index], **kwargs)
+        return res
+
+    def add_column(self, col=None, cells=None, cells_content=None, **kwargs):
+        if Tools.do_log(logger, logging.DEBUG):
+            logger.debug(f"add_column({col=}, {cells=}, {cells_content=})")
+        if col is not None:
+            self.add_column(cells=col.cells, **kwargs)
+        elif cells is not None:
+            if len(cells) != self.nb_rows:
+                raise TechnicalException(f"Length of cells is {len(cells)} whereas table has {self.nb_rows} rows")
+            for i, cell in enumerate(cells):
+                self.get_row(i).add_cell(cell=cell, **kwargs)
+        elif cells_content is not None:
+            if len(cells_content) != self.nb_rows:
+                raise TechnicalException(f"Length of cells is {len(cells_content)} whereas table has {self.nb_rows} rows")
+            for i, cell_content in enumerate(cells_content):
+                self.get_row(i).add_cell(content=cell_content, **kwargs)
+        else:
+            for row in self.rows:
+                row.add_cell(content=None, **kwargs)
+        
+    def remove_column(self, index=None, **kwargs):
+        if index is None:
+            raise TechnicalException("index must be specified")
+        
+        for row in self.rows:
+            row.remove_cell(index, **kwargs)
+        
+    def remove_row(self, index=None, **kwargs):  # @UnusedVariable
+        if index is None:
+            raise TechnicalException("index must be specified")
+        elif index >= self.nb_rows:
+            raise FunctionalException(f"index is out of range ({index} >= {self.nb_rows})")
+        
+        return self.rows.pop(index)
+    
+    def represent(self, indent = 0, limit_rows=-1):
+        res_list = []
+        has_limited = False
+        for row in self.rows:
+            if limit_rows >=0 and len(res_list) >= limit_rows:
+                has_limited = True
+                break
+            
+            if row is not None:
+                res_row = row.represent(indent)
+            else:
+                res_row = "{ROW_IS_NONE}"
+            res_row += "\n"
+            res_list.append(res_row)
+            
+        res = "".join(res_list)
+        if has_limited:
+            res += Tools.indent_string(indent, "[...]\n")
+        return res
+    
+    def switch_columns(self, index_1, index_2, **kwargs):
+        if index_1 == index_2:
+            raise TechnicalException(f"The two indexes are equal (index = {index_1})")
+    
+        for row in self.rows:
+            row.switch_cells(index_1, index_2, **kwargs)
+            
+    def sort(self, indexes, reverse=False, **kwargs):  # @UnusedVariable
+        """Sort table rows according to indexes order."""
+        if not indexes:
+            raise TechnicalException("At least one index must be defined")
+        self.__rows.sort(key=lambda x: tuple(x[i] for i in indexes), reverse=reverse)
+    
+    def is_sorted(self, indexes, reverse=False, **kwargs):  # @UnusedVariable
+        """Check if table rows are sorted according to indexes order."""
+        if not indexes:
+            raise TechnicalException("At least one index must be defined")
+        return is_sorted(self.__rows, key=lambda x: tuple(x[i] for i in indexes), reverse=reverse)
+
+    def order_columns(self, indexes=None, **kwargs):
+        orig_col_indexes = list(range(self.nb_columns))
+        for col_index, orig_col_ind in enumerate(indexes):
+            cur_col_ind = orig_col_indexes.index(orig_col_ind)
+            if cur_col_ind != col_index:
+                self.switch_columns(index_1=col_index, index_2=cur_col_ind, **kwargs)
+                orig_col_indexes[col_index], orig_col_indexes[cur_col_ind] = orig_col_indexes[cur_col_ind], orig_col_indexes[col_index]
+        
+    def remove_rows_verifying(self, expected_table, table_comparator, keep_rows=False, **kwargs):
+        """
+        Remove rows that are equals compared to at least one line of expected_table.
+        If keep_rows is True, keep the rows rather than remove them. 
+        """
+        n = 0
+        while n < self.nb_rows:
+            row = self.get_row(n, **kwargs)
+            
+            found = False
+            for i in range(expected_table.nb_rows):
+                found = table_comparator.row_comparator.equals(row, expected_table.get_row(i), raise_exception=False);
+                if found:
+                    break
+            
+            if found ^ keep_rows:
+                self.remove_row(n)
+            else:
+                n += 1
+            
+    def remove_rows_duplicated(self, row_comparator, **kwargs):
+        """
+        Remove rows that are duplicates of previous rows, using given row_comparator.
+        """
+        n = 1
+        while n < self.nb_rows:
+            row = self.get_row(n)
+            
+            found = False
+            for i in range(n):
+                found = row_comparator.equals(row, self.get_row(i), raise_exception=False);
+                if found:
+                    break
+            
+            if found:
+                self.remove_row(n, **kwargs)
+            else:
+                n += 1
+            
+    def is_empty(self, **kwargs):  # @UnusedVariable
+        return self.nb_rows == 0
+
+

holado_core/common/tables/table_cell.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.
+#################################################
+
+from holado_core.common.tools.tools import Tools
+import copy
+from functools import total_ordering
+from holado_core.common.exceptions.technical_exception import TechnicalException
+from holado_python.standard_library.typing import Typing
+
+
+@total_ordering
+class TableCell(object):
+    EMPTY_SYMBOL = u"None"
+    # LEFT_MERGED_SYMBOL = u"LeftMerged";
+    # TOP_MERGED_SYMBOL = u"TopMerged";
+    
+    """
+    @summary: Table cell
+    """
+    def __init__(self, cell_content = None):
+        self.__parent = None
+        
+        if cell_content is not None and isinstance(cell_content, str) and cell_content == TableCell.EMPTY_SYMBOL:
+            self.__content = None
+        else:
+            self.__content = cell_content
+    
+    @property
+    def parent(self):
+        """ Parent, relevant for some table types. It's usually the origin of its creation. """
+        return self.__parent
+    
+    @parent.setter
+    def parent(self, parent):
+        """ Set parent. """
+        self.__parent = parent
+
+    @property
+    def content(self):
+        return self.__content
+    
+    @content.setter
+    def content(self, cell_content):
+        self.__content = cell_content
+    
+    @property
+    def string_content(self):
+        if self.__content is not None:
+            return str(self.__content)
+        else:
+            return None
+    
+    def _verify_valid_compared_object(self, other, raise_exception=True):
+        res = isinstance(other, TableCell)
+        if not res and raise_exception:
+            return TechnicalException(f"Unmanaged comparison between types '{self.__class__.__name__}' and '{other.__class__.__name__}'")
+        
+    def __eq__(self, other):
+        self._verify_valid_compared_object(other)
+        return (self.content == other.content)
+    
+    def __lt__(self, other):
+        self._verify_valid_compared_object(other)
+        return (self.content < other.content)
+
+    def __copy__(self):
+        cls = self.__class__
+        result = cls.__new__(cls)
+        result.__dict__.update(self.__dict__)
+        return result
+
+    def __deepcopy__(self, memo):
+        cls = self.__class__
+        result = cls.__new__(cls)
+        memo[id(self)] = result
+        for k, v in self.__dict__.items():
+            setattr(result, k, copy.deepcopy(v, memo))
+        return result
+
+    def __eq__(self, other):
+        if not isinstance(other, TableCell):
+            return NotImplemented(f"Not implemented to compare a {Typing.get_object_class_fullname(self)} to a {Typing.get_object_class_fullname(other)}")
+        return (self.content == other.content)
+    
+    def __lt__(self, other):
+        if not isinstance(other, TableCell):
+            return NotImplemented(f"Not implemented to compare a {Typing.get_object_class_fullname(self)} to a {Typing.get_object_class_fullname(other)}")
+        return (self.content < other.content)
+    
+    def __repr__(self)->str:
+        return f"<{self.__class__.__name__}>[{self.represent()}]"
+        
+    def is_empty(self, **kwargs):  # @UnusedVariable
+        return (self.__content is None)
+        
+    def represent(self, indent = 0, cell_value_prefix = "'", cell_value_postfix = "'"):
+        res_list = []
+        
+        res_list.append(Tools.get_indent_string(indent))
+        
+        if self.is_empty():
+            res_list.append(TableCell.EMPTY_SYMBOL)
+        elif isinstance(self.__content, str):
+            if cell_value_prefix is not None:
+                res_list.append(cell_value_prefix)
+            res_list.append(self.string_content)
+            if cell_value_postfix is not None:
+                res_list.append(cell_value_postfix)
+        else:
+            res_list.append(self.string_content)
+        
+        return "".join(res_list)
+        
+    def compare_to(self, cell):
+        raise NotImplementedError()
+