holado 0.22.0.dev0__tar.gz → 0.22.0.dev2__tar.gz

{holado-0.22.0.dev0 → holado-0.22.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: holado
-Version: 0.22.0.dev0
+Version: 0.22.0.dev2
 Summary: HolAdo framework
 Project-URL: Homepage, https://gitlab.com/holado_framework/python
 Project-URL: Issues, https://gitlab.com/holado_framework/python/-/issues

holado-0.22.0.dev2/packaging/VERSION

@@ -0,0 +1 @@
+0.22.0.dev2

{holado-0.22.0.dev0 → holado-0.22.0.dev2}/src/holado_core/common/tools/string_tools.py

@@ -100,14 +100,13 @@ class StrTools(object):
     def to_bytes(cls, src):
         if isinstance(src, int):
             signed = True if src < 0 else False
-        
-            length = 1
-            val = src
-            while val > 255:
-                length += 1
-                val = val / 256
-        
-            res = src.to_bytes(length, 'big', signed=signed)
+            length = (src.bit_length() + 7) // 8
+            try:
+                res = src.to_bytes(length, 'big', signed=signed)
+            except OverflowError:
+                # A bug exists in to_bytes method for some rare cases (ex: -50126786515683650) for which a size of plus one is needed
+                res = src.to_bytes(length + 1, 'big', signed=signed)
+                res = res.lstrip(b'\x00')
         elif isinstance(src, bytes):
             res = src
         elif isinstance(src, str):

holado-0.22.0.dev2/src/holado_data/data/encoder/BaseXEncoder.py

@@ -0,0 +1,125 @@
+
+#################################################
+# 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.common.handlers.undefined import default
+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 BaseXEncoder(object):
+    """ Encoder in a given base
+    Default digits enable to encode in a base in range [2, 62] (default: 62)
+    """
+
+    def __init__(self, padding_character=default, digits=default):
+        if digits is default:
+            self.__digs = string.digits + string.ascii_uppercase + string.ascii_lowercase
+        else:
+            self.__digs = digits
+
+        if padding_character is default:
+            # Use first digit by default
+            self.__padding_character = self.__digs[0]
+        else:
+            self.__padding_character = padding_character
+
+
+    def encode(self, value, base=62, padding_length=None, padding_character=None, raise_if_padding_impossible=True):
+        """ Encode given value in given base
+        :param value: Value to encode (accepted types: int, bytes, hex string)
+        :param base: Base (default: 62)
+        :param padding_length: padding length (default: None => no padding is done)
+        :param padding_character: padding_character (default: None => padding character defined at BaseXEncoder creation is used)
+        :param raise_if_padding_impossible: If True and encode result has a size greater than padding_length, raise TechnicalException
+        """
+        if isinstance(value, int):
+            int_value = value
+        elif isinstance(value, bytes):
+            int_value = int.from_bytes(value, byteorder='big', signed=False)
+        elif isinstance(value, str):
+            int_value = int(value, 16)
+        else:
+            raise TechnicalException("Value has to be of any type in (int, bytes, hex string)")
+
+        res = self.__encode_int_until_base62(int_value, base)
+
+        if padding_length:
+            if len(res) > padding_length and raise_if_padding_impossible:
+                raise TechnicalException(f"Encode result 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 BaseXEncoder.encode or constructor of BaseXEncoder")
+                pc = padding_character if padding_character is not None else self.__padding_character
+                res = res.rjust(padding_length, pc)
+
+        return res
+
+    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)
+
+    @classmethod
+    def get_max_int_for_base_length(cls, base, length):
+        """
+        Compute maximum integer so that associated value doesn't exceed given length once encoded in given base
+        :param base: base number
+        :param length: max length in given base
+        :return: max integer
+        """
+        return base ** length - 1
+
+    @classmethod
+    def get_max_value_nb_bytes_for_base_length(cls, base, length, round_method=default):
+        """
+        Compute maximum number of bytes of a value so that it has given length once encoded in given base.
+        By default, round_method is math.floor to ensure that the result after encoding has not a length exceeding given length.
+        For some use case, it is preferable to set round_method=math.ceil in order to get a nb of bytes to ensure that result will have at least the given length.
+        :param base: base number
+        :param length: max length in given base
+        :param round_method: method to round value (default: math.floor)
+        :return: max number of bytes
+        """
+        import math
+        if round_method is default:
+            round_method = math.floor
+
+        max_base_value = cls.get_max_int_for_base_length(base, length)
+        max_nb_bytes_as_float = math.log(max_base_value) / math.log(256)
+        # Note: Get the floor of max_nb_bytes_as_float to return the max nb of bytes that won't exceed given base length after encode
+        return round_method(max_nb_bytes_as_float)
+
+
+

