holado 0.13.22__py3-none-any.whl

holado_value/common/tables/comparators/table_2_value_table_row_comparator.py

@@ -0,0 +1,27 @@
+
+#################################################
+# 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_row_comparator import TableRowComparator
+from holado_value.common.tables.comparators.table_2_value_table_cell_comparator import Table2ValueTable_CellComparator
+
+
+class Table2ValueTable_RowComparator(TableRowComparator):
+    def __init__(self, cell_comparator=None , **kwargs):
+        if cell_comparator is None:
+            cell_comparator = Table2ValueTable_CellComparator(**kwargs)
+        super().__init__(cell_comparator=cell_comparator)
+    
+    

holado_value/common/tables/comparators/table_2_value_table_with_header_comparator.py

@@ -0,0 +1,27 @@
+
+#################################################
+# 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_value.common.tables.comparators.table_2_value_table_row_comparator import Table2ValueTable_RowComparator
+from holado_core.common.tables.comparators.table_with_header_comparator import TableWithHeaderComparator
+
+
+class Table2ValueTable_WithHeaderComparator(TableWithHeaderComparator):
+    def __init__(self, header_comparator=None, row_comparator=None, cell_comparator=None , **kwargs):
+        if row_comparator is None:
+            row_comparator = Table2ValueTable_RowComparator(cell_comparator=cell_comparator, **kwargs)
+        super().__init__(header_comparator=header_comparator, row_comparator=row_comparator, cell_comparator=None)
+    
+    

holado_value/common/tables/converters/value_table_converter.py

