odxtools 9.2.0__py3-none-any.whl → 9.4.0__py3-none-any.whl

odxtools/standardlengthtype.py

@@ -3,7 +3,7 @@ from dataclasses import dataclass
 from typing import List, Literal, Optional
 from xml.etree import ElementTree
 
-from typing_extensions import override
+from typing_extensions import SupportsBytes, override
 
 from .decodestate import DecodeState
 from .diagcodedtype import DctType, DiagCodedType
@@ -59,7 +59,7 @@ class StandardLengthType(DiagCodedType):
                 'Can not apply a bit_mask on a value of type {self.base_data_type}',
             )
 
-    def __get_raw_mask(self, internal_value: AtomicOdxType) -> Optional[bytes]:
+    def __get_used_mask(self, internal_value: AtomicOdxType) -> Optional[bytes]:
         """Returns a byte field where all bits that are used by the
         DiagCoded type are set and all unused ones are not set.
 
@@ -68,10 +68,6 @@ class StandardLengthType(DiagCodedType):
         if self.bit_mask is None:
             return None
 
-        if self.is_condensed:
-            odxraise("Condensed bit masks are not yet supported", NotImplementedError)
-            return
-
         endianness: Literal["little", "big"] = "big"
         if not self.is_highlow_byte_order and self.base_data_type in [
                 DataType.A_INT32, DataType.A_UINT32, DataType.A_FLOAT32, DataType.A_FLOAT64
@@ -82,52 +78,132 @@ class StandardLengthType(DiagCodedType):
             # been anticipated by the standard, though...
             endianness = "little"
 
+        if self.is_condensed:
+            # if a condensed bitmask is specified, the number of bits
+            # set to one in the bit mask are used in the PDU
+
+            # TODO: this is pretty slow. replace it by
+            # `self.bit_mask.bit_count()` once we require python >=
+            # 3.10.
+            bit_sz = bin(self.bit_mask).count("1")
+            used_mask = (1 << bit_sz) - 1
+
+            return used_mask.to_bytes((bit_sz + 7) // 8, endianness)
+
         sz: int
-        if isinstance(internal_value, (bytes, bytearray)):
-            sz = len(internal_value)
+        if isinstance(internal_value, (bytearray, SupportsBytes)):
+            sz = len(bytes(internal_value))
         else:
             sz = (odxrequire(self.get_static_bit_length()) + 7) // 8
 
         max_value = (1 << (sz * 8)) - 1
-        bit_mask = self.bit_mask & max_value
+        used_mask = self.bit_mask & max_value
 
-        return bit_mask.to_bytes(sz, endianness)
+        return used_mask.to_bytes(sz, endianness)
 
     def __apply_mask(self, internal_value: AtomicOdxType) -> AtomicOdxType:
         if self.bit_mask is None:
             return internal_value
+
         if self.is_condensed:
-            odxraise("Serialization of condensed bit mask is not supported", NotImplementedError)
-            return
+            int_value: int
+            if isinstance(internal_value, (bytearray, SupportsBytes)):
+                int_value = int.from_bytes(internal_value, 'big')
+            elif isinstance(internal_value, int):
+                int_value = internal_value
+            else:
+                odxraise("bit masks can only be specified for integers and byte fields")
+                return None
+
+            result = 0
+            mask_bit = 0
+            result_bit = 0
+
+            while self.bit_mask >= (1 << mask_bit):
+                if self.bit_mask & (1 << mask_bit):
+                    result |= ((int_value & (1 << mask_bit)) >> mask_bit) << result_bit
+                    result_bit += 1
+
+                mask_bit += 1
+
+            if isinstance(internal_value, (bytearray, SupportsBytes)):
+                return result.to_bytes(len(internal_value), 'big')
+
+            return result
+
         if isinstance(internal_value, int):
             return internal_value & self.bit_mask
-        if isinstance(internal_value, bytes):
+        if isinstance(internal_value, (bytearray, SupportsBytes)):
             int_value = int.from_bytes(internal_value, 'big')
-            int_value = int_value & self.bit_mask
-            return int_value.to_bytes(len(internal_value), 'big')
+            int_value &= self.bit_mask
+            return int_value.to_bytes(len(bytes(internal_value)), 'big')
 
         odxraise(f'Can not apply a bit_mask on a value of type {type(internal_value)}')
         return internal_value
 
+    def __unapply_mask(self, raw_value: AtomicOdxType) -> AtomicOdxType:
+        if self.bit_mask is None:
+            return raw_value
+        if self.is_condensed:
+            int_value: int
+            if isinstance(raw_value, (bytearray, SupportsBytes)):
+                int_value = int.from_bytes(raw_value, 'big')
+            elif isinstance(raw_value, int):
+                int_value = raw_value
+            else:
+                odxraise("bit masks can only be specified for integers and byte fields")
+                return None
+
+            result = 0
+            mask_bit = 0
+            input_bit = 0
+            while self.bit_mask >= (1 << mask_bit):
+                if self.bit_mask & (1 << mask_bit):
+                    result |= ((int_value & (1 << input_bit)) >> input_bit) << mask_bit
+                    input_bit += 1
+
+                mask_bit += 1
+
+            if isinstance(raw_value, (bytearray, SupportsBytes)):
+                return result.to_bytes(len(raw_value), 'big')
+
+            return result
+        if isinstance(raw_value, int):
+            return raw_value & self.bit_mask
+        if isinstance(raw_value, (bytearray, SupportsBytes)):
+            int_value = int.from_bytes(raw_value, 'big')
+            int_value &= self.bit_mask
+            return int_value
+
+        odxraise(f'Can not apply a bit_mask on a value of type {type(raw_value)}')
+        return raw_value
+
     def get_static_bit_length(self) -> Optional[int]:
+        if self.bit_mask is not None and self.is_condensed:
+            # TODO: this is pretty slow. replace it by
+            # `self.bit_mask.bit_count()` once we require python >=
+            # 3.10.
+            return bin(self.bit_mask).count("1")
+
         return self.bit_length
 
     @override
     def encode_into_pdu(self, internal_value: AtomicOdxType, encode_state: EncodeState) -> None:
         encode_state.emplace_atomic_value(
             internal_value=self.__apply_mask(internal_value),
-            used_mask=self.__get_raw_mask(internal_value),
+            used_mask=self.__get_used_mask(internal_value),
             bit_length=self.bit_length,
             base_data_type=self.base_data_type,
+            base_type_encoding=self.base_type_encoding,
             is_highlow_byte_order=self.is_highlow_byte_order)
 
     @override
     def decode_from_pdu(self, decode_state: DecodeState) -> AtomicOdxType:
-        internal_value = decode_state.extract_atomic_value(
-            self.bit_length,
-            self.base_data_type,
-            self.is_highlow_byte_order,
-        )
-        internal_value = self.__apply_mask(internal_value)
+        raw_value = decode_state.extract_atomic_value(
+            bit_length=self.bit_length,
+            base_data_type=self.base_data_type,
+            base_type_encoding=self.base_type_encoding,
+            is_highlow_byte_order=self.is_highlow_byte_order)
+        internal_value = self.__unapply_mask(raw_value)
 
         return internal_value

odxtools/statetransition.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
 from .element import IdentifiableElement
@@ -11,6 +11,20 @@ from .state import State
 from .utils import dataclass_fields_asdict
 
 
+@dataclass
+class ExternalAccessMethod(IdentifiableElement):
+    method: str
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "ExternalAccessMethod":
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+
+        method = odxrequire(et_element.findtext("METHOD"))
+
+        return ExternalAccessMethod(method=method, **kwargs)
+
+
 @dataclass
 class StateTransition(IdentifiableElement):
     """