{holado-0.22.0.dev0 → holado-0.22.0.dev2}/src/holado_python/standard_library/hashlib.py

@@ -15,6 +15,7 @@
 import logging
 import hashlib
 from holado_core.common.exceptions.technical_exception import TechnicalException
+from holado_core.common.tools.string_tools import StrTools
 
 logger = logging.getLogger(__name__)
 
@@ -92,8 +93,8 @@ class HashTools(object):
         if not isinstance(content, str): 
             try:
                 for cont in content:
-                    if type(cont) != bytes:
-                        cont = cont.encode('utf-8')
+                    # Convert ot bytes if needed
+                    cont = StrTools.to_bytes(cont)
                     hash_obj.update(cont)
                 done = True
             except TypeError:
@@ -103,8 +104,7 @@ class HashTools(object):
             if type(content) != bytes:
                 content = content.encode('utf-8')
             hash_obj.update(content)
-    
-    
-    
-    
+
+
+
     

{holado-0.22.0.dev0 → holado-0.22.0.dev2}/src/holado_report/campaign/campaign_manager.py

@@ -6,7 +6,7 @@
 # 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.
-
+import copy
 # 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.
 #################################################
 
@@ -90,7 +90,11 @@ class CampaignManager(object):
         return """CREATE TABLE campaign_scenarios (
                 id INTEGER PRIMARY KEY,
                 campaign_id INTEGER NOT NULL,
-                uid TEXT NOT NULL,
+                executed_scenario_uid TEXT NOT NULL,
+                scenario_uid TEXT NOT NULL,
+                scenario_version TEXT NOT NULL,
+                scenario_example_row_uid TEXT, 
+                scenario_example_row TEXT,
                 name TEXT NOT NULL,
                 report_path TEXT,
                 status TEXT,
@@ -100,12 +104,12 @@ class CampaignManager(object):
 
     def __get_campaign_scenarios_table_unique_indexes(self):
         return [
-            ('campaign_id', 'uid')
+            ('campaign_id', 'executed_scenario_uid')
             ]
 
     def __get_campaign_scenarios_table_indexes(self):
         return [
-            ('uid', 'status_at')
+            ('executed_scenario_uid', 'status_at')
             ]
 
     def update_stored_campaigns(self):
@@ -127,8 +131,8 @@ class CampaignManager(object):
     def __get_campaigns_report_paths(self, since_datetime):
         reports_path = self._path_manager.get_reports_path(name="test_runner", with_application_group=False)
         file_paths = self._path_manager.find_files(reports_path,
-                                                                       subdir_relative_path=Config.campaign_manager_import_report_name,  # @UndefinedVariable
-                                                                       since_datetime=since_datetime)
+                                                   subdir_relative_path=Config.campaign_manager_import_report_name,  # @UndefinedVariable
+                                                   since_datetime=since_datetime)
         return [os.path.dirname(p) for p in file_paths]
 
     def __get_last_campaign_updated_datetime(self):
@@ -204,20 +208,27 @@ class CampaignManager(object):
                     logger.debug(f"Failed to import campaign report '{report_path}' from '{Config.campaign_manager_import_report_name}': {str(exc)}")  # @UndefinedVariable
             else:
                 logger.debug(f"Imported campaign report '{report_path}' from '{Config.campaign_manager_import_report_name}'")  # @UndefinedVariable
-            
-            # Try to import information from 'report_summary_scenario_all.txt'
-            if updated_dt is None:
-                try:
-                    updated_dt = self.__import_campaign_report_summary_scenario_all(report_path, camp_id)
-                except:
-                    raise TechnicalException(f"Failed to import campaign report '{report_path}'")
-                else:
-                    logger.debug(f"Imported campaign report '{report_path}' from 'report_summary_scenario_all.txt'")
+
+            # Note: It is commented since not maintained anymore (see note on __import_campaign_report_summary_scenario_all)
+            # # Try to import information from 'report_summary_scenario_all.txt'
+            # if updated_dt is None:
+            #     try:
+            #         updated_dt = self.__import_campaign_report_summary_scenario_all(report_path, camp_id)
+            #     except:
+            #         raise TechnicalException(f"Failed to import campaign report '{report_path}'")
+            #     else:
+            #         logger.debug(f"Imported campaign report '{report_path}' from 'report_summary_scenario_all.txt'")
             
             # Update campaign updated datetime
             self.__update_campaign_updated_datetime(camp_id, updated_dt)
 
+    def get_executed_scenario_uids(self, since=None, until=None):
+        return self._get_scenario_field_values('executed_scenario_uid', since, until)
+
     def get_scenario_uids(self, since=None, until=None):
+        return self._get_scenario_field_values('scenario_uid', since, until)
+
+    def _get_scenario_field_values(self, field_name, since=None, until=None):
         client = self.__get_db_client()
 
         # Get data from DB
@@ -230,20 +241,25 @@ class CampaignManager(object):
             if isinstance(until, datetime):
                 until = DateTime.datetime_2_str(until)
             w_compare_data.append(('status_at', CompareOperator.Inferior, until))
-        camp_names_gen = client.select("campaign_scenarios", where_compare_data=w_compare_data, sql_return='name',
-                                       result_as_dict_list=True, as_generator=True, order_bys=['name'], distinct=True)
+        camp_names_gen = client.select("campaign_scenarios", where_compare_data=w_compare_data, sql_return=field_name,
+                                       result_as_dict_list=True, as_generator=True, order_bys=[field_name], distinct=True)
 
         # Build result
-        res = [cn['uid'] for cn in camp_names_gen]
+        res = [cn[field_name] for cn in camp_names_gen]
 
         return res
 
-    def get_scenario_history(self, scenario_uid=None, size=None, since=None, until=None,
+    def get_scenario_history(self, executed_scenario_uid=None, scenario_uid=None, scenario_version=None, scenario_example_row_uid=None, scenario_example_row_id=None,
+                             size=None, since=None, until=None,
                              since_history=None, until_history=None, with_details=None):
         """
         Get history of a campaign scenario or of all scenarios run during a period of time.
 
