holado 0.2.8__py3-none-any.whl → 0.4.0__py3-none-any.whl

holado_ais/ais/ais_messages.py

@@ -22,6 +22,7 @@ from holado_binary.ipc.binary import Binary
 from holado_core.common.tools.tools import Tools
 from holado_python.standard_library.typing import Typing
 import copy
+from holado_core.common.exceptions.functional_exception import FunctionalException
 
 logger = logging.getLogger(__name__)
 
@@ -46,6 +47,9 @@ class AISMessages(object):
     def is_available(cls):
         return with_pyais
     
+    ###########################################################################
+    # Methods depending to pyais
+    ###########################################################################
     if with_pyais:
         
         def __init__(self):
@@ -172,12 +176,6 @@ class AISMessages(object):
             
             return res
         
-        def __new_tag_block_group_id(self):
-            self.__tag_block_group_id += 1
-            if self.__tag_block_group_id > 9999:
-                self.__tag_block_group_id = 0
-            return self.__tag_block_group_id
-        
         def convert_message_to_binary_str(self, msg):
             return msg.to_bitarray().to01()
         
@@ -201,4 +199,97 @@ class AISMessages(object):
             return res
         
     
+    
+    ###########################################################################
+    # Methods independent of pyais
+    ###########################################################################
+    
+    def __new_tag_block_group_id(self):
+        self.__tag_block_group_id += 1
+        if self.__tag_block_group_id > 9999:
+            self.__tag_block_group_id = 0
+        return self.__tag_block_group_id
+    
+    def split_raw_to_sentences(self, ais_raw):
+        if isinstance(ais_raw, str):
+            split_char = '\n'
+        elif isinstance(ais_raw, bytes):
+            split_char = b'\n'
+        else:
+            raise FunctionalException(f"Raw must by of type str or bytes (obtained type: {Typing.get_object_class_fullname(ais_raw)})")
+        
+        res = ais_raw.split(split_char)
+        
+        return res
+    
+    def split_sentence_to_tab_block_and_message(self, ais_sentence):
+        if isinstance(ais_sentence, str):
+            split_char = '\\'
+        elif isinstance(ais_sentence, bytes):
+            split_char = b'\\'
+        else:
+            raise FunctionalException(f"Sentence must by of type str or bytes (obtained type: {Typing.get_object_class_fullname(ais_sentence)})")
+        
+        res = ais_sentence.split(split_char)
+        if len(res) > 1:
+            # Remove part before first '\'
+            del res[0]
+        else:
+            # Tag block is not present, insert it as None
+            res.insert(0, None)
+            
+        return res
+    
+    def convert_tag_block_to_dict(self, tag_block):
+        if isinstance(tag_block, str):
+            checksum_delimiter = '*'
+            param_delimiter = ','
+            name_delimiter = ':'
+        elif isinstance(tag_block, bytes):
+            checksum_delimiter = b'*'
+            param_delimiter = b','
+            name_delimiter = b':'
+        else:
+            raise FunctionalException(f"Tag Block must by of type str or bytes (obtained type: {Typing.get_object_class_fullname(tag_block)})")
+        
+        # Remove checksum
+        try:
+            chk_index = tag_block.index(checksum_delimiter)
+        except:
+            chk_index = None
+        tb_str = tag_block[:chk_index] if chk_index else tag_block
+        
+        # Split parameters
+        tb_list = tb_str.split(param_delimiter)
+        
+        # Extract parameter names and values
+        param_list = [e.split(name_delimiter) for e in tb_list]
+        res = {p[0]:p[1] for p in param_list}
+        
+        return res
+    
+    def split_message_to_fields(self, ais_message):
+        split_char = self.__get_fields_delimiter_for_message(ais_message)
+        res = ais_message.split(split_char)
+        return res
+    
+    def __get_fields_delimiter_for_message(self, ais_message):
+        if isinstance(ais_message, str):
+            return ','
+        elif isinstance(ais_message, bytes):
+            return b','
+        else:
+            raise FunctionalException(f"Message must by of type str or bytes (obtained type: {Typing.get_object_class_fullname(ais_message)})")
+        
+    def replace_message_id_in_message(self, ais_message, replacement_id):
+        if type(ais_message) != type(replacement_id):
+            raise FunctionalException(f"Replacement ID must of same type than message ({Typing.get_object_class_fullname(ais_message)})")
+        
+        fields = self.split_message_to_fields(ais_message)
+        fields[3] = replacement_id
+        
+        split_char = self.__get_fields_delimiter_for_message(ais_message)
+        return split_char.join(fields)
+        
+        
     

