fprime-gds 4.0.2a3__py3-none-any.whl → 4.0.2a5__py3-none-any.whl

fprime_gds/common/communication/ccsds/apid.py

@@ -1,19 +1,21 @@
-""" ccsds.apid: APID mapping functions for F´ data """
+"""ccsds.apid: APID mapping functions for F´ data"""
+
 from fprime_gds.common.utils.data_desc_type import DataDescType
-from fprime.common.models.serialize.numerical_types import U32Type
+from fprime.common.models.serialize.numerical_types import NumericalType
+
 
 class APID(object):
-    """ APID implementations """
-    #TODO: use the DataDescType configured by loading the dictionary
+    """APID implementations"""
+
+    # TODO: use the DataDescType configured by loading the dictionary
 
     @classmethod
     def from_type(cls, data_type: DataDescType):
-        """ Map from data description type to APID """
+        """Map from data description type to APID"""
         return data_type.value
 
     @classmethod
-    def from_data(cls, data):
-        """ Map from data bytes to APID """
-        u32_type = U32Type()
-        u32_type.deserialize(data, offset=0)
-        return cls.from_type(DataDescType(u32_type.val))
+    def from_data(cls, data, packet_descriptor_type: NumericalType):
+        """Map from data bytes to APID"""
+        packet_descriptor_type.deserialize(data, offset=0)
+        return cls.from_type(DataDescType(packet_descriptor_type.val))

fprime_gds/common/communication/ccsds/space_packet.py

@@ -10,6 +10,7 @@ from spacepackets.ccsds.spacepacket import SpacePacketHeader, PacketType, SpaceP
 from fprime_gds.common.communication.framing import FramerDeframer
 from fprime_gds.plugin.definitions import gds_plugin_implementation, gds_plugin
 from fprime_gds.common.utils.data_desc_type import DataDescType
+from fprime_gds.common.utils.config_manager import ConfigManager
 
 from .apid import APID
 import logging
@@ -29,17 +30,21 @@ class SpacePacketFramerDeframer(FramerDeframer):
     IDLE_APID = 0x7FF  # max 11 bit value per protocol specification
 
     def __init__(self):
-        # self.sequence_number = 0
         # Map APID to sequence counts
         self.apid_to_sequence_count_map = dict()
         for key in DataDescType:
             self.apid_to_sequence_count_map[key.value] = 0
+        self.packet_descriptor_type = ConfigManager.get_instance().get_type(
+            "FwPacketDescriptorType"
+        )
 
     def frame(self, data):
         """Frame the supplied data in Space Packet"""
         # The protocol defines length token to be number of bytes minus 1
         data_length_token = len(data) - 1
-        apid = APID.from_data(data)
+        # Extract the APID from the data
+        # F' has the packet descriptor (= APID currently) as first n bytes of the data
+        apid = APID.from_data(data, self.packet_descriptor_type)
         space_header = SpacePacketHeader(
             packet_type=PacketType.TC,
             apid=apid,

fprime_gds/common/communication/framing.py

@@ -47,7 +47,7 @@ class FramerDeframer(abc.ABC):
         self, data: bytes, no_copy=False
     ) -> tuple[(bytes | None), bytes, bytes]:
         """
-        Deframes the incoming data from the specified format. 
+        Deframes the incoming data from the specified format.
         Produces:
         - One packet, or None if no packet found
         - leftover bytes (not consumed yet)
@@ -80,7 +80,7 @@ class FramerDeframer(abc.ABC):
             # Deframe and return only on None
             (deframed, data, discarded) = self.deframe(data, no_copy=True)
             discarded_aggregate += discarded
-            if deframed is None: # No more packets available, return aggregate
+            if deframed is None:  # No more packets available, return aggregate
                 return packets, data, discarded_aggregate
             packets.append(deframed)
 

fprime_gds/common/distributor/distributor.py

@@ -16,6 +16,7 @@ descriptor header will be passed on to the registered objects.
 
 import logging
 
+from fprime.common.models.serialize.type_exceptions import DeserializeException
 from fprime_gds.common.decoders.decoder import DecodingException
 from fprime_gds.common.handlers import DataHandler
 from fprime_gds.common.utils import config_manager, data_desc_type
@@ -147,7 +148,6 @@ class Distributor(DataHandler):
         # | ...                       |      |
         # | ..                        |      |
         #   .                                :
-
         offset = 0
 
         # Parse length
@@ -199,13 +199,16 @@ class Distributor(DataHandler):
         ), "Leftover data is not equivalent to the remaining data in buffer"
 
         for raw_msg in raw_msgs:
-            (length, data_desc, msg) = self.parse_raw_msg_api(raw_msg)
-
-            data_desc_key = data_desc_type.DataDescType(data_desc).name
-            decoders = self.__decoders[data_desc_key]
-
+            try:
+                (length, data_desc, msg) = self.parse_raw_msg_api(raw_msg)
+                data_desc_key = data_desc_type.DataDescType(data_desc).name
+            except DeserializeException as deserialize_exception:
+                LOGGER.warning(f"Invalid message: {deserialize_exception}")
+                return
+            decoders = self.__decoders.get(data_desc_key, None)
             if not decoders:
                 LOGGER.warning(f"No decoder registered for: {data_desc_key}")
+                return
 
             for d in decoders:
                 try:

fprime_gds/common/encoders/encoder.py

@@ -20,6 +20,7 @@ purpose is to define the interface for an encoder.
 
 @bug No known bugs
 """