@@ -0,0 +1,267 @@
+
+#################################################
+# 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_value.common.tables.value_table import ValueTable
+from holado_value.common.tables.value_table_with_header import ValueTableWithHeader
+from holado_core.common.tables.table_row import TableRow
+from holado_core.common.tables.converters.table_converter import TableConverter
+from holado_core.common.tables.table_with_header import TableWithHeader
+from holado_core.common.tables.table import Table
+import copy
+import logging
+from holado_value.common.tables.value_table_manager import ValueTableManager
+from holado_core.common.exceptions.functional_exception import FunctionalException
+from holado_value.common.tools.value_types import ValueTypes
+from holado_core.common.tools.tools import Tools
+from holado_json.ipc.json_converter import JsonConverter
+from holado_python.standard_library.typing import Typing
+from holado_data.data.generator.base import BaseGenerator
+
+logger = logging.getLogger(__name__)
+
+
+class ValueTableConverter(TableConverter):
+    
+    @classmethod
+    def convert_table_2_value_table(cls, table, do_eval_once=True):
+        if isinstance(table, TableWithHeader):
+            res = ValueTableWithHeader()
+            res.header = copy.copy(table.header)
+        else:
+            res = ValueTable()
+        for row in table:
+            cells_content = [f"'{cc}'" if isinstance(cc, str) else f"{cc}" for cc in row.cells_content]
+            res.add_row(cells_content=cells_content, do_eval_once=do_eval_once)
+        return res
+    
+    @classmethod
+    def convert_value_table_2_table(cls, table):
+        ValueTableManager.verify_is_value_table(table)
+        
+        if isinstance(table, ValueTableWithHeader):
+            res = TableWithHeader()
+            res.header = copy.copy(table.header)
+        else:
+            res = Table()
+        for row in table:
+            cells_content = row.cells_value
+            res.add_row(cells_content=cells_content)
+        return res
+    
+    @classmethod
+    def convert_table_with_header_to_dict_list(cls, table, as_generator=False):
+        if not ValueTableManager.is_value_table(table):
+            return TableConverter.convert_table_with_header_to_dict_list(table, as_generator=as_generator)
+        
+        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).value 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).value 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 not ValueTableManager.is_value_table(table):
+            return TableConverter.convert_table_2_list_of_tuples(table, as_generator=as_generator)
+        
+        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.value 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_name_value_table_2_dict(cls, table, with_original_value_content = False):
+        if not ValueTableManager.is_value_table(table):
+            return TableConverter.convert_name_value_table_2_dict(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
+            ValueTableManager.verify_table_is_name_value_table(table)
+            ValueTableManager.verify_is_value_table(table)
+            
+            for row in table.rows:
+                if row.get_cell(1).value_type not in [ValueTypes.NotApplicable]:
+                    if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+                        logger.trace("Converting row (%s)", row)
+                    
+                    name = row.get_cell(0).value
+                    if with_original_value_content:
+                        value = row.get_cell(1).content
+                    else:
+                        value = row.get_cell(1).value
+                    
+                    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_list_and_dict(cls, table, with_original_value_content = False):
+        # if not ValueTableManager.is_value_table(table):
+        #     return TableConverter.convert_name_value_table_2_list_and_dict(table)
+        
+        if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+            logger.trace(f"Converting Name/Value table to list and dict (table = {table})")
+
+        # Verify table structure
+        ValueTableManager.verify_table_is_name_value_table(table)
+        ValueTableManager.verify_is_value_table(table)
+        
+        res_list = []
+        res_dict = {}
+        for row in table.rows:
+            if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+                logger.trace("Converting row (%s)", row)
+            
+            name = row.get_cell(0).value
+            if with_original_value_content:
+                value = row.get_cell(1).content
+            else:
+                value = row.get_cell(1).value
+            
+            if name and len(name) > 0:
+                if name in res_dict:
+                    raise FunctionalException("Name '{}' appears several times in table".format(name))
+                else:
+                    res_dict[name] = value
+            else:
+                res_list.append(value)
+                
+        if Tools.do_log(logger, logging.DEBUG):
+            logger.debug(f"Converting Name/Value table to list and dict (table = {table}) => {res_list} ; {res_dict}")
+        return [res_list, res_dict]
+ 
+    @classmethod
+    def convert_name_value_table_2_json_object(cls, table, converter=None):
+        if not ValueTableManager.is_value_table(table):
+            return TableConverter.convert_name_value_table_2_json_object(table, converter=converter)
+        
+        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
+        ValueTableManager.verify_table_is_name_value_table(table)
+        ValueTableManager.verify_is_value_table(table)
+        
+        res = {}
+        for row in table.rows:
+            if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+                logger.trace("Converting row (%s)", row)
+            
+            if row.get_cell(1).value_type in [ValueTypes.NotApplicable, ValueTypes.Merged]:
+                pass
+            elif ValueTypes.is_string(row.get_cell(1).value_type):
+                name = row.get_cell(0).value
+                value = row.get_cell(1).value
+                
+                if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+                
+                    logger.trace(f"Adding for name '{name}' string value [{value}] (type: {Typing.get_object_class_fullname(value)})")
+                cls._fill_json_dict(res, name, value)
+            else:
+                name = row.get_cell(0).value
+                value = row.get_cell(1).value
+                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 convert_x_name_value_table_2_list_x_values(cls, table, x_name, with_original_value_content = False):
+        # if not ValueTableManager.is_value_table(table):
+        #     return TableConverter.convert_x_name_value_table_2_list_x_values(table, x_name)
+        
+        if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+            logger.trace(f"Converting {x_name}/Name/Value table to list of {x_name} and values dict (table = {table})")
+
+        # Verify table structure
+        ValueTableManager.verify_table_is_x_name_value_table(table, x_name)
+        
+        x_list = []
+        res_dict = {}
+        for row in table.rows:
+            if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+                logger.trace("Converting row (%s)", row)
+
+            x = row.get_cell(0).value
+            name = row.get_cell(1).value
+            if with_original_value_content:
+                value = row.get_cell(2).content
+            else:
+                value = row.get_cell(2).value
+            
+            if x not in res_dict:
+                res_dict[x] = {}
+                x_list.append(x)
+            res_dict[x][name] = value
+                
+        res = [{x_name:x, 'values':res_dict[x]} for x in x_list]
+        
+        if Tools.do_log(logger, logging.DEBUG):
+            logger.debug(f"Converting {x_name}/Name/Value table to list of {x_name} and values dict (table = {table}) => {res}")
+        return res
+        
+    
+    
+        

holado_value/common/tables/value_table.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
+from holado_core.common.tables.table import Table
+from holado_value.common.tables.value_table_row import ValueTableRow
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class ValueTable(Table):
+    def __init__(self):
+        super().__init__()
+        
+    def _new_row(self, cells=None, cells_content=None, cells_value=None, **kwargs):  # @UnusedVariable
+        return ValueTableRow(cells=cells, cells_content=cells_content, cells_value=cells_value, **kwargs)
+    
+    

holado_value/common/tables/value_table_cell.py

@@ -0,0 +1,76 @@
+
+#################################################
+# 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
+import logging
+from holado_value.common.tools.value import Value
+
+logger = logging.getLogger(__name__)
+
+
+class ValueTableCell(TableCell):
+    
+    def __init__(self, cell_content, cell_value=None, do_eval_once=True):
+        """
+        @summary: Constructor
+        @param cell_content: Cell content
+        @param cell_value: Cell value
+        @param do_eval_once: If cell value must be evaluated only at first value evaluation (ie at first call of value property) (default: True)
+        """
+        super().__init__(cell_content)
+        
+        self.__value = Value(original_value=cell_content, value=cell_value, do_eval_once=do_eval_once)
+        self.content = self.__value.original_value
+        
+    def __eq__(self, other):
+        self._verify_valid_compared_object(other)
+        if isinstance(other, ValueTableCell):
+            return (self.value == other.value)
+        else:
+            return (self.value == other.content)
+    
+    def __lt__(self, other):
+        self._verify_valid_compared_object(other)
+        if isinstance(other, ValueTableCell):
+            return (self.value < other.value)
+        else:
+            return (self.value < other.content)
+
+    @TableCell.string_content.getter  # @UndefinedVariable
+    def string_content(self):
+        return self.__value.string_value
+    
+    @property
+    def content_type(self):
+        return self.__value.original_value_type
+    
+    @property
+    def value_type(self):
+        return self.__value.value_type
+    
+    @property
+    def value(self):
+        return self.__value.value
+    
+    @value.setter
+    def value(self, value):
+        self.__value = Value(original_value=None, value=value, do_eval_once=self.__value.do_eval_once)
+        self.content = self.__value.original_value
+    
+    def get_value(self, raise_if_undefined=False):
+        return self.__value.get_value(raise_if_undefined=raise_if_undefined)
+    
+    def represent(self, indent = 0, do_evaluation = False):
+        return self.__value.represent(indent, do_evaluation)
+        

holado_value/common/tables/value_table_manager.py

@@ -0,0 +1,48 @@
+
+#################################################
+# HolAdo (Holistic Automation do)
+#
+# (C) Copyright 2021-2025 by Eric Klumpp
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+# The Software is provided “as is”, without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the software or the use or other dealings in the Software.
+#################################################
+
+import logging
+from holado_value.common.tables.value_table_with_header import ValueTableWithHeader
+from holado_core.common.tables.table_manager import TableManager
+from holado_core.common.tools.tools import Tools
+from holado_value.common.tables.value_table import ValueTable
+from holado_core.common.exceptions.verify_exception import VerifyException
+
+logger = logging.getLogger(__name__)
+
+
+class ValueTableManager(TableManager):
+    
+    @classmethod
+    def is_value_table(cls, table):
+        return isinstance(table, ValueTable) or isinstance(table, ValueTableWithHeader)
+    
+    @classmethod
+    def verify_is_value_table(cls, table, raise_exception=True):
+        res = cls.is_value_table(table)
+        
+        if not res and raise_exception:
+            raise VerifyException(f"Table is not a ValueTable of ValueTableWithHeader (table type: {type(table)})")
+        return res
+    
+    @classmethod
+    def set_object_attributes_according_name_value_table(cls, obj, table):
+        if not cls.is_value_table(table):
+            super().set_object_attributes_according_name_value_table(obj, table)
+        
+        # Verify table structure
+        cls.verify_table_is_name_value_table(table)
+        
+        for row in table.rows:
+            setattr(obj, row.get_cell(0).value, row.get_cell(1).value)
+    

holado_value/common/tables/value_table_row.py

@@ -0,0 +1,43 @@
+
+#################################################
+# 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_value.common.tables.value_table_cell import ValueTableCell
+from holado_core.common.tables.table_row import TableRow
+import logging
+from holado_core.common.tools.tools import Tools
+from holado.common.handlers.undefined import undefined_value
+
+logger = logging.getLogger(__name__)
+
+
+class ValueTableRow(TableRow):
+    def __init__(self, cells=None, cells_content=None, cells_value=None, **kwargs):
+        super().__init__(cells=cells, cells_content=cells_content, **kwargs)
+        if cells_value is not None:
+            self.add_cells_from_values(cells_value, **kwargs)
+    
+    @property
+    def cells_value(self): 
+        return tuple(c.value for c in self.cells)
+
+    def _new_cell(self, content, value=undefined_value, do_eval_once=True, **kwargs):  # @UnusedVariable
+        return ValueTableCell(cell_content=content, cell_value=value, do_eval_once=do_eval_once)
+    
+    def add_cells_from_values(self, cells_value, do_eval_once=True, **kwargs):
+        if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+            logger.trace(f"add_cells_from_values({cells_value=})")
+        for cell_value in cells_value:
+            self.add_cell(value=cell_value, do_eval_once=do_eval_once, **kwargs)
+    
+    

holado_value/common/tables/value_table_with_header.py

@@ -0,0 +1,28 @@
+
+#################################################
+# 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_with_header import TableWithHeader
+from holado_value.common.tables.value_table_row import ValueTableRow
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class ValueTableWithHeader(TableWithHeader):
+    def __init__(self):
+        super().__init__()
+        
+    def _new_row(self, cells=None, cells_content=None, cells_value=None, **kwargs):  # @UnusedVariable
+        return ValueTableRow(cells=cells, cells_content=cells_content, cells_value=cells_value, **kwargs)
+    

holado_value/common/tools/unique_value_manager.py

@@ -0,0 +1,109 @@
+
+#################################################
+# 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 int
+import logging
+from datetime import datetime
+import string
+from holado_core.common.exceptions.technical_exception import TechnicalException
+from holado_core.common.tools.tools import Tools
+from holado_python.common.tools.datetime import DateTime
+
+logger = logging.getLogger(__name__)
+
+
+
+class UniqueValueManager(object):
+    """
+    @summary: Unique value manager.
+    An internal counter is used to generate a unique integer at any moment.
+    At first use, this counter is initialized with the number of seconds since 01/01/2020, to ensure a minimal uniqueness between sessions.
+    
+    This manager can generate unique integers and unique strings.
+    For strings, a unique integer is encoded in a base in range [2, 62] (default: 62).
+    """
+    
+    def __init__(self, padding_character='0'):
+        self.__last_unique_int = None
+        self.__padding_character = padding_character
+        
+        self.__digs = string.digits + string.ascii_uppercase + string.ascii_lowercase
+        
+    def new_integer(self, do_log=True):
+        if self.__last_unique_int is None:
+            # Compute timestamp as number of seconds since 01/01/2016
+            self.__last_unique_int = int((DateTime.now(tz=None) - datetime(2020, 1, 1)).total_seconds()) - 1
+            
+        self.__last_unique_int += 1
+        res = self.__last_unique_int
+        
+        if do_log:
+            if Tools.do_log(logger, logging.DEBUG):
+                logger.debug(f"New unique integer: {res}")
+        return res
+    
+    def new_hex(self, length=None, truncate_to_length=True, do_log=True):
+        res = self.new_string(base=16, padding_length=length, padding_character="0", raise_if_padding_impossible=not truncate_to_length, do_log=False)
+        res = res.upper()
+        if length is not None and len(res) > length:
+            if truncate_to_length:
+                res = res[-length:]
+            else:
+                raise TechnicalException(f"Unique HEX integer ({res}) has length {len(res)} that exceeds expected length {length}")
+        
+        if do_log:
+            if Tools.do_log(logger, logging.DEBUG):
+                logger.debug(f"New unique HEX integer: {res}")
+        return res
+    
+    def new_string(self, base=62, padding_length=None, padding_character=None, raise_if_padding_impossible=True, do_log=True):
+        if base < 2 or base > 62:
+            raise TechnicalException("Base must be in range [2, 62]")
+        value = self.new_integer(do_log=False)
+        res = self.__encode_int_until_base62(value, base)
+        
+        if padding_length:
+            if len(res) > padding_length and raise_if_padding_impossible:
+                raise TechnicalException(f"Unique string before padding has length {len(res)}, it is not possible to apply a padding length of {padding_length}")
+            if len(res) < padding_length:
+                if padding_character is None and self.__padding_character is None:
+                    raise TechnicalException(f"In order to manage padding, the padding character must be given as parameter to UniqueValueManager.new_string or constructor of UniqueValueManager")
+                pc = padding_character if padding_character is not None else self.__padding_character
+                res = res.rjust(padding_length, pc)
+            
+        if do_log:
+            if Tools.do_log(logger, logging.DEBUG):
+                logger.debug(f"New unique string: [{res}]")
+        return res
+    
+    def __encode(self, int_value, base):
+        # Encode given integer in 36 base
+        return self.__encode_int_until_base62(int_value, base)
+    
+    def __encode_int_until_base62(self, x, base):
+        if x < 0: 
+            sign = -1
+        elif x == 0: 
+            return self.__digs[0]
+        else: 
+            sign = 1
+        x *= sign
+        digits = []
+        while x:
+            x, ind_digits = divmod(x, base)
+            digits.append(self.__digs[ind_digits])
+        if sign < 0:
+            digits.append('-')
+        digits.reverse()
+        return ''.join(digits)
+