holado_ais/tests/behave/steps/ais/ais_manager_steps.py

@@ -16,7 +16,7 @@
 from holado_test.scenario.step_tools import StepTools
 from holado.common.context.session_context import SessionContext
 import logging
-from holado_test.behave.behave import *
+from holado_test.behave.behave import *  # @UnusedWildImport
 
 logger = logging.getLogger(__name__)
 

holado_ais/tests/behave/steps/ais/ais_messages_steps.py

@@ -18,7 +18,7 @@ from holado.common.context.session_context import SessionContext
 import logging
 from holado_test.behave.scenario.behave_step_tools import BehaveStepTools
 from holado_ais.ais.ais_messages import AISMessages
-from holado_test.behave.behave import *
+from holado_test.behave.behave import *  # @UnusedWildImport
 from holado_ais.ais.enums import AISMessageType
 from holado_core.common.tools.string_tools import StrTools
 from holado_value.common.tables.converters.value_table_converter import ValueTableConverter
@@ -152,7 +152,7 @@ if AISMessages.is_available():
         
         __get_variable_manager().register_variable(var_name, res)
     
-    @Step(r"(?P<var_name>{Variable}) = decode AIS NMEA message (?P<encoded_ais_message>{Str})(?P<dictionnary_str> as dictionnary)?")
+    @Step(r"(?P<var_name>{Variable}) = decode NMEA AIS message (?P<encoded_ais_message>{Str})(?P<dictionnary_str> as dictionnary)?")
     def step_impl(context, var_name, encoded_ais_message, dictionnary_str):
         var_name = StepTools.evaluate_variable_name(var_name)
         encoded_ais_message = StepTools.evaluate_scenario_parameter(encoded_ais_message)
@@ -167,15 +167,54 @@ if AISMessages.is_available():
             
         __get_variable_manager().register_variable(var_name, res)
     
-    @Given(r"(?P<var_name>{Variable}) = split AIS NMEA message (?P<bytes_ais_message>{Bytes}) to fields as string list")
-    def step_impl(context, var_name, bytes_ais_message):
+    #TODO EKL: rename step
+    @Given(r"(?P<var_name>{Variable}) = split NMEA AIS message (?P<ais_message>{Bytes}|{Str}) to fields")
+    def step_impl(context, var_name, ais_message):
         var_name = StepTools.evaluate_variable_name(var_name)
-        bytes_ais_message = StepTools.evaluate_scenario_parameter(bytes_ais_message)
+        ais_message = StepTools.evaluate_scenario_parameter(ais_message)
         
-        res = bytes_ais_message.split(',')
+        res = __get_ais_messages().split_message_to_fields(ais_message)
+        
+        __get_variable_manager().register_variable(var_name, res)
+    
+    @Given(r"(?P<var_name>{Variable}) = split (?P<ais_raw>{Bytes}|{Str}) to NMEA AIS sentences")
+    def step_impl(context, var_name, ais_raw):
+        var_name = StepTools.evaluate_variable_name(var_name)
+        ais_raw = StepTools.evaluate_scenario_parameter(ais_raw)
+        
+        res = __get_ais_messages().split_raw_to_sentences(ais_raw)
         
         __get_variable_manager().register_variable(var_name, res)
         
