fprime-gds 4.0.0a8__py3-none-any.whl → 4.0.0a10__py3-none-any.whl

fprime_gds/executables/data_product_writer.py

@@ -194,6 +194,7 @@ class QualifiedType(BaseModel):
 class StructMember(BaseModel):
     type: Union[IntegerType, FloatType, BoolType, StringType, QualifiedType]
     size: int = 1
+    index: int
 
 class StructType(BaseModel):
     kind: str
@@ -209,7 +210,7 @@ class StructType(BaseModel):
 class AliasType(BaseModel):
     kind: str
     qualifiedName: str
-    type: Union[AliasType, StructType, ArrayType, IntegerType, FloatType, QualifiedType, StringType]
+    type: Union[AliasType, StructType, ArrayType, IntegerType, BoolType, FloatType, StringType, QualifiedType]
     underlyingType: Union[StructType, ArrayType, IntegerType, BoolType, FloatType, StringType, QualifiedType]
 
     @field_validator('kind')
@@ -222,7 +223,7 @@ class ArrayType(BaseModel):
     kind: str
     qualifiedName: str
     size: int
-    elementType: Union[AliasType, StructType, ArrayType, IntegerType, FloatType, QualifiedType, StringType]
+    elementType: Union[AliasType, StructType, ArrayType, IntegerType, BoolType, FloatType, StringType, QualifiedType]
 
     @field_validator('kind')
     def kind_qualifiedIdentifier(cls, v):
@@ -297,29 +298,33 @@ class DPHeader(BaseModel):
     @computed_field
     @property
     def header(self) -> Dict[str, Union[Type, ArrayType, EnumType]]:
