wiliot-certificate 4.4.2__py3-none-any.whl → 4.5.0__py3-none-any.whl

brg_certificate/tests/sensors/ext_sensor_test/ext_sensor_test.py

@@ -1,305 +0,0 @@
-from brg_certificate.cert_prints import *
-from brg_certificate.cert_defines import *
-from brg_certificate.wlt_types import *
-import brg_certificate.cert_common as cert_common
-import brg_certificate.cert_config as cert_config
-import brg_certificate.cert_mqtt as cert_mqtt
-import csv
-# test MACROS definitions #
-DEFAULT_SENSOR_PAYLOAD_DATA = "0200002929B0FFF98DB104FA68BD5491456B55CC18AADB"
-DEFAULT_ADVA0 = "112233445566"
-DEFAULT_ADVA1 = "778899AABBCC"
-ERM_SMART_MS_PAYLOAD = "0201060303374C17FFAE0421EF9DE99CE7AE7C5EB13B744D401CC6CFCF0107"
-ZEBRA_PRINTER_PAYLOAD = "0201020F0958585A564A323331363038333435030279FEA5A5A5A5A5A5A5A5"
-DEFAULT_SPECIAL_PAYLOAD = ZEBRA_PRINTER_PAYLOAD
-DEFAULT_PACKET_LENGTH = "1E"
-
-SCAN_TIMEOUT = 60
-
-# UUID defines for logs review #
-ERM_SMART_MS_UUID = 0xFFAE04
-ZEBRA_PRINTER_UUID = 0x0279FE
-UUID_0 = ZEBRA_PRINTER_UUID
-UUID_1 = 0x987654
-SCRAMBLE_ON = 0x01
-SCRAMBLE_OFF = 0x00
-
-
-def uuid_scramble_cfg_add(uuid, scramble):
-    return uuid << 8 | scramble
-
-
-def unscramble(packet):
-    unscrambled_packet_id = int(hex(packet[RSSI])[2:] + packet[SENSOR_ID][-6:], 16)  # transforming parameters string to hex format
-    for idx in range(6, 60, 8):
-        current_word = int(packet[PAYLOAD][idx: idx + 8], 16)
-        unscrambled_packet_id ^= current_word
-    return packet[PAYLOAD][8:-8] + hex(unscrambled_packet_id)[2:]
-
-
-def find_packet_in_csv(unscrambled_payload):
-    base_path = os.path.dirname(os.path.abspath(__file__))
-    with open(f'{base_path}/out_sensor_data.csv', 'r') as csv_file:
-        csv_reader = csv.DictReader(csv_file)
-        next(csv_reader)                        # stepping over the header line
-        for line in csv_reader:
-            raw_data_payload = line['raw packet'][20:]
-            if raw_data_payload[:8] == unscrambled_payload[:8]:
-                return True
-        return False
-
-
-# Test functions description #
-def create_csv_file_in(test, length=500):
-    if test.data != DATA_SIMULATION:
-        return []
-    else:
-        base_path = os.path.dirname(os.path.abspath(__file__))
-    pkts = []
-    payload_0 = DEFAULT_ADVA0 + DEFAULT_SPECIAL_PAYLOAD
-    payload_1 = DEFAULT_ADVA1 + DEFAULT_PACKET_LENGTH + cert_common.int2mac_get(UUID_1)[6:] + DEFAULT_SENSOR_PAYLOAD_DATA
-    with open(f"{base_path}/in_sensor_data.csv", "w+") as f:
-        f.write("raw packet,output power,delay,duplicates,channel,COM\n")
-        for i in range(length):
-            f.write(payload_0 + ",8,200,6,37,COM3\n")
-            f.write(payload_1 + "{:08X}".format(i) + ",8,200,6,37,COM3\n")
-            pkts.append(payload_0)
-            pkts.append(payload_1 + "{:08X}".format(i))
-    return pkts
-
-
-def create_csv_file_out(test):
-    if test.data != DATA_SIMULATION:
-        return
-    else:
-        base_path = os.path.dirname(os.path.abspath(__file__))
-    uuid_0 = cert_common.int2mac_get(UUID_0)[6:]
-    with (open(f"{base_path}/in_sensor_data.csv", "r") as csv_in,
-          open(f"{base_path}/out_sensor_data.csv", "w") as csv_out):
-        csv_out.write("raw packet,output power,delay,duplicates,channel,COM\n")
-        csv_in = csv.DictReader(csv_in)
-        next(csv_in)                        # stepping over the header line
-        for line in csv_in:
-            input_payload = line['raw packet'][12:]
-            if uuid_0 in input_payload:
-                csv_out.write(DEFAULT_ADVA0 + process_sensor_payload(input_payload, uuid_0) + ",8,200,6,37,COM3\n")
-            else:
-                csv_out.write(line['raw packet'] + ",8,200,6,37,COM3\n")
-
-
-def process_sensor_payload(payload, uuid):
-    uuid_idx = payload.find(uuid)
-    if uuid_idx == -1:
-        raise ValueError(f"Pattern {uuid_idx} not found in the packet")
-
-    len = int(payload[uuid_idx - 2:uuid_idx], 16)
-    segment_start_idx = uuid_idx - 2
-    segment_end_idx = uuid_idx + len * 2
-    segment = payload[segment_start_idx:segment_end_idx]
-    output = segment + payload[:segment_start_idx] + payload[segment_end_idx:]
-    return output
-
-
-def pkts_get(test, phase):
-    test.mqttc.flush_pkts()
-    mqtt_scan_wait(test, duration=SCAN_TIMEOUT)
-    sensor_pkts = cert_mqtt.get_all_sensor_pkts(test)
-    generate_log_file(test, phase)
-
-    if len(sensor_pkts) == 0:
-        if phase != "tag_data_only" and phase != "rssi_threshold":
-            test.rc = TEST_FAILED
-            test.add_reason(f"Phase {phase} failed - didn't find any sensor packets")
-    else:
-        if phase == "tag_data_only":
-            test.rc = TEST_FAILED
-            test.add_reason(f"Phase {phase} failed - found sensor packets")
-        sensor0_pkts = [p[SENSOR_UUID] == f"{UUID_0:06X}" for p in sensor_pkts]
-        if phase == "snsr0_scrmbl_snsr1_no_scrmbl" or phase == "snsr0_scrmbl_snsr1_scrmbl" or phase == "snsr0_no_scrmbl":
-            if not any(sensor0_pkts):
-                test.rc = TEST_FAILED
-                test.add_reason(f"Phase {phase} failed - didn't find any sensor0 packets")
-        sensor1_pkts = [p[SENSOR_UUID] == f"{UUID_1:06X}" for p in sensor_pkts]
-        if phase == "snsr0_scrmbl_snsr1_no_scrmbl" or phase == "snsr0_scrmbl_snsr1_scrmbl" or phase == "snsr1_scrmbl":
-            if not any(sensor1_pkts):
-                test.rc = TEST_FAILED
-                test.add_reason(f"Phase {phase} failed - didn't find any sensor1 packets")
-
-    return sensor_pkts
-
-
-def test_tag_data_only(test, phase, _):
-    pkts_get(test, phase)
-    return test
-
-
-def test_rssi_threshold(test, phase, ext_sensors_module):
-    rssi_threshold = -25
-    # Config
-    utPrint(f"UUID_0 only without scrambling, RSSI Threshold = {rssi_threshold}\n", "BLUE")
-    sensor0 = uuid_scramble_cfg_add(UUID_0, SCRAMBLE_OFF)
-    test = cert_config.brg_configure(test=test, module=ext_sensors_module,
-                                     fields=[BRG_SENSOR0, BRG_RSSI_THRESHOLD], values=[sensor0, rssi_threshold])[0]
-    # Analyze
-    sensor_pkts = pkts_get(test, phase)
-    if test.rc == TEST_FAILED:
-        return test
-    rssi_threshold_viloation_pkts = [p for p in sensor_pkts if p[RSSI] >= -1 * rssi_threshold]
-    if rssi_threshold_viloation_pkts:
-        test.rc = TEST_FAILED
-        test.add_reason("rssi_threshold phase failed - received"
-                        f" {len(rssi_threshold_viloation_pkts)} sensor packets\n with RSSI weaker than {rssi_threshold}")
-        return test
-    return test
-
-
-def test_snsr0_no_scrmbl(test, phase, ext_sensors_module):
-    # Config
-    utPrint("UUID_0 only without scrambling - UUID is 0x{:06X}".format(UUID_0), "BLUE")
-    sensor0 = uuid_scramble_cfg_add(UUID_0, SCRAMBLE_OFF)
-    test = cert_config.brg_configure(test=test, module=ext_sensors_module, fields=[BRG_SENSOR0], values=[sensor0])[0]
-    if test.rc == TEST_FAILED:
-        test.add_reason(f"Configuration for phase {phase} failed")
-        return test
-    # Analyze
-    sensor_pkts = pkts_get(test, phase)
-    if test.rc == TEST_FAILED:
-        return test
-    for p in sensor_pkts:
-        if p[SENSOR_UUID] != "{:06X}".format(UUID_0):
-            test.rc = TEST_FAILED
-            test.add_reason(f"Phase {phase} failed - received packets from an un-registered sensor")
-            return test
-        unscrambled_payload = p[PAYLOAD][8:]
-        if find_packet_in_csv(unscrambled_payload) is False:
-            test.rc = TEST_FAILED
-            test.add_reason(f"Phase {phase} failed - couldn't find unscrambled payload")
-            return test
-    return test
-
-
-def test_snsr1_scrmbl(test, phase, ext_sensors_module):
-    # Config
-    utPrint("UUID_1 only with scrambling - UUID is 0x{:06X}".format(UUID_1), "BLUE")
-    sensor1 = uuid_scramble_cfg_add(UUID_1, SCRAMBLE_ON)
-    test = cert_config.brg_configure(test=test, module=ext_sensors_module, fields=[BRG_SENSOR1], values=[sensor1])[0]
-    if test.rc == TEST_FAILED:
-        test.add_reason(f"Configuration for phase {phase} failed")
-        return test
-    # Analyze
-    sensor_pkts = pkts_get(test, phase)
-    if test.rc == TEST_FAILED:
-        return test
-    for p in sensor_pkts:
-        if p[SENSOR_UUID] != "{:06X}".format(UUID_1):
-            test.rc = TEST_FAILED
-            test.add_reason(f"Phase {phase} failed - received packets from an un-registered sensor")
-            return test
-        unscrambled_payload = unscramble(p)
-        if find_packet_in_csv(unscrambled_payload) is False:
-            test.rc = TEST_FAILED
-            test.add_reason(f"Phase {phase} failed - scrambling algorithm error")
-            return test
-    return test
-
-
-def test_snsr0_scrmbl_snsr1_no_scrmbl(test, phase, ext_sensors_module):
-    # Config
-    print(f"UUID_0 with scrambling, UUID_1 without scrambling, {SCAN_TIMEOUT} sec\n")
-    sensor0 = uuid_scramble_cfg_add(UUID_0, SCRAMBLE_ON)
-    sensor1 = uuid_scramble_cfg_add(UUID_1, SCRAMBLE_OFF)
-    test = cert_config.brg_configure(test=test, module=ext_sensors_module, fields=[BRG_SENSOR0, BRG_SENSOR1], values=[sensor0, sensor1])[0]
-    if test.rc == TEST_FAILED:
-        test.add_reason(f"Configuration for phase {phase} failed")
-        return test
-    # Analyze
-    sensor_pkts = pkts_get(test, phase)
-    if test.rc == TEST_FAILED:
-        return test
-    for p in sensor_pkts:
-        if p[SENSOR_UUID] == "{:06X}".format(UUID_0):
-            unscrambled_payload = unscramble(p)
-            if find_packet_in_csv(unscrambled_payload) is False:
-                test.rc = TEST_FAILED
-                test.add_reason(f"Phase {phase} failed - scrambling algorithm error")
-                return test
-        if p[SENSOR_UUID] == "{:06X}".format(UUID_1):
-            unscrambled_payload = p[PAYLOAD][8:]
-            if find_packet_in_csv(unscrambled_payload) is False:
-                test.rc = TEST_FAILED
-                test.add_reason(f"Phase {phase} failed - couldn't find unscrambled payload")
-                return test
-    return test
-
-
-def test_snsr0_scrmbl_snsr1_scrmbl(test, phase, ext_sensors_module):
-    # Config
-    utPrint(f"UUID_0 with scrambling, UUID_1 with scrambling, {SCAN_TIMEOUT} sec\n", "BLUE")
-    sensor0 = uuid_scramble_cfg_add(UUID_0, SCRAMBLE_ON)
-    sensor1 = uuid_scramble_cfg_add(UUID_1, SCRAMBLE_ON)
-    test = cert_config.brg_configure(test=test, module=ext_sensors_module, fields=[BRG_SENSOR0, BRG_SENSOR1], values=[sensor0, sensor1])[0]
-    if test.rc == TEST_FAILED:
-        return test
-    # Analyze
-    sensor_pkts = pkts_get(test, phase)
-    if test.rc == TEST_FAILED:
-        return test
-    for p in sensor_pkts:
-        unscrambled_payload = unscramble(p)
-        if find_packet_in_csv(unscrambled_payload) is False:
-            test.rc = TEST_FAILED
-            test.add_reason(f"Phase {phase} failed - scrambling algorithm error")
-            return test
-    return test
-
-
-EXT_SENSOR_TEST_MAP = {"tag_data_only": test_tag_data_only,
-                       "rssi_threshold": test_rssi_threshold,
-                       "snsr0_no_scrmbl": test_snsr0_no_scrmbl,
-                       "snsr1_scrmbl": test_snsr1_scrmbl,
-                       "snsr0_scrmbl_snsr1_no_scrmbl": test_snsr0_scrmbl_snsr1_no_scrmbl,
-                       "snsr0_scrmbl_snsr1_scrmbl": test_snsr0_scrmbl_snsr1_scrmbl}
-
-
-def run(test):
-    datapath_module = test.active_brg.datapath
-    ext_sensors_module = test.active_brg.sensors
-    test = cert_common.test_prolog(test)
-    # check for problems in prolog
-    if test.rc == TEST_FAILED:
-        test = cert_common.test_epilog(test)
-        return test
-
-    # Adaptation of GW configuration for internal BRG test
-    if test.internal_brg:
-        test = cert_config.brg_configure(test, fields=[BRG_RX_CHANNEL], values=[ag.RX_CHANNEL_37], module=datapath_module, wait=True)[0]
-        if test.rc == TEST_FAILED and test.exit_on_param_failure:
-            return cert_common.test_epilog(test, revert_gws=True)
-
-    # create csv file for the test
-    in_pkts = create_csv_file_in(test)
-    create_csv_file_out(test)
-
-    if test.data == DATA_SIMULATION:
-        # start generating sensor pkts and send them using data simulator
-        pixel_sim_thread = cert_data_sim.DataSimThread(test=test, num_of_pixels=len(in_pkts), duplicates=6, delay=200,
-                                                       pkt_types=[0], pixels_type=RAW_DATA, pkts=in_pkts)
-        pixel_sim_thread.start()
-        ble_sim_thread = pixel_sim_thread
-
-    for param in test.params:
-        functionality_run_print(param.name)
-        test = EXT_SENSOR_TEST_MAP[param.value](test, param.name, ext_sensors_module)
-        field_functionality_pass_fail_print(test, param.name)
-        test.set_phase_rc(param.name, test.rc)
-        test.add_phase_reason(param.name, test.reason)
-        if test.rc == TEST_FAILED:
-            if test.exit_on_param_failure:
-                break  # break the whole for loop and keep the test as failed
-        test.reset_result()  # reset result and continue to next param
-
-    # Kill the ble simulator
-    if test.data == DATA_SIMULATION:
-        ble_sim_thread.stop()
-
-    return cert_common.test_epilog(test, revert_brgs=True, modules=[ext_sensors_module, datapath_module])