+    @Given(r"(?P<tb_var_name>{Variable}), (?P<msg_var_name>{Variable}) = split NMEA AIS sentence (?P<ais_sentence>{Bytes}|{Str}) to tag block and message")
+    def step_impl(context, tb_var_name, msg_var_name, ais_sentence):
+        tb_var_name = StepTools.evaluate_variable_name(tb_var_name)
+        msg_var_name = StepTools.evaluate_variable_name(msg_var_name)
+        ais_sentence = StepTools.evaluate_scenario_parameter(ais_sentence)
+        
+        tb, msg = __get_ais_messages().split_sentence_to_tab_block_and_message(ais_sentence)
+        
+        __get_variable_manager().register_variable(tb_var_name, tb)
+        __get_variable_manager().register_variable(msg_var_name, msg)
+        
+    @Given(r"(?P<var_name>{Variable}) = split NMEA AIS Tag Block (?P<tag_block>{Bytes}|{Str}) to dict")
+    def step_impl(context, var_name, tag_block):
+        var_name = StepTools.evaluate_variable_name(var_name)
+        tag_block = StepTools.evaluate_scenario_parameter(tag_block)
+        
+        res = __get_ais_messages().convert_tag_block_to_dict(tag_block)
+        
+        __get_variable_manager().register_variable(var_name, res)
+        
+    @Given(r"(?P<var_name>{Variable}) = NMEA AIS message (?P<ais_message>{Bytes}|{Str}) with message ID replaced by (?P<replacement_id>{Bytes}|{Str})")
+    def step_impl(context, var_name, ais_message, replacement_id):
+        var_name = StepTools.evaluate_variable_name(var_name)
+        ais_message = StepTools.evaluate_scenario_parameter(ais_message)
+        replacement_id = StepTools.evaluate_scenario_parameter(replacement_id)
+        
+        res = __get_ais_messages().replace_message_id_in_message(ais_message, replacement_id)
+        
+        __get_variable_manager().register_variable(var_name, res)
     
     
 

holado_binary/ipc/bit_series.py

@@ -14,7 +14,7 @@
 import logging
 from holado_core.common.tables.table_with_header import TableWithHeader
 from holado_core.common.exceptions.technical_exception import TechnicalException
-from typing import NamedTuple
+from typing import NamedTuple, Iterable
 from holado_core.common.tables.table_row import TableRow
 from holado_core.common.exceptions.functional_exception import FunctionalException
 from holado_binary.ipc.binary import Binary
