wiliot-certificate 1.3.0a1__py3-none-any.whl

gw_certificate/tests/registration.py

@@ -0,0 +1,288 @@
+import datetime
+import time
+import os
+from enum import Enum
+
+from wiliot_api.api_client import WiliotCloudError
+
+from gw_certificate.common.debug import debug_print
+from gw_certificate.tests.generic import INCONCLUSIVE_MINIMUM, PassCriteria, MINIMUM_SCORE, PERFECT_SCORE, GenericStage, GenericTest, INFORMATIVE
+from gw_certificate.api.extended_api import ExtendedEdgeClient
+from gw_certificate.tests.static.connection_defines import *
+from gw_certificate.tests.static.references import GW_REGISTER_DOC, GW_MQTT_DOC
+
+
+# HELPER DEFINES
+REG_CERT_OWNER_ID = 'gw-certification-account'
+ENV_VAR_AWS = 'WLT_REG_CERT_KEY_AWS'
+STAGES_TIMEOUT = 2
+TOKEN_EXPIRY_MINUTES = 3
+
+ERROR_NO_API_KEY = f'You must receive an API security key from wiliot and save if to the environment variable {ENV_VAR_AWS} first.'
+ERROR_NO_REGISTER = 'Gateway did not register itself in time.'
+ERROR_NO_ONLINE = 'Gateway did not connect to MQTT in time.'
+ERROR_NO_ACTIVE = 'Gateway did not upload a status message with its configurations in time.'
+ERROR_NO_REFRESH = 'Gateway did not reconnect to MQTT in time.'
+
+# HELPER CLASSES
+class GetGwField(Enum):
+    STATUS = 'status'
+    ONLINE = 'online'
+    ONLINE_UPDATED_AT = 'onlineUpdatedAt'
+    ACTIVATED_AT = 'activatedAt'
+
+class Status(Enum):
+    PRE_REGISTERED = 'pre-registered'
+    APPROVED = 'approved'
+    ACTIVE = 'active'
+
+class Online(Enum):
+    FALSE = False
+    TRUE = True
+
+class SharedData():
+    """
+    Hold variables which values must be shared between different stages.
+    gw_online_ts hold the time in which the gateway status became online
+    """
+    def __init__(self):
+        self.gw_online_ts = None
+
+# TEST STAGES
+class GenericRegistrationStage(GenericStage):
+    def __init__(self, gw_id, edge:ExtendedEdgeClient, **kwargs):
+        self.__dict__.update(kwargs)
+        self.gw_id = gw_id
+        self.edge = edge
+        super().__init__(**self.__dict__)
+    
+    def get_gateway_field(self, field:GetGwField):
+        temp = self.edge.get_gateway(self.gw_id)
+        return temp[field.value]
+
+class RegistryStage(GenericRegistrationStage):
+    def __init__(self, **kwargs):
+        self.__dict__.update(kwargs)
+        self.stage_tooltip = "Validate the gateway's registry step"
+        super().__init__(stage_name=type(self).__name__, **self.__dict__)
+
+    def prepare_stage(self):
+        super().prepare_stage()
+        debug_print('Pre-registering the gateway, please make sure it is not registered to any other account '
+                    'and that your device is ready to run the registration flow')
+        
+        def pre_register_gw_anew(gw_id):
+            try:
+                pre_registered = self.edge.register_gateway([gw_id])
+            except WiliotCloudError as wce:
+                wce_dict = wce.args[0]
+                status_code = wce_dict.get('status_code')
+                msg = wce_dict.get('message')
+                if status_code == 400 and 'already exists' in msg:
+                    debug_print(f'{gw_id} already exists in Wiliot platform! Deleting and pre-registering from scratch')
+                    self.edge.delete_gateway(gw_id)
+                    pre_registered = self.edge.register_gateway([gw_id])
+                else:
+                    raise wce
+            return pre_registered
+
+        pre_registered = pre_register_gw_anew(self.gw_id)
+        if not pre_registered:
+            debug_print('Failed pre-registering the gateway')
+            raise Exception(f"Failed pre-registering the gateway. Make sure:\n-Your API key ({ENV_VAR_AWS}) is valid.\n"
+                            "-You have a stable internet connection.\nOtherwise, try again later.")
+        debug_print(f"{self.gw_id} was pre-registered successfully")
+
+    def run(self):
+        super().run()
+        debug_print(f"Waiting for the gateway to finish the Registry step..")
+        timeout = datetime.datetime.now() + datetime.timedelta(minutes=STAGES_TIMEOUT)
+        self.status = self.get_gateway_field(GetGwField.STATUS)
+        while datetime.datetime.now() < timeout and not any(self.status == s.value for s in {Status.APPROVED, Status.ACTIVE}):
+            time.sleep(5)
+            self.status = self.get_gateway_field(GetGwField.STATUS)
+
+    def generate_stage_report(self):
+        self.add_report_header()
+        if not any(self.status == s.value for s in {Status.APPROVED, Status.ACTIVE}):
+            self.stage_pass = MINIMUM_SCORE
+            self.error_summary = ERROR_NO_REGISTER
+            self.add_to_stage_report(ERROR_NO_REGISTER)
+            debug_print(f"The gateway failed to register. Its status is '{self.status}' while it is expected to be '{Status.APPROVED.value}'.")
+            self.add_to_stage_report(f"There was an error in the Device-authorize or Registry steps.")
+            self.add_to_stage_report(f"Please go over the Device-authorize and Registry sections in this document:\n{GW_REGISTER_DOC}")
+            # TODO Ideally we should know where the error is exactly and inform the user. We currently lack such resolution
+        else:
+            self.stage_pass = PERFECT_SCORE
+            self.add_to_stage_report("Device-authorize and Registry requests were issued well.")
+            self.add_to_stage_report("Gateway registered successfully.")
+            debug_print("Gateway registered successfully")
+
+        self.report_html = self.template_engine.render_template('stage.html', stage=self,
+                                                                stage_report=self.report.split('\n'))
+        return super().generate_stage_report()
+    
+class OnlineStage(GenericRegistrationStage):
+    def __init__(self, **kwargs):
+        self.__dict__.update(kwargs)
+        self.stage_tooltip = "Validate the gateway become online on the platform"
+        super().__init__(stage_name=type(self).__name__, **self.__dict__)
+
+    def prepare_stage(self):
+        super().prepare_stage()
+
+    def run(self):
+        super().run()
+        debug_print(f"Waiting for the gateway to connect to MQTT..")
+        timeout = datetime.datetime.now() + datetime.timedelta(minutes=STAGES_TIMEOUT)
+        self.online = self.get_gateway_field(GetGwField.ONLINE)
+        while datetime.datetime.now() < timeout and self.online != True:
+            time.sleep(5)
+            self.online = self.get_gateway_field(GetGwField.ONLINE)
+
+    def generate_stage_report(self):
+        self.add_report_header()
+        if self.online != True:
+            self.stage_pass = MINIMUM_SCORE
+            self.error_summary = ERROR_NO_ONLINE
+            self.add_to_stage_report(ERROR_NO_ONLINE)
+            self.add_to_stage_report(f"Either it didn't acquire a token or it didn't connect to MQTT in time.")
+            self.add_to_stage_report(f"Please go over the Poll For Token section in:\n{GW_REGISTER_DOC}")
+            self.add_to_stage_report(f"and the MQTT details in:\n{GW_MQTT_DOC}")
+            debug_print("Gateway did not connect ot MQTT within time limit")
+            # TODO Ideally we should know where the error is exactly and inform the user. We currently lack such resolution
+        else:
+            self.stage_pass = PERFECT_SCORE
+            self.add_to_stage_report("Token acquisition and MQTT connection were done succesfully.")
+            self.add_to_stage_report("Gateway is online.")
+            debug_print("Gateway connected to MQTT successfully, it is online")
+            self.shared_data.gw_online_ts = datetime.datetime.now()
+
+        self.report_html = self.template_engine.render_template('stage.html', stage=self,
+                                                                stage_report=self.report.split('\n'))
+        return super().generate_stage_report()
+
+class ActiveStage(GenericRegistrationStage):
+    def __init__(self, **kwargs):
+        self.__dict__.update(kwargs)
+        self.stage_tooltip = "Validate the gateway upload a status message upon MQTT connection"
+        super().__init__(stage_name=type(self).__name__, **self.__dict__)
+
+    def prepare_stage(self):
+        super().prepare_stage()
+
+    def run(self):
+        super().run()
+        debug_print(f"Waiting for the gateway to upload a status message..")
+        timeout = datetime.datetime.now() + datetime.timedelta(minutes=STAGES_TIMEOUT)
+        self.status = self.get_gateway_field(GetGwField.STATUS)
+        while datetime.datetime.now() < timeout and self.status != Status.ACTIVE.value:
+            time.sleep(5)
+            self.status = self.get_gateway_field(GetGwField.STATUS)
+
+    def generate_stage_report(self):
+        self.add_report_header()
+        if self.status != Status.ACTIVE.value:
+            self.stage_pass = MINIMUM_SCORE
+            self.error_summary = ERROR_NO_ACTIVE
+            self.add_to_stage_report(ERROR_NO_ACTIVE)
+            self.add_to_stage_report(f"Please go over the Status section in:\n{GW_MQTT_DOC}")
+            debug_print("Gateway did not upload a status message upon connecting to MQTT")
+        else:
+            self.stage_pass = PERFECT_SCORE
+            self.add_to_stage_report("The gateway uploaded a status message in time.")
+            self.add_to_stage_report("Gateway is active.")
+            debug_print("Gateway uploaded a status message, it is active")
+
+        self.report_html = self.template_engine.render_template('stage.html', stage=self,
+                                                                stage_report=self.report.split('\n'))
+        return super().generate_stage_report()
+
+class RefreshStage(GenericRegistrationStage):
+    def __init__(self, **kwargs):
+        self.__dict__.update(kwargs)
+        self.stage_tooltip = "Validate the gateway refresh-token step"
+        super().__init__(stage_name=type(self).__name__, **self.__dict__)
+
+    def prepare_stage(self):
+        super().prepare_stage()
+
+    def run(self):
+        super().run()
+        debug_print(f"Waiting for the token to expire..")
+        timeout = self.shared_data.gw_online_ts + datetime.timedelta(minutes=TOKEN_EXPIRY_MINUTES)
+        while datetime.datetime.now() < timeout:
+            time.sleep(5)
+
+        def kick_gw_from_mqtt():
+            response = self.edge.kick_gw_from_mqtt(self.gw_id)
+            debug_print(f"Kick response:{response}")
+
+        debug_print(f"Token expired, kicking gateway")
+        kick_gw_from_mqtt()
+
+        debug_print(f"Waiting for the gateway to refresh its token and connect to MQTT..")
+        timeout = datetime.datetime.now() + datetime.timedelta(minutes=STAGES_TIMEOUT)
+        self.online = self.get_gateway_field(GetGwField.ONLINE)
+        while datetime.datetime.now() < timeout and self.online != True:
+            time.sleep(5)
+            self.online = self.get_gateway_field(GetGwField.ONLINE)
+
+    def generate_stage_report(self):
+        self.add_report_header()
+        if self.online != True:
+            self.stage_pass = MINIMUM_SCORE
+            self.error_summary = ERROR_NO_REFRESH
+            self.add_to_stage_report(ERROR_NO_REFRESH)
+            self.add_to_stage_report(f"Either it didn't refresh its token or it didn't connect to MQTT in time.")
+            self.add_to_stage_report(f"Please go over the Refresh Token section in:\n{GW_REGISTER_DOC}")
+            self.add_to_stage_report(f"and the MQTT details in:\n{GW_MQTT_DOC}")
+            debug_print("Gateway did not reconnect MQTT (was the token refreshed?)")
+        else:
+            self.stage_pass = PERFECT_SCORE
+            self.add_to_stage_report("Token refresh and MQTT reconnection were done succesfully.")
+            self.add_to_stage_report("Gateway is online.")
+
+        self.report_html = self.template_engine.render_template('stage.html', stage=self,
+                                                                stage_report=self.report.split('\n'))
+        return super().generate_stage_report()
+
+
+STAGES = [RegistryStage, OnlineStage, ActiveStage, RefreshStage]
+
+class RegistrationTest(GenericTest):
+    def __init__(self, **kwargs):
+        self.__dict__.update(kwargs)
+        self.test_tooltip = "Stages related to the process of registering a gateway with the Wiliot cloud"
+
+        # Set up the edge client for all stages
+        env = '' if self.env == 'prod' else '_' + str(self.env).upper()
+        api_sec_key = os.environ.get(ENV_VAR_AWS + env)
+        if not api_sec_key:
+            raise Exception(f"An API security key must be set to the envrionment variable {ENV_VAR_AWS} in order to run the RegistrationTest")
+        self.edge = ExtendedEdgeClient(api_sec_key, REG_CERT_OWNER_ID, env=self.env)
+
+        self.shared_data = SharedData()
+
+        super().__init__(**self.__dict__, test_name=type(self).__name__)
+        stages = STAGES
+        self.stages = [stage(**self.__dict__) for stage in stages]
+        
+    def run(self):
+        super().run()
+        self.test_pass = PERFECT_SCORE
+        for idx, stage in enumerate(self.stages):
+            stage.prepare_stage()
+            stage.run()
+            self.add_to_test_report(stage.generate_stage_report())
+            self.test_pass = PassCriteria.calc_for_test(self.test_pass, stage)
+            if self.test_pass != PERFECT_SCORE and stage != self.stages[-1]:
+                debug_print(f"{type(self).__name__} stopped without running all of its stages since {type(stage).__name__} failed")
+                self.add_to_test_report(f"{type(self).__name__} stopped without running all of its stages since {type(stage).__name__} failed")
+                self.stages = self.stages[0:idx + 1]
+                break
+    
+    def end_test(self):
+        debug_print(f'Deleting {self.gw_id} from {REG_CERT_OWNER_ID} before exiting')
+        self.edge.delete_gateway(self.gw_id)
+        super().end_test()

