wiliot-certificate 4.4.3__py3-none-any.whl → 4.5.0a1__py3-none-any.whl

gw_certificate/tests/registration.py

@@ -1,340 +0,0 @@
-import datetime
-import time
-import os
-from enum import Enum
-from typing import Literal
-
-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_MINUTES = 2
-TOKEN_EXPIRY_MINUTES = 3
-CLOUD_DELAY_SEC = 7
-BUSY_WAIT_DELAY_SEC = 5
-STAGE_START_DELAY_MS = (BUSY_WAIT_DELAY_SEC + CLOUD_DELAY_SEC + 1) * 1000
-
-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'
-    REGISTERED = 'registered'
-    APPROVED = 'approved'
-    ACTIVE = 'active'
-
-class RegistrationData():
-    """
-    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]
-    
-    def kick_gw_from_mqtt(self):
-        response = self.edge.kick_gw_from_mqtt(self.gw_id)
-        debug_print(f"Kick response:{response}")
-    
-    def validate_kong_logs(self, endpoint:Literal['device-authorize', 'registry', 'token', 'refresh']):
-        message = None
-        try:
-            message = self.edge.get_kong_logs(self.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 == 404 and 'not found' in msg:
-                debug_print("Could not find gw when requesting for logs.")
-                debug_print("Either it is not registered, didn't issue any requests, or is missing the X-Gateway-ID header.")
-                return False
-            elif status_code == None:
-                raise wce
-        if isinstance(message, dict) and message.get('status_code') != 200:
-            debug_print(f"Failed fetching logs, status_code:{message.get('status_code')}")
-            return False
-
-        # Convert datetime.now() format to epoch in MS
-        stage_start_ts = self.start_time.timestamp() * 1000 - STAGE_START_DELAY_MS
-
-        for log in message['data']:
-            if log['timestamp'] > stage_start_ts and endpoint in log['endpoint']:
-                response_code = log['responseCode']
-                if response_code != 200:
-                    debug_print(f"An HTTP request to /{endpoint} resulted in an invalid response code:{response_code}")
-                else:
-                    debug_print(f"A valid HTTP request to /{endpoint} was received")
-                    return True
-        
-        debug_print(f"No valid HTTP request to /{endpoint} was found")
-        return False
-        
-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.kick_gw_from_mqtt()
-                    self.edge.delete_gateway(gw_id)
-                    time.sleep(CLOUD_DELAY_SEC)
-                    pre_registered = self.edge.register_gateway([gw_id])
-                else:
-                    if status_code == 403:
-                        debug_print(f"The API key within {self.env_variable} seems invalid. It is not authorized to pre-register the gateway")
-                    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_MINUTES)
-        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(BUSY_WAIT_DELAY_SEC)
-            self.status = self.get_gateway_field(GetGwField.STATUS)
-
-        time.sleep(CLOUD_DELAY_SEC)
-        self.validate_kong_logs('device-authorize')
-        self.validate_kong_logs('registry')
-
-    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}")
-            if self.status == Status.REGISTERED:
-                self.add_to_stage_report(f"Highly likely that the gateway is missing the 'X-Gateway-ID' header in it's HTTP requests.")
-        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_MINUTES)
-        self.online = self.get_gateway_field(GetGwField.ONLINE)
-        while datetime.datetime.now() < timeout and self.online != True:
-            time.sleep(BUSY_WAIT_DELAY_SEC)
-            self.online = self.get_gateway_field(GetGwField.ONLINE)
-
-        time.sleep(CLOUD_DELAY_SEC)
-        self.validate_kong_logs('token')
-
-    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 to MQTT within time limit")
-        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.reg_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_MINUTES)
-        self.status = self.get_gateway_field(GetGwField.STATUS)
-        while datetime.datetime.now() < timeout and self.status != Status.ACTIVE.value:
-            time.sleep(BUSY_WAIT_DELAY_SEC)
-            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.reg_data.gw_online_ts + datetime.timedelta(minutes=TOKEN_EXPIRY_MINUTES)
-        while datetime.datetime.now() < timeout:
-            time.sleep(BUSY_WAIT_DELAY_SEC)
-
-        debug_print(f"Token expired, kicking gateway")
-        self.kick_gw_from_mqtt()
-
-        # Sleep here since it sometimes take time for the cloud to kick and change the gateway's online status
-        time.sleep(CLOUD_DELAY_SEC)
-        debug_print(f"Waiting for the gateway to refresh its token and connect to MQTT..")
-        timeout = datetime.datetime.now() + datetime.timedelta(minutes=STAGES_TIMEOUT_MINUTES)
-        self.online = self.get_gateway_field(GetGwField.ONLINE)
-        while datetime.datetime.now() < timeout and self.online != True:
-            time.sleep(BUSY_WAIT_DELAY_SEC)
-            self.online = self.get_gateway_field(GetGwField.ONLINE)
-
-        time.sleep(CLOUD_DELAY_SEC)
-        self.validate_kong_logs('refresh')
-
-    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()
-        self.env_variable = ENV_VAR_AWS + env
-        api_sec_key = os.environ.get(self.env_variable)
-        if not api_sec_key:
-            raise Exception(f"An API security key must be set to the envrionment variable {self.env_variable} in order to run the RegistrationTest")
-        self.edge = ExtendedEdgeClient(api_sec_key, REG_CERT_OWNER_ID, env=self.env)
-
-        self.reg_data = RegistrationData()
-
-        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, 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')
-        time.sleep(CLOUD_DELAY_SEC)
-        self.edge.delete_gateway(self.gw_id)
-        super().end_test()

gw_certificate/tests/static/connection_defines.py

@@ -1,9 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,195 +0,0 @@
-
-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 *
-
-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_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_acl_data(self) -> pd.DataFrame:
-        t = self.table
-        return t.loc[((t['test'] == 'acl'))] 
-
-    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
-                    packet_list.append({'test': TEST_UNIFIED,
-                                        'duplication': duplication,
-                                        'time_delay': time_delay,
-                                        'bridge_idx': idx,
-                                        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
-            packet_list.append({
-                'test': TEST_STRESS,
-                'duplication': 1,
-                'bridge_idx': target_idx,
-                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, ADVA_PAYLOAD: "3B613D0817FB101690FCA1016417913C42FD38AF3F23AC0201060303E1FF060000FA0EAB04", "payload":"90FCA1016417913C42FD38AF3F23AC0201060303E1FF060000FA0EAB04" ,"si": "3B613D0817FB1E16C6FC0000EB3B613D08177B00003600AC233FAF38FD16E1FF05FA0EAB04", "bridge_id": "3B613D08177B", "adva": "3B613D0817FB", "pkt_id": "FA0EAB04"},
-                {"test": "sensor", "duplication": "5", "time_delay": "20", "bridge_idx": 2, ADVA_PAYLOAD: "3B613D0817FB101690FCA10164157D358A0E39AF3F23AC0201060303E1FF0600007EE3A33F", "payload":"90FCA10164157D358A0E39AF3F23AC0201060303E1FF0600007EE3A33F" ,"si": "3B613D0817FB1E16C6FC0000EB3B613D08177B00004300AC233FAF390E16E1FF057EE3A33F", "bridge_id": "3B613D08177B", "adva": "3B613D0817FB", "pkt_id": "7EE3A33F"},
-                {"test": "sensor", "duplication": "5", "time_delay": "20", "bridge_idx": 2, ADVA_PAYLOAD: "3B613D0817FB111690FCA1085CCA5BF13F23AC4D425330310201060303E1FF0500E16ED8EA", "payload":"90FCA1085CCA5BF13F23AC4D425330310201060303E1FF0500E16ED8EA" ,"si": "3B613D0817FB1E16C6FC0000EB3B613D08177B00004700AC233FF15BCA16E1FF05E16ED8EA", "bridge_id": "3B613D08177B", "adva": "3B613D0817FB", "pkt_id": "E16ED8EA"},
-                {"test": "sensor", "duplication": "5", "time_delay": "20", "bridge_idx": 2, ADVA_PAYLOAD: "3B613D0817FB101690FCA10164157D358A0E39AF3F23AC0201060303E1FF06000003E3A33F", "payload":"90FCA10164157D358A0E39AF3F23AC0201060303E1FF06000003E3A33F" ,"si": "3B613D0817FB1E16C6FC0000EB3B613D08177B00073E00AC233FAF390E16E1FF0503E3A33F", "bridge_id": "3B613D08177B", "adva": "3B613D0817FB", "pkt_id": "03E3A33F"},
-                {"test": "sensor", "duplication": "5", "time_delay": "20", "bridge_idx": 2, ADVA_PAYLOAD: "3B613D0817FB111690FCA10858CA5BF13F23AC4D425330310201060303E1FF0500996ED8EE", "payload":"90FCA10858CA5BF13F23AC4D425330310201060303E1FF0500996ED8EE" ,"si": "3B613D0817FB1E16C6FC0000EB3B613D08177B00043F00AC233FF15BCA16E1FF05996ED8EE", "bridge_id": "3B613D08177B", "adva": "3B613D0817FB", "pkt_id": "996ED8EE"},
-                {"test": "sensor", "duplication": "5", "time_delay": "20", "bridge_idx": 2, ADVA_PAYLOAD: "3B613D0817FB0E1690FCA10864FD38AF3F23AC53310201060303E1FF0800000000157A359C", "payload":"90FCA10864FD38AF3F23AC53310201060303E1FF0800000000157A359C" ,"si": "3B613D0817FB1E16C6FC0000EB3B613D08177B000E3600AC233FAF38FD16E1FF05157A359C", "bridge_id": "3B613D08177B", "adva": "3B613D0817FB", "pkt_id": "157A359C"},
-                {"test": "sensor", "duplication": "5", "time_delay": "20", "bridge_idx": 2, ADVA_PAYLOAD: "3B613D0817FB1E1690FC0200002CC60917A02CB02367771BE9EA20F9666ED8A06F6612745B", "payload":"90FC0200002CC60917A02CB02367771BE9EA20F9666ED8A06F6612745B" ,"si": "3B613D0817FB1E16C6FC0000EB3B613D08177BF1EBC500000000000000000000006612745B", "bridge_id": "3B613D08177B", "adva": "3B613D0817FB", "pkt_id": "6612745B"},
-                {"test": "sensor", "duplication": "5", "time_delay": "20", "bridge_idx": 2, ADVA_PAYLOAD: "3B613D0817FB1E1690FC02000007EFE229109B044DB995A506179C99094720AE8BF9F78C1A", "payload":"90FC02000007EFE229109B044DB995A506179C99094720AE8BF9F78C1A" ,"si": "3B613D0817FB1E16C6FC0000EB3B613D08177B6CEC9A0000000000000000000000F9F78C1A", "bridge_id": "3B613D08177B", "adva": "3B613D0817FB", "pkt_id": "F9F78C1A"},
-                {"test": "sensor", "duplication": "5", "time_delay": "20", "bridge_idx": 2, ADVA_PAYLOAD: "3B613D0817FB1E1690FC0200002CA1E008E364D0DCF65631718BCD659DE3323A69A674F7B9", "payload":"90FC0200002CA1E008E364D0DCF65631718BCD659DE3323A69A674F7B9" ,"si": "3B613D0817FB1E16C6FC0000EB3B613D08177B1051900000000000000000000000A674F7B9", "bridge_id": "3B613D08177B", "adva": "3B613D0817FB", "pkt_id": "A674F7B9"},
-                {"test": "sensor", "duplication": "5", "time_delay": "20", "bridge_idx": 2, ADVA_PAYLOAD: "3B613D0817FB1E1690FC02000049ADD722F535679C37983927655C974A4980B080045DA6C2", "payload":"90FC02000049ADD722F535679C37983927655C974A4980B080045DA6C2" ,"si": "3B613D0817FB1E16C6FC0000EB3B613D08177B5280B20000000000000000000000045DA6C2", "bridge_id": "3B613D08177B", "adva": "3B613D0817FB", "pkt_id": "045DA6C2"},
-                {"test": "sensor", "duplication": "5", "time_delay": "20", "bridge_idx": 2, ADVA_PAYLOAD: "3B613D0817FB1E1690FC0200004C8AD49C6D96923BFB70DF06554F5E8F438F1DF57E063773", "payload":"90FC0200004C8AD49C6D96923BFB70DF06554F5E8F438F1DF57E063773" ,"si": "3B613D0817FB1E16C6FC0000EB3B613D08177BB4085900000000000000000000007E063773", "bridge_id": "3B613D08177B", "adva": "3B613D0817FB", "pkt_id": "7E063773"},
-                {"test": "sensor", "duplication": "5", "time_delay": "20", "bridge_idx": 2, ADVA_PAYLOAD: "3B613D0817FB1E1690FC02000064A5B54285BB6BCDB457ABBED8EE26B4EB43B27A8C26781C", "payload":"90FC02000064A5B54285BB6BCDB457ABBED8EE26B4EB43B27A8C26781C" ,"si": "3B613D0817FB1E16C6FC0000EB3B613D08177B27363800000000000000000000008C26781C", "bridge_id": "3B613D08177B", "adva": "3B613D0817FB", "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, ADVA_PAYLOAD: "A365FEC659D21E16C6FC0000EE020AD2A365FEC65912095E9101FF1104EB0958D400110100", "payload": "C6FC0000EE020AD2A365FEC65912095E9101FF1104EB0958D400110100", "si": "", "bridge_id": "A365FEC65912", "adva": "A365FEC659D2", "pkt_id": "00110100"},
-                {"test": "mgmt", "duplication": "10", "time_delay": "20", "bridge_idx": 2, 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)
-
-        def _acl_data(df):
-            hardcoded_data = [
-                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 1, ADVA_PAYLOAD: "1659CAFE65E31E16C6FC00003F020AD2A365FECA5916095E9101FF1104EB0958D400110100", "payload": "C6FC00003F020AD2A365FECA5916095E9101FF1104EB0958D400110100", "si": "", "bridge_id": "A365FECA5916", "adva": "1659CAFE65E3", "pkt_id": "00110100"},
-                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 2, ADVA_PAYLOAD: "1A59C6FE65E31E16C6FC00003F020AD2A365FEC6591A095E9101FF1104EB0958D400110100", "payload": "C6FC00003F020AD2A365FEC6591A095E9101FF1104EB0958D400110100", "si": "", "bridge_id": "A365FEC6591A", "adva": "1A59C6FE65E3", "pkt_id": "00110100"},
-                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 1, ADVA_PAYLOAD: "1659CAFE65E31E16C6FC00003F020AD3A365FECA5916095E9101FF1104EB0958D400110101", "payload": "C6FC00003F020AD3A365FECA5916095E9101FF1104EB0958D400110101", "si": "", "bridge_id": "A365FECA5916", "adva": "1659CAFE65E3", "pkt_id": "00110101"},
-                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 2, ADVA_PAYLOAD: "1A59C6FE65E31E16C6FC00003F020AD3A365FEC6591A095E9101FF1104EB0958D400110101", "payload": "C6FC00003F020AD3A365FEC6591A095E9101FF1104EB0958D400110101", "si": "", "bridge_id": "A365FEC6591A", "adva": "1A59C6FE65E3", "pkt_id": "00110101"},
-                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 1, ADVA_PAYLOAD: "1659CAFE65E31E16C6FC00003F020AD4A365FECA5916095E9101FF1104EB0958D400110102", "payload": "C6FC00003F020AD4A365FECA5916095E9101FF1104EB0958D400110102", "si": "", "bridge_id": "A365FECA5916", "adva": "1659CAFE65E3", "pkt_id": "00110102"},
-                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 2, ADVA_PAYLOAD: "1A59C6FE65E31E16C6FC00003F020AD4A365FEC6591A095E9101FF1104EB0958D400110102", "payload": "C6FC00003F020AD4A365FEC6591A095E9101FF1104EB0958D400110102", "si": "", "bridge_id": "A365FEC6591A", "adva": "1A59C6FE65E3", "pkt_id": "00110102"},
-                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 1, ADVA_PAYLOAD: "1659CAFE65E31E16C6FC00003F020AD5A365FECA5916095E9101FF1104EB0958D400110103", "payload": "C6FC00003F020AD5A365FECA5916095E9101FF1104EB0958D400110103", "si": "", "bridge_id": "A365FECA5916", "adva": "1659CAFE65E3", "pkt_id": "00110103"},
-                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 2, ADVA_PAYLOAD: "1A59C6FE65E31E16C6FC00003F020AD5A365FEC6591A095E9101FF1104EB0958D400110103", "payload": "C6FC00003F020AD5A365FEC6591A095E9101FF1104EB0958D400110103", "si": "", "bridge_id": "A365FEC6591A", "adva": "1A59C6FE65E3", "pkt_id": "00110103"},
-                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 1, ADVA_PAYLOAD: "1659CAFE65E31E16C6FC00003F020AD6A365FECA5916095E9101FF1104EB0958D400110104", "payload": "C6FC00003F020AD6A365FECA5916095E9101FF1104EB0958D400110104", "si": "", "bridge_id": "A365FECA5916", "adva": "1659CAFE65E3", "pkt_id": "00110104"},
-                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 2, ADVA_PAYLOAD: "1A59C6FE65E31E16C6FC00003F020AD6A365FEC6591A095E9101FF1104EB0958D400110104", "payload": "C6FC00003F020AD6A365FEC6591A095E9101FF1104EB0958D400110104", "si": "", "bridge_id": "A365FEC6591A", "adva": "1A59C6FE65E3", "pkt_id": "00110104"},
-                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 1, ADVA_PAYLOAD: "1659CAFE65E31E16C6FC00003F020AD7A365FECA5916095E9101FF1104EB0958D400110105", "payload": "C6FC00003F020AD7A365FECA5916095E9101FF1104EB0958D400110105", "si": "", "bridge_id": "A365FECA5916", "adva": "1659CAFE65E3", "pkt_id": "00110105"},
-                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 2, ADVA_PAYLOAD: "1A59C6FE65E31E16C6FC00003F020AD7A365FEC6591A095E9101FF1104EB0958D400110105", "payload": "C6FC00003F020AD7A365FEC6591A095E9101FF1104EB0958D400110105", "si": "", "bridge_id": "A365FEC6591A", "adva": "1A59C6FE65E3", "pkt_id": "00110105"},
-                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 1, ADVA_PAYLOAD: "1659CAFE65E31E16C6FC00003F020AD8A365FECA5916095E9101FF1104EB0958D400110106", "payload": "C6FC00003F020AD8A365FECA5916095E9101FF1104EB0958D400110106", "si": "", "bridge_id": "A365FECA5916", "adva": "1659CAFE65E3", "pkt_id": "00110106"},
-                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 2, ADVA_PAYLOAD: "1A59C6FE65E31E16C6FC00003F020AD8A365FEC6591A095E9101FF1104EB0958D400110106", "payload": "C6FC00003F020AD8A365FEC6591A095E9101FF1104EB0958D400110106", "si": "", "bridge_id": "A365FEC6591A", "adva": "1A59C6FE65E3", "pkt_id": "00110106"},
-                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 1, ADVA_PAYLOAD: "1659CAFE65E31E16C6FC00003F020AD9A365FECA5916095E9101FF1104EB0958D400110107", "payload": "C6FC00003F020AD9A365FECA5916095E9101FF1104EB0958D400110107", "si": "", "bridge_id": "A365FECA5916", "adva": "1659CAFE65E3", "pkt_id": "00110107"},
-                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 2, ADVA_PAYLOAD: "1A59C6FE65E31E16C6FC00003F020AD9A365FEC6591A095E9101FF1104EB0958D400110107", "payload": "C6FC00003F020AD9A365FEC6591A095E9101FF1104EB0958D400110107", "si": "", "bridge_id": "A365FEC6591A", "adva": "1A59C6FE65E3", "pkt_id": "00110107"},
-            ]
-        
-            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 = _acl_data(df)
-        df.to_csv(PACKET_TABLE_CSV_PATH)
-    
-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 ACLRunData:
-    def __init__(self) -> None:
-        self.data = GeneratedPacketTable().get_acl_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()