@@ -18,7 +32,7 @@ class StateTransition(IdentifiableElement):
     """
     source_snref: str
     target_snref: str
-    # external_access_method: Optional[ExternalAccessMethod] # TODO
+    external_access_method: Optional[ExternalAccessMethod]
 
     @property
     def source_state(self) -> State:
@@ -40,7 +54,14 @@ class StateTransition(IdentifiableElement):
         target_snref_elem = odxrequire(et_element.find("TARGET-SNREF"))
         target_snref = odxrequire(target_snref_elem.attrib["SHORT-NAME"])
 
-        return StateTransition(source_snref=source_snref, target_snref=target_snref, **kwargs)
+        external_access_method = None
+        if (eam_elem := et_element.find("EXTERNAL-ACCESS-METHOD")) is not None:
+            external_access_method = ExternalAccessMethod.from_et(eam_elem, doc_frags)
+        return StateTransition(
+            source_snref=source_snref,
+            target_snref=target_snref,
+            external_access_method=external_access_method,
+            **kwargs)
 
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         return {self.odx_id: self}

odxtools/structure.py

@@ -1,19 +1,27 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List
+from typing import List, Optional
 from xml.etree import ElementTree
 
 from .basicstructure import BasicStructure
 from .odxlink import OdxDocFragment
+from .odxtypes import odxstr_to_bool
 from .utils import dataclass_fields_asdict
 
 
 @dataclass
 class Structure(BasicStructure):
+    is_visible_raw: Optional[bool]
 
     @staticmethod
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Structure":
         """Read a STRUCTURE element from XML."""
         kwargs = dataclass_fields_asdict(BasicStructure.from_et(et_element, doc_frags))
 
-        return Structure(**kwargs)
+        is_visible_raw = odxstr_to_bool(et_element.get("IS-VISIBLE"))
+
+        return Structure(is_visible_raw=is_visible_raw, **kwargs)
+
+    @property
+    def is_visible(self) -> bool:
+        return self.is_visible_raw in (True, None)

odxtools/swvariable.py

@@ -11,11 +11,13 @@ from .utils import dataclass_fields_asdict
 @dataclass
 class SwVariable(NamedElement):
     origin: Optional[str]
+    oid: Optional[str]
 
     @staticmethod
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "SwVariable":
         kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
 
         origin = et_element.findtext("ORIGIN")
+        oid = et_element.attrib.get("OID")
 
-        return SwVariable(origin=origin, **kwargs)
+        return SwVariable(origin=origin, oid=oid, **kwargs)

odxtools/table.py

@@ -5,16 +5,54 @@ from xml.etree import ElementTree
 
 from .admindata import AdminData
 from .dataobjectproperty import DataObjectProperty
+from .diagcomm import DiagComm
 from .element import IdentifiableElement
-from .exceptions import odxassert
+from .exceptions import odxassert, odxrequire
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from .snrefcontext import SnRefContext
 from .specialdatagroup import SpecialDataGroup
 from .tablerow import TableRow
 from .utils import dataclass_fields_asdict
 
 
+@dataclass
+class TableDiagCommConnector:
+    semantic: str
+
+    diag_comm_ref: Optional[OdxLinkRef]
+    diag_comm_snref: Optional[str]
+
+    @property
+    def diag_comm(self) -> DiagComm:
+        return self._diag_comm
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "TableDiagCommConnector":
+
+        semantic = odxrequire(et_element.findtext("SEMANTIC"))
+        diag_comm_ref = OdxLinkRef.from_et(et_element.find("DIAG-COMM-REF"), doc_frags)
+        diag_comm_snref = None
+        if (dc_snref_elem := et_element.find("DIAG-COMM-SNREF")) is not None:
+            diag_comm_snref = odxrequire(dc_snref_elem.get("SHORT-NAME"))
+
+        return TableDiagCommConnector(
+            semantic=semantic, diag_comm_ref=diag_comm_ref, diag_comm_snref=diag_comm_snref)
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        return {}
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        if self.diag_comm_ref is not None:
+            self._diag_comm = odxlinks.resolve(self.diag_comm_ref, DiagComm)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        if self.diag_comm_snref is not None:
+            dl = odxrequire(context.diag_layer)
+            self._diag_comm = resolve_snref(self.diag_comm_snref, dl.diag_comms, DiagComm)
+
+
 @dataclass
 class Table(IdentifiableElement):
     """This class represents a TABLE."""
@@ -24,7 +62,7 @@ class Table(IdentifiableElement):
     admin_data: Optional[AdminData]
     key_dop_ref: Optional[OdxLinkRef]
     table_rows_raw: List[Union[TableRow, OdxLinkRef]]
-    # TODO: table_diag_comm_connectors
+    table_diag_comm_connectors: List[TableDiagCommConnector]
     sdgs: List[SpecialDataGroup]
 
     @staticmethod
@@ -47,6 +85,10 @@ class Table(IdentifiableElement):
             elif sub_elem.tag == "TABLE-ROW-REF":
                 table_rows_raw.append(OdxLinkRef.from_et(sub_elem, doc_frags))
 
+        table_diag_comm_connectors = [
+            TableDiagCommConnector.from_et(dcc_elem, doc_frags) for dcc_elem in et_element.iterfind(
+                "TABLE-DIAG-COMM-CONNECTORS/TABLE-DIAG-COMM-CONNECTOR")
+        ]
         sdgs = [
             SpecialDataGroup.from_et(sdge, doc_frags) for sdge in et_element.iterfind("SDGS/SDG")
         ]
@@ -58,6 +100,7 @@ class Table(IdentifiableElement):
             admin_data=admin_data,
             key_dop_ref=key_dop_ref,
             table_rows_raw=table_rows_raw,
+            table_diag_comm_connectors=table_diag_comm_connectors,
             sdgs=sdgs,
             **kwargs)
 
@@ -78,6 +121,9 @@ class Table(IdentifiableElement):
             if isinstance(table_row_wrapper, TableRow):
                 result.update(table_row_wrapper._build_odxlinks())
 
+        for dcc in self.table_diag_comm_connectors:
+            result.update(dcc._build_odxlinks())
+
         return result
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
@@ -98,7 +144,13 @@ class Table(IdentifiableElement):
 
         self._table_rows = NamedItemList(table_rows)
 
+        for dcc in self.table_diag_comm_connectors:
+            dcc._resolve_odxlinks(odxlinks)
+
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         for table_row_wrapper in self.table_rows_raw:
             if isinstance(table_row_wrapper, TableRow):
                 table_row_wrapper._resolve_snrefs(context)
+
+        for dcc in self.table_diag_comm_connectors:
+            dcc._resolve_snrefs(context)

odxtools/tablerow.py

@@ -3,15 +3,21 @@ from dataclasses import dataclass, fields
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple
 from xml.etree import ElementTree
 
+from .admindata import AdminData
+from .audience import Audience
 from .basicstructure import BasicStructure
 from .dataobjectproperty import DataObjectProperty
 from .dtcdop import DtcDop
 from .element import IdentifiableElement
 from .exceptions import odxassert, odxraise, odxrequire
+from .functionalclass import FunctionalClass
+from .nameditemlist import NamedItemList
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
-from .odxtypes import AtomicOdxType
+from .odxtypes import AtomicOdxType, odxstr_to_bool
 from .snrefcontext import SnRefContext
 from .specialdatagroup import SpecialDataGroup
+from .state import State
+from .statetransition import StateTransition
 from .utils import dataclass_fields_asdict
 
 if TYPE_CHECKING:
@@ -21,18 +27,52 @@ if TYPE_CHECKING:
 @dataclass
 class TableRow(IdentifiableElement):
     """This class represents a TABLE-ROW."""
-    table_ref: OdxLinkRef
     key_raw: str
-    structure_ref: Optional[OdxLinkRef]
-    structure_snref: Optional[str]
+    table_ref: OdxLinkRef
 
-    # the referenced DOP must be a simple DOP (i.e.,
-    # DataObjectProperty or DtcDop, cf section 7.3.6.11 of the spec)!
+    # The spec mandates that either a structure or a non-complex DOP
+    # must be referenced here, i.e., exactly one of the four
+    # attributes below is not None
     dop_ref: Optional[OdxLinkRef]
     dop_snref: Optional[str]
+    structure_ref: Optional[OdxLinkRef]
+    structure_snref: Optional[str]
 
-    semantic: Optional[str]
     sdgs: List[SpecialDataGroup]
+    audience: Optional[Audience]
+    functional_class_refs: List[OdxLinkRef]
+    state_transition_refs: List[OdxLinkRef]
+    pre_condition_state_refs: List[OdxLinkRef]
+    admin_data: Optional[AdminData]
+
+    is_executable_raw: Optional[bool]
+    semantic: Optional[str]
+    is_mandatory_raw: Optional[bool]
+    is_final_raw: Optional[bool]
+
+    @property
+    def functional_classes(self) -> NamedItemList[FunctionalClass]:
+        return self._functional_classes
+
+    @property
+    def state_transitions(self) -> NamedItemList[StateTransition]:
+        return self._state_transitions
+
+    @property
+    def pre_condition_states(self) -> NamedItemList[State]:
+        return self._pre_condition_states
+
+    @property
+    def is_executable(self) -> bool:
+        return self.is_executable_raw in (None, True)
+
+    @property
+    def is_mandatory(self) -> bool:
+        return self.is_mandatory_raw is True
+
+    @property
+    def is_final(self) -> bool:
+        return self.is_final_raw is True
 
     def __post_init__(self) -> None:
         self._structure: Optional[BasicStructure] = None
@@ -73,15 +113,49 @@ class TableRow(IdentifiableElement):
             SpecialDataGroup.from_et(sdge, doc_frags) for sdge in et_element.iterfind("SDGS/SDG")
         ]
 
+        audience = None
+        if (audience_elem := et_element.find("AUDIENCE")) is not None:
+            audience = Audience.from_et(audience_elem, doc_frags)
+
+        functional_class_refs = [
+            odxrequire(OdxLinkRef.from_et(el, doc_frags))
+            for el in et_element.iterfind("FUNCT-CLASS-REFS/FUNCT-CLASS-REF")
+        ]
+
+        state_transition_refs = [
+            odxrequire(OdxLinkRef.from_et(el, doc_frags))
+            for el in et_element.iterfind("STATE-TRANSITION-REFS/STATE-TRANSITION-REF")
+        ]
+
+        pre_condition_state_refs = [
+            odxrequire(OdxLinkRef.from_et(el, doc_frags))
+            for el in et_element.iterfind("PRE-CONDITION-STATE-REFS/PRE-CONDITION-STATE-REF")
+        ]
+
+        admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), doc_frags)
+
+        is_executable_raw = odxstr_to_bool(et_element.attrib.get("IS-EXECUTABLE"))
+        semantic = et_element.attrib.get("SEMANTIC")
+        is_mandatory_raw = odxstr_to_bool(et_element.attrib.get("IS-MANDATORY"))
+        is_final_raw = odxstr_to_bool(et_element.attrib.get("IS-FINAL"))
+
         return TableRow(
             table_ref=table_ref,
-            semantic=semantic,
             key_raw=key_raw,
             structure_ref=structure_ref,
             structure_snref=structure_snref,
             dop_ref=dop_ref,
             dop_snref=dop_snref,
             sdgs=sdgs,
+            audience=audience,
+            functional_class_refs=functional_class_refs,
+            state_transition_refs=state_transition_refs,
+            pre_condition_state_refs=pre_condition_state_refs,
+            admin_data=admin_data,
+            is_executable_raw=is_executable_raw,
+            semantic=semantic,
+            is_mandatory_raw=is_mandatory_raw,
+            is_final_raw=is_final_raw,
             **kwargs)
 
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
@@ -108,6 +182,15 @@ class TableRow(IdentifiableElement):
         for sdg in self.sdgs:
             sdg._resolve_odxlinks(odxlinks)
 
+        self._functional_classes = NamedItemList(
+            [odxlinks.resolve(fc_ref, FunctionalClass) for fc_ref in self.functional_class_refs])
+
+        self._state_transitions = NamedItemList(
+            [odxlinks.resolve(st_ref, StateTransition) for st_ref in self.state_transition_refs])
+
+        self._pre_condition_states = NamedItemList(
+            [odxlinks.resolve(pcs_ref, State) for pcs_ref in self.pre_condition_state_refs])
+
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         # convert the raw key into the proper internal
         # representation. note that we cannot do this earlier because

odxtools/templates/macros/printDOP.xml.jinja2

@@ -12,10 +12,10 @@
 
 {%- macro printDiagCodedType(dct) -%}
 <DIAG-CODED-TYPE {{-make_xml_attrib("BASE-DATA-TYPE", dct.base_data_type.value)}}
-                 {{-make_xml_attrib("BASE-TYPE-ENCODING", dct.base_type_encoding)}}
+                 {{-make_xml_attrib("BASE-TYPE-ENCODING", dct.base_type_encoding and dct.base_type_encoding.value)}}
                  {{-make_bool_xml_attrib("IS-HIGHLOW-BYTE-ORDER", dct.is_highlow_byte_order_raw)}}
                  {%- if dct.termination is defined %}
-                 {{-make_xml_attrib("TERMINATION", dct.termination)}}
+                 {{-make_xml_attrib("TERMINATION", dct.termination.value)}}
                  {%- endif %}
                  {#- #} xsi:type="{{dct.dct_type}}">
  {%- if dct.dct_type in ("STANDARD-LENGTH-TYPE", "LEADING-LENGTH-INFO-TYPE") %}

odxtools/templates/macros/printDescription.xml.jinja2

@@ -9,7 +9,11 @@
 {%- if desc.external_docs %}
 <EXTERNAL-DOCS>
  {%- for ed in desc.external_docs %}
- <EXTERNAL-DOC HREF="{{ed}}" />
+ {%- if ed.description is none %}}
+ <EXTERNAL-DOC HREF="{{ed.href}}" />
+ {%- else %}}
+ <EXTERNAL-DOC HREF="{{ed.href}}">{{ed.description}}</EXTERNAL-DOC>
+ {%- endif %}}
  {%- endfor %}
 </EXTERNAL-DOCS>
 {%- endif -%}

odxtools/templates/macros/printDiagLayer.xml.jinja2

@@ -134,8 +134,8 @@
     {{ pt.printTable(table)|indent(3) }}
     {%- endfor %}
   </TABLES>
-  {{- psd.printSpecialDataGroups(ddds.sdgs)|indent(2, first=True) }}
   {%- endif %}
+  {{- psd.printSpecialDataGroups(ddds.sdgs)|indent(2, first=True) }}
 </DIAG-DATA-DICTIONARY-SPEC>
 {%- endif %}
 {%- if dlr.diag_comms_raw %}

odxtools/templates/macros/printDiagVariable.xml.jinja2

@@ -5,18 +5,20 @@
 {%- import('macros/printElementId.xml.jinja2') as peid %}
 {%- import('macros/printAdminData.xml.jinja2') as pad %}
 {%- import('macros/printDescription.xml.jinja2') as pd %}
+{%- import('macros/printSpecialData.xml.jinja2') as psd %}
 
 {%- macro printDiagVariable(diag_var) -%}
-<DIAG-VARIABLE {{-peid.printElementIdAttribs(diag_var)}}>
+<DIAG-VARIABLE {{-peid.printElementIdAttribs(diag_var)}}
+               {{-make_bool_xml_attrib("IS-READ-BEFORE-WRITE", diag_var.is_read_before_write_raw}}>
   {{ peid.printElementIdSubtags(diag_variable)|indent(2) }}
   {%- if diag_variable.admin_data is not none %}
   {{ pad.printAdminData(diag_variable.admin_data)|indent(2) }}
   {%- endif %}
   <VARIABLE-GROUP-REF ID-REF="{{ diag_var.ref_id }}" />
   {%- if diag_variable.sw_variables %}
-  <SW-VARIABLES>
+   <SW-VARIABLES>
     {%- for sw_var in diag_variable.sw_variables %}
-    <SW-VARIABLE {{-peid.printElementIdAttribs(sw_var)}}>
+    <SW-VARIABLE {{-peid.printElementIdAttribs(sw_var)}} {{- make_xml_attrib("OID", sw_var.oid) }}>
       {{ peid.printElementIdSubtags(sw_var)|indent(6) }}
       {%- if sw_var.origin is not none %}
       <ORIGIN>{{ sw_var.origin }}</ORIGIN>
@@ -56,6 +58,13 @@
     {%- endfor %}
   </COMM-RELATIONS>
   {%- endif %}
+  {%- if diag_variable.table_snref is not none %}
+  <SNREF-TO-TABLE-ROW>
+    <TABLE-SNREF SHORT-NAME="{{diag_variable.table_snref}}" />
+    <TABLE-ROW-SNREF SHORT-NAME="{{diag_variable.table_row_snref}}" />
+  </SNREF-TO-TABLE-ROW>
+  {%- endif %}
+  {{- psd.printSpecialDataGroups(ddds.sdgs)|indent(2, first=True) }}
 </DIAG-VARIABLE>
 {%- endmacro -%}
 

odxtools/templates/macros/printFunctionalClass.xml.jinja2

@@ -5,9 +5,13 @@
 -#}
 
 {%- import('macros/printElementId.xml.jinja2') as peid %}
+{%- import('macros/printAdminData.xml.jinja2') as pad %}
 
 {%- macro printFunctionalClass(fc) -%}
 <FUNCT-CLASS {{-peid.printElementIdAttribs(fc)}}>
  {{ peid.printElementIdSubtags(fc)|indent(1) }}
+ {%- if fc.admin_data is not none -%}
+ {{ pad.printAdminData(fc.admin_data)|indent(1) }}
+ {%- endif -%}
 </FUNCT-CLASS>
 {%- endmacro -%}

odxtools/templates/macros/printParentRef.xml.jinja2

@@ -17,6 +17,15 @@
 {%-  endfor %}
  </NOT-INHERITED-DIAG-COMMS>
 {%- endif %}
+{%- if par.not_inherited_variables %}
+ <NOT-INHERITED-VARIABLES>
+{%-  for nivar in par.not_inherited_variables %}
+  <NOT-INHERITED-VARIABLE>
+   <DIAG-VARIABLE-SNREF SHORT-NAME="{{nivar}}"/>
+  </NOT-INHERITED-VARIABLE>
+{%-  endfor %}
+ </NOT-INHERITED-VARIABLES>
+{%- endif %}
 {%- if par.not_inherited_dops %}
  <NOT-INHERITED-DOPS>
 {%-  for nidop in par.not_inherited_dops %}
@@ -26,6 +35,24 @@
 {%-  endfor %}
  </NOT-INHERITED-DOPS>
 {%- endif %}
+{%- if par.not_inherited_tables %}
+ <NOT-INHERITED-TABLES>
+{%-  for nitable in par.not_inherited_tables %}
+  <NOT-INHERITED-TABLE>
+   <TABLE-SNREF SHORT-NAME="{{nitable}}"/>
+  </NOT-INHERITED-TABLE>
+{%-  endfor %}
+ </NOT-INHERITED-TABLES>
+{%- endif %}
+{%- if par.not_inherited_global_neg_responses %}
+ <NOT-INHERITED-GLOBAL-NEG-RESPONSES>
+{%-  for nignr in par.not_inherited_global_neg_responses %}
+  <NOT-INHERITED-GLOBAL-NEG-RESPONSE>
+   <GLOBAL-NEG-RESPONSE-SNREF SHORT-NAME="{{nignr}}"/>
+  </NOT-INHERITED-GLOBAL-NEG-RESPONSE>
+{%-  endfor %}
+ </NOT-INHERITED-GLOBAL-NEG-RESPONSES>
+{%- endif %}
 </PARENT-REF>
 {%- endmacro -%}
 

odxtools/templates/macros/printProtocol.xml.jinja2

@@ -13,7 +13,7 @@
   {%- set dlr = protocol.protocol_raw %}
 
   {%- set cps_docfrag = dlr.comparam_spec_ref.ref_docs[-1] %}
-  <COMPARAM-SPEC-REF ID-REF="{{dlr.comparam_spec_ref.ref_id}}" DOCREF="{{cps_docfrag.doc_name}}" DOCTYPE="{{cps_docfrag.doc_type}}" />
+  <COMPARAM-SPEC-REF ID-REF="{{dlr.comparam_spec_ref.ref_id}}" DOCREF="{{cps_docfrag.doc_name}}" DOCTYPE="{{cps_docfrag.doc_type.value}}" />
 
   {%- if dlr.prot_stack_snref is not none %}
   <PROT-STACK-SNREF SHORT-NAME="{{ dlr.prot_stack_snref }}" />