python.PGNs.j2

# pylint: skip-file
from .utils import *
from .message import NMEA2000Message, NMEA2000Field, LookupFieldTypeEnumeration, int_to_bytes
from .consts import PhysicalQuantities, FieldTypes, IndirectLookupEncodeMaps

master_dict = {
{% for lookup in data['LookupEnumerations']%}
    '{{ lookup.Name }}': {
        {%- for item in lookup.EnumValues %}
        {{ item.Value }}: "{{ item.Name }}",
        {%- endfor %}
    },
{%- endfor %}
}

master_flags_dict = {
{% for lookup in data['LookupBitEnumerations']%}
    '{{ lookup.Name }}': {
        {%- for item in lookup.EnumBitValues %}
        {{ item.Bit }}: "{{ item.Name }}",
        {%- endfor %}
    },
{%- endfor %}
}

master_indirect_lookup_dict = {
{% for lookup in data['LookupIndirectEnumerations']%}
    '{{ lookup.Name }}': {
        {%- for item in lookup.EnumValues %}
        "{{ item.Value1 }}_{{ item.Value2 }}": "{{ item.Name }}",
        {%- endfor %}
    },
{%- endfor %}
}


def _optional_message_field(nmea2000Message: NMEA2000Message, field_id: str) -> NMEA2000Field | None:
    return next((field for field in nmea2000Message.fields if field.id == field_id), None)


def _get_repeating_entries(
    nmea2000Message: NMEA2000Message,
    list_field_id: str,
    field_ids: tuple[str, ...]
) -> list[dict[str, NMEA2000Field]]:
    list_field = _optional_message_field(nmea2000Message, list_field_id)
    if list_field is not None:
        if list_field.value is None:
            return []
        if not isinstance(list_field.value, list):
            raise ValueError(f"{list_field_id} must be a list of dict items")

        entries: list[dict[str, NMEA2000Field]] = []
        for item in list_field.value:
            if not isinstance(item, dict):
                raise ValueError(f"{list_field_id} must contain dict items")
            entry: dict[str, NMEA2000Field] = {}
            for field_id in field_ids:
                if field_id in item:
                    val = item[field_id]
                    if not isinstance(val, NMEA2000Field):
                        raise ValueError(f"Repeating field '{field_id}' must be an NMEA2000Field, got {type(val).__name__}")
                    entry[field_id] = val
            entries.append(entry)
        return entries

    entry: dict[str, NMEA2000Field] = {}
    for field_id in field_ids:
        field = _optional_message_field(nmea2000Message, field_id)
        if field is not None:
            entry[field_id] = field
    return [entry] if entry else []


def _lookup_field_type_encode(value, lookup_dict: dict[int, LookupFieldTypeEnumeration], lookup_name: str) -> int:
    for raw_value, metadata in lookup_dict.items():
        if metadata.name == value:
            return raw_value
    raise ValueError(f"Cant encode this message, {value} is missing from {lookup_name}")


{%- macro emit_encode_value(field, field_ref, pgn, in_repeating=false) %}
    advance_running_offset = True
    {%- set field_signed = field.Signed | default(false) %}
    {%- if field.FieldType == 'NUMBER' or field.FieldType == 'PGN' or field.FieldType == 'MMSI' or field.FieldType == 'FIELD_INDEX' %}
    if isinstance({{ field_ref }}.raw_value, int) and raw_number_matches_value({{ field_ref }}.raw_value, {{ field_ref }}.value, {{ field.Resolution }}):
        field_value = encode_number_raw({{ field_ref }}.raw_value, {{ field.BitLength }}, {{ field_signed }})
    elif isinstance({{ field_ref }}.raw_value, (int, float)):
        field_value = encode_number({{ field_ref }}.raw_value, {{ field.BitLength }}, {{ field_signed }}, {{ field.Resolution }})
    else:
        assert {{ field_ref }}.value is None or isinstance({{ field_ref }}.value, (int, float))
        field_value = encode_number({{ field_ref }}.value, {{ field.BitLength }}, {{ field_signed }}, {{ field.Resolution }})
    field_bit_length = {{ field.BitLength }}
    {%- elif field.FieldType == 'RESERVED' or field.FieldType == 'SPARE' %}
    field_value = {{ field_ref }}.raw_value if isinstance({{ field_ref }}.raw_value, int) else {{ field_ref }}.value
    if field_value is None:
        field_value = 0
    if not isinstance(field_value, int):
        raise ValueError("Cant encode this message, '{{ field.Name }}' must be an integer")
    field_bit_length = {{ field.BitLength }}
    {%- elif field.FieldType == 'FLOAT' %}
    assert {{ field_ref }}.value is None or isinstance({{ field_ref }}.value, (int, float))
    field_value = encode_float({{ field_ref }}.value)
    field_bit_length = {{ field.BitLength }}
    {%- elif field.FieldType == 'LOOKUP' %}
    if isinstance({{ field_ref }}.raw_value, int):
        field_value = {{ field_ref }}.raw_value
    elif isinstance({{ field_ref }}.value, int):
        field_value = {{ field_ref }}.value
    else:
        field_value = lookup_encode_{{ field.LookupEnumeration }}({{ field_ref }}.value)
    field_bit_length = {{ field.BitLength }}
    {%- elif field.FieldType == 'DATE' %}
    if isinstance({{ field_ref }}.raw_value, int):
        field_value = {{ field_ref }}.raw_value
    else:
        assert {{ field_ref }}.value is None or isinstance({{ field_ref }}.value, date)
        field_value = encode_date({{ field_ref }}.value, {{ field.BitLength }})
    field_bit_length = {{ field.BitLength }}
    {%- elif field.FieldType == 'TIME' or field.FieldType == 'DURATION' %}
    if isinstance({{ field_ref }}.raw_value, int) and ({% if field.FieldType == 'TIME' %}isinstance({{ field_ref }}.value, time){% else %}raw_number_matches_value({{ field_ref }}.raw_value, {{ field_ref }}.value, {{ field.Resolution }}){% endif %}):
        field_value = encode_number_raw({{ field_ref }}.raw_value, {{ field.BitLength }}, {{ field_signed }})
    elif isinstance({{ field_ref }}.raw_value, (int, float)):
        field_value = encode_number({{ field_ref }}.raw_value, {{ field.BitLength }}, {{ field_signed }}, {{ field.Resolution }})
    elif isinstance({{ field_ref }}.value, (int, float)):
        field_value = encode_number({{ field_ref }}.value, {{ field.BitLength }}, {{ field_signed }}, {{ field.Resolution }})
    else:
        assert {{ field_ref }}.value is None or isinstance({{ field_ref }}.value, time)
        field_value = encode_time({{ field_ref }}.value, {{ field.BitLength }})
    field_bit_length = {{ field.BitLength }}
    {%- elif field.FieldType == 'DECIMAL' %}
    if isinstance({{ field_ref }}.raw_value, int):
        field_value = {{ field_ref }}.raw_value
    else:
        field_value = encode_decimal({{ field_ref }}.value)
    if field_value is None:
        field_value = 0
    field_bit_length = {{ field.BitLength }}
    {%- elif field.FieldType == 'STRING_FIX' %}
    field_value = encode_string_fix({{ field_ref }}.raw_value if isinstance({{ field_ref }}.raw_value, (bytes, bytearray, memoryview)) else ({{ field_ref }}.value if {{ field_ref }}.value is not None else {{ field_ref }}.raw_value), {{ field.BitLength }})
    field_bit_length = {{ field.BitLength }}
    {%- elif field.FieldType == 'STRING_LZ' %}
    field_bytes = encode_string_lz({{ field_ref }}.raw_value if isinstance({{ field_ref }}.raw_value, (bytes, bytearray, memoryview)) else {{ field_ref }}.value)
    field_value = encode_little_endian_data(field_bytes)
    field_bit_length = binary_data_bit_length(field_bytes)
    {%- elif field.FieldType == 'STRING_LAU' %}
    field_bytes = encode_string_lau({{ field_ref }}.raw_value if isinstance({{ field_ref }}.raw_value, (bytes, bytearray, memoryview)) else {{ field_ref }}.value)
    field_value = encode_little_endian_data(field_bytes)
    field_bit_length = binary_data_bit_length(field_bytes)
    {%- elif field.FieldType == 'BITLOOKUP' %}
    field_value = {{ field_ref }}.raw_value if isinstance({{ field_ref }}.raw_value, int) else encode_bit_lookup({{ field_ref }}.value, master_flags_dict['{{ field.LookupBitEnumeration }}'])
    field_bit_length = {{ field.BitLength }}
    {%- elif field.FieldType == 'INDIRECT_LOOKUP' %}
        {%- set controller_field = pgn.Fields[field.LookupIndirectEnumerationFieldOrder - 1] %}
    if isinstance({{ field_ref }}.raw_value, int):
        field_value = {{ field_ref }}.raw_value
    elif isinstance({{ field_ref }}.value, int):
        field_value = {{ field_ref }}.value
    else:
        controller_field = nmea2000Message.get_field_by_id("{{ generate_field_id(controller_field.Id, controller_field.FieldType, controller_field.BitOffset) }}")
        if isinstance(controller_field.raw_value, int):
            controller_raw_value = controller_field.raw_value
        else:
            controller_raw_value = lookup_encode_{{ controller_field.LookupEnumeration }}(controller_field.value)
        indirect_lookup_values = IndirectLookupEncodeMaps['{{ field.LookupIndirectEnumeration }}'].get(controller_raw_value)
        if indirect_lookup_values is None:
            raise ValueError("Cant encode this message, '{{ field.Name }}' controller value is missing")
        field_value = indirect_lookup_values.get({{ field_ref }}.value)
        if field_value is None:
            raise ValueError("Cant encode this message, '{{ field.Name }}' indirect lookup value is missing")
    field_bit_length = {{ field.BitLength }}
    {%- elif field.FieldType == 'ISO_NAME' %}
    field_value = {{ field_ref }}.raw_value if isinstance({{ field_ref }}.raw_value, int) else encode_iso_name({{ field_ref }}.value)
    field_bit_length = {{ field.BitLength }}
    {%- elif field.FieldType == 'BINARY' %}
    field_bytes = normalize_binary_data({{ field_ref }}.raw_value) if isinstance({{ field_ref }}.raw_value, (bytes, bytearray, memoryview)) else normalize_binary_data({{ field_ref }}.value)
    field_value = encode_binary_data(field_bytes)
        {%- if field.BitLengthField is defined %}
            {%- set length_field = pgn.Fields[field.BitLengthField - 1] %}
    length_field = nmea2000Message.get_field_by_id("{{ generate_field_id(length_field.Id, length_field.FieldType, length_field.BitOffset) }}")
    if isinstance(length_field.raw_value, (int, float)):
        field_bit_length = int(length_field.raw_value)
    else:
        assert length_field.value is None or isinstance(length_field.value, (int, float))
        field_bit_length = int(length_field.value or 0)
    advance_running_offset = False
        {%- else %}
    field_bit_length = {{ field.BitLength }}
        {%- endif %}
    {%- elif field.FieldType == 'VARIABLE' %}
    field_bytes = normalize_binary_data({{ field_ref }}.raw_value) if isinstance({{ field_ref }}.raw_value, (bytes, bytearray, memoryview)) else normalize_binary_data({{ field_ref }}.value)
    field_value = encode_binary_data(field_bytes)
    field_bit_length = binary_data_bit_length(field_bytes)
    advance_running_offset = False
    {%- elif field.FieldType == 'DYNAMIC_FIELD_KEY' %}
    if isinstance({{ field_ref }}.raw_value, int):
        field_value = {{ field_ref }}.raw_value
    elif isinstance({{ field_ref }}.value, int):
        field_value = {{ field_ref }}.value
    else:
        field_value = _lookup_field_type_encode({{ field_ref }}.value, lookup_field_type_dict_{{ field.LookupFieldTypeEnumeration }}, "{{ field.LookupFieldTypeEnumeration }}")
    dyn_kv_metadata = lookup_field_type_{{ field.LookupFieldTypeEnumeration }}(field_value)
    field_bit_length = {{ field.BitLength }}
    {%- elif field.FieldType == 'DYNAMIC_FIELD_LENGTH' %}
    if isinstance({{ field_ref }}.raw_value, int) and raw_number_matches_value({{ field_ref }}.raw_value, {{ field_ref }}.value, {{ field.Resolution }}):
        field_value = encode_number_raw({{ field_ref }}.raw_value, {{ field.BitLength }}, {{ field_signed }})
    elif isinstance({{ field_ref }}.raw_value, (int, float)):
        field_value = encode_number({{ field_ref }}.raw_value, {{ field.BitLength }}, {{ field_signed }}, {{ field.Resolution }})
    else:
        assert {{ field_ref }}.value is None or isinstance({{ field_ref }}.value, (int, float))
        field_value = encode_number({{ field_ref }}.value, {{ field.BitLength }}, {{ field_signed }}, {{ field.Resolution }})
    field_bit_length = {{ field.BitLength }}
    {%- elif field.FieldType == 'DYNAMIC_FIELD_VALUE' %}
    if isinstance({{ field_ref }}.raw_value, int):
        field_value = {{ field_ref }}.raw_value
        field_bytes = b""
    elif isinstance({{ field_ref }}.value, int):
        field_value = {{ field_ref }}.value
        field_bytes = b""
    else:
        field_bytes = normalize_binary_data({{ field_ref }}.raw_value) if isinstance({{ field_ref }}.raw_value, (bytes, bytearray, memoryview)) else normalize_binary_data({{ field_ref }}.value)
        field_value = encode_binary_data(field_bytes)
    {%- if field.Order > 1 and pgn.Fields[field.Order - 2].FieldType == 'DYNAMIC_FIELD_LENGTH' %}
        {%- set length_field = pgn.Fields[field.Order - 2] %}
        {%- set length_field_id = generate_field_id(length_field.Id, length_field.FieldType, length_field.BitOffset) %}
        {%- if in_repeating %}
    length_field = repeating_entry.get("{{ length_field_id }}")
        {%- else %}
    length_field = nmea2000Message.get_field_by_id("{{ length_field_id }}")
        {%- endif %}
    if isinstance(length_field.raw_value, (int, float)):
        field_bit_length = int(length_field.raw_value) * 8
    else:
        assert length_field.value is None or isinstance(length_field.value, (int, float))
        field_bit_length = int(length_field.value or 0) * 8
    {%- else %}
    if dyn_kv_metadata is not None and dyn_kv_metadata.bits > 0:
        field_bit_length = dyn_kv_metadata.bits
    else:
        field_bit_length = binary_data_bit_length(field_bytes)
    {%- endif %}
    {%- else %}
    raise ValueError("Encoding '{{field.FieldType}}' not supported")
    {%- endif %}
{%- endmacro %}


{%- macro emit_repeating_decode_value(field, field_name) %}
    {%- set field_signed = field.Signed | default(false) %}
    {%- if field.FieldType == 'NUMBER' or field.FieldType == 'MMSI' or field.FieldType == 'PGN' or field.FieldType == 'DURATION' %}
    {{ field_name }} = {{ field_name }}_raw = decode_number(_data_raw_, running_bit_offset, {{ field.BitLength }}, {{ field_signed }}, {{ field.Resolution }}, {{ field.RangeMin }}, {{ field.RangeMax }})
    running_bit_offset += {{ field.BitLength }}
    {%- elif field.FieldType == 'LOOKUP' %}
    {{ field_name }}_raw = decode_int(_data_raw_, running_bit_offset, {{ field.BitLength }})
    {{ field_name }} = master_dict['{{ field.LookupEnumeration }}'].get({{ field_name }}_raw, None)
    running_bit_offset += {{ field.BitLength }}
    {%- elif field.FieldType == 'BITLOOKUP' %}
    {{ field_name }}_raw = decode_int(_data_raw_, running_bit_offset, {{ field.BitLength }})
    {{ field_name }} = decode_bit_lookup({{ field_name }}_raw, master_flags_dict['{{ field.LookupBitEnumeration }}'])
    running_bit_offset += {{ field.BitLength }}
    {%- elif field.FieldType == 'FIELD_INDEX' %}
    {{ field_name }} = {{ field_name }}_raw = decode_number(_data_raw_, running_bit_offset, {{ field.BitLength }}, {{ field_signed }}, {{ field.Resolution }}, {{ field.RangeMin }}, {{ field.RangeMax }})
    running_bit_offset += {{ field.BitLength }}
    {%- elif field.FieldType == 'TIME' %}
    {{ field_name }}_raw = decode_number(_data_raw_, running_bit_offset, {{ field.BitLength }}, {{ field_signed }}, {{ field.Resolution }}, {{ field.RangeMin }}, {{ field.RangeMax }})
    {{ field_name }} = decode_time({{ field_name }}_raw)
    running_bit_offset += {{ field.BitLength }}
    {%- elif field.FieldType == 'DATE' %}
    {{ field_name }}_raw = decode_number(_data_raw_, running_bit_offset, {{ field.BitLength }}, {{ field_signed }}, {{ field.Resolution }}, {{ field.RangeMin }}, {{ field.RangeMax }})
    {{ field_name }} = decode_date({{ field_name }}_raw)
    running_bit_offset += {{ field.BitLength }}
    {%- elif field.FieldType == 'RESERVED' or field.FieldType == 'SPARE' %}
    {{ field_name }} = {{ field_name }}_raw = decode_int(_data_raw_, running_bit_offset, {{ field.BitLength }})
    running_bit_offset += {{ field.BitLength }}
    {%- elif field.FieldType == 'STRING_FIX' %}
    {{ field_name }}, {{ field_name }}_raw = decode_string_fix_raw(_data_raw_, running_bit_offset, {{ field.BitLength }})
    running_bit_offset += {{ field.BitLength }}
    {%- elif field.FieldType == 'STRING_LZ' %}
    {{ field_name }} = {{ field_name }}_raw = decode_string_lz(_data_raw_, running_bit_offset)
    running_bit_offset += len(encode_string_lz({{ field_name }}_raw)) * 8
    {%- elif field.FieldType == 'STRING_LAU' %}
    {{ field_name }}_raw, bits_to_skip = decode_string_lau(_data_raw_, running_bit_offset)
    {{ field_name }} = {{ field_name }}_raw
    running_bit_offset += bits_to_skip
    {%- elif field.FieldType == 'VARIABLE' %}
    _variable_bits = _data_length_bits_ - running_bit_offset
    if _variable_bits > 0:
        {{ field_name }} = {{ field_name }}_raw = int_to_bytes(decode_int(_data_raw_, running_bit_offset, _variable_bits))
    else:
        {{ field_name }} = {{ field_name }}_raw = None
    running_bit_offset = _data_length_bits_
    {%- elif field.FieldType == 'BINARY' %}
    {%- if field.BitLength is defined and field.BitLength > 0 %}
    {{ field_name }} = {{ field_name }}_raw = int_to_bytes(decode_int(_data_raw_, running_bit_offset, {{ field.BitLength }}))
    running_bit_offset += {{ field.BitLength }}
    {%- else %}
    _binary_bits = _data_length_bits_ - running_bit_offset
    if _binary_bits > 0:
        {{ field_name }} = {{ field_name }}_raw = int_to_bytes(decode_int(_data_raw_, running_bit_offset, _binary_bits))
    else:
        {{ field_name }} = {{ field_name }}_raw = None
    running_bit_offset = _data_length_bits_
    {%- endif %}
    {%- else %}
    raise ValueError("PGN {{ field.PGN | default('unknown') }} repeating FieldType ({{ field.FieldType }}) not supported")
    {%- endif %}
{%- endmacro %}


{% for lookup in data['LookupEnumerations']%}
lookup_dict_encode_{{ lookup.Name }} = {
    {%- for item in lookup.EnumValues %}
    "{{ item.Name }}" : {{ item.Value }},
    {%- endfor %}
}
def lookup_encode_{{ lookup.Name }}(value):
    result = lookup_dict_encode_{{ lookup.Name }}.get(value, None)
    if result is None:
        raise ValueError(f"Cant encode this message, {value} is missing from {{lookup.Name}}")
    return result
{% endfor %}


{% for lookup_field_type in data['LookupFieldTypeEnumerations']%}
lookup_field_type_dict_{{ lookup_field_type.Name }} = {
    {%- for item in lookup_field_type.EnumFieldTypeValues %}
    {{ item.value }}: LookupFieldTypeEnumeration("{{ item.name }}", FieldTypes.{{ item.FieldType }}, {% if item.Resolution is defined -%}{{item.Resolution}}{%- else -%}None{%- endif -%}, {% if item.Unit is defined -%}"{{item.Unit}}"{%- else -%}None{%- endif -%}, {{ item.Bits }}, {% if item.LookupEnumeration is defined -%}"{{item.LookupEnumeration}}"{%- else -%}None{%- endif -%}),
    {%- endfor %}
}
def lookup_field_type_{{ lookup_field_type.Name }}(value):
    return lookup_field_type_dict_{{ lookup_field_type.Name }}.get(value)
{% endfor %}


{%- set groups_ns = namespace(pgn_groups={}) %}
{%- for pgn in data['PGNs'] %}
    {%- set name = pgn.PGN %}
    {%- if name in groups_ns.pgn_groups %}
        {%- set _ = groups_ns.pgn_groups[name].append(pgn) %}
    {%- else %}
        {%- set _ = groups_ns.pgn_groups.update({name: [pgn]}) %}
    {%- endif %}
{%- endfor %}


{%- for name, pgns_in_group in groups_ns.pgn_groups.items() %}
def is_fast_pgn_{{ pgns_in_group[0].PGN }}() -> bool:
    """Return True if PGN {{ pgns_in_group[0].PGN }} is a fast PGN."""
{%- if pgns_in_group[0].Type == 'Fast' %}
    return True
{%- elif pgns_in_group[0].Type == 'Single' %}
    return False
{%- else %}
    raise ValueError('PGEN type {{ pgns_in_group[0].Type }} not supported')
{% endif %}

{%- set ns_pgn = namespace(has_match=false) %}

{%- for pgn in pgns_in_group %}
{%- for field in pgn.Fields %}
    {%- if field.Match is defined %}
        {%- set ns_pgn.has_match = true %}
    {%- endif %}
{%- endfor %}
{%- if pgn.Fallback is defined and pgn.Fallback == true %}
    {%- set ns_pgn.fallback_pgn = pgn %}
{%- endif %}
{%- endfor %}

{%- if pgns_in_group | length  > 1 and ns_pgn.has_match == false %}
# ERROR: This PGN is corrupted. It has multiple fields but none of them have a match attribute.
{%- endif %}

{%- if pgns_in_group | length  > 1 and ns_pgn.has_match == true %}
# Complex PGN. number of matches: {{ pgns_in_group | length }}
def decode_pgn_{{ pgns_in_group[0].PGN }}(data_raw: int, data_length_bits: int | None = None) -> NMEA2000Message | None:
    {%- for pgn in pgns_in_group if pgn.Fallback is not defined or pgn.Fallback == false %}
    # {{ pgn.Id }} | Description: {{ pgn.Description }}
    if (
        {%- for field in pgn.Fields if field.Match is defined%}
        {%- set field_FF = bits_to_hex(field.BitLength) %}
        (((data_raw >> {{ field.BitOffset }}) & {{ field_FF }}) == {{ field.Match }}){% if not loop.last %} and{% endif %}
        {%- endfor%}
        ):
        return decode_pgn_{{ pgn.PGN }}_{{ pgn.Id }}(data_raw, data_length_bits)
    {% endfor%}
    {% if ns_pgn.fallback_pgn is defined -%}
    return decode_pgn_{{ ns_pgn.fallback_pgn.PGN }}_{{ ns_pgn.fallback_pgn.Id }}(data_raw, data_length_bits)
    {% else %}
    return None
    {% endif %}
{%- endif %}
{%- for pgn in pgns_in_group %}
{%- if pgns_in_group | length  > 1 and ns_pgn.has_match == true %}
{%- set func_name_suffix = pgn.PGN | string + '_' + pgn.Id %}
{%- else %}
{%- set func_name_suffix = pgn.PGN %}
{%- endif %}
def decode_pgn_{{ func_name_suffix }}(_data_raw_: int, _data_length_bits_: int) -> NMEA2000Message:
    """Decode PGN {{ pgn.PGN }}."""
    nmea2000Message = NMEA2000Message(PGN={{pgn.PGN}}, id='{{pgn.Id}}', description='{{pgn.Description}}'{% if pgn.TransmissionInterval is defined -%}, ttl=timedelta(milliseconds={{pgn.TransmissionInterval}}){%- endif -%})
    {%- set ns_fields = namespace() %}
    running_bit_offset = 0
    {%- if pgn.RepeatingFieldSet1Size is defined %}
    _repeating_field_set_1_offset = 0
    {%- endif %}
    {%- for field in pgn.Fields %}
    {%- set field_name = generate_field_python_name(field.Name, field.FieldType, field.BitOffset) %}
    {%- set field_signed = field.Signed | default(false)  %}
    # {{ field.Order }}:{{ field_name }} | Offset: {{ field.BitOffset }}, Length: {{ field.BitLength }}, Signed: {{ field_signed }} Resolution: {{ field.Resolution }}, Field Type: {{ field.FieldType }}, Match: {{ field.Match }}, PartOfPrimaryKey: {{ field.PartOfPrimaryKey }},
    {%- if field.BitOffset is defined %}
    running_bit_offset = {{ field.BitOffset }}
    {%- endif %}
    {%- if pgn.RepeatingFieldSet1Size is defined and field.Order == pgn.RepeatingFieldSet1StartField %}
    _repeating_field_set_1_offset = running_bit_offset
    {%- endif %}
    {%- if field.FieldType == 'NUMBER' or field.FieldType == 'MMSI' or field.FieldType == 'PGN' or field.FieldType == 'DURATION' %}
    {{ field_name }} = {{ field_name }}_raw = decode_number(_data_raw_, running_bit_offset, {{ field.BitLength }}, {{ field_signed }}, {{ field.Resolution }}, {{ field.RangeMin }}, {{ field.RangeMax }})
        {%- elif field.FieldType == 'LOOKUP' %}
    {{ field_name }}_raw = decode_int(_data_raw_, running_bit_offset, {{ field.BitLength }})
    {{ field_name }} = master_dict['{{ field.LookupEnumeration }}'].get({{ field_name }}_raw, None)
        {%- elif field.FieldType == 'BITLOOKUP' %}
    {{ field_name }}_raw = decode_int(_data_raw_, running_bit_offset, {{ field.BitLength }})
    {{ field_name }} = decode_bit_lookup({{ field_name }}_raw, master_flags_dict['{{ field.LookupBitEnumeration }}'])
        {%- elif field.FieldType == 'FIELDTYPE_LOOKUP' %}
    {{ field_name }}_raw = decode_int(_data_raw_, running_bit_offset, {{ field.BitLength }})
    kv_metadata = lookup_field_type_{{ field.LookupFieldTypeEnumeration }}({{ field_name }}_raw)
    {{ field_name }} = kv_name = kv_metadata.name
        {%- elif field.FieldType == 'KEY_VALUE' %}
    if kv_metadata.field_type == 'LOOKUP':
        {{ field_name }}_raw = decode_int(_data_raw_, running_bit_offset, kv_metadata.bits)
        {{ field_name }} = master_dict[kv_metadata.lookup_enumeration].get({{ field_name }}_raw, None)
    if kv_metadata.field_type == 'NUMBER':
        {{ field_name }} = {{ field_name }}_raw = decode_number(_data_raw_, running_bit_offset, kv_metadata.bits, {{ field_signed }}, kv_metadata.resolution, kv_metadata.range_min, kv_metadata.range_max)
    if kv_metadata.field_type == 'TIME':
        {{ field_name }}_raw = decode_number(_data_raw_, running_bit_offset, kv_metadata.bits, {{ field_signed }},kv_metadata.resolution, kv_metadata.range_min, kv_metadata.range_max)
        {{ field_name }} = decode_time({{ field_name }}_raw)
    nmea2000Message.fields.append(NMEA2000Field('{{ field_name }}', kv_metadata.name, '', kv_metadata.unit, {{ field_name }}, {{ field_name }}_raw, {% if field.PhysicalQuantity is defined -%}PhysicalQuantities.{{field.PhysicalQuantity}}{%- else -%}None{%- endif -%}, kv_metadata.field_type, {% if field.PartOfPrimaryKey is defined -%}{{field.PartOfPrimaryKey}}{%- else -%}False{%- endif -%}))
    running_bit_offset += kv_metadata.bits
        {%- elif field.FieldType == 'STRING_FIX'%}
    {{ field_name }}, {{ field_name }}_raw = decode_string_fix_raw(_data_raw_, running_bit_offset, {{ field.BitLength }})
        {%- elif field.FieldType == 'STRING_LZ'%}
    {{ field_name }} = {{ field_name }}_raw = decode_string_lz(_data_raw_, running_bit_offset)
        {%- elif field.FieldType == 'STRING_LAU'%}
    {{ field_name }}_raw, bits_to_skip = decode_string_lau(_data_raw_, running_bit_offset)
    {{ field_name }} = {{ field_name }}_raw
    running_bit_offset += bits_to_skip
        {%- elif field.FieldType == 'FLOAT'%}
    {{ field_name }} = {{ field_name }}_raw = decode_float(_data_raw_, running_bit_offset, {{ field.BitLength }}, {{ field.RangeMin }}, {{ field.RangeMax }})
        {%- elif field.FieldType == 'TIME' %}
    {{ field_name }}_raw = decode_number(_data_raw_, running_bit_offset, {{ field.BitLength }}, {{ field_signed }}, {{ field.Resolution }}, {{ field.RangeMin }}, {{ field.RangeMax }})
    {{ field_name }} = decode_time({{ field_name }}_raw)
        {%- elif field.FieldType == 'DATE' %}
    {{ field_name }}_raw = decode_number(_data_raw_, running_bit_offset, {{ field.BitLength }}, {{ field_signed }}, {{ field.Resolution }}, {{ field.RangeMin }}, {{ field.RangeMax }})
    {{ field_name }} = decode_date({{ field_name }}_raw)
        {%- elif field.FieldType == 'RESERVED' or field.FieldType == 'SPARE' %}
    {{ field_name }} = {{ field_name }}_raw = decode_int(_data_raw_, running_bit_offset, {{ field.BitLength }})
        {%- elif field.FieldType == 'INDIRECT_LOOKUP' %}
            {%- set ns_fields.indirect_lookup_order_orig = field.Order %}
            {%- set ns_fields.indirect_lookup_order = field.LookupIndirectEnumerationFieldOrder %}
            {%- set ns_fields.indirect_lookup_lookup = field.LookupIndirectEnumeration %}
            {%- set ns_fields.indirect_lookup_field_name = field_name %}
    {{ field_name }}_raw = decode_int(_data_raw_, running_bit_offset, {{ field.BitLength }})
    {{ field_name }} = 'TEMP_VAL'
        {%- elif field.FieldType == 'BINARY' %}
            {%- if field.BitLength is defined %}
    {{ field_name }} = {{ field_name }}_raw = int_to_bytes(decode_int(_data_raw_, running_bit_offset, {{ field.BitLength }}))
            {%- else -%}
            {%- set length_field = pgn.Fields[field.BitLengthField-1] %}
            {%- set length_field_name = generate_field_python_name(length_field.Name, length_field.FieldType, length_field.BitOffset) %}
    assert isinstance({{ length_field_name }}, (int, float))
    {{ field_name }} = {{ field_name }}_raw = int_to_bytes(decode_int(_data_raw_, running_bit_offset, int({{ length_field_name }})))
            {%- endif -%}
        {%- elif field.FieldType == 'FIELD_INDEX' %}
    {{ field_name }} = {{ field_name }}_raw = decode_number(_data_raw_, running_bit_offset, {{ field.BitLength }}, {{ field_signed }}, {{ field.Resolution }}, {{ field.RangeMin }}, {{ field.RangeMax }})
        {%- elif field.FieldType == 'VARIABLE' %}
    _remaining_bits = _data_length_bits_ - running_bit_offset
    if _remaining_bits > 0:
        {{ field_name }} = {{ field_name }}_raw = int_to_bytes(decode_int(_data_raw_, running_bit_offset, _remaining_bits))
    else:
        {{ field_name }} = {{ field_name }}_raw = None
        {%- elif field.FieldType == 'DECIMAL' %}
    {{ field_name }}_raw = decode_int(_data_raw_, running_bit_offset, {{ field.BitLength }})
    {{ field_name }} = decode_decimal({{ field_name }}_raw)
        {%- elif field.FieldType == 'ISO_NAME' %}
    {{ field_name }} = {{ field_name }}_raw = decode_int(_data_raw_, running_bit_offset, {{ field.BitLength }})
        {%- elif field.FieldType == 'DYNAMIC_FIELD_KEY' %}
    {{ field_name }}_raw = decode_int(_data_raw_, running_bit_offset, {{ field.BitLength }})
    dyn_kv_metadata = lookup_field_type_{{ field.LookupFieldTypeEnumeration }}({{ field_name }}_raw)
    {{ field_name }} = dyn_kv_metadata.name if dyn_kv_metadata is not None else None
        {%- elif field.FieldType == 'DYNAMIC_FIELD_LENGTH' %}
    {{ field_name }} = {{ field_name }}_raw = decode_number(_data_raw_, running_bit_offset, {{ field.BitLength }}, {{ field_signed }}, {{ field.Resolution }}, {{ field.RangeMin }}, {{ field.RangeMax }})
        {%- elif field.FieldType == 'DYNAMIC_FIELD_VALUE' %}
    if dyn_kv_metadata is not None and dyn_kv_metadata.bits > 0:
        _dyn_bits = dyn_kv_metadata.bits
    else:
        _dyn_bits = _data_length_bits_ - running_bit_offset
    if _dyn_bits > 0:
        {{ field_name }} = {{ field_name }}_raw = int_to_bytes(decode_int(_data_raw_, running_bit_offset, _dyn_bits))
        running_bit_offset += _dyn_bits
    else:
        {{ field_name }} = {{ field_name }}_raw = None
        {%- else %}
    raise ValueError("PGN {{ pgn.PGN }} FieldType ({{ field.FieldType }}) not supported")
        {%- endif %}
    {%- if field.FieldType != 'KEY_VALUE'  %}
    nmea2000Message.fields.append(NMEA2000Field('{{ generate_field_id(field.Id, field.FieldType, field.BitOffset) }}', '{{ field.Name }}', {% if field.Description is defined -%}"{{field.Description}}"{%- else -%}None{%- endif -%}, {% if field.Unit is defined -%}'{{field.Unit}}'{%- else -%}None{%- endif -%}, {{ field_name }}, {{ field_name }}_raw, {% if field.PhysicalQuantity is defined -%}PhysicalQuantities.{{field.PhysicalQuantity}}{%- else -%}None{%- endif -%}, FieldTypes.{{field.FieldType}}, {% if field.PartOfPrimaryKey is defined -%}{{field.PartOfPrimaryKey}}{%- else -%}False{%- endif -%}))
    {% if field.BitLength is defined -%}
    running_bit_offset += {{ field.BitLength }}
    {%- endif -%}
    {%- if ns_fields.indirect_lookup_order == field.Order %}
    combined_key = str({{ field_name }}_raw) + "_" + str({{ ns_fields.indirect_lookup_field_name }}_raw)
    {{ ns_fields.indirect_lookup_field_name }} = master_indirect_lookup_dict['{{ ns_fields.indirect_lookup_lookup }}'].get(combined_key, None)
    nmea2000Message.fields[{{ ns_fields.indirect_lookup_order_orig-1 }}].value = {{ ns_fields.indirect_lookup_field_name }}
    {%- endif -%}
    {%- endif %}
{% endfor %}
    {%- set ns_repeating = namespace(set1_has_dynamic_field=false) %}
    {%- if pgn.RepeatingFieldSet1Size is defined %}
        {%- for repeating_field in pgn.Fields if repeating_field.Order >= pgn.RepeatingFieldSet1StartField and repeating_field.Order < pgn.RepeatingFieldSet1StartField + pgn.RepeatingFieldSet1Size %}
            {%- if repeating_field.FieldType == 'DYNAMIC_FIELD_KEY' or repeating_field.FieldType == 'DYNAMIC_FIELD_LENGTH' or repeating_field.FieldType == 'DYNAMIC_FIELD_VALUE' %}
                {%- set ns_repeating.set1_has_dynamic_field = true %}
            {%- endif %}
        {%- endfor %}
    {%- endif %}
    {%- if pgn.RepeatingFieldSet1Size is defined and ns_repeating.set1_has_dynamic_field == false %}
    running_bit_offset = _repeating_field_set_1_offset
    repeating_field_set_1_entries = []
        {%- if pgn.RepeatingFieldSet1CountField is defined %}
            {%- set count_field = pgn.Fields[pgn.RepeatingFieldSet1CountField - 1] %}
            {%- set count_field_name = generate_field_python_name(count_field.Name, count_field.FieldType, count_field.BitOffset) %}
    _repeating_field_set_1_count = int({{ count_field_name }}_raw or 0)
        {%- else %}
    _repeating_field_set_1_count = None
        {%- endif %}
    while (
        (_repeating_field_set_1_count is None and running_bit_offset < _data_length_bits_) or
        (_repeating_field_set_1_count is not None and len(repeating_field_set_1_entries) < _repeating_field_set_1_count)
    ):
        repeating_entry = {}
        {%- for repeating_field in pgn.Fields if repeating_field.Order >= pgn.RepeatingFieldSet1StartField and repeating_field.Order < pgn.RepeatingFieldSet1StartField + pgn.RepeatingFieldSet1Size %}
            {%- set repeating_field_name = generate_field_python_name(repeating_field.Name, repeating_field.FieldType, repeating_field.BitOffset) %}
{{ emit_repeating_decode_value(repeating_field, repeating_field_name) | indent(4, true) }}
        repeating_entry["{{ generate_field_id(repeating_field.Id, repeating_field.FieldType, repeating_field.BitOffset) }}"] = NMEA2000Field('{{ generate_field_id(repeating_field.Id, repeating_field.FieldType, repeating_field.BitOffset) }}', '{{ repeating_field.Name }}', {% if repeating_field.Description is defined -%}"{{repeating_field.Description}}"{%- else -%}None{%- endif -%}, {% if repeating_field.Unit is defined -%}'{{repeating_field.Unit}}'{%- else -%}None{%- endif -%}, {{ repeating_field_name }}, {{ repeating_field_name }}_raw, {% if repeating_field.PhysicalQuantity is defined -%}PhysicalQuantities.{{repeating_field.PhysicalQuantity}}{%- else -%}None{%- endif -%}, FieldTypes.{{repeating_field.FieldType}}, {% if repeating_field.PartOfPrimaryKey is defined -%}{{repeating_field.PartOfPrimaryKey}}{%- else -%}False{%- endif -%})
        {%- endfor %}
        repeating_field_set_1_entries.append(repeating_entry)
    if repeating_field_set_1_entries:
        nmea2000Message.fields = [
            field for field in nmea2000Message.fields
            if field.id not in {
                {%- for repeating_field in pgn.Fields if repeating_field.Order >= pgn.RepeatingFieldSet1StartField and repeating_field.Order < pgn.RepeatingFieldSet1StartField + pgn.RepeatingFieldSet1Size %}
                "{{ generate_field_id(repeating_field.Id, repeating_field.FieldType, repeating_field.BitOffset) }}",
                {%- endfor %}
            }
        ]
        nmea2000Message.fields.append(NMEA2000Field('##list##', 'List', None, None, repeating_field_set_1_entries, None, None, FieldTypes.VARIABLE, False))
    {%- elif pgn.RepeatingFieldSet1Size is defined and ns_repeating.set1_has_dynamic_field == true %}
    running_bit_offset = _repeating_field_set_1_offset
    repeating_field_set_1_entries = []
        {%- if pgn.RepeatingFieldSet1CountField is defined %}
            {%- set count_field = pgn.Fields[pgn.RepeatingFieldSet1CountField - 1] %}
            {%- set count_field_name = generate_field_python_name(count_field.Name, count_field.FieldType, count_field.BitOffset) %}
    _repeating_field_set_1_count = int({{ count_field_name }}_raw or 0)
        {%- else %}
    _repeating_field_set_1_count = None
        {%- endif %}
    while (
        (_repeating_field_set_1_count is None and running_bit_offset < _data_length_bits_) or
        (_repeating_field_set_1_count is not None and len(repeating_field_set_1_entries) < _repeating_field_set_1_count)
    ):
        repeating_entry = {}
        {%- set ns_dyn = namespace(has_preceding_length=false) %}
        {%- for repeating_field in pgn.Fields if repeating_field.Order >= pgn.RepeatingFieldSet1StartField and repeating_field.Order < pgn.RepeatingFieldSet1StartField + pgn.RepeatingFieldSet1Size %}
            {%- set repeating_field_name = generate_field_python_name(repeating_field.Name, repeating_field.FieldType, repeating_field.BitOffset) %}
            {%- if repeating_field.FieldType == 'DYNAMIC_FIELD_KEY' %}
        {{ repeating_field_name }}_raw = decode_int(_data_raw_, running_bit_offset, {{ repeating_field.BitLength }})
        dyn_kv_metadata = lookup_field_type_{{ repeating_field.LookupFieldTypeEnumeration }}({{ repeating_field_name }}_raw)
        {{ repeating_field_name }} = dyn_kv_metadata.name if dyn_kv_metadata is not None else {{ repeating_field_name }}_raw
        running_bit_offset += {{ repeating_field.BitLength }}
            {%- elif repeating_field.FieldType == 'DYNAMIC_FIELD_LENGTH' %}
                {%- set ns_dyn.has_preceding_length = true %}
        {{ repeating_field_name }} = {{ repeating_field_name }}_raw = decode_number(_data_raw_, running_bit_offset, {{ repeating_field.BitLength }}, {{ repeating_field.Signed | default(false) }}, {{ repeating_field.Resolution }}, {{ repeating_field.RangeMin }}, {{ repeating_field.RangeMax }})
        running_bit_offset += {{ repeating_field.BitLength }}
            {%- elif repeating_field.FieldType == 'DYNAMIC_FIELD_VALUE' %}
                {%- if ns_dyn.has_preceding_length %}
        _dyn_value_bit_length = int({{ generate_field_python_name(pgn.Fields[repeating_field.Order - 2].Name, pgn.Fields[repeating_field.Order - 2].FieldType, pgn.Fields[repeating_field.Order - 2].BitOffset) }}_raw or 0) * 8
                {%- else %}
        if dyn_kv_metadata is not None and dyn_kv_metadata.bits > 0:
            _dyn_value_bit_length = dyn_kv_metadata.bits
        else:
            _dyn_value_bit_length = _data_length_bits_ - running_bit_offset
                {%- endif %}
        if _dyn_value_bit_length > 0:
            {{ repeating_field_name }} = {{ repeating_field_name }}_raw = int_to_bytes(decode_int(_data_raw_, running_bit_offset, _dyn_value_bit_length))
        else:
            {{ repeating_field_name }} = {{ repeating_field_name }}_raw = None
        running_bit_offset += _dyn_value_bit_length
            {%- else %}
{{ emit_repeating_decode_value(repeating_field, repeating_field_name) | indent(4, true) }}
            {%- endif %}
        repeating_entry["{{ generate_field_id(repeating_field.Id, repeating_field.FieldType, repeating_field.BitOffset) }}"] = NMEA2000Field('{{ generate_field_id(repeating_field.Id, repeating_field.FieldType, repeating_field.BitOffset) }}', '{{ repeating_field.Name }}', {% if repeating_field.Description is defined -%}"{{repeating_field.Description}}"{%- else -%}None{%- endif -%}, {% if repeating_field.Unit is defined -%}'{{repeating_field.Unit}}'{%- else -%}None{%- endif -%}, {{ repeating_field_name }}, {{ repeating_field_name }}_raw, {% if repeating_field.PhysicalQuantity is defined -%}PhysicalQuantities.{{repeating_field.PhysicalQuantity}}{%- else -%}None{%- endif -%}, FieldTypes.{{repeating_field.FieldType}}, {% if repeating_field.PartOfPrimaryKey is defined -%}{{repeating_field.PartOfPrimaryKey}}{%- else -%}False{%- endif -%})
        {%- endfor %}
        repeating_field_set_1_entries.append(repeating_entry)
    if repeating_field_set_1_entries:
        nmea2000Message.fields = [
            field for field in nmea2000Message.fields
            if field.id not in {
                {%- for repeating_field in pgn.Fields if repeating_field.Order >= pgn.RepeatingFieldSet1StartField and repeating_field.Order < pgn.RepeatingFieldSet1StartField + pgn.RepeatingFieldSet1Size %}
                "{{ generate_field_id(repeating_field.Id, repeating_field.FieldType, repeating_field.BitOffset) }}",
                {%- endfor %}
            }
        ]
        nmea2000Message.fields.append(NMEA2000Field('##list##', 'List', None, None, repeating_field_set_1_entries, None, None, FieldTypes.VARIABLE, False))
    {%- endif %}
    return nmea2000Message