-        # All types/constants that make up the DP header
-        header_dict = {
-            "FwPacketDescriptorType": None,
-            "FwDpIdType": None,
-            "FwDpPriorityType" : None,
-            "Seconds": None,
-            "USeconds": None,
-            "FwTimeBaseStoreType": None,
-            "FwTimeContextStoreType": None,
-            "Fw.DpCfg.ProcType": None,
-            "Fw.DpCfg.CONTAINER_USER_DATA_SIZE": None,
-            "Fw.DpState": None,
-            "FwSizeStoreType": None
+        # Mapping from type/constant names to header field names
+        header_field_names = {
+            "FwPacketDescriptorType": "PacketDescriptor",
+            "FwDpIdType": "Id",
+            "FwDpPriorityType" : "Priority",
+            "Seconds": "Seconds",
+            "USeconds": "USeconds",
+            "FwTimeBaseStoreType": "TimeBase",
+            "FwTimeContextStoreType": "Context",
+            "Fw.DpCfg.ProcType": "ProcTypes",
+            "Fw.DpCfg.CONTAINER_USER_DATA_SIZE": "UserData",
+            "Fw.DpState": "DpState",
+            "FwSizeStoreType": "DataSize"
         }
-        for k in header_dict.keys():
+        # All types/constants that make up the DP header
+        # Key: Values of above header_field_names
+        # Values: Initialized to None, populated below based on type names/constants in the JSON dictionary
+        header_dict = {v: None for v in header_field_names.values()}
+        for k, v in header_field_names.items():
             # Seconds and USeconds are not in the dictionary, but are both always U32
             if k == "Seconds" or k == "USeconds":
-                header_dict[k] = Type(type=IntegerType(name="U32", kind="integer", size=32, signed=False))
+                header_dict[v] = Type(type=IntegerType(name="U32", kind="integer", size=32, signed=False))
             # According to Fw.Dp SDD, Header::UserData is an array of U8 of size Fw::DpCfg::CONTAINER_USER_DATA_SIZE.
             elif k == "Fw.DpCfg.CONTAINER_USER_DATA_SIZE":
                 for t in self.constants:
                     if t.qualifiedName == k:
-                        header_dict[k] = ArrayType(
+                        header_dict[v] = ArrayType(
                             kind="array", 
                             qualifiedName="UserData",
                             size=t.value,
@@ -329,7 +334,7 @@ class DPHeader(BaseModel):
             else:
                 for t in self.typeDefinitions:
                     if t.qualifiedName == k:
-                        header_dict[k] = t
+                        header_dict[v] = t
                         break
 
         return header_dict
@@ -337,12 +342,15 @@ class DPHeader(BaseModel):
     @computed_field
     @property
     def dataId(self) -> AliasType:
-        return self.header.get("FwDpIdType")
+        return self.header.get("Id")
     
     @computed_field
     @property
     def dataSize(self) -> AliasType:
-        return self.header.get("FwSizeStoreType")
+        return self.header.get("DataSize")
+
+    def get_size_store_bytes(self) -> int:
+        return self.header.get("DataSize").underlyingType.size // 8
 
     @model_validator(mode='after')
     def validate_header(self) -> 'DPHeader':
@@ -371,7 +379,8 @@ type_mapping = {
     'U64': 'Q', # Unsigned 64-bit integer
     'F32': 'f',  # 32-bit float
     'F64': 'd',  # 64-bit float
-    'bool': '?' # An 8 bit boolean
+    'bool': '?', # An 8 bit boolean
+    'string': 's'
     # Add more mappings as needed
 }
 
@@ -485,6 +494,7 @@ class DataProductWriter:
         self.binaryFileName = binaryFileName
         self.totalBytesRead = 0
         self.calculatedCRC = 0
+        self.headerJSON = None
 
 
     # ----------------------------------------------------------------------------------------------
@@ -520,8 +530,29 @@ class DataProductWriter:
         except KeyError:
             raise KeyError(f"Unrecognized JSON Dictionary Type: {intType}")
         data = struct.unpack(format_str, bytes_read)[0]
+        return data
+
+    def read_and_deserialize_string(self) -> str:
+        size_store_type_bytes = self.headerJSON.get_size_store_bytes()
+        bytes_read_store = self.binaryFile.read(size_store_type_bytes)
+        if len(bytes_read_store) != size_store_type_bytes:
+            raise IOError(f"Tried to read {size_store_type_bytes} bytes from the binary file, but failed.")
+
+        self.totalBytesRead += size_store_type_bytes
+        
+        format_str = f'{BIG_ENDIAN}H'
+        string_size_data = struct.unpack(format_str, bytes_read_store)[0]
+
+        bytes_read = self.binaryFile.read(string_size_data)
+        if len(bytes_read) != string_size_data:
+            raise IOError(f"Tried to read {string_size_data} bytes from the binary file, but failed.")
 
+        self.calculatedCRC = crc32(bytes_read_store + bytes_read, self.calculatedCRC) & 0xffffffff
+        self.totalBytesRead += string_size_data
 
+        format_str = f'{BIG_ENDIAN}{string_size_data}s'
+        data = struct.unpack(format_str, bytes_read)[0]
+        data = data.decode()
         return data
 
     # -----------------------------------------------------------------------------------------------------------------------
@@ -568,7 +599,7 @@ class DataProductWriter:
     #   AssertionError: If the field_config is not an IntegerType, FloatType, or BoolType.
     # -----------------------------------------------------------------------------------------------------------------------
 
-    def read_field(self, field_config: Union[IntegerType, FloatType, BoolType]) -> Union[int, float, bool]:
+    def read_field(self, field_config: Union[IntegerType, FloatType, BoolType, StringType]) -> Union[int, float, bool]:
 
         if type(field_config) is IntegerType:
             sizeBytes = field_config.size // 8
@@ -579,6 +610,9 @@ class DataProductWriter:
         elif type(field_config) is BoolType:
             sizeBytes = field_config.size // 8
 
+        elif type(field_config) is StringType:
+            return self.read_and_deserialize_string()
+
         else:
             assert False, "Unsupported typeKind encountered"
 
@@ -626,6 +660,8 @@ class DataProductWriter:
         elif isinstance(typeKind, BoolType):
             parent_dict[field_name] = self.read_field(typeKind)
 
+        elif isinstance(typeKind, StringType):
+            parent_dict[field_name] = self.read_field(typeKind)
 
         elif isinstance(typeKind, EnumType):
             value = self.read_field(typeKind.representationType)
@@ -646,7 +682,8 @@ class DataProductWriter:
 
         elif isinstance(typeKind, StructType):
             array_list = []
-            for key, member in typeKind.members.items():
+            sorted_members = dict(sorted(typeKind.members.items(), key=lambda member: member[1].index))
+            for key, member in sorted_members.items():
                 for i in range(member.size):
                     element_dict = {}
                     self.get_struct_item(key, member.type, typeList, element_dict)
@@ -830,7 +867,7 @@ class DataProductWriter:
                         header_json["typeDefinitions"] = dict_json["typeDefinitions"]
                     if "constants" in dict_json:
                         header_json["constants"] = dict_json["constants"]
-                    headerJSON = DPHeader(**header_json)
+                    self.headerJSON = DPHeader(**header_json)
             
             except json.JSONDecodeError as e:
                 raise DictionaryError(self.jsonDict, e.lineno)
@@ -840,10 +877,10 @@ class DataProductWriter:
             with open(self.binaryFileName, 'rb') as self.binaryFile:
 
                 # Read the header data up until the Records
-                headerData = self.get_header_info(headerJSON)
+                headerData = self.get_header_info(self.headerJSON)
 
                 # Read the total data size
-                dataSize = headerData['FwSizeStoreType']
+                dataSize = headerData['DataSize']
 
                 # Restart the count of bytes read
                 self.totalBytesRead = 0
@@ -851,13 +888,12 @@ class DataProductWriter:
                 recordList = [headerData]
 
                 while self.totalBytesRead < dataSize:
-
-                    recordData = self.get_record_data(headerJSON, dictJSON)
+                    recordData = self.get_record_data(self.headerJSON, dictJSON)
                     recordList.append(recordData)
 
                 computedCRC = self.calculatedCRC
                 # Read the data checksum
-                headerData['dataHash'] = self.read_field(headerJSON.dataHash.type)
+                headerData['dataHash'] = self.read_field(self.headerJSON.dataHash.type)
 
                 if computedCRC != headerData['dataHash']:
                     raise CRCError("Data", headerData['dataHash'], computedCRC)

{fprime_gds-4.0.0a8.dist-info → fprime_gds-4.0.0a10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fprime-gds
-Version: 4.0.0a8
+Version: 4.0.0a10
 Summary: F Prime Flight Software Ground Data System layer
 Author-email: Michael Starch <Michael.D.Starch@jpl.nasa.gov>, Thomas Boyer-Chammard <Thomas.Boyer.Chammard@jpl.nasa.gov>
 License: 
@@ -240,6 +240,7 @@ Requires-Dist: Jinja2>=2.11.3
 Requires-Dist: openpyxl>=3.0.10
 Requires-Dist: pyserial>=3.5
 Requires-Dist: pydantic>=2.6
+Requires-Dist: lark>=1.2.2
 Requires-Dist: PyYAML>=6.0.2
 Requires-Dist: spacepackets>=0.30.0
 Requires-Dist: crc>=7.0.0

{fprime_gds-4.0.0a8.dist-info → fprime_gds-4.0.0a10.dist-info}/RECORD

@@ -49,9 +49,15 @@ fprime_gds/common/files/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG
 fprime_gds/common/files/downlinker.py,sha256=CZPfhH0J9-LNqW5Cv_ryicLTuoedLSWK8OPQmmQDZZY,7498
 fprime_gds/common/files/helpers.py,sha256=sGaxcczXmZ5_soawT7x_eJ_cC2PZ6KOGBfusAV4QC_g,7219
 fprime_gds/common/files/uplinker.py,sha256=lgqhlgeipBt3Arx-ohzK8vCdS54fKpv9Rg7SUTocUX8,13244
+fprime_gds/common/fpy/README.md,sha256=AJE9KJDarTTW9nsTJBiZ6cKyPYQbWKbKJbFiNz6M8Z4,1414
+fprime_gds/common/fpy/SPEC.md,sha256=XTMgr96BIVJheOtjAp6Qgu5l5RE16DxxIkPl0WwXfEs,2248
 fprime_gds/common/fpy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fprime_gds/common/fpy/serialize_bytecode.py,sha256=RbBojtDGUjZyqGqKfqzJDLzU0Z9UBsNGaKMf8y2Qz7o,7283
-fprime_gds/common/fpy/types.py,sha256=XeDG6E_cm57lpG4wEdZuoGgtEJeSO8WmkCsIBbwWoQc,6143
+fprime_gds/common/fpy/codegen.py,sha256=5VdV-f6CdU1LPJx4swB_GV5pvPe3Cqh9E3bkS0dBAo4,59828
+fprime_gds/common/fpy/grammar.lark,sha256=QIQgmj58pW9ou2u7DzE39c0fz55eGNj3X7ridzAHRFk,2128
+fprime_gds/common/fpy/main.py,sha256=U50sQCrwhZgxGzkjKgaJywoQM_cEH78hN9Vy3pDKKMA,1073
+fprime_gds/common/fpy/parser.py,sha256=g-l67oZN_vB1JAdZ5S3u9m8APf6PdJ88GZyz0iX66qo,4418
+fprime_gds/common/fpy/bytecode/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fprime_gds/common/fpy/bytecode/directives.py,sha256=tBpPQ2ZnQXA7juB85HhacDdil1vEHUKW8m_AsMf1KdQ,13360
 fprime_gds/common/gds_cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fprime_gds/common/gds_cli/base_commands.py,sha256=nHnzHRMXs9haRjiUmq-Ciu1DSo1BXtcVscByk1Ypsxo,9432
 fprime_gds/common/gds_cli/channels.py,sha256=S8y0Mo2JbBFPvMzeW22HFVJ8p-UC-tzpYM7rXqIGWi4,2136
@@ -97,7 +103,7 @@ fprime_gds/common/pipeline/router.py,sha256=-P1wI0KXEh_snOzDaq8CjEoWuM_zRm8vUMR1
 fprime_gds/common/pipeline/standard.py,sha256=fDSPfyhYPMNhev5IQG2j51sCtQxXZ5PrqmulKH8TNjE,9778
 fprime_gds/common/templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fprime_gds/common/templates/ch_template.py,sha256=1MoDZsia0dI_CvnIttwyKLhbQhum35OcJnFc50Xohuo,3893
-fprime_gds/common/templates/cmd_template.py,sha256=Bdkfgjb9Yqw7zaZyS8fR9ZUebrkFsRofF0g7xpKtkE4,5180
+fprime_gds/common/templates/cmd_template.py,sha256=n91z4WhFgHwTu6_fQqy7JqpkEObAkllIeEy0AR0DvrQ,5455
 fprime_gds/common/templates/data_template.py,sha256=U87d8oC-BDTDuBRZbNnPkXy6rI_Pr-XnChHWZunw5jo,735
 fprime_gds/common/templates/event_template.py,sha256=L0hkWB_kEMhTNodPUqBAev76SMmWT9EWdcqxaaQX9ZE,4062
 fprime_gds/common/templates/pkt_template.py,sha256=5Wi6389m5j8w7JITBGfeUnw6CYE1-hjcVJ42NJmLDcE,1794
@@ -117,9 +123,9 @@ fprime_gds/common/utils/event_severity.py,sha256=7qPXHrDaM_REJ7sKBUEJTZIE0D4qVnV
 fprime_gds/common/utils/string_util.py,sha256=u_2iahRG3ROu3lAAt_KVcK226gEByElXqrA8mH8eDpI,3584
 fprime_gds/executables/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fprime_gds/executables/apps.py,sha256=u79T_PlgMmNmA4YwWjs7LvPMCJnrjnURr05NMthOYP0,13350
-fprime_gds/executables/cli.py,sha256=SfKL8UZL2aR_YwcG8_4ndZeLxdvgnZOlfIF2yGr1zKo,50729
+fprime_gds/executables/cli.py,sha256=Qqq3JQOqTsfDRsbTALw25xnwN7fCEVlpcKDV4jvGopQ,50961
 fprime_gds/executables/comm.py,sha256=08rO0o0MJgTRngB7Ygu2IL_gEAWKF7WFvFyro1CqReE,5214
-fprime_gds/executables/data_product_writer.py,sha256=PGNju52vjfg7-AUURFojmMV8S83Tzy58Hyti5tmpffc,35821
+fprime_gds/executables/data_product_writer.py,sha256=e1Rp2LT_Cpg08f0Ki8GhirC7Wn6LtYiAef7KLAkZHUY,37773
 fprime_gds/executables/fprime_cli.py,sha256=CMoT7zWNwM8h2mSZW03AR96wl_XnZXoLNiOZN_sDi38,12431
 fprime_gds/executables/run_deployment.py,sha256=Zl0Y9-6i6c8tZhcS7XkAeVQtzn0d9fV-3UJQZ0bnBrc,7237
 fprime_gds/executables/tcpserver.py,sha256=KspVpu5YIuiWKOk5E6UDMKvqXYrRB1j9aX8CkMxysfw,17555
@@ -238,10 +244,10 @@ fprime_gds/flask/static/third-party/webfonts/fa-solid-900.woff2,sha256=mDS4KtJuK
 fprime_gds/plugin/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fprime_gds/plugin/definitions.py,sha256=QlxW1gNvoiqGMslSJjh3dTFZuv0igFHawN__3XJ0Wns,5355
 fprime_gds/plugin/system.py,sha256=M9xb-8jBhCUUx3X1z2uAP8Wx_v6NkL8JeaFgGcMnQqY,13432
-fprime_gds-4.0.0a8.dist-info/licenses/LICENSE.txt,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-fprime_gds-4.0.0a8.dist-info/licenses/NOTICE.txt,sha256=vXjA_xRcQhd83Vfk5D_vXg5kOjnnXvLuMi5vFKDEVmg,1612
-fprime_gds-4.0.0a8.dist-info/METADATA,sha256=LQafB-nq76AfTT18Hgog3D2SZVDsSfDTi97SSn8W6_0,24549
-fprime_gds-4.0.0a8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fprime_gds-4.0.0a8.dist-info/entry_points.txt,sha256=qFBHIR7CZ5CEeSEdZ-ZVQN9ZfUOZfm0PvvDZAAheuLk,445
-fprime_gds-4.0.0a8.dist-info/top_level.txt,sha256=6vzFLIX6ANfavKaXFHDMSLFtS94a6FaAsIWhjgYuSNE,27
-fprime_gds-4.0.0a8.dist-info/RECORD,,
+fprime_gds-4.0.0a10.dist-info/licenses/LICENSE.txt,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+fprime_gds-4.0.0a10.dist-info/licenses/NOTICE.txt,sha256=vXjA_xRcQhd83Vfk5D_vXg5kOjnnXvLuMi5vFKDEVmg,1612
+fprime_gds-4.0.0a10.dist-info/METADATA,sha256=zD-VViHWpGeATD0SzBD1-yKMFOR25JIEIM3uBqMlY5Q,24577
+fprime_gds-4.0.0a10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fprime_gds-4.0.0a10.dist-info/entry_points.txt,sha256=V2XMHMUJUGTVx5s3_kK1jLmoxSKE1vvj2XWHH9y49WQ,423
+fprime_gds-4.0.0a10.dist-info/top_level.txt,sha256=6vzFLIX6ANfavKaXFHDMSLFtS94a6FaAsIWhjgYuSNE,27
+fprime_gds-4.0.0a10.dist-info/RECORD,,

{fprime_gds-4.0.0a8.dist-info → fprime_gds-4.0.0a10.dist-info}/entry_points.txt

@@ -1,7 +1,7 @@
 [console_scripts]
 fprime-cli = fprime_gds.executables.fprime_cli:main
 fprime-dp-write = fprime_gds.executables.data_product_writer:main
-fprime-fpy-bytecode = fprime_gds.common.fpy.serialize_bytecode:main
+fprime-fpyc = fprime_gds.common.fpy.main:main
 fprime-gds = fprime_gds.executables.run_deployment:main
 fprime-prm-write = fprime_gds.common.tools.params:main
 fprime-seqgen = fprime_gds.common.tools.seqgen:main

fprime_gds/common/fpy/serialize_bytecode.py

@@ -1,229 +0,0 @@
-from __future__ import annotations
-from dataclasses import astuple
-import inspect
-import json
-from pathlib import Path
-from argparse import ArgumentParser
-import struct
-import zlib
-from fprime_gds.common.fpy.types import (
-    StatementTemplate,
-    StatementData,
-    Header,
-    Footer,
-    HEADER_FORMAT,
-    FOOTER_FORMAT,
-    StatementType,
-    FPY_DIRECTIVES,
-    BytecodeParseContext,
-    get_type_obj_for,
-)
-from fprime_gds.common.loaders.ch_json_loader import ChJsonLoader
-from fprime_gds.common.loaders.cmd_json_loader import CmdJsonLoader
-from fprime.common.models.serialize.numerical_types import (
-    U8Type,
-)
-
-from fprime_gds.common.loaders.prm_json_loader import PrmJsonLoader
-
-
-def serialize_statement(stmt: StatementData) -> bytes:
-    """converts a StatementData object into bytes that the FpySequencer can read"""
-    # see https://github.com/nasa/fprime/issues/3023#issuecomment-2693051677
-    # TODO replace this with actual documentation
-
-    # type: U8 (0 if directive, 1 if cmd)
-    # opcode: FwOpcodeType (default U32)
-    # argBufSize: FwSizeStoreType (default U16)
-    # argBuf: X bytes
-
-    output = bytes()
-    output += U8Type(stmt.template.statement_type.value).serialize()
-    output += get_type_obj_for("FwOpcodeType")(stmt.template.opcode).serialize()
-
-    arg_bytes = bytes()
-    for arg in stmt.arg_values:
-        arg_bytes += arg.serialize()
-
-    output += get_type_obj_for("FwSizeStoreType")(len(arg_bytes)).serialize()
-    output += arg_bytes
-
-    return output
-
-
-def parse_str_as_statement(
-    stmt: str, templates: list[StatementTemplate], context: BytecodeParseContext
-) -> StatementData:
-    """Converts a human-readable line of bytecode into a StatementData instance, given a list of
-    possible statement templates"""
-    name = stmt.split()[0]
-    args = stmt[len(name) :]
-
-    args = json.loads("[" + args + "]")
-
-    matching_template = [t for t in templates if t.name == name]
-    if len(matching_template) != 1:
-        # no unique match
-        if len(matching_template) == 0:
-            raise RuntimeError("Could not find command or directive " + str(name))
-        raise RuntimeError(
-            "Found multiple commands or directives with name " + str(name)
-        )
-    matching_template = matching_template[0]
-
-    arg_values = []
-    if len(args) < len(matching_template.args):
-        raise RuntimeError(
-            "Missing arguments for statement "
-            + str(matching_template.name)
-            + ": "
-            + str(matching_template.args[len(args) :])
-        )
-    if len(args) > len(matching_template.args):
-        raise RuntimeError(
-            "Extra arguments for"
-            + str(matching_template.name)
-            + ": "
-            + str(args[len(matching_template.args) :])
-        )
-    for index, arg_json in enumerate(args):
-        arg_type = matching_template.args[index]
-        if inspect.isclass(arg_type):
-            # it's a type. instantiate it with the json
-            arg_value = arg_type(arg_json)
-        else:
-            # it's a function. give it the json and the ctx
-            arg_value = arg_type(arg_json, context)
-        arg_values.append(arg_value)
-
-    return StatementData(matching_template, arg_values)
-
-
-def main():
-    arg_parser = ArgumentParser()
-    arg_parser.add_argument(
-        "input", type=Path, help="The path to the input .fpybc file"
-    )
-
-    arg_parser.add_argument(
-        "-d",
-        "--dictionary",
-        type=Path,
-        help="The JSON topology dictionary to compile against",
-        required=True,
-    )
-
-    arg_parser.add_argument(
-        "-o",
-        "--output",
-        type=Path,
-        help="The output .bin file path. Defaults to the input file path with a .bin extension",
-        default=None,
-    )
-
-    args = arg_parser.parse_args()
-
-    if not args.input.exists():
-        print("Input file", args.input, "does not exist")
-        exit(1)
-
-    if not args.dictionary.exists():
-        print("Dictionary file", args.dictionary, "does not exist")
-        exit(1)
-
-    serialize_bytecode(args.input, args.dictionary, args.output)
-
-
-def serialize_bytecode(input: Path, dictionary: Path, output: Path = None):
-    """Given an input .fpybc file, and a dictionary .json file, converts the
-    bytecode file into binary and writes it to the output file. If the output file
-    is None, writes it to the input file with a .bin extension"""
-    cmd_json_dict_loader = CmdJsonLoader(str(dictionary))
-    (_, cmd_name_dict, _) = cmd_json_dict_loader.construct_dicts(
-        str(dictionary)
-    )
-
-    stmt_templates = []
-    stmt_templates.extend(FPY_DIRECTIVES)
-    for cmd_template in cmd_name_dict.values():
-        stmt_template = StatementTemplate(
-            StatementType.CMD,
-            cmd_template.opcode,
-            cmd_template.get_full_name(),
-            [arg[2] for arg in cmd_template.arguments],
-        )
-        stmt_templates.append(stmt_template)
-
-    tlm_json_loader = ChJsonLoader(str(dictionary))
-    (_, tlm_name_dict, _) = tlm_json_loader.construct_dicts(
-        str(dictionary)
-    )
-
-    prm_json_loader = PrmJsonLoader(str(dictionary))
-    (_, prm_name_dict, _) = prm_json_loader.construct_dicts(
-        str(dictionary)
-    )
-
-    context = BytecodeParseContext()
-    context.types = cmd_json_dict_loader.parsed_types
-    context.channels = tlm_name_dict
-    context.params = prm_name_dict
-
-    input_lines = input.read_text().splitlines()
-    input_lines = [line.strip() for line in input_lines]
-    # remove comments and empty lines
-    input_lines = [
-        line for line in input_lines if not line.startswith(";") and len(line) > 0
-    ]
-
-    goto_tags = {}
-    stmt_idx = 0
-    statement_strs: list[str] = []
-    for stmt in input_lines:
-        if stmt.endswith(":"):
-            # it's a goto tag
-            goto_tags[stmt[:-1]] = stmt_idx
-        else:
-            statement_strs.append(stmt)
-            stmt_idx += 1
-
-    context.goto_tags = goto_tags
-
-    statements: list[StatementData] = []
-    for stmt_idx, stmt in enumerate(statement_strs):
-        try:
-            stmt_data = parse_str_as_statement(stmt, stmt_templates, context)
-            statements.append(stmt_data)
-        except BaseException as e:
-            raise RuntimeError(
-                "Exception while parsing statement index " + str(stmt_idx) + ": " + stmt
-            ) from e
-
-    # perform some checks for things we know will fail
-    for stmt in statements:
-        if stmt.template.name == "GOTO":
-            if stmt.arg_values[0].val > len(statements):
-                raise RuntimeError(
-                    f"GOTO index is outside the valid range for this sequence (was {stmt.arg_values[0].val}, should be <{len(statements)})"
-                )
-
-    output_bytes = bytes()
-
-    for stmt in statements:
-        output_bytes += serialize_statement(stmt)
-
-    header = Header(0, 0, 0, 1, 0, len(statements), len(output_bytes))
-    output_bytes = struct.pack(HEADER_FORMAT, *astuple(header)) + output_bytes
-
-    crc = zlib.crc32(output_bytes) % (1 << 32)
-    footer = Footer(crc)
-    output_bytes += struct.pack(FOOTER_FORMAT, *astuple(footer))
-
-    if output is None:
-        output = input.with_suffix(".bin")
-
-    output.write_bytes(output_bytes)
-
-
-if __name__ == "__main__":
-    main()