+
 import abc
 import logging
 

fprime_gds/common/fpy/README.md

@@ -1,56 +1,204 @@
-# Fpy Advanced Sequencing Language Version 0.1
-The Fpy advanced sequencing language is a combination of a high-level scripting language and a low-level bytecode language for running complex command sequences on spacecraft flight software.
-## Fpy Syntax
-### Modules, components, channels, commands and types
-You can imagine the Fpy syntax as Python with the following mappings:
-1. FPrime modules become Python namespaces
-2. FPrime components become Python classes
-3. FPrime types (structs, arrays and enums) become Python classes
-4. FPrime component instances become Python object instances
-5. FPrime commands become member functions of Python object instances
-6. FPrime telemetry channels become member properties of Python object instances
+# Fpy Guide
 
-FPrime declaration:
+Fpy is an easy to learn, powerful spacecraft scripting language backed by decades of JPL heritage. It is designed to work with the FPrime flight software framework. The syntax is inspired by Python, and it compiles to an efficient binary format.
+
+This guide is a quick overview of the most important features of Fpy. It should be easy to follow for someone who has used Python and FPrime before.
+
+## 1. Compiling and Running a Sequence
+
+First, make sure `fprime-gds` is installed.
+
+Fpy sequences are suffixed with `.fpy`. Let's make a test sequence that dispatches a no-op:
+```py
+# hash denotes a comment
+# assume this file is named "test.fpy"
+
+# use the full name of the no-op command:
+CdhCore.cmdDisp.CMD_NO_OP() # empty parentheses indicate no arguments
 ```
-module Ref {
-    passive component ExampleComponent {
-        telemetry testChannel: U8
-        sync command TEST_COMMAND(arg: string size 40)
-    }
 
-    instance exampleInstance: ExampleComponent base id 0x01
-}
+You can compile it with `fprime-fpyc test.fpy --dictionary Ref/build-artifacts/Linux/dict/RefTopologyDictionary.json`
+
+Make sure your deployment topology has an instance of the `Svc.FpySequencer` component. You can run the sequence by passing it in as an argument to the `Svc.FpySequencer.RUN` command.
+
+## 2. Variables and Basic Types
+
+Fpy supports statically-typed, mutable local variables. You can change their value, but the type of the variable can't change. 
+
+This is how you declare a variable, and change its value:
+```py
+unsigned_var: U8 = 0
+# this is a variable named unsigned_var with a type of unsigned 8-bit integer and a value of 0
+
+unsigned_var = 123
+# now it has a value of 123
+```
+
+For types, Fpy has most of the same basic ones that FPP does:
+* Signed integers: `I8, I16, I32, I64`
+* Unsigned integers: `U8, U16, U32, U64`
+* Floats: `F32, F64`
+* Boolean: `bool`
+
+Float literals are denoted with a decimal point (`5.0`, `0.123`) and Boolean literals have a capitalized first letter: `True`, `False`. There is no way to differentiate between signed and unsigned integer literals, so the compiler looks at where the literal is used to determine the signedness.
+
+Note there is currently no built-in `string` type. See [Strings](#13-strings).
+
+## 3. Dictionary Types
+
+Fpy also has access to all structs, arrays and enums in the FPrime dictionary:
+```py
+# you can access enum constants by name:
+enum_var: Fw.Success = Fw.Success.SUCCESS
+
+# you can construct arrays:
+array_var: Ref.DpDemo.U32Array = Ref.DpDemo.U32Array(0, 1, 2, 3, 4)
+
+# you can construct structs:
+struct_var: Ref.SignalPair = Ref.SignalPair(0.0, 1.0)
 ```
-Fpy usage:
+
+In general, the syntax for instantiating a struct or array type is `Full.Type.Name(arg, ..., arg)`.
+
+## 4. Math
+You can do basic math and store the result in variables in Fpy:
 ```py
-# reference a telemetry channel
-Ref.exampleInstance.testChannel
-# call a command
-Ref.exampleInstance.TEST_COMMAND("arg value")
+pemdas: F32 = 1 - 2 + 3 * 4 + 10 / 5 * 2 # == 15.0
 ```
 
+Fpy supports the following math operations:
+* Basic arithmetic: `+, -, *, /`
+* Modulo: `%`
+* Exponentiation: `**`
+* Floor division: `//`
+* Natural logarithm: `log(x)`
+
+The behavior of these operators is designed to mimic Python. Note that **division always returns a float**. This means that `5 / 2 == 2.5`, not `2`. This may be confusing coming from C++, but it is consistent with Python.
 
-FPrime declaration:
+## 5. Variable Arguments to Commands
+
+Where this really gets interesting is when you pass variables or expressions into commands:
+```py
+# this is a command that takes an F32
+Ref.recvBuffComp.PARAMETER4_PRM_SET(1 - 2 + 3 * 4 + 10 / 5 * 2)
+# alternatively:
+param4: F32 = 15.0
+Ref.recvBuffComp.PARAMETER4_PRM_SET(param4)
 ```
-struct ExampleStruct {
-    member: F32
-}
 
-enum TestEnum {
-    ONE
-    TWO
-    THREE
-}
+The same syntax works with the [`sleep`](#11-relative-and-absolute-sleep), [`exit`](#12-exit-macro), and `log` macros.
 
-array TestArray = [3] U8
+There are some restrictions on passing string values, or complex types containing string values, to commands. See [Strings](#13-strings).
+
+## 6. Getting Telemetry Channels
+
+Fpy supports getting the value of telemetry channels:
+```py
+cmds_dispatched: U32 = CdhCore.cmdDisp.CommandsDispatched
+
+signal_pair: Ref.SignalPair = Ref.SG1.PairOutput
 ```
 
-Fpy usage:
+It's important to note that if your component hasn't written telemetry to the telemetry database (`TlmPacketizer` or `TlmChan`) in a while, the value the sequence sees may be old. Make sure to regularly write your telemetry!
+
+## 7. Getting Parameters
+
+Fpy supports getting the value of parameters:
 ```py
-# construct a struct
-ExampleStruct(0.0)
-# reference an enum const
-TestEnum.THREE
-# construct an array
-TestArray(1, 2, 3)
-```
+prm_3: U8 = Ref.sendBuffComp.parameter3
+```
+
+A significant limitation of this is that it will only return the value most recently saved to the parameter database. This means you must command `_PRM_SAVE` before the sequence will see the new value.
+
+## 8. Conditionals
+Fpy supports comparison operators:
+```py
+value: bool = 1 > 2 and (3 + 4) != 5
+```
+* Inequalities: `>, <, >=, <=`
+* Equalities: `==, !=`
+* Boolean functions: `and, or, not`
+
+
+The inequality operators can compare two numbers of any type together. The equality operators, in addition to comparing numbers, can check for equality between two of the same complex type:
+```py
+record1: Svc.DpRecord = Svc.DpRecord(0, 1, 2, 3, 4, 5, Fw.DpState.UNTRANSMITTED)
+record2: Svc.DpRecord = Svc.DpRecord(0, 1, 2, 3, 4, 5, Fw.DpState.UNTRANSMITTED)
+records_equal: bool = record1 == record2 # == True
+```
+## 9. If/elif/else
+
+You can branch off of conditionals with `if`, `elif` and `else`:
+```py
+random_value: I8 = 4 # chosen by fair dice roll. guaranteed to be random
+
+if random_value < 0:
+    CdhCore.cmdDisp.CMD_NO_OP_STRING("won't happen")
+elif random_value > 0 and random_value <= 6:
+    CdhCore.cmdDisp.CMD_NO_OP_STRING("should happen!")
+else:
+    CdhCore.cmdDisp.CMD_NO_OP_STRING("uh oh...")
+```
+
+This is particularly useful for checking telemetry channel values:
+```py
+# dispatch a no-op
+CdhCore.cmdDisp.CMD_NO_OP()
+# the commands dispatched count should be >= 1
+if CdhCore.cmdDisp.CommandsDispatched >= 1:
+    CdhCore.cmdDisp.CMD_NO_OP_STRING("should happen")
+```
+
+## 10. Getting Struct Members and Array Items
+
+You can access members of structs by name, or array elements by index:
+```py
+# access struct members with "." syntax
+signal_pair_time: F32 = Ref.SG1.PairOutput.time
+
+# access array elements with "[]" syntax
+com_queue_depth_0: U32 = ComCcsds.comQueue.comQueueDepth[0]
+```
+
+You cannot reassign struct members or array elements however:
+```py
+# Ref.SignalPair is a struct type
+signal_pair: Ref.SignalPair = Ref.SG1.PairOutput
+# compiler error:
+signal_pair.time = 0.2
+
+# Svc.ComQueueDepth is an array type
+com_queue_depth: Svc.ComQueueDepth = ComCcsds.comQueue.comQueueDepth
+# compiler error:
+com_queue_depth[0] = 1
+```
+
+## 11. Relative and Absolute Sleep
+You can pause the execution of a sequence for a relative duration, or until an absolute time:
+```py
+CdhCore.cmdDisp.CMD_NO_OP_STRING("second 0")
+# sleep for 1 second and 0 microseconds
+sleep(1, 0)
+CdhCore.cmdDisp.CMD_NO_OP_STRING("second 1")
+
+
+CdhCore.cmdDisp.CMD_NO_OP_STRING("today")
+# sleep until 12345678900 seconds and 0 microseconds after the epoch
+sleep_until(0, 0, 12345678900, 0)
+CdhCore.cmdDisp.CMD_NO_OP_STRING("much later")
+```
+
+Make sure that the `Svc.FpySequencer.checkTimers` port is connected to a rate group. The sequencer only checks if a sleep is done when the port is called, so the more frequently you call it, the more accurate the wakeup time.
+
+## 12. Exit Macro
+You can end the execution of the sequence early by calling the `exit` macro:
+```py
+# exit takes a boolean argument
+# True means "end the sequence without an error"
+exit(True)
+# False means "end the sequence and raise an error"
+exit(False)
+```
+
+## 13. Strings
+Fpy does not support a fully-fledged `string` type yet. You can pass a string literal as an argument to a command, but you cannot pass a string from a telemetry channel. You also cannot store a string in a variable, or perform any string manipulation. These features will be added in a later Fpy update.

fprime_gds/common/fpy/SPEC.md

@@ -1,69 +1,183 @@
 Nothing type is a type whose set of values is an empty set
 Unit type is a type whose set of values is a set with one element
+BIG question: what if we made an arbitrary precision int type? and float type?
+
+# Types
+
+The following types are built into Fpy, and the developer can directly refer to them by name:
+* Numeric types: `U8, U16, U32, U64, I8, I16, I32, I64, F32, F64`
+* Boolean type: `bool`
+* Time type: `Fw.Time`
+
+In addition, the developer can directly refer to any displayable type defined in FPP via its fully-qualified name. This includes user-defined structs, arrays and enums.
+
+There are some types which exist in Fpy but cannot be directly referenced by name by the developer. These are the internal *Int*, and *String* types. See [literals](#literals).
+
+## Structs
+You can instantiate a new struct at runtime by calling its constructor. A struct's constructor is a function with the same name as the type, with arguments corresponding to the type and position of the struct's members. For example, a struct defined as:
+```
+module Fw {
+    struct Example {
+        intValue: U8
+        boolValue: bool
+    }
+}
+```
+can be constructed in Fpy like:
+```
+Fw.Example(0, True)
+```
+
+
+# Literals
+The following literals are supported by Fpy:
+* Integer literals: `123`, `-456_879`
+* Float literals: `0.123`, `1e-5`
+* String literals: `"hello world"`, `'example string'`
+* Boolean literals: `True` and `False`
+
+## Integer literals
+Integer literals are strings matching:
+```
+DEC_NUMBER:   "1".."9" ("_"?  "0".."9" )*
+          |   "0"      ("_"?  "0"      )* /(?![1-9])/
+```
+
+The first rule of this syntax allows for integers without leading zeroes, separated by underscores. So this is okay:
+```
+123_456
+```
+but this is not:
+```
+0123_456
+```
+
+The second rule allows you to write any number of zeroes, separated by underscores:
+```
+00_000_0
+```
+
+Integer literals have a internal type *Int*, which is not directly referenceable by the user. The *Int* type supports integers of arbitrary size.
+
+## Float literals
+Float literals are strings matching:
+```
+FLOAT_NUMBER: _SPECIAL_DEC _EXP | DECIMAL _EXP?
+```
+where `_SPECIAL_DEC`, `_EXP` and `DECIMAL` are defined as:
+
+```
+_SPECIAL_DEC: "0".."9" ("_"?  "0".."9")*
+_EXP: ("e"|"E") ["+" | "-"] _SPECIAL_DEC
+DECIMAL: "." _SPECIAL_DEC | _SPECIAL_DEC "." _SPECIAL_DEC?
+```
+
+A `FLOAT_NUMBER` can be any string of digits suffixed with an exponent, like these:
+```
+1e-5
+100_200e10
+```
 
-# `if` statement
+or it can be a `DECIMAL` optionally suffixed by an exponent, like these:
+```
+1.
+2.123
+100.5e+10
+```
 
-## Syntactical and semantic checks
+Float literals are of type `F64`.
 
-`"if" condition ":" INDENT stmt* DEDENT ("elif" condition ":" INDENT stmt* DEDENT)* ["else" ":" INDENT stmt* DEDENT]`
+## String literals
+String literals are strings matching:
+```
+STRING: /("(?!"").*?(?<!\\)(\\\\)*?"|'(?!'').*?(?<!\\)(\\\\)*?')/i
+```
 
-1. where `condition` is an expression which evaluates to a boolean
-2. where `stmt` is a statement
+They have a internal type *String*, which is not directly referenceable by the user. The *String* type supports strings of arbitrary length.
 
-## Code generation
+# Functions
+Functions have arguments and a return type. You can call a function like:
+```
+function_name(arg_1, arg_2, arg_3)
+```
 
-1. `if` generates `IF`, followed by the generated code for the first body, followed by `GOTO` to the end of the if statement
-2. `elif` generates `IF`, followed by the generated code for its body, followed by `GOTO` to the end of the if statement
-3. `else` generates the code for its body
+## Commands
 
-# `not` boolean operator
 
-## Syntactical and semantic checks
+# Type conversion
+
+Type conversion is the process of converting an expression from one type to another. It can either be implicit, in which case it is called coercion, or explicit, in which case it is called casting.
 
-`"not" value` evaluates to a boolean at runtime
+## Coercion
+Coercion happens when an expression of type *A* is used in a syntactic element which requires an expression of type *B*. For example, functions, operators and variable assignments all require specific input types, so type coercion happens in each of these.
 
-1. where `value` is an expression which evaluates to a boolean
+When type coercion happens, the following type conversion rules are applied:
+
+1. Expressions of any integer type can be converted to any signed or unsigned integer or float type.
+2. Expressions of any float type can be converted to any float type.
+3. Expressions of internal type *String* can be converted to any string type.
+
+TODO try out with forcing type casting--see what the FF's think
+TODO require explicit narrowing casts? or have a compiler warning?
+TODO consider float to int conversion?
+TODO consider adding constants
 
-## Code generation
+If no rule matches, then the compiler raises an error.
 
-1. `not` generates `NOT`
+There is currently no support for converting non-internal string expressions to other string expressions.
 
-# `and` and `or` boolean operators
+# Operators
 
-## Syntactical and semantic checks
+Fpy supports the following operators:
+* Basic arithmetic: `+, -, *, /`
+* Modulo: `%`
+* Exponentiation: `**`
+* Floor division: `//`
+* Boolean: `and, or, not`
+* Comparison: `<, >, <=, >=, ==, !=`
 
-`value (op value)+` evaluates to a boolean at runtime
+Each time an operator is used, an intermediate type must be picked and both args must be converted to that type.
 
-1. where `op: "and"|"or"`
-2. where `value` is an expression which evaluates to a boolean
+## Behavior of operators
 
-## Code generation
+### Addition (`+`)
+### Subtraction (`-`)
+### Multiplication (`*`)
+### Division (`/`)
+### Modulo (`%`)
+### Exponentiation (`**`)
+### Floor division (`//`)
+### And (`and`)
+### Or (`or`)
+### Not (`not`)
 
-1. Each `and` or `or` between two `value`s generates an `AND` or `OR`, respectively
 
-# Infix comparisons
+## Intermediate types
 
-## Syntactical and semantic checks
+Intermediate types are picked via the following rules:
 
-`lhs op rhs` evaluates to a boolean at runtime
+1. The intermediate type of Boolean operators is always `bool`.
+2. The intermediate type of `==` and `!=` may be any type, so long as the left and right hand sides are the same type. If both are numeric then continue.
+3. If either argument is non-numeric, raise an error.
+4. If the operator is `/` or `**`, the intermediate type is always `F64`.
+5. If either argument is a float, the intermediate type is `F64`.
+6. If either argument is an unsigned integer, the intermediate type is `U64`.
+7. Otherwise, the intermediate type is `I64`.
 
-1. where `op: ">" | "<" | "<=" | ">=" | "==" | "!="`
-2. and `lhs`, `rhs` are expressions which evaluate to a number
+If the expressions given to the operator are not of the intermediate type, type coercion rules are applied.
 
-If either `lhs` or `rhs` evaluate to a float:
-3. both `lhs` and `rhs` must evaluate to floats of the same bit width
+## Result type
 
-Otherwise, `lhs` and `rhs` evaluate to integer values. All comparisons between integer values are valid.
+The result type is the type of the value produced by the operator.
+1. For numeric operators, the result type is the intermediate type.
+2. For boolean and comparison operators, the result type is `bool`.
 
-## Code generation
+Normal type coercion rules apply to the result, of course. Once the operator has produced a value, it may be coerced into some other type depending on context.
 
-### Equality comparisons
 
-1. `==` or `!=` between two floats generates `FEQ` or `FNE`, respectively
-2. `==` or `!=` between two ints generates `IEQ` or `INE`, respectively
+# Macros
 
-### Inequality comparisons
-
-1. `>`, `<`, `<=`, or `>=` between two floats generates `FGT`, `FLT`, `FLE` or `FGE`, respectively
-2. `>`, `<`, `<=`, or `>=` between two unsigned ints generates `UGT`, `ULT`, `ULE` or `UGE`, respectively
-2. `>`, `<`, `<=`, or `>=` between two ints, where at least one is signed, generates `SGT`, `SLT`, `SLE` or `SGE`, respectively
+## exit
+## log
+## sleep
+## sleep_until

fprime_gds/common/fpy/bytecode/assembler.py

@@ -0,0 +1,62 @@
+from dataclasses import astuple, dataclass
+import struct
+import zlib
+from fprime_gds.common.fpy.bytecode.directives import Directive
+from pathlib import Path
+
+HEADER_FORMAT = "!BBBBBHI"
+HEADER_SIZE = struct.calcsize(HEADER_FORMAT)
+
+
+@dataclass
+class Header:
+    majorVersion: int
+    minorVersion: int
+    patchVersion: int
+    schemaVersion: int
+    argumentCount: int
+    statementCount: int
+    bodySize: int
+
+
+FOOTER_FORMAT = "!I"
+FOOTER_SIZE = struct.calcsize(FOOTER_FORMAT)
+
+SCHEMA_VERSION = 2
+
+
+@dataclass
+class Footer:
+    crc: int
+
+
+def serialize_directives(dirs: list[Directive], output: Path):
+    output_bytes = bytes()
+
+    for dir in dirs:
+        output_bytes += dir.serialize()
+
+    header = Header(0, 0, 0, SCHEMA_VERSION, 0, len(dirs), 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))
+    output.write_bytes(output_bytes)
+
+
+def deserialize_directives(bytes: bytes) -> list[Directive]:
+    header = Header(*struct.unpack_from(HEADER_FORMAT, bytes))
+
+    dirs = []
+    idx = 0
+    offset = HEADER_SIZE
+    while idx < header.statementCount:
+        offset_and_dir = Directive.deserialize(bytes, offset)
+        if offset_and_dir is None:
+            raise RuntimeError("Unable to deserialize sequence")
+        offset, dir = offset_and_dir
+        dirs.append(dir)
+        idx += 1
+
+    return dirs