brg_certificate/wltPb_pb2.pyi

@@ -1,234 +0,0 @@
-from google.protobuf.internal import containers as _containers
-from google.protobuf import descriptor as _descriptor
-from google.protobuf import message as _message
-from collections.abc import Iterable as _Iterable, Mapping as _Mapping
-from typing import ClassVar as _ClassVar, Optional as _Optional, Union as _Union
-
-DESCRIPTOR: _descriptor.FileDescriptor
-
-class Location(_message.Message):
-    __slots__ = ("lat", "lng")
-    LAT_FIELD_NUMBER: _ClassVar[int]
-    LNG_FIELD_NUMBER: _ClassVar[int]
-    lat: float
-    lng: float
-    def __init__(self, lat: _Optional[float] = ..., lng: _Optional[float] = ...) -> None: ...
-
-class Value(_message.Message):
-    __slots__ = ("integerValue", "numberValue", "stringValue", "boolValue")
-    INTEGERVALUE_FIELD_NUMBER: _ClassVar[int]
-    NUMBERVALUE_FIELD_NUMBER: _ClassVar[int]
-    STRINGVALUE_FIELD_NUMBER: _ClassVar[int]
-    BOOLVALUE_FIELD_NUMBER: _ClassVar[int]
-    integerValue: int
-    numberValue: float
-    stringValue: str
-    boolValue: bool
-    def __init__(self, integerValue: _Optional[int] = ..., numberValue: _Optional[float] = ..., stringValue: _Optional[str] = ..., boolValue: bool = ...) -> None: ...
-
-class GatewayData(_message.Message):
-    __slots__ = ("gatewayId", "timestamp", "packets", "location")
-    class Packet(_message.Message):
-        __slots__ = ("payload", "timestamp", "sequenceId", "rssi", "aliasBridgeId")
-        PAYLOAD_FIELD_NUMBER: _ClassVar[int]
-        TIMESTAMP_FIELD_NUMBER: _ClassVar[int]
-        SEQUENCEID_FIELD_NUMBER: _ClassVar[int]
-        RSSI_FIELD_NUMBER: _ClassVar[int]
-        ALIASBRIDGEID_FIELD_NUMBER: _ClassVar[int]
-        payload: bytes
-        timestamp: int
-        sequenceId: int
-        rssi: int
-        aliasBridgeId: str
-        def __init__(self, payload: _Optional[bytes] = ..., timestamp: _Optional[int] = ..., sequenceId: _Optional[int] = ..., rssi: _Optional[int] = ..., aliasBridgeId: _Optional[str] = ...) -> None: ...
-    GATEWAYID_FIELD_NUMBER: _ClassVar[int]
-    TIMESTAMP_FIELD_NUMBER: _ClassVar[int]
-    PACKETS_FIELD_NUMBER: _ClassVar[int]
-    LOCATION_FIELD_NUMBER: _ClassVar[int]
-    gatewayId: str
-    timestamp: int
-    packets: _containers.RepeatedCompositeFieldContainer[GatewayData.Packet]
-    location: Location
-    def __init__(self, gatewayId: _Optional[str] = ..., timestamp: _Optional[int] = ..., packets: _Optional[_Iterable[_Union[GatewayData.Packet, _Mapping]]] = ..., location: _Optional[_Union[Location, _Mapping]] = ...) -> None: ...
-
-class UplinkMessage(_message.Message):
-    __slots__ = ("gatewayStatus", "gatewayInfo", "gatewayLogs", "actionStatus")
-    GATEWAYSTATUS_FIELD_NUMBER: _ClassVar[int]
-    GATEWAYINFO_FIELD_NUMBER: _ClassVar[int]
-    GATEWAYLOGS_FIELD_NUMBER: _ClassVar[int]
-    ACTIONSTATUS_FIELD_NUMBER: _ClassVar[int]
-    gatewayStatus: GatewayStatus
-    gatewayInfo: GatewayInfo
-    gatewayLogs: GatewayLogs
-    actionStatus: ActionStatus
-    def __init__(self, gatewayStatus: _Optional[_Union[GatewayStatus, _Mapping]] = ..., gatewayInfo: _Optional[_Union[GatewayInfo, _Mapping]] = ..., gatewayLogs: _Optional[_Union[GatewayLogs, _Mapping]] = ..., actionStatus: _Optional[_Union[ActionStatus, _Mapping]] = ...) -> None: ...
-
-class ACL(_message.Message):
-    __slots__ = ("mode_allow", "ids")
-    MODE_ALLOW_FIELD_NUMBER: _ClassVar[int]
-    IDS_FIELD_NUMBER: _ClassVar[int]
-    mode_allow: bool
-    ids: _containers.RepeatedScalarFieldContainer[bytes]
-    def __init__(self, mode_allow: bool = ..., ids: _Optional[_Iterable[bytes]] = ...) -> None: ...
-
-class GatewayConfigValue(_message.Message):
-    __slots__ = ("integerValue", "numberValue", "stringValue", "boolValue", "aclValue")
-    INTEGERVALUE_FIELD_NUMBER: _ClassVar[int]
-    NUMBERVALUE_FIELD_NUMBER: _ClassVar[int]
-    STRINGVALUE_FIELD_NUMBER: _ClassVar[int]
-    BOOLVALUE_FIELD_NUMBER: _ClassVar[int]
-    ACLVALUE_FIELD_NUMBER: _ClassVar[int]
-    integerValue: int
-    numberValue: float
-    stringValue: str
-    boolValue: bool
-    aclValue: ACL
-    def __init__(self, integerValue: _Optional[int] = ..., numberValue: _Optional[float] = ..., stringValue: _Optional[str] = ..., boolValue: bool = ..., aclValue: _Optional[_Union[ACL, _Mapping]] = ...) -> None: ...
-
-class GatewayStatus(_message.Message):
-    __slots__ = ("gatewayId", "gatewayType", "downlinkSupported", "bridgeOtaUpgradeSupported", "apiVersion", "version", "bleSwVersion", "interfaceSwVersion", "location", "config", "bleAddress")
-    class ConfigEntry(_message.Message):
-        __slots__ = ("key", "value")
-        KEY_FIELD_NUMBER: _ClassVar[int]
-        VALUE_FIELD_NUMBER: _ClassVar[int]
-        key: str
-        value: GatewayConfigValue
-        def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[GatewayConfigValue, _Mapping]] = ...) -> None: ...
-    GATEWAYID_FIELD_NUMBER: _ClassVar[int]
-    GATEWAYTYPE_FIELD_NUMBER: _ClassVar[int]
-    DOWNLINKSUPPORTED_FIELD_NUMBER: _ClassVar[int]
-    BRIDGEOTAUPGRADESUPPORTED_FIELD_NUMBER: _ClassVar[int]
-    APIVERSION_FIELD_NUMBER: _ClassVar[int]
-    VERSION_FIELD_NUMBER: _ClassVar[int]
-    BLESWVERSION_FIELD_NUMBER: _ClassVar[int]
-    INTERFACESWVERSION_FIELD_NUMBER: _ClassVar[int]
-    LOCATION_FIELD_NUMBER: _ClassVar[int]
-    CONFIG_FIELD_NUMBER: _ClassVar[int]
-    BLEADDRESS_FIELD_NUMBER: _ClassVar[int]
-    gatewayId: str
-    gatewayType: str
-    downlinkSupported: bool
-    bridgeOtaUpgradeSupported: bool
-    apiVersion: int
-    version: str
-    bleSwVersion: str
-    interfaceSwVersion: str
-    location: Location
-    config: _containers.MessageMap[str, GatewayConfigValue]
-    bleAddress: str
-    def __init__(self, gatewayId: _Optional[str] = ..., gatewayType: _Optional[str] = ..., downlinkSupported: bool = ..., bridgeOtaUpgradeSupported: bool = ..., apiVersion: _Optional[int] = ..., version: _Optional[str] = ..., bleSwVersion: _Optional[str] = ..., interfaceSwVersion: _Optional[str] = ..., location: _Optional[_Union[Location, _Mapping]] = ..., config: _Optional[_Mapping[str, GatewayConfigValue]] = ..., bleAddress: _Optional[str] = ...) -> None: ...
-
-class GatewayInfo(_message.Message):
-    __slots__ = ("entries",)
-    class EntriesEntry(_message.Message):
-        __slots__ = ("key", "value")
-        KEY_FIELD_NUMBER: _ClassVar[int]
-        VALUE_FIELD_NUMBER: _ClassVar[int]
-        key: str
-        value: Value
-        def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[Value, _Mapping]] = ...) -> None: ...
-    ENTRIES_FIELD_NUMBER: _ClassVar[int]
-    entries: _containers.MessageMap[str, Value]
-    def __init__(self, entries: _Optional[_Mapping[str, Value]] = ...) -> None: ...
-
-class GatewayLogs(_message.Message):
-    __slots__ = ("logs",)
-    LOGS_FIELD_NUMBER: _ClassVar[int]
-    logs: _containers.RepeatedScalarFieldContainer[str]
-    def __init__(self, logs: _Optional[_Iterable[str]] = ...) -> None: ...
-
-class ActionStatus(_message.Message):
-    __slots__ = ("action", "status", "step", "progress", "bridgeId")
-    ACTION_FIELD_NUMBER: _ClassVar[int]
-    STATUS_FIELD_NUMBER: _ClassVar[int]
-    STEP_FIELD_NUMBER: _ClassVar[int]
-    PROGRESS_FIELD_NUMBER: _ClassVar[int]
-    BRIDGEID_FIELD_NUMBER: _ClassVar[int]
-    action: int
-    status: int
-    step: int
-    progress: int
-    bridgeId: bytes
-    def __init__(self, action: _Optional[int] = ..., status: _Optional[int] = ..., step: _Optional[int] = ..., progress: _Optional[int] = ..., bridgeId: _Optional[bytes] = ...) -> None: ...
-
-class DownlinkMessage(_message.Message):
-    __slots__ = ("txPacket", "gatewayAction", "bridgeUpgrade", "gatewayConfig", "customMessage")
-    TXPACKET_FIELD_NUMBER: _ClassVar[int]
-    GATEWAYACTION_FIELD_NUMBER: _ClassVar[int]
-    BRIDGEUPGRADE_FIELD_NUMBER: _ClassVar[int]
-    GATEWAYCONFIG_FIELD_NUMBER: _ClassVar[int]
-    CUSTOMMESSAGE_FIELD_NUMBER: _ClassVar[int]
-    txPacket: TxPacket
-    gatewayAction: GatewayAction
-    bridgeUpgrade: BridgeUpgrade
-    gatewayConfig: GatewayConfig
-    customMessage: CustomMessage
-    def __init__(self, txPacket: _Optional[_Union[TxPacket, _Mapping]] = ..., gatewayAction: _Optional[_Union[GatewayAction, _Mapping]] = ..., bridgeUpgrade: _Optional[_Union[BridgeUpgrade, _Mapping]] = ..., gatewayConfig: _Optional[_Union[GatewayConfig, _Mapping]] = ..., customMessage: _Optional[_Union[CustomMessage, _Mapping]] = ...) -> None: ...
-
-class TxPacket(_message.Message):
-    __slots__ = ("payload", "maxRetries", "maxDurationMs")
-    PAYLOAD_FIELD_NUMBER: _ClassVar[int]
-    MAXRETRIES_FIELD_NUMBER: _ClassVar[int]
-    MAXDURATIONMS_FIELD_NUMBER: _ClassVar[int]
-    payload: bytes
-    maxRetries: int
-    maxDurationMs: int
-    def __init__(self, payload: _Optional[bytes] = ..., maxRetries: _Optional[int] = ..., maxDurationMs: _Optional[int] = ...) -> None: ...
-
-class GatewayAction(_message.Message):
-    __slots__ = ("action",)
-    ACTION_FIELD_NUMBER: _ClassVar[int]
-    action: str
-    def __init__(self, action: _Optional[str] = ...) -> None: ...
-
-class BridgeUpgrade(_message.Message):
-    __slots__ = ("rebootPacket", "txMaxDurationMs", "txMaxRetries", "bridgeId", "versionUuid", "upgradeBlSd", "imageDirUrl")
-    REBOOTPACKET_FIELD_NUMBER: _ClassVar[int]
-    TXMAXDURATIONMS_FIELD_NUMBER: _ClassVar[int]
-    TXMAXRETRIES_FIELD_NUMBER: _ClassVar[int]
-    BRIDGEID_FIELD_NUMBER: _ClassVar[int]
-    VERSIONUUID_FIELD_NUMBER: _ClassVar[int]
-    UPGRADEBLSD_FIELD_NUMBER: _ClassVar[int]
-    IMAGEDIRURL_FIELD_NUMBER: _ClassVar[int]
-    rebootPacket: bytes
-    txMaxDurationMs: int
-    txMaxRetries: int
-    bridgeId: str
-    versionUuid: str
-    upgradeBlSd: bool
-    imageDirUrl: str
-    def __init__(self, rebootPacket: _Optional[bytes] = ..., txMaxDurationMs: _Optional[int] = ..., txMaxRetries: _Optional[int] = ..., bridgeId: _Optional[str] = ..., versionUuid: _Optional[str] = ..., upgradeBlSd: bool = ..., imageDirUrl: _Optional[str] = ...) -> None: ...
-
-class GatewayConfig(_message.Message):
-    __slots__ = ("version", "bleSwVersion", "interfaceSwVersion", "location", "config")
-    class ConfigEntry(_message.Message):
-        __slots__ = ("key", "value")
-        KEY_FIELD_NUMBER: _ClassVar[int]
-        VALUE_FIELD_NUMBER: _ClassVar[int]
-        key: str
-        value: GatewayConfigValue
-        def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[GatewayConfigValue, _Mapping]] = ...) -> None: ...
-    VERSION_FIELD_NUMBER: _ClassVar[int]
-    BLESWVERSION_FIELD_NUMBER: _ClassVar[int]
-    INTERFACESWVERSION_FIELD_NUMBER: _ClassVar[int]
-    LOCATION_FIELD_NUMBER: _ClassVar[int]
-    CONFIG_FIELD_NUMBER: _ClassVar[int]
-    version: str
-    bleSwVersion: str
-    interfaceSwVersion: str
-    location: Location
-    config: _containers.MessageMap[str, GatewayConfigValue]
-    def __init__(self, version: _Optional[str] = ..., bleSwVersion: _Optional[str] = ..., interfaceSwVersion: _Optional[str] = ..., location: _Optional[_Union[Location, _Mapping]] = ..., config: _Optional[_Mapping[str, GatewayConfigValue]] = ...) -> None: ...
-
-class CustomMessage(_message.Message):
-    __slots__ = ("entries",)
-    class EntriesEntry(_message.Message):
-        __slots__ = ("key", "value")
-        KEY_FIELD_NUMBER: _ClassVar[int]
-        VALUE_FIELD_NUMBER: _ClassVar[int]
-        key: str
-        value: Value
-        def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[Value, _Mapping]] = ...) -> None: ...
-    ENTRIES_FIELD_NUMBER: _ClassVar[int]
-    entries: _containers.MessageMap[str, Value]
-    def __init__(self, entries: _Optional[_Mapping[str, Value]] = ...) -> None: ...

