holado 0.2.8__tar.gz → 0.3.0__tar.gz

{holado-0.2.8 → holado-0.3.0}/Dockerfile

@@ -72,6 +72,8 @@ COPY --chown=appuser --from=build /code /code
 # Set working directory in HolAdo
 WORKDIR /code/holado/python
 
+# Set environement variable HOLADO_PATH, so that installed holado sources are used instead of holado package
+ENV HOLADO_PATH=/code/holado/python
+
 # Activate permanently python venv
 ENV PATH=/code/env/bin:$PATH
-

{holado-0.2.8 → holado-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: holado
-Version: 0.2.8
+Version: 0.3.0
 Summary: HolAdo framework
 Project-URL: Homepage, https://gitlab.com/holado_framework/python
 Project-URL: Issues, https://gitlab.com/holado_framework/python/-/issues
@@ -21,8 +21,10 @@ Provides-Extra: ais
 Requires-Dist: pyais; extra == 'ais'
 Provides-Extra: db
 Requires-Dist: pypika; extra == 'db'
+Requires-Dist: sql-metadata; extra == 'db'
 Provides-Extra: db-postgresql
 Requires-Dist: psycopg; extra == 'db-postgresql'
+Requires-Dist: psycopg-binary; extra == 'db-postgresql'
 Provides-Extra: docker
 Requires-Dist: docker; extra == 'docker'
 Provides-Extra: grpc
@@ -56,6 +58,7 @@ Requires-Dist: sftpserver; extra == 'sftp'
 Provides-Extra: ssl
 Requires-Dist: certifi; extra == 'ssl'
 Requires-Dist: pip-system-certs; extra == 'ssl'
+Requires-Dist: pyopenssl; extra == 'ssl'
 Provides-Extra: ws-suds
 Requires-Dist: suds; extra == 'ws-suds'
 Provides-Extra: ws-zeep

holado-0.3.0/packaging/VERSION

@@ -0,0 +1 @@
+0.3.0

{holado-0.2.8 → holado-0.3.0}/pyproject.toml

@@ -33,8 +33,8 @@ dependencies = [
 
 [project.optional-dependencies]
 ais = ["pyais"]
-db = ["pypika"]
-db-postgresql = ["psycopg"]
+db = ["pypika", "sql_metadata"]
+db-postgresql = ["psycopg", "psycopg_binary"]
 docker = ["docker"]
 helper_debug = ["pympler"]
 protobuf = ["google", "google-api-core", "protobuf"]
@@ -43,7 +43,7 @@ rabbitmq = ["pika"]
 redis = ["redis", "redis-om"]
 s3 = ["minio", "boto3", "moto", "flask", "flask_cors"]
 sftp = ["pysftp", "sftpserver"]
-ssl = ["pip-system-certs", "certifi"]
+ssl = ["pip-system-certs", "certifi", "pyOpenSSL"]
 ws-suds = ["suds"]
 ws-zeep = ["zeep"]
 yaml = ["pyyaml"]

{holado-0.2.8 → holado-0.3.0}/requirements_docker.txt

@@ -66,17 +66,23 @@ pympler     # memory profiling
 # For yaml module
 pyyaml
 
+# For ssl: next packages have sometimes to be updated
+pip-system-certs
+certifi
+pyOpenSSL
+
 
 ### DB modules
 
 # For PostreSQL module
-# Prerequirement: install libpq
-#    Example on ubuntu: sudo apt install libpq5
 psycopg
+# If installation of psycopg_binary doesn't work, it can be solved by installing on system the postgresql library
+#    Example on Ubuntu: sudo apt install libpq5
+psycopg_binary
 
-# For query builder
+# For query builder/parser
 pypika
-
+sql_metadata
 
 ### UI modules
 

{holado-0.2.8 → holado-0.3.0}/src/holado/common/handlers/undefined.py

@@ -44,6 +44,12 @@ to_be_defined = Undefined("To be defined", 3)               # Usage: initial var
 # Note: Real value is defined by methods managing these values as argument.
 
 default_value = Undefined("Default value", 10)
-default_context = Undefined("Defautl context", 11)      # Example of real value: for ThreadsManager it means "current ScenarioContext" if a scenario context exists else "SessionContext".
+default_context = Undefined("Default context", 11)      # Example of real value: for ThreadsManager it means "current ScenarioContext" if a scenario context exists else "SessionContext".
+
+
+# Define symbolic values
+
+any_value = Undefined("Any value", 20)
+not_defined_value = Undefined("Not defined value", 21)
 
 

{holado-0.2.8 → holado-0.3.0}/src/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-0.2.8 → holado-0.3.0}/src/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-0.2.8 → holado-0.3.0}/src/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-0.2.8 → holado-0.3.0}/src/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-0.2.8 → holado-0.3.0}/src/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-0.2.8 → holado-0.3.0}/src/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-0.2.8 → holado-0.3.0}/src/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-0.2.8 → holado-0.3.0}/src/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-0.2.8 → holado-0.3.0}/src/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-0.2.8 → holado-0.3.0}/src/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-0.2.8 → holado-0.3.0}/src/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-0.2.8 → holado-0.3.0}/src/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: