qiskit 1.0.0b1__cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

qiskit/qpy/common.py

@@ -0,0 +1,305 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2019.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+
+"""
+Common functions across several serialization and deserialization modules.
+"""
+
+import io
+import struct
+
+from qiskit.qpy import formats
+
+QPY_VERSION = 10
+ENCODE = "utf8"
+
+
+def read_generic_typed_data(file_obj):
+    """Read a single data chunk from the file like object.
+
+    Args:
+        file_obj (File): A file like object that contains the QPY binary data.
+
+    Returns:
+        tuple: Tuple of type key binary and the bytes object of the single data.
+    """
+    data = formats.INSTRUCTION_PARAM._make(
+        struct.unpack(formats.INSTRUCTION_PARAM_PACK, file_obj.read(formats.INSTRUCTION_PARAM_SIZE))
+    )
+
+    return data.type, file_obj.read(data.size)
+
+
+def read_sequence(file_obj, deserializer, **kwargs):
+    """Read a sequence of data from the file like object.
+
+    Args:
+        file_obj (File): A file like object that contains the QPY binary data.
+        deserializer (Callable): Deserializer callback that can handle input object type.
+            This must take type key and binary data of the element and return object.
+        kwargs: Options set to the deserializer.
+
+    Returns:
+        list: Deserialized object.
+    """
+    sequence = []
+
+    data = formats.SEQUENCE._make(
+        struct.unpack(formats.SEQUENCE_PACK, file_obj.read(formats.SEQUENCE_SIZE))
+    )
+    for _ in range(data.num_elements):
+        type_key, datum_bytes = read_generic_typed_data(file_obj)
+        sequence.append(deserializer(type_key, datum_bytes, **kwargs))
+
+    return sequence
+
+
+def read_mapping(file_obj, deserializer, **kwargs):
+    """Read a mapping from the file like object.
+
+    .. note::
+
+        This function must be used to make a binary data of mapping
+        which include QPY serialized values.
+        It's easier to use JSON serializer followed by encoding for standard data formats.
+        This only supports flat dictionary and key must be string.
+
+    Args:
+        file_obj (File): A file like object that contains the QPY binary data.
+        deserializer (Callable): Deserializer callback that can handle mapping item.
+            This must take type key and binary data of the mapping value and return object.
+        kwargs: Options set to the deserializer.
+
+    Returns:
+        dict: Deserialized object.
+    """
+    mapping = {}
+
+    data = formats.SEQUENCE._make(
+        struct.unpack(formats.SEQUENCE_PACK, file_obj.read(formats.SEQUENCE_SIZE))
+    )
+    for _ in range(data.num_elements):
+        map_header = formats.MAP_ITEM._make(
+            struct.unpack(formats.MAP_ITEM_PACK, file_obj.read(formats.MAP_ITEM_SIZE))
+        )
+        key = file_obj.read(map_header.key_size).decode(ENCODE)
+        datum = deserializer(map_header.type, file_obj.read(map_header.size), **kwargs)
+        mapping[key] = datum
+
+    return mapping
+
+
+def read_type_key(file_obj):
+    """Read a type key from the file like object.
+
+    Args:
+        file_obj (File): A file like object that contains the QPY binary data.
+
+    Returns:
+        bytes: Type key.
+    """
+    key_size = struct.calcsize("!1c")
+    return struct.unpack("!1c", file_obj.read(key_size))[0]
+
+
+def write_generic_typed_data(file_obj, type_key, data_binary):
+    """Write statically typed binary data to the file like object.
+
+    Args:
+        file_obj (File): A file like object to write data.
+        type_key (Enum): Object type of the data.
+        data_binary (bytes): Binary data to write.
+    """
+    data_header = struct.pack(formats.INSTRUCTION_PARAM_PACK, type_key, len(data_binary))
+    file_obj.write(data_header)
+    file_obj.write(data_binary)
+
+
+def write_sequence(file_obj, sequence, serializer, **kwargs):
+    """Write a sequence of data in the file like object.
+
+    Args:
+        file_obj (File): A file like object to write data.
+        sequence (Sequence): Object to serialize.
+        serializer (Callable): Serializer callback that can handle input object type.
+            This must return type key and binary data of each element.
+        kwargs: Options set to the serializer.
+    """
+    num_elements = len(sequence)
+
+    file_obj.write(struct.pack(formats.SEQUENCE_PACK, num_elements))
+    for datum in sequence:
+        type_key, datum_bytes = serializer(datum, **kwargs)
+        write_generic_typed_data(file_obj, type_key, datum_bytes)
+
+
+def write_mapping(file_obj, mapping, serializer, **kwargs):
+    """Write a mapping in the file like object.
+
+    .. note::
+
+        This function must be used to make a binary data of mapping
+        which include QPY serialized values.
+        It's easier to use JSON serializer followed by encoding for standard data formats.
+        This only supports flat dictionary and key must be string.
+
+    Args:
+        file_obj (File): A file like object to write data.
+        mapping (Mapping): Object to serialize.
+        serializer (Callable): Serializer callback that can handle mapping item.
+            This must return type key and binary data of the mapping value.
+        kwargs: Options set to the serializer.
+    """
+    num_elements = len(mapping)
+
+    file_obj.write(struct.pack(formats.SEQUENCE_PACK, num_elements))
+    for key, datum in mapping.items():
+        key_bytes = key.encode(ENCODE)
+        type_key, datum_bytes = serializer(datum, **kwargs)
+        item_header = struct.pack(formats.MAP_ITEM_PACK, len(key_bytes), type_key, len(datum_bytes))
+        file_obj.write(item_header)
+        file_obj.write(key_bytes)
+        file_obj.write(datum_bytes)
+
+
+def write_type_key(file_obj, type_key):
+    """Write a type key in the file like object.
+
+    Args:
+        file_obj (File): A file like object that contains the QPY binary data.
+        type_key (bytes): Type key to write.
+    """
+    file_obj.write(struct.pack("!1c", type_key))
+
+
+def data_to_binary(obj, serializer, **kwargs):
+    """Convert object into binary data with specified serializer.
+
+    Args:
+        obj (any): Object to serialize.
+        serializer (Callable): Serializer callback that can handle input object type.
+        kwargs: Options set to the serializer.
+
+    Returns:
+        bytes: Binary data.
+    """
+    with io.BytesIO() as container:
+        serializer(container, obj, **kwargs)
+        binary_data = container.getvalue()
+
+    return binary_data
+
+
+def sequence_to_binary(sequence, serializer, **kwargs):
+    """Convert sequence into binary data with specified serializer.
+
+    Args:
+        sequence (Sequence): Object to serialize.
+        serializer (Callable): Serializer callback that can handle input object type.
+            This must return type key and binary data of each element.
+        kwargs: Options set to the serializer.
+
+    Returns:
+        bytes: Binary data.
+    """
+    with io.BytesIO() as container:
+        write_sequence(container, sequence, serializer, **kwargs)
+        binary_data = container.getvalue()
+
+    return binary_data
+
+
+def mapping_to_binary(mapping, serializer, **kwargs):
+    """Convert mapping into binary data with specified serializer.
+
+    .. note::
+
+        This function must be used to make a binary data of mapping
+        which include QPY serialized values.
+        It's easier to use JSON serializer followed by encoding for standard data formats.
+        This only supports flat dictionary and key must be string.
+
+    Args:
+        mapping (Mapping): Object to serialize.
+        serializer (Callable): Serializer callback that can handle mapping item.
+            This must return type key and binary data of the mapping value.
+        kwargs: Options set to the serializer.
+
+    Returns:
+        bytes: Binary data.
+    """
+    with io.BytesIO() as container:
+        write_mapping(container, mapping, serializer, **kwargs)
+        binary_data = container.getvalue()
+
+    return binary_data
+
+
+def data_from_binary(binary_data, deserializer, **kwargs):
+    """Load object from binary data with specified deserializer.
+
+    Args:
+        binary_data (bytes): Binary data to deserialize.
+        deserializer (Callable): Deserializer callback that can handle input object type.
+        kwargs: Options set to the deserializer.
+
+    Returns:
+        any: Deserialized object.
+    """
+    with io.BytesIO(binary_data) as container:
+        container.seek(0)
+        obj = deserializer(container, **kwargs)
+    return obj
+
+
+def sequence_from_binary(binary_data, deserializer, **kwargs):
+    """Load object from binary sequence with specified deserializer.
+
+    Args:
+        binary_data (bytes): Binary data to deserialize.
+        deserializer (Callable): Deserializer callback that can handle input object type.
+            This must take type key and binary data of the element and return object.
+        kwargs: Options set to the deserializer.
+
+    Returns:
+        any: Deserialized sequence.
+    """
+    with io.BytesIO(binary_data) as container:
+        sequence = read_sequence(container, deserializer, **kwargs)
+
+    return sequence
+
+
+def mapping_from_binary(binary_data, deserializer, **kwargs):
+    """Load object from binary mapping with specified deserializer.
+
+    .. note::
+
+        This function must be used to make a binary data of mapping
+        which include QPY serialized values.
+        It's easier to use JSON serializer followed by encoding for standard data formats.
+        This only supports flat dictionary and key must be string.
+
+    Args:
+        binary_data (bytes): Binary data to deserialize.
+        deserializer (Callable): Deserializer callback that can handle mapping item.
+            This must take type key and binary data of the mapping value and return object.
+        kwargs: Options set to the deserializer.
+
+    Returns:
+        dict: Deserialized object.
+    """
+    with io.BytesIO(binary_data) as container:
+        mapping = read_mapping(container, deserializer, **kwargs)
+
+    return mapping