-        :param scenario_uid: If defined, get history of scenario with this UID
+        :param executed_scenario_uid: If defined, get history for this executed scenario UID
+        :param scenario_uid: If defined, get history of executed scenario with this UID
+        :param scenario_version: If defined, get history of executed scenario with this version
+        :param scenario_example_row_uid: If defined, get history of executed scenario with this example row UID
+        :param scenario_example_row_id: If defined, get history of executed scenario with this example row ID
         :param size: Size max of each scenario history
         :param since: Begin of period to find scenarios for which return history (and history if since_history is not defined)
         :param until: End of period to find scenarios for which return history (and history if since_history is not defined)
@@ -260,16 +276,24 @@ class CampaignManager(object):
         client = self.__get_db_client()
 
         # Get UID of scenarios for which return history
-        if scenario_uid is not None:
-            scenario_uids = [scenario_uid]
+        if executed_scenario_uid is not None:
+            executed_scenario_uids = [executed_scenario_uid]
         else:
-            scenario_uids = self.get_scenario_uids(since=since, until=until)
+            executed_scenario_uids = self.get_executed_scenario_uids(since=since, until=until)
 
         # Get data from DB
         w_data = {}
         w_compare_data = []
+        if executed_scenario_uid is not None:
+            w_data['executed_scenario_uid'] = executed_scenario_uid
         if scenario_uid is not None:
-            w_data['uid'] = scenario_uid
+            w_data['scenario_uid'] = scenario_uid
+        if scenario_version is not None:
+            w_data['scenario_version'] = scenario_version
+        if scenario_example_row_uid is not None:
+            w_data['scenario_example_row_uid'] = scenario_example_row_uid
+        if scenario_example_row_id is not None:
+            w_data['scenario_example_row_id'] = scenario_example_row_id
         if since_history:
             if isinstance(since_history, datetime):
                 since_history = DateTime.datetime_2_str(since_history)
@@ -281,75 +305,86 @@ class CampaignManager(object):
         # Note: order by scenario name to have same order than filesystem
         camp_scenarios_gen = client.select("campaign_scenarios", where_data=w_data, where_compare_data=w_compare_data,
                                            result_as_dict_list=True, as_generator=True,
-                                           order_bys=['name', ('status_at', 'DESC')])
+                                           order_bys=['executed_scenario_uid', ('scenario_version', 'DESC'), ('status_at', 'DESC')])
 
         # Build result
         res = []
-        cur_scenario_uid = None
-        cur_scenario_data = None
+        cur_res_uid = None
+        cur_res_data = None
+        cur_res_version = None
+        cur_res_version_data = None
+        cur_res_size = 0
         for cs in camp_scenarios_gen:
             # Skip unwanted scenarios
-            if cs['uid'] not in scenario_uids:
+            if cs['executed_scenario_uid'] not in executed_scenario_uids:
                 continue
 
-            # Manage new scenario
-            if cur_scenario_uid is None or cur_scenario_uid != cs['uid']:
-                cur_scenario_data = []
-                cur_scenario_uid = cs['uid']
-                res.append({'uid':cur_scenario_uid, 'history':cur_scenario_data})
-            
+            # Manage new executed scenario
+            if cur_res_uid is None or cur_res_uid != cs['executed_scenario_uid']:
+                cur_res_data = []
+                cur_res_size = 0
+                cur_res_uid = cs['executed_scenario_uid']
+                res.append({'executed_scenario_uid': cur_res_uid, 'history_by_version': cur_res_data})
+
+            # Manage new scenario version
+            if cur_res_version is None or cur_res_version != cs['scenario_version']:
+                cur_res_version_data = []
+                cur_res_version = cs['scenario_version']
+                cur_res_data.append({'scenario_version': cur_res_version, 'history': cur_res_version_data})
+
             # Add campaign info for this scenario execution if size limit is not reached
-            if size is None or len(cur_scenario_data) < size:
+            if size is None or cur_res_size < size:
                 data = {'at':cs['status_at'], 'status':cs['status']}
                 if with_details:
                     data['report_path'] = cs['report_path']
                     details = json.loads(cs['details'])
                     data.update({k:v for k,v in details.items() if k in ['validation_category', 'failure']})
-                cur_scenario_data.append(data)
+                cur_res_version_data.append(data)
+                cur_res_size += 1
 
         if scenario_uid is not None and len(res) > 0:
-            return res[0]['history']
+            return res[0]['history_by_version']
         else:
             return res
 
-    def get_scenario_last_first_campaigns(self, scenario_uid):
+    def get_scenario_last_first_campaigns(self, executed_scenario_uid):
         """ For given scenario, get last campaign in which it passed (respectively failed) and after it first campaign in which it failed (respectively passed).
         Depending on validation category of the scenario, only one of both couples is generally interesting, but sometimes both are needed.
         For performance consideration, this method manages in same time the couple (last failed, next first passed) and (last passed, next first failed).
-        :param scenario_uid: UID of scenario
+        :param executed_scenario_uid: UID of executed scenario
         :return: 2 tuples ((last_passed, first_failed), (last_failed, first_passed)) with campaign names
         """
-        if scenario_uid is None:
-            raise TechnicalException(f"No scenario UID provided")
+        if executed_scenario_uid is None:
+            raise TechnicalException(f"No executed scenario UID provided")
 
         client = self.__get_db_client()
         placeholder = client._get_sql_placeholder()
         query_str = f'''
             select lp.last_passed, 
             (select c.name as first_failed from campaign_scenarios csff join campaigns c on c.id = csff.campaign_id
-                where csff.uid = {placeholder} and csff.status like 'Failed%'
+                where csff.executed_scenario_uid = {placeholder} and csff.status like 'Failed%'
                     and csff.status_at > lp.last_passed_at
                 order by csff.status_at
                 limit 1
             ) first_failed,
             lf.last_failed,
             (select c.name as first_passed from campaign_scenarios csfp join campaigns c on c.id = csfp.campaign_id
-                where csfp.uid = {placeholder} and csfp.status = 'Passed'
+                where csfp.executed_scenario_uid = {placeholder} and csfp.status = 'Passed'
                     and csfp.status_at > lf.last_failed_at
                 order by csfp.status_at
                 limit 1
             ) first_passed
             from
             (select c.name as last_passed, cslp.status_at as last_passed_at from campaign_scenarios cslp join campaigns c on c.id = cslp.campaign_id
-                where cslp.uid = {placeholder} and cslp.status = 'Passed'
+                where cslp.executed_scenario_uid = {placeholder} and cslp.status = 'Passed'
                 order by cslp.status_at desc
                 limit 1) lp,
             (select c.name as last_failed, cs.status_at as last_failed_at from campaign_scenarios cs join campaigns c on c.id = cs.campaign_id
-            where cs.uid = {placeholder} and cs.status like 'Failed%'
-            order by cs.status_at desc
-            limit 1) lf        
+                where cs.executed_scenario_uid = {placeholder} and cs.status like 'Failed%'
+                order by cs.status_at desc
+                limit 1) lf        
         '''
