How to leverage fpp defined structs in python integration test applications

[ReggieMarr]

Hello,

I have an application which has a number of structs defined using fpp like so:

    struct EsupStatusGetResult {
        SystemState: U8 #EsupSystemState @< 1,2,3,4 (1 byte unsigned char value)
        StatusFlags: U8 @< 1 byte unsigned char value
        Reserved: U16 @< 2 byte unsigned short value
        CpuTemperature: F32 @< -40 to 125 °C (4 byte float value)
        FirmwareVersion: U32 @< firmware version (4 byte unsigned int value)
    }

    telemetry EsupState: EsupStatusGetResult update on change

Currently I retrieve this data with my python application like so:

@dataclass_json
@dataclass
class EsupStatusGetResult:
    SystemState: int
    StatusFlags: int
    Reserved: int
    CpuTemperature: float
    FirmwareVersion: int


class TxOrchestrator(object):
    """
    Class for controlling the Transmitter.
    """

    def __init__(self, cfg: TelemLinkCfg, logger: Logger) -> None:
        """
        Initializes a TelemLink object with the provided configuration
        and logger objects.
        """
        self._establish_connection(cfg, logger)

        self.cfg = cfg
        self.logger = logger

    def __del__(self):
        self.fprime_api.teardown()
        self.fprime_pipeline.disconnect()

    # NOTE we currently leverage docker compose to bring up fprime-gds as a self contained
    # app, if we want to ship this on it's own we'll call this
    def _start_prereq_deployments(self, cfg: TelemLinkCfg):
        # Launch tcp server
        # NOTE since we don't have direct access to args this is a bit better
        tts_cmd = BASE_MODULE_ARGUMENTS + [
            "fprime_gds.executables.tcpserver",
            f"--host=0.0.0.0",
            f"--port={cfg.port}",
        ]
        log_path = "tx_orch.log"

        app_cmd = ['/usr/bin/python3', '-u', '-m', 'fprime_gds.executables.comm', '--ip-address', '0.0.0.0', '--ip-port', '50000', '--uart-device', '/dev/ttyACM0', '--uart-baud', '9600', '--comm-adapter', 'ip', '--comm-checksum-type', 'crc32', '--logs', '/downlink-client/gds/src/logs/2024_06_07-19_05_43', '--log-directly', '--zmq-transport', 'ipc:///tmp/fprime-server-in', 'ipc:///tmp/fprime-server-out', '--tts-port', str(cfg.port), '--tts-addr', '0.0.0.0']

        run_deployment.launch_process(app_cmd, logfile=log_path, name="Comm Application", launch_time=1)

        run_deployment.launch_process(tts_cmd, logfile=log_path, name="TCP Server")

    def _establish_connection(self, cfg: TelemLinkCfg, logger: Logger) -> Tuple[IntegrationTestAPI, StandardPipeline]:
        """
        Establishes connection with the api interface by setting up
        the pipeline using the provided configuration and logger.
        """
        # Instantiate a pipeline and config manager for managing the api interface
        self.fprime_pipeline = StandardPipeline()
        config_manager = ConfigManager()
        # self._start_prereq_deployments(cfg)

        # Setup pipeline
        self.fprime_pipeline.setup(config_manager, cfg.dict_path, cfg.tmp_path)

        api_connect_str = f"tcp://{cfg.ip}:{cfg.port}"
        self.fprime_api = IntegrationTestAPI(self.fprime_pipeline, cfg.log_path)
        self.fprime_pipeline = self.fprime_pipeline.connect(api_connect_str)
        logger.info(f"Connected to {api_connect_str}")
        
      def get_tx_state(self):
        result = self.fprime_api.await_telemetry("txOrch.EsupState")
        if result is None:
            self.logger.info(result)
            ret = result
        else:
            ret = EsupStatusGetResult.from_dict(result.get_val())
            self.logger.info(ret)

        return ret

Is there a way to leverage fpp-tools or something similar so that I don't have to define each struct in python manually ?