qiskit/qpy/exceptions.py

@@ -0,0 +1,28 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2022.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Exception for errors raised by the QPY module."""
+
+from qiskit.exceptions import QiskitError
+
+
+class QpyError(QiskitError):
+    """Errors raised by the qpy module."""
+
+    def __init__(self, *message):
+        """Set the error message."""
+        super().__init__(*message)
+        self.message = " ".join(message)
+
+    def __str__(self):
+        """Return the message."""
+        return repr(self.message)

qiskit/qpy/formats.py

@@ -0,0 +1,360 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021, 2022.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+# pylint: disable=invalid-name
+
+"""Binary format definition."""
+
+import struct
+from collections import namedtuple
+
+
+# FILE_HEADER_V10
+FILE_HEADER_V10 = namedtuple(
+    "FILE_HEADER",
+    [
+        "preface",
+        "qpy_version",
+        "major_version",
+        "minor_version",
+        "patch_version",
+        "num_programs",
+        "symbolic_encoding",
+    ],
+)
+FILE_HEADER_V10_PACK = "!6sBBBBQc"
+FILE_HEADER_V10_SIZE = struct.calcsize(FILE_HEADER_V10_PACK)
+
+# FILE_HEADER
+FILE_HEADER = namedtuple(
+    "FILE_HEADER",
+    ["preface", "qpy_version", "major_version", "minor_version", "patch_version", "num_programs"],
+)
+FILE_HEADER_PACK = "!6sBBBBQ"
+FILE_HEADER_SIZE = struct.calcsize(FILE_HEADER_PACK)
+
+# CIRCUIT_HEADER_V2
+CIRCUIT_HEADER_V2 = namedtuple(
+    "HEADER",
+    [
+        "name_size",
+        "global_phase_type",
+        "global_phase_size",
+        "num_qubits",
+        "num_clbits",
+        "metadata_size",
+        "num_registers",
+        "num_instructions",
+    ],
+)
+CIRCUIT_HEADER_V2_PACK = "!H1cHIIQIQ"
+CIRCUIT_HEADER_V2_SIZE = struct.calcsize(CIRCUIT_HEADER_V2_PACK)
+
+# CIRCUIT_HEADER
+CIRCUIT_HEADER = namedtuple(
+    "HEADER",
+    [
+        "name_size",
+        "global_phase",
+        "num_qubits",
+        "num_clbits",
+        "metadata_size",
+        "num_registers",
+        "num_instructions",
+    ],
+)
+CIRCUIT_HEADER_PACK = "!HdIIQIQ"
+CIRCUIT_HEADER_SIZE = struct.calcsize(CIRCUIT_HEADER_PACK)
+
+# REGISTER
+REGISTER_V4 = namedtuple("REGISTER", ["type", "standalone", "size", "name_size", "in_circuit"])
+REGISTER_V4_PACK = "!1c?IH?"
+REGISTER_V4_SIZE = struct.calcsize(REGISTER_V4_PACK)
+
+REGISTER = namedtuple("REGISTER", ["type", "standalone", "size", "name_size"])
+REGISTER_PACK = "!1c?IH"
+REGISTER_SIZE = struct.calcsize(REGISTER_PACK)
+
+# CIRCUIT_INSTRUCTION
+CIRCUIT_INSTRUCTION = namedtuple(
+    "CIRCUIT_INSTRUCTION",
+    [
+        "name_size",
+        "label_size",
+        "num_parameters",
+        "num_qargs",
+        "num_cargs",
+        "has_condition",
+        "condition_register_size",
+        "condition_value",
+    ],
+)
+CIRCUIT_INSTRUCTION_PACK = "!HHHII?Hq"
+CIRCUIT_INSTRUCTION_SIZE = struct.calcsize(CIRCUIT_INSTRUCTION_PACK)
+
+# CIRCUIT_INSTRUCTION_V2
+CIRCUIT_INSTRUCTION_V2 = namedtuple(
+    "CIRCUIT_INSTRUCTION",
+    [
+        "name_size",
+        "label_size",
+        "num_parameters",
+        "num_qargs",
+        "num_cargs",
+        "conditional_key",
+        "condition_register_size",
+        "condition_value",
+        "num_ctrl_qubits",
+        "ctrl_state",
+    ],
+)
+CIRCUIT_INSTRUCTION_V2_PACK = "!HHHIIBHqII"
+CIRCUIT_INSTRUCTION_V2_SIZE = struct.calcsize(CIRCUIT_INSTRUCTION_V2_PACK)
+
+
+# CIRCUIT_INSTRUCTION_ARG
+CIRCUIT_INSTRUCTION_ARG = namedtuple("CIRCUIT_INSTRUCTION_ARG", ["type", "size"])
+CIRCUIT_INSTRUCTION_ARG_PACK = "!1cI"
+CIRCUIT_INSTRUCTION_ARG_SIZE = struct.calcsize(CIRCUIT_INSTRUCTION_ARG_PACK)
+
+# SparsePauliOp List
+SPARSE_PAULI_OP_LIST_ELEM = namedtuple("SPARSE_PAULI_OP_LIST_ELEMENT", ["size"])
+SPARSE_PAULI_OP_LIST_ELEM_PACK = "!Q"
+SPARSE_PAULI_OP_LIST_ELEM_SIZE = struct.calcsize(SPARSE_PAULI_OP_LIST_ELEM_PACK)
+
+# Pauli Evolution Gate
+PAULI_EVOLUTION_DEF = namedtuple(
+    "PAULI_EVOLUTION_DEF",
+    ["operator_size", "standalone_op", "time_type", "time_size", "synth_method_size"],
+)
+PAULI_EVOLUTION_DEF_PACK = "!Q?1cQQ"
+PAULI_EVOLUTION_DEF_SIZE = struct.calcsize(PAULI_EVOLUTION_DEF_PACK)
+
+# CUSTOM_CIRCUIT_DEF_HEADER
+CUSTOM_CIRCUIT_DEF_HEADER = namedtuple("CUSTOM_CIRCUIT_DEF_HEADER", ["size"])
+CUSTOM_CIRCUIT_DEF_HEADER_PACK = "!Q"
+CUSTOM_CIRCUIT_DEF_HEADER_SIZE = struct.calcsize(CUSTOM_CIRCUIT_DEF_HEADER_PACK)
+
+# CUSTOM_CIRCUIT_INST_DEF_V2
+CUSTOM_CIRCUIT_INST_DEF_V2 = namedtuple(
+    "CUSTOM_CIRCUIT_INST_DEF",
+    [
+        "gate_name_size",
+        "type",
+        "num_qubits",
+        "num_clbits",
+        "custom_definition",
+        "size",
+        "num_ctrl_qubits",
+        "ctrl_state",
+        "base_gate_size",
+    ],
+)
+CUSTOM_CIRCUIT_INST_DEF_V2_PACK = "!H1cII?QIIQ"
+CUSTOM_CIRCUIT_INST_DEF_V2_SIZE = struct.calcsize(CUSTOM_CIRCUIT_INST_DEF_V2_PACK)
+
+# CUSTOM_CIRCUIT_INST_DEF
+CUSTOM_CIRCUIT_INST_DEF = namedtuple(
+    "CUSTOM_CIRCUIT_INST_DEF",
+    ["gate_name_size", "type", "num_qubits", "num_clbits", "custom_definition", "size"],
+)
+CUSTOM_CIRCUIT_INST_DEF_PACK = "!H1cII?Q"
+CUSTOM_CIRCUIT_INST_DEF_SIZE = struct.calcsize(CUSTOM_CIRCUIT_INST_DEF_PACK)
+
+# CALIBRATION
+CALIBRATION = namedtuple("CALIBRATION", ["num_cals"])
+CALIBRATION_PACK = "!H"
+CALIBRATION_SIZE = struct.calcsize(CALIBRATION_PACK)
+
+# CALIBRATION_DEF
+CALIBRATION_DEF = namedtuple("CALIBRATION_DEF", ["name_size", "num_qubits", "num_params", "type"])
+CALIBRATION_DEF_PACK = "!HHH1c"
+CALIBRATION_DEF_SIZE = struct.calcsize(CALIBRATION_DEF_PACK)
+
+# SCHEDULE_BLOCK binary format
+SCHEDULE_BLOCK_HEADER = namedtuple(
+    "SCHEDULE_BLOCK",
+    [
+        "name_size",
+        "metadata_size",
+        "num_elements",
+    ],
+)
+SCHEDULE_BLOCK_HEADER_PACK = "!HQH"
+SCHEDULE_BLOCK_HEADER_SIZE = struct.calcsize(SCHEDULE_BLOCK_HEADER_PACK)
+
+# WAVEFORM binary format
+WAVEFORM = namedtuple("WAVEFORM", ["epsilon", "data_size", "amp_limited"])
+WAVEFORM_PACK = "!fI?"
+WAVEFORM_SIZE = struct.calcsize(WAVEFORM_PACK)
+
+# SYMBOLIC_PULSE
+SYMBOLIC_PULSE = namedtuple(
+    "SYMBOLIC_PULSE",
+    [
+        "type_size",
+        "envelope_size",
+        "constraints_size",
+        "valid_amp_conditions_size",
+        "amp_limited",
+    ],
+)
+SYMBOLIC_PULSE_PACK = "!HHHH?"
+SYMBOLIC_PULSE_SIZE = struct.calcsize(SYMBOLIC_PULSE_PACK)
+
+# SYMBOLIC_PULSE_V2
+SYMBOLIC_PULSE_V2 = namedtuple(
+    "SYMBOLIC_PULSE",
+    [
+        "class_name_size",
+        "type_size",
+        "envelope_size",
+        "constraints_size",
+        "valid_amp_conditions_size",
+        "amp_limited",
+    ],
+)
+SYMBOLIC_PULSE_PACK_V2 = "!HHHHH?"
+SYMBOLIC_PULSE_SIZE_V2 = struct.calcsize(SYMBOLIC_PULSE_PACK_V2)
+
+# INSTRUCTION_PARAM
+INSTRUCTION_PARAM = namedtuple("INSTRUCTION_PARAM", ["type", "size"])
+INSTRUCTION_PARAM_PACK = "!1cQ"
+INSTRUCTION_PARAM_SIZE = struct.calcsize(INSTRUCTION_PARAM_PACK)
+
+# PARAMETER
+PARAMETER = namedtuple("PARAMETER", ["name_size", "uuid"])
+PARAMETER_PACK = "!H16s"
+PARAMETER_SIZE = struct.calcsize(PARAMETER_PACK)
+
+# COMPLEX
+COMPLEX = namedtuple("COMPLEX", ["real", "imag"])
+COMPLEX_PACK = "!dd"
+COMPLEX_SIZE = struct.calcsize(COMPLEX_PACK)
+
+# PARAMETER_VECTOR_ELEMENT
+PARAMETER_VECTOR_ELEMENT = namedtuple(
+    "PARAMETER_VECTOR_ELEMENT", ["vector_name_size", "vector_size", "uuid", "index"]
+)
+PARAMETER_VECTOR_ELEMENT_PACK = "!HQ16sQ"
+PARAMETER_VECTOR_ELEMENT_SIZE = struct.calcsize(PARAMETER_VECTOR_ELEMENT_PACK)
+
+# PARAMETER_EXPR
+PARAMETER_EXPR = namedtuple("PARAMETER_EXPR", ["map_elements", "expr_size"])
+PARAMETER_EXPR_PACK = "!QQ"
+PARAMETER_EXPR_SIZE = struct.calcsize(PARAMETER_EXPR_PACK)
+
+# PARAMETER_EXPR_MAP_ELEM_V3
+PARAM_EXPR_MAP_ELEM_V3 = namedtuple("PARAMETER_EXPR_MAP_ELEM", ["symbol_type", "type", "size"])
+PARAM_EXPR_MAP_ELEM_V3_PACK = "!ccQ"
+PARAM_EXPR_MAP_ELEM_V3_SIZE = struct.calcsize(PARAM_EXPR_MAP_ELEM_V3_PACK)
+
+# PARAMETER_EXPR_MAP_ELEM
+PARAM_EXPR_MAP_ELEM = namedtuple("PARAMETER_EXPR_MAP_ELEM", ["type", "size"])
+PARAM_EXPR_MAP_ELEM_PACK = "!cQ"
+PARAM_EXPR_MAP_ELEM_SIZE = struct.calcsize(PARAM_EXPR_MAP_ELEM_PACK)
+
+# RANGE
+RANGE = namedtuple("RANGE", ["start", "stop", "step"])
+RANGE_PACK = "!qqq"
+RANGE_SIZE = struct.calcsize(RANGE_PACK)
+
+# SEQUENCE
+SEQUENCE = namedtuple("SEQUENCE", ["num_elements"])
+SEQUENCE_PACK = "!Q"
+SEQUENCE_SIZE = struct.calcsize(SEQUENCE_PACK)
+
+# MAP_ITEM
+MAP_ITEM = namedtuple("MAP_ITEM", ["key_size", "type", "size"])
+MAP_ITEM_PACK = "!H1cH"
+MAP_ITEM_SIZE = struct.calcsize(MAP_ITEM_PACK)
+
+LAYOUT_V2 = namedtuple(
+    "LAYOUT",
+    [
+        "exists",
+        "initial_layout_size",
+        "input_mapping_size",
+        "final_layout_size",
+        "extra_registers",
+        "input_qubit_count",
+    ],
+)
+LAYOUT_V2_PACK = "!?iiiIi"
+LAYOUT_V2_SIZE = struct.calcsize(LAYOUT_V2_PACK)
+
+
+LAYOUT = namedtuple(
+    "LAYOUT",
+    ["exists", "initial_layout_size", "input_mapping_size", "final_layout_size", "extra_registers"],
+)
+LAYOUT_PACK = "!?iiiI"
+LAYOUT_SIZE = struct.calcsize(LAYOUT_PACK)
+
+INITIAL_LAYOUT_BIT = namedtuple("INITIAL_LAYOUT_BIT", ["index", "register_size"])
+INITIAL_LAYOUT_BIT_PACK = "!ii"
+INITIAL_LAYOUT_BIT_SIZE = struct.calcsize(INITIAL_LAYOUT_BIT_PACK)
+
+# EXPRESSION
+
+EXPRESSION_DISCRIMINATOR_SIZE = 1
+
+EXPRESSION_CAST = namedtuple("EXPRESSION_CAST", ["implicit"])
+EXPRESSION_CAST_PACK = "!?"
+EXPRESSION_CAST_SIZE = struct.calcsize(EXPRESSION_CAST_PACK)
+
+EXPRESSION_UNARY = namedtuple("EXPRESSION_UNARY", ["opcode"])
+EXPRESSION_UNARY_PACK = "!B"
+EXPRESSION_UNARY_SIZE = struct.calcsize(EXPRESSION_UNARY_PACK)
+
+EXPRESSION_BINARY = namedtuple("EXPRESSION_BINARY", ["opcode"])
+EXPRESSION_BINARY_PACK = "!B"
+EXPRESSION_BINARY_SIZE = struct.calcsize(EXPRESSION_BINARY_PACK)
+
+
+# EXPR_TYPE
+
+EXPR_TYPE_DISCRIMINATOR_SIZE = 1
+
+EXPR_TYPE_BOOL = namedtuple("EXPR_TYPE_BOOL", [])
+EXPR_TYPE_BOOL_PACK = "!"
+EXPR_TYPE_BOOL_SIZE = struct.calcsize(EXPR_TYPE_BOOL_PACK)
+
+EXPR_TYPE_UINT = namedtuple("EXPR_TYPE_UINT", ["width"])
+EXPR_TYPE_UINT_PACK = "!L"
+EXPR_TYPE_UINT_SIZE = struct.calcsize(EXPR_TYPE_UINT_PACK)
+
+
+# EXPR_VAR
+
+EXPR_VAR_DISCRIMINATOR_SIZE = 1
+
+EXPR_VAR_CLBIT = namedtuple("EXPR_VAR_CLBIT", ["index"])
+EXPR_VAR_CLBIT_PACK = "!L"
+EXPR_VAR_CLBIT_SIZE = struct.calcsize(EXPR_VAR_CLBIT_PACK)
+
+EXPR_VAR_REGISTER = namedtuple("EXPR_VAR_REGISTER", ["reg_name_size"])
+EXPR_VAR_REGISTER_PACK = "!H"
+EXPR_VAR_REGISTER_SIZE = struct.calcsize(EXPR_VAR_REGISTER_PACK)
+
+
+# EXPR_VALUE
+
+EXPR_VALUE_DISCRIMINATOR_SIZE = 1
+
+EXPR_VALUE_BOOL = namedtuple("EXPR_VALUE_BOOL", ["value"])
+EXPR_VALUE_BOOL_PACK = "!?"
+EXPR_VALUE_BOOL_SIZE = struct.calcsize(EXPR_VALUE_BOOL_PACK)
+
+EXPR_VALUE_INT = namedtuple("EXPR_VALUE_INT", ["num_bytes"])
+EXPR_VALUE_INT_PACK = "!B"
+EXPR_VALUE_INT_SIZE = struct.calcsize(EXPR_VALUE_INT_PACK)