def encode_pgn_{{ func_name_suffix }}(nmea2000Message: NMEA2000Message) -> bytes:
    """Encode Nmea2000Message object to binary data for PGN {{ pgn.PGN }}."""
    data_raw = 0
    running_bit_offset = 0
    payload_bit_length = 0
    {%- if pgn.RepeatingFieldSet1Size is defined %}
    repeating_field_set_1_entries = _get_repeating_entries(nmea2000Message, "##list##", (
        {%- for repeating_field in pgn.Fields if repeating_field.Order >= pgn.RepeatingFieldSet1StartField and repeating_field.Order < pgn.RepeatingFieldSet1StartField + pgn.RepeatingFieldSet1Size %}
        "{{ generate_field_id(repeating_field.Id, repeating_field.FieldType, repeating_field.BitOffset) }}",
        {%- endfor %}
    ))
    {%- endif %}
    {%- if pgn.RepeatingFieldSet2Size is defined %}
    repeating_field_set_2_entries = _get_repeating_entries(nmea2000Message, "##list2##", (
        {%- for repeating_field in pgn.Fields if repeating_field.Order >= pgn.RepeatingFieldSet2StartField and repeating_field.Order < pgn.RepeatingFieldSet2StartField + pgn.RepeatingFieldSet2Size %}
        "{{ generate_field_id(repeating_field.Id, repeating_field.FieldType, repeating_field.BitOffset) }}",
        {%- endfor %}
    ))
    {%- endif %}
    {%- for field in pgn.Fields %}
    {%- if pgn.RepeatingFieldSet1Size is defined and field.Order == pgn.RepeatingFieldSet1StartField %}
    {%- if field.BitOffset is defined %}
    running_bit_offset = {{ field.BitOffset }}
    {%- endif %}
    for repeating_entry in repeating_field_set_1_entries:
        {%- for repeating_field in pgn.Fields if repeating_field.Order >= pgn.RepeatingFieldSet1StartField and repeating_field.Order < pgn.RepeatingFieldSet1StartField + pgn.RepeatingFieldSet1Size %}
        # {{ generate_field_id(repeating_field.Id, repeating_field.FieldType, repeating_field.BitOffset) }} | Offset: {{ repeating_field.BitOffset }}, Length: {{ repeating_field.BitLength }}, Resolution: {{ repeating_field.Resolution }}, Field Type: {{ repeating_field.FieldType }}
        field = repeating_entry.get("{{ generate_field_id(repeating_field.Id, repeating_field.FieldType, repeating_field.BitOffset) }}")
        if field is None:
            raise ValueError("Cant encode this message, missing '{{repeating_field.Name}}'")
        field_offset = running_bit_offset
{{ emit_encode_value(repeating_field, 'field', pgn, in_repeating=true) | indent(4, true) }}
        assert isinstance(field_value, int)
        if field_value < 0:
            raise ValueError("Cant encode this message, '{{repeating_field.Name}}' cannot be negative")
        if field_bit_length < 0:
            raise ValueError("Cant encode this message, '{{repeating_field.Name}}' has a negative bit length")
        if field_bit_length > 0 and field_value.bit_length() > field_bit_length:
            raise ValueError("Cant encode this message, '{{repeating_field.Name}}' exceeds the encoded bit length")
        field_mask = (1 << field_bit_length) - 1 if field_bit_length > 0 else 0
        data_raw |= (field_value & field_mask) << field_offset
        payload_end_offset = field_offset + field_bit_length
        running_bit_offset = payload_end_offset if advance_running_offset else field_offset
        payload_bit_length = max(payload_bit_length, payload_end_offset)
        {%- endfor %}
    {%- elif pgn.RepeatingFieldSet1Size is defined and field.Order > pgn.RepeatingFieldSet1StartField and field.Order < pgn.RepeatingFieldSet1StartField + pgn.RepeatingFieldSet1Size %}
    {# Repeating Field Set 1 is encoded at the start field #}
    {%- elif pgn.RepeatingFieldSet2Size is defined and field.Order == pgn.RepeatingFieldSet2StartField %}
    {%- if field.BitOffset is defined %}
    running_bit_offset = {{ field.BitOffset }}
    {%- endif %}
    for repeating_entry in repeating_field_set_2_entries:
        {%- for repeating_field in pgn.Fields if repeating_field.Order >= pgn.RepeatingFieldSet2StartField and repeating_field.Order < pgn.RepeatingFieldSet2StartField + pgn.RepeatingFieldSet2Size %}
        # {{ generate_field_id(repeating_field.Id, repeating_field.FieldType, repeating_field.BitOffset) }} | Offset: {{ repeating_field.BitOffset }}, Length: {{ repeating_field.BitLength }}, Resolution: {{ repeating_field.Resolution }}, Field Type: {{ repeating_field.FieldType }}
        field = repeating_entry.get("{{ generate_field_id(repeating_field.Id, repeating_field.FieldType, repeating_field.BitOffset) }}")
        if field is None:
            raise ValueError("Cant encode this message, missing '{{repeating_field.Name}}'")
        field_offset = running_bit_offset
{{ emit_encode_value(repeating_field, 'field', pgn, in_repeating=true) | indent(4, true) }}
        assert isinstance(field_value, int)
        if field_value < 0:
            raise ValueError("Cant encode this message, '{{repeating_field.Name}}' cannot be negative")
        if field_bit_length < 0:
            raise ValueError("Cant encode this message, '{{repeating_field.Name}}' has a negative bit length")
        if field_bit_length > 0 and field_value.bit_length() > field_bit_length:
            raise ValueError("Cant encode this message, '{{repeating_field.Name}}' exceeds the encoded bit length")
        field_mask = (1 << field_bit_length) - 1 if field_bit_length > 0 else 0
        data_raw |= (field_value & field_mask) << field_offset
        payload_end_offset = field_offset + field_bit_length
        running_bit_offset = payload_end_offset if advance_running_offset else field_offset
        payload_bit_length = max(payload_bit_length, payload_end_offset)
        {%- endfor %}
    {%- elif pgn.RepeatingFieldSet2Size is defined and field.Order > pgn.RepeatingFieldSet2StartField and field.Order < pgn.RepeatingFieldSet2StartField + pgn.RepeatingFieldSet2Size %}
    {# Repeating Field Set 2 is encoded at the start field #}
    {%- else %}
    {%- set field_id = generate_field_id(field.Id, field.FieldType, field.BitOffset) %}
    # {{ field_id }} | Offset: {{ field.BitOffset }}, Length: {{ field.BitLength }}, Resolution: {{ field.Resolution }}, Field Type: {{ field.FieldType }}
    {%- if field.BitOffset is defined %}
    running_bit_offset = {{ field.BitOffset }}
    {%- endif %}
    field_offset = running_bit_offset
    field = nmea2000Message.get_field_by_id("{{ field_id }}")
{{ emit_encode_value(field, 'field', pgn) }}
    assert isinstance(field_value, int)
    if field_value < 0:
        raise ValueError("Cant encode this message, '{{field.Name}}' cannot be negative")
    if field_bit_length < 0:
        raise ValueError("Cant encode this message, '{{field.Name}}' has a negative bit length")
    if field_bit_length > 0 and field_value.bit_length() > field_bit_length:
        raise ValueError("Cant encode this message, '{{field.Name}}' exceeds the encoded bit length")
    field_mask = (1 << field_bit_length) - 1 if field_bit_length > 0 else 0
    data_raw |= (field_value & field_mask) << field_offset
    payload_end_offset = field_offset + field_bit_length
    running_bit_offset = payload_end_offset if advance_running_offset else field_offset
    payload_bit_length = max(payload_bit_length, payload_end_offset)
    {%- endif %}
    {%- endfor %}
    return data_raw.to_bytes({{pgn.Length | default('(payload_bit_length + 7) // 8') }}, byteorder="little")
{% endfor %}
{% endfor %}