odxtools 9.3.0__py3-none-any.whl → 9.4.1__py3-none-any.whl

odxtools/companyrevisioninfo.py

@@ -25,7 +25,7 @@ class CompanyRevisionInfo:
 
         company_data_ref = odxrequire(
             OdxLinkRef.from_et(et_element.find("COMPANY-DATA-REF"), doc_frags))
-        revision_label = et_element.findtext("REVISION_LABEL")
+        revision_label = et_element.findtext("REVISION-LABEL")
         state = et_element.findtext("STATE")
 
         return CompanyRevisionInfo(

odxtools/comparaminstance.py

@@ -138,9 +138,4 @@ class ComparamInstance:
 
     @property
     def short_name(self) -> str:
-        if self.spec:
-            return self.spec.short_name
-
-        # ODXLINK IDs allow dots and hyphens, but short names do not.
-        # (This should not happen anyway in a correct PDX...)
-        return self.spec_ref.ref_id.replace(".", "__").replace("-", "_")
+        return self.spec.short_name

odxtools/comparamspec.py

@@ -5,7 +5,7 @@ from xml.etree import ElementTree
 
 from .nameditemlist import NamedItemList
 from .odxcategory import OdxCategory
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxlink import DocType, OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from .protstack import ProtStack
 from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
@@ -16,12 +16,13 @@ if TYPE_CHECKING:
 
 @dataclass
 class ComparamSpec(OdxCategory):
+
     prot_stacks: NamedItemList[ProtStack]
 
     @staticmethod
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "ComparamSpec":
 
-        cat = OdxCategory.category_from_et(et_element, doc_frags, doc_type="COMPARAM-SPEC")
+        cat = OdxCategory.category_from_et(et_element, doc_frags, doc_type=DocType.COMPARAM_SPEC)
         doc_frags = cat.odx_id.doc_fragments
         kwargs = dataclass_fields_asdict(cat)
 

odxtools/comparamsubset.py

@@ -8,7 +8,7 @@ from .complexcomparam import ComplexComparam
 from .dataobjectproperty import DataObjectProperty
 from .nameditemlist import NamedItemList
 from .odxcategory import OdxCategory
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxlink import DocType, OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from .snrefcontext import SnRefContext
 from .unitspec import UnitSpec
 from .utils import dataclass_fields_asdict
@@ -19,24 +19,26 @@ if TYPE_CHECKING:
 
 @dataclass
 class ComparamSubset(OdxCategory):
-    # mandatory in ODX 2.2, but non-existent in ODX 2.0
-    category: Optional[str]
-
     comparams: NamedItemList[Comparam]
     complex_comparams: NamedItemList[ComplexComparam]
     data_object_props: NamedItemList[DataObjectProperty]
     unit_spec: Optional[UnitSpec]
+    category: Optional[str]  # mandatory in ODX 2.2, but non-existent in ODX 2.0
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "ComparamSubset":
 
-        cat = OdxCategory.category_from_et(et_element, doc_frags, doc_type="COMPARAM-SUBSET")
+        category = et_element.get("CATEGORY")
+
+        # In ODX 2.0, COMPARAM-SPEC is used, whereas in ODX 2.2, it refers to something else and has been replaced by COMPARAM-SUBSET.
+        # - If 'category' is missing (ODX 2.0), use COMPARAM_SPEC,
+        # - else (ODX 2.2), use COMPARAM_SUBSET.
+        doc_type = DocType.COMPARAM_SUBSET if category else DocType.COMPARAM_SPEC
+        cat = OdxCategory.category_from_et(et_element, doc_frags, doc_type=doc_type)
         doc_frags = cat.odx_id.doc_fragments
         kwargs = dataclass_fields_asdict(cat)
 
-        category = et_element.get("CATEGORY")
-
         data_object_props = NamedItemList([
             DataObjectProperty.from_et(el, doc_frags)
             for el in et_element.iterfind("DATA-OBJECT-PROPS/DATA-OBJECT-PROP")

odxtools/dataobjectproperty.py

@@ -10,7 +10,7 @@ from .decodestate import DecodeState
 from .diagcodedtype import DiagCodedType
 from .dopbase import DopBase
 from .encodestate import EncodeState
-from .exceptions import DecodeError, EncodeError, odxraise, odxrequire
+from .exceptions import EncodeError, odxraise, odxrequire
 from .internalconstr import InternalConstr
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .odxtypes import AtomicOdxType, ParameterValue
@@ -136,11 +136,17 @@ class DataObjectProperty(DopBase):
 
         if self.compu_method.is_valid_internal_value(internal):
             return self.compu_method.convert_internal_to_physical(internal)
-        else:
-            # TODO: How to prevent this?
-            raise DecodeError(
-                f"DOP {self.short_name} could not convert the coded value "
-                f" {repr(internal)} to physical type {self.physical_type.base_data_type}.")
+
+        internal_to_phys = self.compu_method.compu_internal_to_phys
+        default_value = internal_to_phys.compu_default_value if internal_to_phys else None
+
+        if default_value and default_value.value is not None:
+            return default_value.value
+
+        odxraise(f"DOP {self.short_name} could not convert the coded value "
+                 f"{repr(internal)} to physical type {self.physical_type.base_data_type}.")
+
+        return None
 
     def is_valid_physical_value(self, physical_value: ParameterValue) -> bool:
         return self.compu_method.is_valid_physical_value(cast(AtomicOdxType, physical_value))

odxtools/decodestate.py

@@ -1,10 +1,9 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Dict, List, Optional, Tuple, cast
+from typing import TYPE_CHECKING, Dict, List, Optional, Tuple
 
-import odxtools.exceptions as exceptions
-
-from .exceptions import DecodeError
+from .encoding import Encoding, get_string_encoding
+from .exceptions import DecodeError, odxassert, odxraise, strict_mode
 from .odxtypes import AtomicOdxType, DataType, ParameterValue
 
 try:
@@ -54,8 +53,10 @@ class DecodeState:
 
     def extract_atomic_value(
         self,
+        *,
         bit_length: int,
         base_data_type: DataType,
+        base_type_encoding: Optional[Encoding],
         is_highlow_byte_order: bool,
     ) -> AtomicOdxType:
         """Extract an internal value from a blob of raw bytes.
@@ -68,6 +69,13 @@ class DecodeState:
         if bit_length == 0:
             return base_data_type.python_type()
 
+        if base_data_type == DataType.A_FLOAT32 and bit_length != 32:
+            odxraise("The bit length of FLOAT32 values must be 32 bits")
+            bit_length = 32
+        elif base_data_type == DataType.A_FLOAT64 and bit_length != 64:
+            odxraise("The bit length of FLOAT64 values must be 64 bits")
+            bit_length = 64
+
         byte_length = (bit_length + self.cursor_bit_position + 7) // 8
         if self.cursor_byte_position + byte_length > len(self.coded_message):
             raise DecodeError(f"Expected a longer message.")
@@ -87,32 +95,118 @@ class DecodeState:
             extracted_bytes = extracted_bytes[::-1]
 
         padding = (8 - (bit_length + self.cursor_bit_position) % 8) % 8
-        internal_value, = bitstruct.unpack_from(
+        raw_value, = bitstruct.unpack_from(
             f"{base_data_type.bitstruct_format_letter}{bit_length}",
             extracted_bytes,
             offset=padding)
-
-        text_errors = 'strict' if exceptions.strict_mode else 'replace'
-        if base_data_type == DataType.A_ASCIISTRING:
-            assert isinstance(internal_value, (bytes, bytearray))
-            # The spec says ASCII, meaning only byte values 0-127.
-            # But in practice, vendors use iso-8859-1, aka latin-1
-            # reason being iso-8859-1 never fails since it has a valid
-            # character mapping for every possible byte sequence.
-            text_encoding = 'iso-8859-1'
-            internal_value = internal_value.decode(encoding=text_encoding, errors=text_errors)
-        elif base_data_type == DataType.A_UTF8STRING:
-            assert isinstance(internal_value, (bytes, bytearray))
-            text_encoding = "utf-8"
-            internal_value = internal_value.decode(encoding=text_encoding, errors=text_errors)
-        elif base_data_type == DataType.A_UNICODE2STRING:
-            assert isinstance(internal_value, (bytes, bytearray))
-            # For UTF-16, we need to manually decode the extracted
-            # bytes to a string
-            text_encoding = "utf-16-be" if is_highlow_byte_order else "utf-16-le"
-            internal_value = internal_value.decode(encoding=text_encoding, errors=text_errors)
+        internal_value: AtomicOdxType
+
+        # Deal with raw byte fields, ...
+        if base_data_type == DataType.A_BYTEFIELD:
+            odxassert(
+                base_type_encoding in (None, Encoding.NONE, Encoding.BCD_P, Encoding.BCD_UP),
+                f"Illegal encoding '{base_type_encoding}' for A_BYTEFIELD")
+
+            # note that we do not ensure that BCD-encoded byte fields
+            # only represent "legal" values
+            internal_value = raw_value
+
+        # ... string types, ...
+        elif base_data_type in (DataType.A_UTF8STRING, DataType.A_ASCIISTRING,
+                                DataType.A_UNICODE2STRING):
+            text_errors = 'strict' if strict_mode else 'replace'
+            str_encoding = get_string_encoding(base_data_type, base_type_encoding,
+                                               is_highlow_byte_order)
+            if str_encoding is not None:
+                internal_value = raw_value.decode(str_encoding, errors=text_errors)
+            else:
+                internal_value = "ERROR"
+
+        # ... signed integers, ...
+        elif base_data_type == DataType.A_INT32:
+            if base_type_encoding == Encoding.ONEC:
+                # one-complement
+                sign_bit = 1 << (bit_length - 1)
+                if raw_value < sign_bit:
+                    internal_value = raw_value
+                else:
+                    # python defines the bitwise inversion of a
+                    # positive integer value x as ~x = -(x + 1).
+                    internal_value = -((1 << bit_length) - raw_value - 1)
+            elif base_type_encoding in (None, Encoding.TWOC):
+                # two-complement
+                sign_bit = 1 << (bit_length - 1)
+                if raw_value < sign_bit:
+                    internal_value = raw_value
+                else:
+                    internal_value = -((1 << bit_length) - raw_value)
+            elif base_type_encoding == Encoding.SM:
+                # sign-magnitude
+                sign_bit = 1 << (bit_length - 1)
+                if raw_value < sign_bit:
+                    internal_value = raw_value
+                else:
+                    internal_value = -(raw_value - sign_bit)
+            else:
+                odxraise(f"Illegal encoding ({base_type_encoding}) specified for "
+                         f"{base_data_type.value}")
+
+                if base_type_encoding == Encoding.BCD_P:
+                    internal_value = self.__decode_bcd_p(raw_value)
+                elif base_type_encoding == Encoding.BCD_UP:
+                    internal_value = self.__decode_bcd_up(raw_value)
+                else:
+                    internal_value = raw_value
+
+        # ... unsigned integers, ...
+        elif base_data_type == DataType.A_UINT32:
+            if base_type_encoding == Encoding.BCD_P:
+                internal_value = self.__decode_bcd_p(raw_value)
+            elif base_type_encoding == Encoding.BCD_UP:
+                internal_value = self.__decode_bcd_up(raw_value)
+            elif base_type_encoding in (None, Encoding.NONE):
+                # no encoding
+                internal_value = raw_value
+            else:
+                odxraise(f"Illegal encoding ({base_type_encoding}) specified for "
+                         f"{base_data_type.value}")
+
+                internal_value = raw_value
+
+        # ... and others (floating point values)
+        else:
+            odxassert(base_data_type in (DataType.A_FLOAT32, DataType.A_FLOAT64))
+            odxassert(
+                base_type_encoding in (None, Encoding.NONE),
+                f"Specified illegal encoding '{base_type_encoding}' for float object")
+
+            internal_value = float(raw_value)
 
         self.cursor_byte_position += byte_length
         self.cursor_bit_position = 0
 
-        return cast(AtomicOdxType, internal_value)
+        return internal_value
+
+    @staticmethod
+    def __decode_bcd_p(value: int) -> int:
+        # packed BCD
+        result = 0
+        factor = 1
+        while value > 0:
+            result += (value & 0xf) * factor
+            factor *= 10
+            value >>= 4
+
+        return result
+
+    @staticmethod
+    def __decode_bcd_up(value: int) -> int:
+        # unpacked BCD
+        result = 0
+        factor = 1
+        while value > 0:
+            result += (value & 0xf) * factor
+            factor *= 10
+            value >>= 8
+
+        return result

odxtools/description.py

@@ -6,10 +6,27 @@ from .exceptions import odxrequire
 from .odxlink import OdxDocFragment
 
 
+@dataclass
+class ExternalDoc:
+    description: Optional[str]
+    href: str
+
+    @staticmethod
+    def from_et(et_element: Optional[ElementTree.Element],
+                doc_frags: List[OdxDocFragment]) -> Optional["ExternalDoc"]:
+        if et_element is None:
+            return None
+
+        description = et_element.text
+        href = odxrequire(et_element.get("HREF"))
+
+        return ExternalDoc(description=description, href=href)
+
+
 @dataclass
 class Description:
     text: str
-    external_docs: List[str]
+    external_docs: List[ExternalDoc]
     text_identifier: Optional[str]
 
     @staticmethod
@@ -35,7 +52,7 @@ class Description:
 
         external_docs = \
             [
-                odxrequire(ed.get("HREF")) for ed in et_element.iterfind("EXTERNAL-DOCS/EXTERNAL-DOC")
+                odxrequire(ExternalDoc.from_et(ed, doc_frags)) for ed in et_element.iterfind("EXTERNAL-DOCS/EXTERNAL-DOC")
             ]
         return Description(text=text, text_identifier=text_identifier, external_docs=external_docs)
 

odxtools/diagcodedtype.py

@@ -5,6 +5,7 @@ from xml.etree import ElementTree
 
 from .decodestate import DecodeState
 from .encodestate import EncodeState
+from .encoding import Encoding
 from .exceptions import odxassert, odxraise, odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from .odxtypes import AtomicOdxType, DataType, odxstr_to_bool
@@ -23,7 +24,7 @@ DctType = Literal[
 class DiagCodedType:
 
     base_data_type: DataType
-    base_type_encoding: Optional[str]
+    base_type_encoding: Optional[Encoding]
     is_highlow_byte_order_raw: Optional[bool]
 
     @staticmethod
@@ -36,7 +37,13 @@ class DiagCodedType:
             odxraise(f"Unknown base data type {base_data_type_str}")
             base_data_type = cast(DataType, None)
 
-        base_type_encoding = et_element.get("BASE-TYPE-ENCODING")
+        base_type_encoding = None
+        if (base_type_encoding_str := et_element.get("BASE-TYPE-ENCODING")) is not None:
+            try:
+                base_type_encoding = Encoding(base_type_encoding_str)
+            except ValueError:
+                odxraise(f"Encountered unknown BASE-TYPE-ENCODING '{base_type_encoding_str}'")
+
         is_highlow_byte_order_raw = odxstr_to_bool(et_element.get("IS-HIGHLOW-BYTE-ORDER"))
 
         return DiagCodedType(

odxtools/diagcomm.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
 from enum import Enum
-from typing import TYPE_CHECKING, Any, Dict, Iterable, List, Optional
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
 from xml.etree import ElementTree
 
 from .admindata import AdminData
@@ -61,8 +61,8 @@ class DiagComm(IdentifiableElement):
     audience: Optional[Audience]
     protocol_snrefs: List[str]
     related_diag_comm_refs: List[RelatedDiagCommRef]
-    pre_condition_state_refs: Iterable[OdxLinkRef]
-    state_transition_refs: Iterable[OdxLinkRef]
+    pre_condition_state_refs: List[OdxLinkRef]
+    state_transition_refs: List[OdxLinkRef]
 
     # attributes
     semantic: Optional[str]
@@ -119,7 +119,7 @@ class DiagComm(IdentifiableElement):
                 odxraise(f"Encountered unknown diagnostic class type '{diagnostic_class_str}'")
 
         is_mandatory_raw = odxstr_to_bool(et_element.get("IS-MANDATORY"))
-        is_executable_raw = odxstr_to_bool(et_element.get("IS-MANDATORY"))
+        is_executable_raw = odxstr_to_bool(et_element.get("IS-EXECUTABLE"))
         is_final_raw = odxstr_to_bool(et_element.get("IS-FINAL"))
 
         return DiagComm(

odxtools/diaglayercontainer.py

@@ -12,7 +12,7 @@ from .diaglayers.functionalgroup import FunctionalGroup
 from .diaglayers.protocol import Protocol
 from .nameditemlist import NamedItemList
 from .odxcategory import OdxCategory
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxlink import DocType, OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
@@ -48,7 +48,7 @@ class DiagLayerContainer(OdxCategory):
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "DiagLayerContainer":
 
-        cat = OdxCategory.category_from_et(et_element, doc_frags, doc_type="CONTAINER")
+        cat = OdxCategory.category_from_et(et_element, doc_frags, doc_type=DocType.CONTAINER)
         doc_frags = cat.odx_id.doc_fragments
         kwargs = dataclass_fields_asdict(cat)
 

odxtools/diaglayers/diaglayerraw.py

@@ -15,7 +15,7 @@ from ..exceptions import odxassert, odxraise, odxrequire
 from ..functionalclass import FunctionalClass
 from ..library import Library
 from ..nameditemlist import NamedItemList
-from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from ..odxlink import DocType, OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from ..request import Request
 from ..response import Response
 from ..singleecujob import SingleEcuJob
@@ -81,7 +81,7 @@ class DiagLayerRaw(IdentifiableElement):
 
         # extend the applicable ODX "document fragments" for the diag layer objects
         doc_frags = copy(doc_frags)
-        doc_frags.append(OdxDocFragment(short_name, "LAYER"))
+        doc_frags.append(OdxDocFragment(short_name, DocType.LAYER))
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
 
         admin_data = None

odxtools/diaglayers/hierarchyelement.py

@@ -137,6 +137,7 @@ class HierarchyElement(DiagLayer):
                 unit_groups=NamedItemList(unit_groups),
                 units=NamedItemList([]),
                 physical_dimensions=NamedItemList([]),
+                admin_data=None,
                 sdgs=[])
         else:
             # locally defined unit spec and inherited unit groups
@@ -144,6 +145,7 @@ class HierarchyElement(DiagLayer):
                 unit_groups=NamedItemList(unit_groups),
                 units=local_unit_spec.units,
                 physical_dimensions=local_unit_spec.physical_dimensions,
+                admin_data=None,
                 sdgs=[])
         ############
 

odxtools/diagnostictroublecode.py

@@ -15,7 +15,7 @@ from .utils import dataclass_fields_asdict
 @dataclass
 class DiagnosticTroubleCode(IdentifiableElement):
     trouble_code: int
-    text: Optional[str]
+    text: str
     display_trouble_code: Optional[str]
     level: Optional[int]
     is_temporary_raw: Optional[bool]
@@ -29,15 +29,11 @@ class DiagnosticTroubleCode(IdentifiableElement):
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "DiagnosticTroubleCode":
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
-        if et_element.find("DISPLAY-TROUBLE-CODE") is not None:
-            display_trouble_code = et_element.findtext("DISPLAY-TROUBLE-CODE")
-        else:
-            display_trouble_code = None
+        display_trouble_code = et_element.findtext("DISPLAY-TROUBLE-CODE")
 
+        level = None
         if (level_str := et_element.findtext("LEVEL")) is not None:
             level = int(level_str)
-        else:
-            level = None
 
         is_temporary_raw = odxstr_to_bool(et_element.get("IS-TEMPORARY"))
         sdgs = [
@@ -46,7 +42,7 @@ class DiagnosticTroubleCode(IdentifiableElement):
 
         return DiagnosticTroubleCode(
             trouble_code=int(odxrequire(et_element.findtext("TROUBLE-CODE"))),
-            text=et_element.findtext("TEXT"),
+            text=odxrequire(et_element.findtext("TEXT")),
             display_trouble_code=display_trouble_code,
             level=level,
             is_temporary_raw=is_temporary_raw,

odxtools/diagservice.py

@@ -31,6 +31,71 @@ class TransMode(Enum):
     SEND_OR_RECEIVE = "SEND-OR-RECEIVE"
 
 
+# note that the spec has a typo here: it calls the corresponding
+# XML tag POS-RESPONSE-SUPPRESSABLE...
+@dataclass
+class PosResponseSuppressible:
+    bit_mask: int
+
+    coded_const_snref: Optional[str]
+    coded_const_snpathref: Optional[str]
+
+    value_snref: Optional[str]
+    value_snpathref: Optional[str]
+
+    phys_const_snref: Optional[str]
+    phys_const_snpathref: Optional[str]
+
+    table_key_snref: Optional[str]
+    table_key_snpathref: Optional[str]
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "PosResponseSuppressible":
+
+        bit_mask = int(odxrequire(et_element.findtext("BITMASK")))
+
+        coded_const_snref = None
+        if (cc_snref_elem := et_element.find("CODED-CONST-SNREF")) is not None:
+            coded_const_snref = cc_snref_elem.attrib["SHORT-NAME"]
+        coded_const_snpathref = None
+        if (cc_snpathref_elem := et_element.find("CODED-CONST-SNPATHREF")) is not None:
+            coded_const_snpathref = cc_snpathref_elem.attrib["SHORT-NAME-PATH"]
+
+        value_snref = None
+        if (cc_snref_elem := et_element.find("VALUE-SNREF")) is not None:
+            value_snref = cc_snref_elem.attrib["SHORT-NAME"]
+        value_snpathref = None
+        if (cc_snpathref_elem := et_element.find("VALUE-SNPATHREF")) is not None:
+            value_snpathref = cc_snpathref_elem.attrib["SHORT-NAME-PATH"]
+
+        phys_const_snref = None
+        if (cc_snref_elem := et_element.find("PHYS-CONST-SNREF")) is not None:
+            phys_const_snref = cc_snref_elem.attrib["SHORT-NAME"]
+        phys_const_snpathref = None
+        if (cc_snpathref_elem := et_element.find("PHYS-CONST-SNPATHREF")) is not None:
+            phys_const_snpathref = cc_snpathref_elem.attrib["SHORT-NAME-PATH"]
+
+        table_key_snref = None
+        if (cc_snref_elem := et_element.find("TABLE-KEY-SNREF")) is not None:
+            table_key_snref = cc_snref_elem.attrib["SHORT-NAME"]
+        table_key_snpathref = None
+        if (cc_snpathref_elem := et_element.find("TABLE-KEY-SNPATHREF")) is not None:
+            table_key_snpathref = cc_snpathref_elem.attrib["SHORT-NAME-PATH"]
+
+        return PosResponseSuppressible(
+            bit_mask=bit_mask,
+            coded_const_snref=coded_const_snref,
+            coded_const_snpathref=coded_const_snpathref,
+            value_snref=value_snref,
+            value_snpathref=value_snpathref,
+            phys_const_snref=phys_const_snref,
+            phys_const_snpathref=phys_const_snpathref,
+            table_key_snref=table_key_snref,
+            table_key_snpathref=table_key_snpathref,
+        )
+
+
 @dataclass
 class DiagService(DiagComm):
     """Representation of a diagnostic service description.
@@ -42,9 +107,7 @@ class DiagService(DiagComm):
     pos_response_refs: List[OdxLinkRef]
     neg_response_refs: List[OdxLinkRef]
 
-    # note that the spec has a typo here: it calls the corresponding
-    # XML tag POS-RESPONSE-SUPPRESSABLE...
-    # TODO: pos_response_suppressible: Optional[PosResponseSuppressible]
+    pos_response_suppressible: Optional[PosResponseSuppressible]
 
     is_cyclic_raw: Optional[bool]
     is_multiple_raw: Optional[bool]
@@ -73,7 +136,9 @@ class DiagService(DiagComm):
             for el in et_element.iterfind("NEG-RESPONSE-REFS/NEG-RESPONSE-REF")
         ]
 
-        # TODO: POS-RESPONSE-SUPPRESSABLE
+        pos_response_suppressible = None
+        if (prs_elem := et_element.find("POS-RESPONSE-SUPPRESSABLE")) is not None:
+            pos_response_suppressible = PosResponseSuppressible.from_et(prs_elem, doc_frags)
 
         is_cyclic_raw = odxstr_to_bool(et_element.get("IS-CYCLIC"))
         is_multiple_raw = odxstr_to_bool(et_element.get("IS-MULTIPLE"))
@@ -99,6 +164,7 @@ class DiagService(DiagComm):
             request_ref=request_ref,
             pos_response_refs=pos_response_refs,
             neg_response_refs=neg_response_refs,
+            pos_response_suppressible=pos_response_suppressible,
             is_cyclic_raw=is_cyclic_raw,
             is_multiple_raw=is_multiple_raw,
             addressing_raw=addressing_raw,