brg_certificate/wlt_types.py

@@ -1,113 +0,0 @@
-import brg_certificate.ag.wlt_types_ag as ag
-
-def eval_pkt(string):
-    try:
-        return eval(f'ag.{string}')
-    except:
-        return None
-
-def eval_one_param(string):
-    string = string.strip("' ")
-    if string in ag.__dict__:
-        return eval(f'ag.{string}')
-    try:
-        return eval(string)
-    except:
-        return string
-
-def eval_param(string):
-    if "," in string:
-        return [eval_one_param(x) for x in string.strip("[]").split(",")]
-    else:
-        return eval_one_param(string)
-
-class WltPkt():
-    supported_pkt_types = ag.WLT_PKT_TYPES
-
-    def __init__(self, raw='', hdr=None, data_hdr=None, generic=None, pkt=None):
-        self.hdr = ag.Hdr() if hdr is None else hdr
-        self.data_hdr = ag.DataHdr() if data_hdr is None else data_hdr
-        self.generic = generic
-        self.pkt = pkt
-        if raw:
-            self.set(raw)
-
-    def __repr__(self) -> str:
-        if isinstance(self.pkt, (ag.UnifiedEchoPktV0, ag.UnifiedEchoPktV1, ag.UnifiedEchoExtPkt)):
-            return f"{self.data_hdr}\n{self.pkt}"
-        return f"{self.hdr}\n{self.pkt}"
-
-    def __eq__(self, other):
-        if isinstance(other, WltPkt):
-            return (
-                (self.hdr == other.hdr or
-                self.data_hdr == other.data_hdr) and
-                self.generic == other.generic and
-                self.pkt == other.pkt
-            )
-        return False
-
-    def dump(self):
-        if self.pkt:
-            if isinstance(self.pkt, (ag.UnifiedEchoPktV0, ag.UnifiedEchoPktV1, ag.UnifiedEchoExtPkt)):
-                return self.data_hdr.dump() + self.pkt.dump()
-            else:
-                return self.hdr.dump() + self.pkt.dump()
-        return self.data_hdr.dump() + self.generic.dump()
-
-    def set(self, string):
-
-        self.hdr.set(string[0:14])
-        self.data_hdr.set(string[0:14])
-        if self.hdr.group_id == ag.GROUP_ID_BRG2GW or self.hdr.group_id == ag.GROUP_ID_GW2BRG:
-            # GROUP_ID_BRG2GW & GROUP_ID_GW2BRG
-            self.generic = eval_pkt(f'GenericV{ag.API_VERSION_LATEST}()')
-            self.generic.set(string[14:62])
-
-            # MEL modules
-            if self.generic.module_type:
-                self.pkt = eval_pkt(f'{ag.MODULES_DICT[self.generic.module_type]}{self.generic.api_version}()')
-            elif self.generic.module_type == ag.MODULE_GLOBAL:
-                # Action pkts
-                if self.generic.msg_type == ag.BRG_MGMT_MSG_TYPE_ACTION:
-                    pkt = eval_pkt(f'ActionGenericV{self.generic.api_version}("{string[14:62]}")')
-                    if self.generic.api_version >= ag.API_VERSION_V8:
-                        pkt = eval_pkt(f'{ag.ACTIONS_DICT[pkt.action_id]}{self.generic.api_version}()')
-                    self.pkt = pkt
-                # OLD global config (GW2BRG & BRG2GW)
-                elif self.hdr.group_id == ag.GROUP_ID_GW2BRG and self.generic.msg_type == ag.BRG_MGMT_MSG_TYPE_CFG_SET:
-                    self.pkt = eval_pkt(f'Gw2BrgCfgV8()') # no api_version field in Gw2BrgCfg pkts - default parse as api version 8 (Latest Gw2BrgCfg)
-                elif self.hdr.group_id == ag.GROUP_ID_BRG2GW:
-                    if self.generic.msg_type == ag.BRG_MGMT_MSG_TYPE_CFG_SET or self.generic.msg_type == ag.BRG_MGMT_MSG_TYPE_CFG_INFO:
-                        self.pkt = eval_pkt(f'Brg2GwCfgV{self.generic.api_version}()')
-                    elif self.generic.msg_type == ag.BRG_MGMT_MSG_TYPE_HB:
-                        self.pkt = eval_pkt(f'Brg2GwHbV{self.generic.api_version}()')
-                    elif self.generic.msg_type == ag.BRG_MGMT_MSG_TYPE_HB_SLEEP:
-                        self.pkt = eval_pkt(f'Brg2GwHbSleepV{self.generic.api_version}()')
-        # Unified pkt
-        elif self.data_hdr.group_id_major in ag.UNIFIED_GROUP_ID_LIST:
-            if self.data_hdr.group_id_major == ag.GROUP_ID_UNIFIED_PKT_V0:
-                self.pkt = ag.UnifiedEchoPktV0()
-            elif self.data_hdr.group_id_major == ag.GROUP_ID_UNIFIED_PKT_V1 or self.data_hdr.group_id_major == ag.GROUP_ID_BLE5_PKT0: 
-                self.pkt = ag.UnifiedEchoPktV1()
-            elif self.data_hdr.group_id_major == ag.GROUP_ID_BLE5_EXTENDED: 
-                self.pkt = ag.UnifiedEchoExtPkt()
-        # SideInfo pkts
-        elif self.hdr.group_id == ag.GROUP_ID_SIDE_INFO_SENSOR:
-            self.pkt = ag.SideInfoSensor()
-        elif self.hdr.group_id == ag.GROUP_ID_SIDE_INFO:
-            self.pkt = ag.SideInfo()
-        if self.pkt:
-            if self.data_hdr.group_id_major == ag.GROUP_ID_BLE5_EXTENDED:
-                self.pkt.set(string[14:84])
-            else:
-                self.pkt.set(string[14:62])
-        # Signal Indicator pkt
-        elif self.hdr.group_id == ag.GROUP_ID_SIGNAL_INDICATOR:
-            self.pkt = eval_pkt(f'SignalIndicatorDataV{ag.SIGNAL_INDICATOR_PACKET_VERSION_LATEST}')(string[8:62])
-        elif self.hdr.uuid_lsb == ag.HDR_DEFAULT_BRG_SENSOR_UUID_LSB and self.hdr.uuid_msb == ag.HDR_DEFAULT_BRG_SENSOR_UUID_MSB:
-            self.pkt = ag.SensorData(string)
-        # Unparsed pkts
-        else:
-            # print(f"Unable to parse packet with payload: {string}")
-            pass