-        where_data = [scenario_uid, scenario_uid, scenario_uid, scenario_uid]
+        where_data = [executed_scenario_uid, executed_scenario_uid, executed_scenario_uid, executed_scenario_uid]
         res_dict_list = client.execute(query_str, *where_data, result_as_dict_list=True, as_generator=False)
 
         if len(res_dict_list) == 1:
@@ -364,9 +399,12 @@ class CampaignManager(object):
         camp = self.__campaigns_table_manager.get_data(filter_data)
         return camp['id']
     
-    def update_or_add_campaign_scenario(self, campaign_id, uid, name, *, report_path=None, status=None, status_at_str=None, details=None):
-        filter_data = {'campaign_id': campaign_id, 'uid':uid, 'name': name}
-        data = {}
+    def update_or_add_campaign_scenario(self, campaign_id, executed_scenario_uid, scenario_uid, scenario_version, scenario_example_row_uid, scenario_example_row_id,
+                                        name, *, report_path=None, status=None, status_at_str=None, details=None):
+        filter_data = {'campaign_id': campaign_id, 'executed_scenario_uid':executed_scenario_uid}
+        data = {'scenario_uid':scenario_uid, 'scenario_version':scenario_version,
+                'scenario_example_row_uid':scenario_example_row_uid, 'scenario_example_row_id':scenario_example_row_id,
+                'name': name}
         if report_path is not None:
             data['report_path'] = report_path
         if status is not None:
@@ -392,12 +430,12 @@ class CampaignManager(object):
         file_dt = DateTime.timestamp_to_datetime(os.path.getmtime(file_path))
         return file_dt > stored_dt
     
-    def __get_campaign_status_at_by_scenario(self, camp_id):
+    def __get_campaign_status_at_by_executed_scenario(self, camp_id):
         res = {}
         
         filter_data = {'campaign_id':camp_id}
         for data in self.__campaign_scenarios_table_manager.get_datas(filter_data, as_generator=True):
-            uid = data.get('uid', data['name'])     # Use name if uid is not available
+            uid = data.get('executed_scenario_uid', data['name'])     # Use name if uid is not available
             res[uid] = data['status_at']
         
         return res
@@ -407,7 +445,7 @@ class CampaignManager(object):
         if not os.path.exists(filepath):
             return None
         
-        status_at_by_scenario = self.__get_campaign_status_at_by_scenario(camp_id)
+        status_at_by_scenario = self.__get_campaign_status_at_by_executed_scenario(camp_id)
         
         # Note: get file modified datetime just before reading it, so that modified datetime is not outdated and elements will be missed on next import 
         file_modified_dt = DateTime.timestamp_to_datetime(os.path.getmtime(filepath))
@@ -420,71 +458,78 @@ class CampaignManager(object):
         for scenario_index, scenario in enumerate(scenarios):
             if 'scenario' not in scenario:
                 raise TechnicalException(f"Unexpected structure of {scenario_index+1}'th scenario: {scenario}")
-            scenario = scenario['scenario']
+            details = copy.copy(scenario['scenario'])
 
-            name = scenario['file']
-            uid = scenario.get('uid', name)     # Use name as uid if uid is not available
+            name = details.pop('file')
+            executed_scenario_uid = details.pop('executed_uid', name)     # Use name as uid if uid is not available
 
-            m = regex_period.match(scenario['scenario_period'])
+            m = regex_period.match(details.pop('scenario_period'))
             if m:
                 status_at_str = m.group(2)
                 # If report is done with dates in compact format, end datetime in period is not a valid datetime, use begin datetime instead
                 if not DateTime.is_str_datetime(status_at_str[:10], '%Y-%m-%d'):
                     status_at_str = m.group(1)
             else:
-                raise TechnicalException(f"Failed to import report of scenario '{name}' in campaign report file '{filepath}'")
+                raise TechnicalException(f"Failed to import report of scenario '{executed_scenario_uid}' in campaign report file '{filepath}'")
             
-            if uid in status_at_by_scenario and status_at_str == status_at_by_scenario[uid]:
+            if executed_scenario_uid in status_at_by_scenario and status_at_str == status_at_by_scenario[executed_scenario_uid]:
                 # Scenario result is already stored
                 continue
             
-            scenario_report_path = scenario['report']
-            status = scenario['validation_status']
-            details = json.dumps( {k:scenario[k] for k in scenario.keys() if k not in ['file', 'scenario_period', 'report', 'validation_status']} )
-            
-            self.update_or_add_campaign_scenario(camp_id, uid, name, report_path=scenario_report_path, status=status, status_at_str=status_at_str, details=details)
-        
-        return file_modified_dt
-        
-    def __import_campaign_report_summary_scenario_all(self, report_path, camp_id):
-        file_path = os.path.join(report_path, 'report_summary_scenario_all.txt')
-        if not os.path.exists(file_path):
-            return None
-        
-        # Note: get file modified datetime just before reading it, so that modified datetime is not outdated and elements will be missed on next import 
-        file_modified_dt = DateTime.timestamp_to_datetime(os.path.getmtime(file_path))
-        lines = File(file_path, do_open=True, mode='rt').readlines(strip_newline=True)
-        
-        regex_line_period = re.compile(r"^\[(.+) - ([^\]]+)\] ([^ ]+) - (.+?)(?: - .+)? - (.*)$")
-        regex_line_time = re.compile(r"^(.+?) - ([^ ]+) - (.+?)(?: - .+)? - (.+)$")
-        regex_status = re.compile(r"^(.*?)(?: \(.*\)| => .*)?$")
-        
-        for line in lines:
-            m = regex_line_period.match(line)
-            if m:
-                status_at_str = m.group(2)
-                # If report is done with dates in compact format, end datetime in period is not a valid datetime, use begin datetime instead
-                if not DateTime.is_str_datetime(status_at_str[:10], '%Y-%m-%d'):
-                    status_at_str = m.group(1)
-                scenario_uid = m.group(3)
-                scenario_name = m.group(4)
-                status_info = m.group(5)
-            else:
-                m = regex_line_time.match(line)
-                if not m:
-                    raise TechnicalException(f"Unexpected line format in {file_path}: [{line}]")
-                status_at_str = m.group(1)
-                scenario_uid = m.group(2)
-                scenario_name = m.group(3)
-                status_info = m.group(4)
-            
-            m = regex_status.match(status_info)
-            status = m.group(1)
+            scenario_uid = details.pop('uid', name)
+            scenario_version = details.pop('version', 0)
+            scenario_example_row_uid = details.pop('example_row_uid', None)
+            scenario_example_row_id = details.pop('example_row_id', None)
+            scenario_report_path = details.pop('report')
+            status = details.pop('validation_status')
+            details_str = json.dumps(details)
             
-            self.update_or_add_campaign_scenario(camp_id, scenario_uid, scenario_name, status=status, status_at_str=status_at_str)
+            self.update_or_add_campaign_scenario(camp_id, executed_scenario_uid, scenario_uid, scenario_version, scenario_example_row_uid, scenario_example_row_id,
+                                                 name, report_path=scenario_report_path, status=status, status_at_str=status_at_str, details=details_str)
         
         return file_modified_dt
 