@@ -82,8 +82,8 @@ class BitSeries():
         Parameter "bit_sections_list" is an iterable of "bit_section".
         """
         if bit_sections_list is not None:
-            if not isinstance(bit_sections_list, list):
-                raise TechnicalException(f"Parameter 'bit_sections_list' has to be a list (obtained type: {Typing.get_object_class_fullname(bit_sections_list)})")
+            if not isinstance(bit_sections_list, Iterable):
+                raise TechnicalException(f"Parameter 'bit_sections_list' has to be an iterable (obtained type: {Typing.get_object_class_fullname(bit_sections_list)})")
             for bit_section in bit_sections_list:
                 self.add_bit_section(bit_section=bit_section)
             return

holado_binary/tests/behave/steps/ipc/binary_steps.py

@@ -13,7 +13,7 @@
 #################################################
 
 
-from holado_test.behave.behave import *
+from holado_test.behave.behave import *  # @UnusedWildImport
 from holado_test.scenario.step_tools import StepTools
 import logging
 from holado_binary.ipc.binary import Binary

holado_binary/tests/behave/steps/ipc/bit_series_steps.py

@@ -13,7 +13,7 @@
 #################################################
 
 
-from holado_test.behave.behave import *
+from holado_test.behave.behave import *  # @UnusedWildImport
 from holado_value.common.tables.value_table_manager import ValueTableManager
 from holado_test.scenario.step_tools import StepTools
 from holado_binary.ipc.bit_series import BitSeries
@@ -25,6 +25,7 @@ from holado_core.common.tables.comparators.table_with_header_comparator import T
 from holado_test.behave.scenario.behave_step_tools import BehaveStepTools
 from holado.common.context.session_context import SessionContext
 from holado_core.common.exceptions.functional_exception import FunctionalException
+from holado_value.common.tables.converters.value_table_converter import ValueTableConverter
 
 logger = logging.getLogger(__name__)
 
@@ -52,7 +53,7 @@ def step_impl(context, var_name):
     table = BehaveStepTools.convert_step_table_2_value_table_with_header(context.table)
     
     __verify_table_is_bit_series_table(table)
-    bs = BitSeries(bit_sections_list = ValueTableManager.convert_table_2_list_of_tuples(table))
+    bs = BitSeries(bit_sections_list = ValueTableConverter.convert_table_2_list_of_tuples(table, as_generator=True))
     
     __get_variable_manager().register_variable(var_name, bs)
 
@@ -93,7 +94,7 @@ def step_impl(context, hex_str):
     # Build a table representing the bit series in hexadecimal string
     declare_table = copy.copy(expected_table)
     declare_table.remove_column(name="Value")
-    bs = BitSeries(bit_sections_list=ValueTableManager.convert_table_2_list_of_tuples(declare_table))
+    bs = BitSeries(bit_sections_list=ValueTableConverter.convert_table_2_list_of_tuples(declare_table, as_generator=True))
     bs.from_hex(hex_str)
     obtained_table = bit_series.convert_bit_series_to_table(bs)
     

holado_context/tests/behave/steps/private/common/context_steps.py

@@ -14,7 +14,7 @@
 
 
 from holado.common.context.session_context import SessionContext
-from holado_test.behave.behave import *
+from holado_test.behave.behave import *  # @UnusedWildImport
 import logging
 
 logger = logging.getLogger(__name__)

holado_core/common/resource/persisted_data_manager.py

@@ -55,23 +55,20 @@ class PersistedDataManager():
         if not self.__resource_manager.has_data_table(self.__table_name, db_name=self.__db_name):
             raise TechnicalException(f"Failed to create table '{self.__table_name}' in DB '{self.__db_name}'")
     
-    def has_persisted_data(self, filter_data):
-        return self.__resource_manager.has_persisted_data(self.__table_name, filter_data, db_name=self.__db_name)
+    def has_persisted_data(self, filter_data=None, filter_compare_data=None):
+        return self.__resource_manager.has_persisted_data(self.__table_name, where_data=filter_data, where_compare_data=filter_compare_data, db_name=self.__db_name)
         
-    def get_persisted_datas(self, filter_data):
+    def get_persisted_datas(self, filter_data=None, filter_compare_data=None, as_generator=False):
         """
         Note: Whereas 'data' is already a plural, a 's' is added in method name to be coherent with other method names
         """
-        res = self.__resource_manager.get_persisted_data(self.__table_name, filter_data, db_name=self.__db_name)
-        if res is not None:
-            res = TableConverter.convert_table_with_header_to_dict_list(res)
-        return res
+        return self.__resource_manager.get_persisted_data(self.__table_name, where_data=filter_data, where_compare_data=filter_compare_data, db_name=self.__db_name, result_as_dict_list=True, as_generator=as_generator)
 
-    def get_persisted_data(self, filter_data):
+    def get_persisted_data(self, filter_data=None, filter_compare_data=None):
         """
         Note: Whereas 'datum' should be the right word in method name since method returns only one datum, method is named with 'data' in its usual singular meaning for most people.
         """
-        data = self.get_persisted_datas(filter_data)
+        data = self.get_persisted_datas(filter_data=filter_data, filter_compare_data=filter_compare_data)
         if len(data) > 1:
             raise TechnicalException(f"Too many ({len(data)}) {self.__data_name} found for filter {filter_data}.")
         elif len(data) == 1:
@@ -79,13 +76,13 @@ class PersistedDataManager():
         else:
             return None
         
-    def count_persisted_data(self, filter_data):
-        return self.__resource_manager.count_persisted_data(self.__table_name, filter_data, db_name=self.__db_name)
+    def count_persisted_data(self, filter_data=None, filter_compare_data=None):
+        return self.__resource_manager.count_persisted_data(self.__table_name, where_data=filter_data, where_compare_data=filter_compare_data, db_name=self.__db_name)
 
-    def update_persisted_data(self, data, persisted_filter_data):
+    def update_persisted_data(self, data, filter_data=None, filter_compare_data=None):
         if Tools.do_log(logger, logging.DEBUG):
-            logger.debug(f"Update persisted {self.__data_name} for {persisted_filter_data}: {data}")
-        self.__resource_manager.update_persisted_data(self.__table_name, data, persisted_filter_data, db_name=self.__db_name)
+            logger.debug(f"Update persisted {self.__data_name} for {filter_data} and {filter_compare_data}: {data}")
+        self.__resource_manager.update_persisted_data(self.__table_name, data, where_data=filter_data, where_compare_data=filter_compare_data, db_name=self.__db_name)
 
     def add_persisted_data(self, data, persisted_filter_data=None):
         if Tools.do_log(logger, logging.DEBUG):
@@ -102,12 +99,12 @@ class PersistedDataManager():
             has_persisted_data = persisted_data is not None
         
         if has_persisted_data:
-            self.update_persisted_data(data, persisted_filter_data)
+            self.update_persisted_data(data, filter_data=persisted_filter_data)
         else:
             self.add_persisted_data(data, persisted_filter_data)
         
     def delete_persisted_data(self, filter_data):
-        self.__resource_manager.delete_persisted_data(self.__table_name, filter_data, db_name=self.__db_name)
+        self.__resource_manager.delete_persisted_data(self.__table_name, where_data=filter_data, db_name=self.__db_name)
 
 
 

holado_core/common/resource/resource_manager.py

@@ -112,32 +112,32 @@ class ResourceManager():
         sql = result[0][0].content
         return sql == create_sql
         
-    def count_persisted_data(self, table_name, data: dict, db_name="default"):
+    def count_persisted_data(self, table_name, where_data: dict=None, where_compare_data: list=None, db_name="default"):
         client = self.get_persistent_db_client(db_name)
-        result = client.select(table_name, where_data=data, sql_return="count(*)")
+        result = client.select(table_name, where_data=where_data, where_compare_data=where_compare_data, sql_return="count(*)")
         if Tools.do_log(logger, logging.DEBUG):
             logger.debug(f"result: {Tools.represent_object(result)}")
         return result[0][0].content
         
-    def has_persisted_data(self, table_name, data: dict, db_name="default"):
-        count = self.count_persisted_data(table_name, data, db_name)
+    def has_persisted_data(self, table_name, where_data: dict=None, where_compare_data: list=None, db_name="default"):
+        count = self.count_persisted_data(table_name, where_data=where_data, where_compare_data=where_compare_data, db_name=db_name)
         return count > 0
         
-    def get_persisted_data(self, table_name, data: dict, db_name="default"):
+    def get_persisted_data(self, table_name, where_data: dict=None, where_compare_data: list=None, db_name="default", result_as_dict_list=False, as_generator=False):
         client = self.get_persistent_db_client(db_name)
-        result = client.select(table_name, where_data=data)
+        result = client.select(table_name, where_data=where_data, where_compare_data=where_compare_data, result_as_dict_list=result_as_dict_list, as_generator=as_generator)
         return result
         
     def add_persisted_data(self, table_name, data: dict, db_name="default", do_commit=True):
         client = self.get_persistent_db_client(db_name)
         client.insert(table_name, data, do_commit=do_commit)
         
-    def update_persisted_data(self, table_name, data: dict, where_data: dict, db_name="default", do_commit=True):
+    def update_persisted_data(self, table_name, data: dict, where_data: dict=None, where_compare_data: list=None, db_name="default", do_commit=True):
         client = self.get_persistent_db_client(db_name)
-        result = client.update(table_name, data=data, where_data=where_data, do_commit=do_commit)
+        result = client.update(table_name, data=data, where_data=where_data, where_compare_data=where_compare_data, do_commit=do_commit)
         return result
         
-    def delete_persisted_data(self, table_name, data: dict, db_name="default", do_commit=True):
+    def delete_persisted_data(self, table_name, where_data: dict=None, where_compare_data: list=None, db_name="default", do_commit=True):
         client = self.get_persistent_db_client(db_name)
-        client.delete(table_name, data, do_commit=do_commit)
+        client.delete(table_name, where_data=where_data, where_compare_data=where_compare_data, do_commit=do_commit)
         

holado_core/common/tables/converters/table_converter.py

@@ -21,6 +21,7 @@ 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__)
@@ -31,7 +32,7 @@ class TableConverter(object):
     
     @classmethod
     def convert_table_with_header_to_dict(cls, table):
-        res_list = cls.convert_table_with_header_to_dict_list(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:
@@ -40,15 +41,52 @@ class TableConverter(object):
             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)
+    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 res
+            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):

holado_core/common/tables/table_manager.py

@@ -40,6 +40,7 @@ class TableManager(object):
     def is_table_with_header(cls, table):
         return isinstance(table, TableWithHeader)
     
+    #TODO: move in TableConverter
     @classmethod
     def convert_object_attributes_2_name_value_table(cls, obj):
         if Tools.do_log(logger, logging.DEBUG):
@@ -59,6 +60,7 @@ class TableManager(object):
             
         return res
     
+    #TODO: move in TableConverter
     @classmethod
     def convert_list_2_column_table(cls, el_list):
         if Tools.do_log(logger, logging.DEBUG):
@@ -72,6 +74,7 @@ class TableManager(object):
             
         return res
  
+    #TODO: move in TableConverter
     @classmethod
     def convert_object_list_2_table_with_attributes_as_column(cls, list_obj):
         if Tools.do_log(logger, logging.DEBUG):
@@ -98,6 +101,7 @@ class TableManager(object):
 
         return res
  
+    #TODO: move in TableConverter
     @classmethod
     def convert_object_list_2_column_table(cls, list_obj):
         if Tools.do_log(logger, logging.DEBUG):
@@ -111,6 +115,7 @@ class TableManager(object):
         return res
         
     
+    #TODO: move in TableConverter
     @classmethod
     def convert_dict_2_name_value_table(cls, obj):
         if Tools.do_log(logger, logging.DEBUG):
@@ -125,6 +130,7 @@ class TableManager(object):
             
         return res
     
+    #TODO: move in TableConverter
     @classmethod
     def convert_dict_2_table_with_keys_as_column(cls, obj):
         if Tools.do_log(logger, logging.DEBUG):
@@ -138,13 +144,6 @@ class TableManager(object):
             
         return res
     
-    @classmethod
-    def convert_table_2_list_of_tuples(cls, table):
-        if Tools.do_log(logger, logging.DEBUG):
-            logger.debug("Converting table to a list of tuples...")
-        return [tuple((cell.content for cell in row.cells)) for row in table.rows]
-    
-    
     @classmethod
     def compare_tables(cls, table_1, table_2, compare_params_table, reorder_columns_table_1=True, reorder_columns_table_2=True, raise_exception=True):
         compared_tables, columns_compare_methods, compared_columns, expected_table_columns = cls._extract_compared_data(table_1, table_2, compare_params_table, reorder_columns_table_1, reorder_columns_table_2)

holado_core/common/tables/table_with_header.py

@@ -53,6 +53,12 @@ class TableWithHeader(Table):
         
         return res
     
+    def set_header(self, row=None, cells=None, cells_content=None):
+        if row is not None:
+            self.header = row
+        else:
+            self.header = TableRow(cells=cells, cells_content=cells_content)
+    
     def add_row(self, row=None, cells=None, cells_content=None, contents_by_colname: dict =None, **kwargs):
         # Manage super call
         if contents_by_colname is None:

holado_core/tests/behave/steps/common/common_steps.py

@@ -16,7 +16,7 @@
 from holado_test.scenario.step_tools import StepTools
 from holado.common.context.session_context import SessionContext
 from holado_core.common.exceptions.functional_exception import FunctionalException
-from holado_test.behave.behave import *
+from holado_test.behave.behave import *  # @UnusedWildImport
 import time
 import logging
 import re
@@ -109,6 +109,7 @@ def step_impl(context, then_step, then_after_steps, accepted, timeout, polling):
 
     redo = StepRedo(then_step, before_steps)
     redo.with_accepted_time(accepted).with_timeout(timeout).polling_every(polling)
+    redo.ignoring(VerifyException)
     redo.execute()
 
 @Then(r"(?P<value>{Str}) matches pattern (?P<pattern_str>{RawStr})")

holado_core/tests/behave/steps/common/config_steps.py

@@ -14,7 +14,7 @@
 
 
 from holado.common.context.session_context import SessionContext
-from holado_test.behave.behave import *
+from holado_test.behave.behave import *  # @UnusedWildImport
 import logging
 
 logger = logging.getLogger(__name__)

holado_core/tests/behave/steps/common/resource_steps.py

@@ -14,7 +14,7 @@
 
 
 from holado.common.context.session_context import SessionContext
-from holado_test.behave.behave import *
+from holado_test.behave.behave import *  # @UnusedWildImport
 import logging
 from holado_test.scenario.step_tools import StepTools
 import os

holado_core/tests/behave/steps/common/tables_steps.py

@@ -38,6 +38,7 @@ from holado_test.behave.scenario.behave_step_tools import BehaveStepTools
 from holado_value.common.tables.converters.value_table_converter import ValueTableConverter
 from holado_python.standard_library.typing import Typing
 from holado_value.common.tables.value_table_manager import ValueTableManager
+from holado_core.common.tables.converters.table_converter import TableConverter
 
 logger = logging.getLogger(__name__)
 
@@ -111,6 +112,21 @@ def step_impl(context, var_name, obj_str):
     
     __get_variable_manager().register_variable(var_name, table)
 
+@Step(r"(?P<var_name>{Variable}) = convert table with header (?P<table>{Variable}) to list of dictionary(?: \((?P<as_generator_str>as generator)\))?")
+def step_impl(context, var_name, table, as_generator_str):
+    var_name = StepTools.evaluate_variable_name(var_name)
+    table = StepTools.evaluate_scenario_parameter(table)
+    as_generator = as_generator_str is not None
+    if not TableManager.is_table_with_header(table):
+        raise TechnicalException(f"Table must be a table with header (obtained type: {Typing.get_object_class_fullname(table)})")
+    
+    if ValueTableManager.is_value_table(table):
+        res = ValueTableConverter.convert_table_with_header_to_dict_list(table, as_generator=as_generator)
+    else:
+        res = TableConverter.convert_table_with_header_to_dict_list(table, as_generator=as_generator)
+    
+    __get_variable_manager().register_variable(var_name, res)
+
 @Step(r'(?P<var_name>{Variable}) = convert object (?P<obj_str>{Variable}) to name/value table')
 def step_impl(context, var_name, obj_str):
     var_name = StepTools.evaluate_variable_name(var_name)
@@ -257,7 +273,7 @@ def step_impl(context, var_name, table_varname):
     table_new_columns = BehaveStepTools.convert_step_table_2_value_table_with_header(context.table, do_eval_once=False)
 
     res_table = copy.copy(table)
-    is_res_value_table = isinstance(res_table, ValueTable) or isinstance(res_table, ValueTableWithHeader)
+    is_res_value_table = ValueTableManager.is_value_table(res_table)
     
     res_col_indexes = res_table.get_column_indexes_by_string_content()
     
@@ -293,7 +309,7 @@ def step_impl(context, var_name, table_varname):
     table_new_rows = BehaveStepTools.convert_step_table_2_value_table_with_header(context.table)
 
     res_table = copy.copy(table)
-    is_res_value_table = isinstance(res_table, ValueTable) or isinstance(res_table, ValueTableWithHeader)
+    is_res_value_table = ValueTableManager.is_value_table(res_table)
     
     # Verify tables headers
     header_comp = StringTableRowComparator()