gw_certificate/tests/static/connection_defines.py

@@ -0,0 +1,9 @@
+CSV_NAME = 'bad_crc_to_PER_quantization.csv'
+INTERFERENCE_ANALYSIS_FW_VER = "4.2.0"
+CHANNELS_TO_ANALYZE = [(37, 2402), (38, 2426), (39, 2480)]
+CNTRS_LISTEN_TIME_SEC = 30
+MAX_UNSIGNED_32_BIT = 4294967295
+NON_WLT_RX = 'non_wlt_rx'
+WLT_RX = 'wlt_rx'
+BAD_CRC = 'bad_crc'
+CNTRS_KEYS = [NON_WLT_RX, WLT_RX, BAD_CRC]

gw_certificate/tests/static/downlink_defines.py

@@ -0,0 +1,9 @@
+SANITY_STAGE = "SanityStage"
+CORRELATION_STAGE = "CorrelationStage"
+STAGE_CONFIGS = {
+    SANITY_STAGE:([i for i in range(700, 901, 100)], range(3)),
+    CORRELATION_STAGE:([i for i in range(100, 2001, 400)], range(3))}
+TX_MAX_DURATIONS = range(100, 501, 100)
+RETRIES = range(5)
+MAX_RX_TX_PERIOD_SECS = 0.255
+DEFAULT_BRG_ID = "FFFFFFFFFFFF"

gw_certificate/tests/static/generated_packet_table.py

@@ -0,0 +1,209 @@
+
+import pkg_resources
+import pandas as pd
+
+from gw_certificate.common.debug import debug_print
+from gw_certificate.interface.pkt_generator import BrgPktGeneratorNetwork
+from gw_certificate.interface.if_defines import *
+from gw_certificate.interface.packet_error import PacketError
+
+CSV_NAME = 'packet_table.csv'
+PACKET_TABLE_CSV_PATH = pkg_resources.resource_filename(__name__, CSV_NAME)
+
+TEST_STRESS = 'stress'
+TEST_COUPLING = 'coupling'
+TEST_DOWNLINK = 'downlink'
+TEST_UPLINK = 'uplink'
+TEST_UNIFIED = 'unified'
+TEST_SENSOR = 'sensor'
+
+TESTS = [TEST_COUPLING, TEST_UPLINK, TEST_UNIFIED]
+class GeneratedPacketTable:
+    
+    def __init__(self) -> None:
+        self.brg_network = BrgPktGeneratorNetwork()
+        self.table = pd.read_csv(PACKET_TABLE_CSV_PATH)
+    
+    def get_data(self, test, duplication, time_delay, bridge_idx) -> list:    
+        assert test in TESTS, 'Invalid Test'
+        assert (duplication in UPLINK_DUPLICATIONS) or (duplication in UNIFIED_DUPLICATIONS), 'Invalid Duplication'
+        assert (time_delay in UPLINK_TIME_DELAYS) or (time_delay in UNIFIED_TIME_DELAYS), 'Invalid Time Delay'
+        assert bridge_idx in BRIDGES, 'Invalid Bridge'
+        
+        t = self.table
+        return t.loc[((t['test'] == test) &
+                      (t['duplication'] == duplication) &
+                      (t['time_delay'] == time_delay) &
+                      (t['bridge_idx'] == bridge_idx))].to_dict('records')[0]
+            
+    def get_df(self, columns=None):
+        if columns is not None:
+            return self.table[columns]
+        return self.table
+
+    # def get_unified_data(self) -> pd.DataFrame:
+    #     t = self.table
+    #     return t.loc[((t['test'] == 'stress'))] 
+    
+    def get_stress_data(self) -> pd.DataFrame:
+        t = self.table
+        return t.loc[((t['test'] == 'stress'))] 
+    
+    def get_sensor_data(self) -> pd.DataFrame:
+        t = self.table
+        return t.loc[((t['test'] == 'sensor'))] 
+
+    def get_mgmt_data(self) -> pd.DataFrame:
+        t = self.table
+        return t.loc[((t['test'] == 'mgmt'))] 
+
+    def get_unified_data(self) -> pd.DataFrame:
+        t = self.table
+        return t.loc[((t['test'] == 'unified'))] 
+    
+    def _generate_packet_table(self):
+        packet_list = []
+        
+        # UNIFIED TEST
+        for duplication in UNIFIED_DUPLICATIONS:
+            debug_print(f'Duplication {duplication}')
+            for time_delay in UNIFIED_TIME_DELAYS:
+                debug_print(f'Time Delay {time_delay}')
+                pkts = self.brg_network.get_new_pkt_unified()
+                for idx, brg in enumerate(self.brg_network.brg_list):
+                    debug_print(f'Bridge {idx}')
+                    data = pkts[idx]['data_packet']
+                    brg_id = self.brg_network.brg_list[idx].bridge_id
+                    # log the sent packet with relevant info from run
+                    expected_pkt = brg.get_expected_mqtt_unified(full_data_pkt=data)
+                    for pkt in expected_pkt:
+                        pkt.update({'duplication': duplication, 'time_delay': time_delay})
+                    packet_list.append({'test': TEST_UNIFIED,
+                                        'duplication': duplication,
+                                        'time_delay': time_delay,
+                                        'bridge_idx': idx,
+                                        'expected_mqtt': expected_pkt
+                                        ,ADVA_PAYLOAD: data, 'bridge_id': brg_id,
+                                        'adva': data[:12], 'payload': data[16:], 'pkt_id': data[-8:]
+                                        })        
+
+        #STRESS TEST
+        i = 0
+        while i < 10000:
+            i += 1
+            pkts = self.brg_network.get_new_pkt_unified()
+            target_idx = 0  
+            brg = self.brg_network.brg_list[target_idx]
+            debug_print(f'Bridge {target_idx}')
+            data = pkts[target_idx]['data_packet']
+            brg_id = brg.bridge_id
+            expected_pkt = brg.get_expected_mqtt_unified(full_data_pkt=data)
+            packet_list.append({
+                'test': TEST_STRESS,
+                'duplication': 1,
+                'bridge_idx': target_idx,
+                'expected_mqtt': expected_pkt,
+                ADVA_PAYLOAD: data,
+                'bridge_id': brg_id,
+                'adva': data[:12],
+                'payload': data[16:],
+                'pkt_id': data[-8:]
+            })          
+
+        def _sensor_data(df):
+            hardcoded_data = [
+                {"test": "sensor", "duplication": "5", "time_delay": "20", "bridge_idx": 2, "expected_mqtt": [{"timestamp": 17305216968476073494, "payload": "90FC020000B54D387A227038613C0D8E0FF376D199289FE6679AA0D902", "duplication": 3, "time_delay": 20}, {"timestamp": 4278768225950047766, "payload": "C6FC0000EB3B613D08177B87B44500000000000000000000009AA0D902", "duplication": 3, "time_delay": 20}], ADVA_PAYLOAD: "F0287B2557141E1690FC020000B54D387A227038613C0D8E0FF376D199289FE6679AA0D902", "payload":"90FC020000B54D387A227038613C0D8E0FF376D199289FE6679AA0D902" ,"si": "3B613D0817FB1E16C6FC0000EB3B613D08177B87B44500000000000000000000009AA0D902", "bridge_id": "3B613D08177B", "adva": "F0287B255714", "pkt_id": "9AA0D902"},
+                {"test": "sensor", "duplication": "5", "time_delay": "20", "bridge_idx": 2, "expected_mqtt": [{"timestamp": 17305216968476073494, "payload": "90FC0200003A79C9BEF41223AC3F4A962D97F519C9DA06CA5F4F643826", "duplication": 3, "time_delay": 20}, {"timestamp": 4278768225950047766, "payload": "C6FC0000EB3B613D08177B7D396B00000000000000000000004F643826", "duplication": 3, "time_delay": 20}], ADVA_PAYLOAD: "F0287B2557141E1690FC0200003A79C9BEF41223AC3F4A962D97F519C9DA06CA5F4F643826", "payload":"90FC0200003A79C9BEF41223AC3F4A962D97F519C9DA06CA5F4F643826" ,"si": "3B613D0817FB1E16C6FC0000EB3B613D08177B7D396B00000000000000000000004F643826", "bridge_id": "3B613D08177B", "adva": "F0287B255714", "pkt_id": "4F643826"},
+                {"test": "sensor", "duplication": "5", "time_delay": "20", "bridge_idx": 2, "expected_mqtt": [{"timestamp": 17305216968476073494, "payload": "90FC0200001B65E90DDC0090175F67F3F8E7E3DA2FFA6A945076D1D979", "duplication": 3, "time_delay": 20}, {"timestamp": 4278768225950047766, "payload": "C6FC0000EB3B613D08177B39B69D000000000000000000000076D1D979", "duplication": 3, "time_delay": 20}], ADVA_PAYLOAD: "F0287B2557141E1690FC0200001B65E90DDC0090175F67F3F8E7E3DA2FFA6A945076D1D979", "payload":"90FC0200001B65E90DDC0090175F67F3F8E7E3DA2FFA6A945076D1D979" ,"si": "3B613D0817FB1E16C6FC0000EB3B613D08177B39B69D000000000000000000000076D1D979", "bridge_id": "3B613D08177B", "adva": "F0287B255714", "pkt_id": "76D1D979"},
+                {"test": "sensor", "duplication": "5", "time_delay": "20", "bridge_idx": 2, "expected_mqtt": [{"timestamp": 17305216968476073494, "payload": "90FC020000D337363E43CDDDFC897492917BCC2DA2977E2751E31CAAA6", "duplication": 3, "time_delay": 20}, {"timestamp": 4278768225950047766, "payload": "C6FC0000EB3B613D08177B3E21640000000000000000000000E31CAAA6", "duplication": 3, "time_delay": 20}], ADVA_PAYLOAD: "F0287B2557141E1690FC020000D337363E43CDDDFC897492917BCC2DA2977E2751E31CAAA6", "payload":"90FC020000D337363E43CDDDFC897492917BCC2DA2977E2751E31CAAA6" ,"si": "3B613D0817FB1E16C6FC0000EB3B613D08177B3E21640000000000000000000000E31CAAA6", "bridge_id": "3B613D08177B", "adva": "F0287B255714", "pkt_id": "E31CAAA6"},
+                {"test": "sensor", "duplication": "5", "time_delay": "20", "bridge_idx": 2, "expected_mqtt": [{"timestamp": 17305216968476073494, "payload": "90FC0200001D646652892618D2CE80CA4A880A8CF46346C7743C509B54", "duplication": 3, "time_delay": 20}, {"timestamp": 4278768225950047766, "payload": "C6FC0000EB3B613D08177B5BCD2900000000000000000000003C509B54", "duplication": 3, "time_delay": 20}], ADVA_PAYLOAD: "F0287B2557141E1690FC0200001D646652892618D2CE80CA4A880A8CF46346C7743C509B54", "payload":"90FC0200001D646652892618D2CE80CA4A880A8CF46346C7743C509B54" ,"si": "3B613D0817FB1E16C6FC0000EB3B613D08177B5BCD2900000000000000000000003C509B54", "bridge_id": "3B613D08177B", "adva": "F0287B255714", "pkt_id": "3C509B54"},
+                {"test": "sensor", "duplication": "5", "time_delay": "20", "bridge_idx": 2, "expected_mqtt": [{"timestamp": 17305216968476073494, "payload": "90FC020000CEE15F2E2EE026B22C739867453C6E2E108E9E8610FE7F07", "duplication": 3, "time_delay": 20}, {"timestamp": 4278768225950047766, "payload": "C6FC0000EB3B613D08177B9647FC000000000000000000000010FE7F07", "duplication": 3, "time_delay": 20}], ADVA_PAYLOAD: "F0287B2557141E1690FC020000CEE15F2E2EE026B22C739867453C6E2E108E9E8610FE7F07", "payload":"90FC020000CEE15F2E2EE026B22C739867453C6E2E108E9E8610FE7F07" ,"si": "3B613D0817FB1E16C6FC0000EB3B613D08177B9647FC000000000000000000000010FE7F07", "bridge_id": "3B613D08177B", "adva": "F0287B255714", "pkt_id": "10FE7F07"},
+                {"test": "sensor", "duplication": "5", "time_delay": "20", "bridge_idx": 2, "expected_mqtt": [{"timestamp": 17305216968476073494, "payload": "90FC0200002CC60917A02CB02367771BE9EA20F9666ED8A06F6612745B", "duplication": 3, "time_delay": 20}, {"timestamp": 4278768225950047766, "payload": "C6FC0000EB3B613D08177BF1EBC500000000000000000000006612745B", "duplication": 3, "time_delay": 20}], ADVA_PAYLOAD: "F0287B2557141E1690FC0200002CC60917A02CB02367771BE9EA20F9666ED8A06F6612745B", "payload":"90FC0200002CC60917A02CB02367771BE9EA20F9666ED8A06F6612745B" ,"si": "3B613D0817FB1E16C6FC0000EB3B613D08177BF1EBC500000000000000000000006612745B", "bridge_id": "3B613D08177B", "adva": "F0287B255714", "pkt_id": "6612745B"},
+                {"test": "sensor", "duplication": "5", "time_delay": "20", "bridge_idx": 2, "expected_mqtt": [{"timestamp": 17305216968476073494, "payload": "90FC02000007EFE229109B044DB995A506179C99094720AE8BF9F78C1A", "duplication": 3, "time_delay": 20}, {"timestamp": 4278768225950047766, "payload": "C6FC0000EB3B613D08177B6CEC9A0000000000000000000000F9F78C1A", "duplication": 3, "time_delay": 20}], ADVA_PAYLOAD: "F0287B2557141E1690FC02000007EFE229109B044DB995A506179C99094720AE8BF9F78C1A", "payload":"90FC02000007EFE229109B044DB995A506179C99094720AE8BF9F78C1A" ,"si": "3B613D0817FB1E16C6FC0000EB3B613D08177B6CEC9A0000000000000000000000F9F78C1A", "bridge_id": "3B613D08177B", "adva": "F0287B255714", "pkt_id": "F9F78C1A"},
+                {"test": "sensor", "duplication": "5", "time_delay": "20", "bridge_idx": 2, "expected_mqtt": [{"timestamp": 17305216968476073494, "payload": "90FC0200002CA1E008E364D0DCF65631718BCD659DE3323A69A674F7B9", "duplication": 3, "time_delay": 20}, {"timestamp": 4278768225950047766, "payload": "C6FC0000EB3B613D08177B1051900000000000000000000000A674F7B9", "duplication": 3, "time_delay": 20}], ADVA_PAYLOAD: "F0287B2557141E1690FC0200002CA1E008E364D0DCF65631718BCD659DE3323A69A674F7B9", "payload":"90FC0200002CA1E008E364D0DCF65631718BCD659DE3323A69A674F7B9" ,"si": "3B613D0817FB1E16C6FC0000EB3B613D08177B1051900000000000000000000000A674F7B9", "bridge_id": "3B613D08177B", "adva": "F0287B255714", "pkt_id": "A674F7B9"},
+                {"test": "sensor", "duplication": "5", "time_delay": "20", "bridge_idx": 2, "expected_mqtt": [{"timestamp": 17305216968476073494, "payload": "90FC02000049ADD722F535679C37983927655C974A4980B080045DA6C2", "duplication": 3, "time_delay": 20}, {"timestamp": 4278768225950047766, "payload": "C6FC0000EB3B613D08177B5280B20000000000000000000000045DA6C2", "duplication": 3, "time_delay": 20}], ADVA_PAYLOAD: "F0287B2557141E1690FC02000049ADD722F535679C37983927655C974A4980B080045DA6C2", "payload":"90FC02000049ADD722F535679C37983927655C974A4980B080045DA6C2" ,"si": "3B613D0817FB1E16C6FC0000EB3B613D08177B5280B20000000000000000000000045DA6C2", "bridge_id": "3B613D08177B", "adva": "F0287B255714", "pkt_id": "045DA6C2"},
+                {"test": "sensor", "duplication": "5", "time_delay": "20", "bridge_idx": 2, "expected_mqtt": [{"timestamp": 17305216968476073494, "payload": "90FC0200004C8AD49C6D96923BFB70DF06554F5E8F438F1DF57E063773", "duplication": 3, "time_delay": 20}, {"timestamp": 4278768225950047766, "payload": "C6FC0000EB3B613D08177BB4085900000000000000000000007E063773", "duplication": 3, "time_delay": 20}], ADVA_PAYLOAD: "F0287B2557141E1690FC0200004C8AD49C6D96923BFB70DF06554F5E8F438F1DF57E063773", "payload":"90FC0200004C8AD49C6D96923BFB70DF06554F5E8F438F1DF57E063773" ,"si": "3B613D0817FB1E16C6FC0000EB3B613D08177BB4085900000000000000000000007E063773", "bridge_id": "3B613D08177B", "adva": "F0287B255714", "pkt_id": "7E063773"},
+                {"test": "sensor", "duplication": "5", "time_delay": "20", "bridge_idx": 2, "expected_mqtt": [{"timestamp": 17305216968476073494, "payload": "90FC02000064A5B54285BB6BCDB457ABBED8EE26B4EB43B27A8C26781C", "duplication": 3, "time_delay": 20}, {"timestamp": 4278768225950047766, "payload": "C6FC0000EB3B613D08177B27363800000000000000000000008C26781C", "duplication": 3, "time_delay": 20}], ADVA_PAYLOAD: "F0287B2557141E1690FC02000064A5B54285BB6BCDB457ABBED8EE26B4EB43B27A8C26781C", "payload":"90FC02000064A5B54285BB6BCDB457ABBED8EE26B4EB43B27A8C26781C" ,"si": "3B613D0817FB1E16C6FC0000EB3B613D08177B27363800000000000000000000008C26781C", "bridge_id": "3B613D08177B", "adva": "F0287B255714", "pkt_id": "8C26781C"},
+            ]
+        
+            hardcoded_df = pd.DataFrame(hardcoded_data)
+            return pd.concat([df, hardcoded_df], ignore_index=True)
+
+        def _mgmt_data(df):
+            hardcoded_data = [
+                # First pkt is HB, second is CFG_INFO of MODULE_IF
+                {"test": "mgmt", "duplication": "10", "time_delay": "20", "bridge_idx": 2, "expected_mqtt": [{"timestamp": 17305216968476073494, "payload": "C6FC0000EE020AD2A365FEC65912095E9101FF1104EB0958D400110100", "duplication": 10, "time_delay": 20}], ADVA_PAYLOAD: "A365FEC659D21E16C6FC0000EE020AD2A365FEC65912095E9101FF1104EB0958D400110100", "payload": "C6FC0000EE020AD2A365FEC65912095E9101FF1104EB0958D400110100", "si": "", "bridge_id": "A365FEC65912", "adva": "A365FEC659D2", "pkt_id": "00110100"},
+                {"test": "mgmt", "duplication": "10", "time_delay": "20", "bridge_idx": 2, "expected_mqtt": [{"timestamp": 17305216968476073494, "payload": "C6FC0000EE110BD3A365FEC6591203040121E8F2FDB000000000000000", "duplication": 10, "time_delay": 20}], ADVA_PAYLOAD: "A365FEC659D21E16C6FC0000EE110BD3A365FEC6591203040121E8F2FDB000000000000000", "payload": "C6FC0000EE110BD3A365FEC6591203040121E8F2FDB000000000000000", "si": "", "bridge_id": "A365FEC65912", "adva": "A365FEC659D2", "pkt_id": "00000000"},
+            ]
+        
+            hardcoded_df = pd.DataFrame(hardcoded_data)
+            return pd.concat([df, hardcoded_df], ignore_index=True)
+        
+        df = pd.DataFrame(packet_list)
+        df = _sensor_data(df)
+        df = _mgmt_data(df)
+        df.to_csv(PACKET_TABLE_CSV_PATH)
+
+class CouplingRunData:
+    def __init__(self, data) -> None:
+        self.test = data['test']
+        self.duplication = data['duplication']
+        self.time_delay = data['time_delay']
+        self.bridge_idx = data['bridge_idx']
+        self.packet_error = eval(data['packet_error'])
+        self.expected_mqtt = eval(data['expected_mqtt'])
+        self.data = data[ADVA_PAYLOAD]
+        self.si = data['si']
+        self.bridge_id = data['bridge_id']
+        self.scattered_time_delay = data['scattered_time_delay']
+
+
+    @classmethod
+    def get_data(cls, test, duplication, time_delay, bridge_idx):
+        packet_data = GeneratedPacketTable().get_data(test, duplication, time_delay, bridge_idx)
+        return cls(packet_data)
+
+class UplinkRunData:
+    def __init__(self, data) -> None:
+        self.test = data['test']
+        self.duplication = data['duplication']
+        self.time_delay = data['time_delay']
+        self.bridge_idx = data['bridge_idx']
+        self.expected_mqtt = eval(data['expected_mqtt'])
+        self.data = data[ADVA_PAYLOAD]
+        self.si = data['si']
+        self.bridge_id = data['bridge_id']   
+
+    @classmethod
+    def get_data(cls, test, duplication, time_delay, bridge_idx):
+        packet_data = GeneratedPacketTable().get_data(test, duplication, time_delay, bridge_idx)
+        return cls(packet_data)
+    
+class UnifiedRunData:
+    def __init__(self) -> None:
+        self.data = GeneratedPacketTable().get_unified_data()
+
+class StressRunData:
+    def __init__(self) -> None:
+        self.data = GeneratedPacketTable().get_stress_data()
+
+class SensorRunData:
+    def __init__(self) -> None:
+        self.data = GeneratedPacketTable().get_sensor_data()
+
+class MgmtRunData:
+    def __init__(self) -> None:
+        self.data = GeneratedPacketTable().get_mgmt_data()
+
+class PacketTableHelper():
+    def __init__(self):
+        self.table = GeneratedPacketTable().get_df()
+
+    def set_field(self, data_payload, field, value):
+        self.table.loc[self.table[ADVA_PAYLOAD].str.contains(data_payload) == True, field] = value
+
+    def get_field(self, data_payload, field):
+        return self.table[self.table[ADVA_PAYLOAD].str.contains(data_payload) == True][field]
+        
+if __name__ == "__main__":
+    GeneratedPacketTable()._generate_packet_table()