+    # Note: Following method is commented as deprecated and not maintained anymore.
+    #       It is kept in case such behavior is again needed.
+    # def __import_campaign_report_summary_scenario_all(self, report_path, camp_id):
+    #     file_path = os.path.join(report_path, 'report_summary_scenario_all.txt')
+    #     if not os.path.exists(file_path):
+    #         return None
+    #
+    #     # Note: get file modified datetime just before reading it, so that modified datetime is not outdated and elements will be missed on next import
+    #     file_modified_dt = DateTime.timestamp_to_datetime(os.path.getmtime(file_path))
+    #     lines = File(file_path, do_open=True, mode='rt').readlines(strip_newline=True)
+    #
+    #     regex_line_period = re.compile(r"^\[(.+) - ([^\]]+)\] ([^ ]+) - (.+?)(?: - .+)? - (.*)$")
+    #     regex_line_time = re.compile(r"^(.+?) - ([^ ]+) - (.+?)(?: - .+)? - (.+)$")
+    #     regex_status = re.compile(r"^(.*?)(?: \(.*\)| => .*)?$")
+    #
+    #     for line in lines:
+    #         m = regex_line_period.match(line)
+    #         if m:
+    #             status_at_str = m.group(2)
+    #             # If report is done with dates in compact format, end datetime in period is not a valid datetime, use begin datetime instead
+    #             if not DateTime.is_str_datetime(status_at_str[:10], '%Y-%m-%d'):
+    #                 status_at_str = m.group(1)
+    #             scenario_uid = m.group(3)
+    #             scenario_name = m.group(4)
+    #             status_info = m.group(5)
+    #         else:
+    #             m = regex_line_time.match(line)
+    #             if not m:
+    #                 raise TechnicalException(f"Unexpected line format in {file_path}: [{line}]")
+    #             status_at_str = m.group(1)
+    #             scenario_uid = m.group(2)
+    #             scenario_name = m.group(3)
+    #             status_info = m.group(4)
+    #
+    #         m = regex_status.match(status_info)
+    #         status = m.group(1)
+    #
+    #         self.update_or_add_campaign_scenario(camp_id, scenario_uid, scenario_name, status=status, status_at_str=status_at_str)
+    #
+    #     return file_modified_dt
+
     def get_qa_data(self, qa_data_type, size=None, since=None, until=None, since_history=None, until_history=None, round_nb_decimal=None, with_details=False):
         match qa_data_type:
             case QAReportType.NumberByQAStatus:
@@ -499,7 +544,7 @@ class CampaignManager(object):
         counter_by_qa_status, counter_by_category = {}, {}
         all_history = self.get_scenario_history(size=size, since=since, until=until, since_history=since_history, until_history=until_history)
         for scenario_history in all_history:
-            sce_hist = scenario_history['history']
+            sce_hist = scenario_history['history_by_version']
             sce_cat = ScenarioTools.compute_validation_category_for_scenario_history(sce_hist)
 
             if sce_cat not in counter_by_category:
@@ -534,14 +579,15 @@ class CampaignManager(object):
         ratio_failed, ratio_success, ratio_by_status = 0, 0, Counter()
         all_history = self.get_scenario_history(size=size, since=since, until=until, since_history=since_history, until_history=until_history)
         for scenario_history in all_history:
-            sce_hist = scenario_history['history']
-            nb_success = sum(1 for x in sce_hist if x['status'] == 'Passed')
-            ratio_success += nb_success / len(sce_hist)
-            ratio_failed += (len(sce_hist) - nb_success) / len(sce_hist)
+            sce_hist = scenario_history['history_by_version']
+            nb_success = sum(1 for ver_hist in sce_hist for x in ver_hist['history'] if x['status'] == 'Passed')
+            nb_exec = sum(len(ver_hist['history']) for ver_hist in sce_hist)
+            ratio_success += nb_success / nb_exec
+            ratio_failed += (nb_exec - nb_success) / nb_exec
 
             if with_details:
-                ratio_by_status += Counter(x['status'] for x in sce_hist)
-        mean_run_nb = statistics.mean(len(x['history']) for x in all_history) if all_history else 0
+                ratio_by_status += Counter(x['status'] for ver_hist in sce_hist for x in ver_hist['history'])
+        mean_run_nb = statistics.mean(sum(len(ver_hist['history']) for ver_hist in sce_hist) for sce_hist in all_history) if all_history else 0
 
         # Compute QA data
         ratio_failed = round(ratio_failed, round_nb_decimal)