odxtools 9.6.1__py3-none-any.whl → 10.0.0__py3-none-any.whl

odxtools/physicaltype.py

@@ -1,19 +1,11 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from enum import IntEnum
-from typing import List, Optional
 from xml.etree import ElementTree
 
 from .exceptions import odxraise
 from .odxlink import OdxDocFragment
 from .odxtypes import DataType
-
-
-class Radix(IntEnum):
-    HEX = 16
-    DEC = 10
-    BIN = 2
-    OCT = 8
+from .radix import Radix
 
 
 @dataclass
@@ -39,20 +31,20 @@ class PhysicalType:
     PhysicalType(DataType.A_FLOAT64, precision=2)
     """
 
-    precision: Optional[int]
+    precision: int | None
     """Number of digits after the decimal point to display to the user
     The precision is only applicable if the base data type is A_FLOAT32 or A_FLOAT64.
     """
 
     base_data_type: DataType
 
-    display_radix: Optional[Radix]
+    display_radix: Radix | None
     """The display radix defines how integers are displayed to the user.
     The display radix is only applicable if the base data type is A_UINT32.
     """
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "PhysicalType":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "PhysicalType":
         precision_str = et_element.findtext("PRECISION")
         precision = int(precision_str) if precision_str is not None else None
 

odxtools/posresponsesuppressible.py

@@ -0,0 +1,72 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from xml.etree import ElementTree
+
+from .exceptions import odxrequire
+from .odxlink import OdxDocFragment
+from .utils import read_hex_binary
+
+
+# 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: str | None
+    coded_const_snpathref: str | None
+
+    value_snref: str | None
+    value_snpathref: str | None
+
+    phys_const_snref: str | None
+    phys_const_snpathref: str | None
+
+    table_key_snref: str | None
+    table_key_snpathref: str | None
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: list[OdxDocFragment]) -> "PosResponseSuppressible":
+
+        bit_mask = odxrequire(read_hex_binary(et_element.find("BIT-MASK")))
+
+        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,
+        )

odxtools/preconditionstateref.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import TYPE_CHECKING, Any
 from xml.etree import ElementTree
 
 from .exceptions import odxassert, odxrequire
@@ -21,10 +21,10 @@ class PreConditionStateRef(OdxLinkRef):
     """
     This class represents the PRE-CONDITION-STATE-REF XML tag.
     """
-    value: Optional[str]
+    value: str | None
 
-    in_param_if_snref: Optional[str]
-    in_param_if_snpathref: Optional[str]
+    in_param_if_snref: str | None
+    in_param_if_snpathref: str | None
 
     @property
     def state(self) -> "State":
@@ -33,7 +33,7 @@ class PreConditionStateRef(OdxLinkRef):
     @staticmethod
     def from_et(  # type: ignore[override]
             et_element: ElementTree.Element,
-            doc_frags: List[OdxDocFragment]) -> "PreConditionStateRef":
+            doc_frags: list[OdxDocFragment]) -> "PreConditionStateRef":
         kwargs = dataclass_fields_asdict(OdxLinkRef.from_et(et_element, doc_frags))
 
         value = et_element.findtext("VALUE")
@@ -57,7 +57,7 @@ class PreConditionStateRef(OdxLinkRef):
             odxassert(self.in_param_if_snref is not None or self.in_param_if_snref is not None,
                       "If VALUE is specified, a parameter must be referenced")
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
@@ -66,7 +66,7 @@ class PreConditionStateRef(OdxLinkRef):
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass
 
-    def applies(self, state_machine: "StateMachine", params: List[Parameter],
+    def applies(self, state_machine: "StateMachine", params: list[Parameter],
                 param_value_dict: ParameterValueDict) -> bool:
         """Given a state machine, evaluate whether the precondition is fulfilled or not
 

odxtools/progcode.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, cast
+from typing import Any, cast
 from xml.etree import ElementTree
 
 from .exceptions import odxraise, odxrequire
@@ -14,11 +14,11 @@ from .snrefcontext import SnRefContext
 class ProgCode:
     """A reference to code that is executed by a single ECU job"""
     code_file: str
-    encryption: Optional[str]
+    encryption: str | None
     syntax: str
     revision: str
-    entrypoint: Optional[str]
-    library_refs: List[OdxLinkRef]
+    entrypoint: str | None
+    library_refs: list[OdxLinkRef]
 
     @property
     def code(self) -> bytes:
@@ -29,7 +29,7 @@ class ProgCode:
         return self._libraries
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "ProgCode":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "ProgCode":
         code_file = odxrequire(et_element.findtext("CODE-FILE"))
         encryption = et_element.findtext("ENCRYPTION")
         syntax = odxrequire(et_element.findtext("SYNTAX"))
@@ -50,7 +50,7 @@ class ProgCode:
             library_refs=library_refs,
         )
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:

odxtools/protstack.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List
+from typing import Any
 from xml.etree import ElementTree
 
 from .comparamsubset import ComparamSubset
@@ -17,14 +17,14 @@ class ProtStack(IdentifiableElement):
     # mandatory in ODX 2.2, but non existent in ODX 2.0
     pdu_protocol_type: str
     physical_link_type: str
-    comparam_subset_refs: List[OdxLinkRef]
+    comparam_subset_refs: list[OdxLinkRef]
 
     @property
     def comparam_subsets(self) -> NamedItemList[ComparamSubset]:
         return self._comparam_subsets
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "ProtStack":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "ProtStack":
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
 
         pdu_protocol_type = odxrequire(et_element.findtext("PDU-PROTOCOL-TYPE"))
@@ -41,7 +41,7 @@ class ProtStack(IdentifiableElement):
             comparam_subset_refs=comparam_subset_refs,
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = {self.odx_id: self}
         return result
 

odxtools/radix.py

@@ -0,0 +1,9 @@
+# SPDX-License-Identifier: MIT
+from enum import IntEnum
+
+
+class Radix(IntEnum):
+    HEX = 16
+    DEC = 10
+    BIN = 2
+    OCT = 8

odxtools/relateddiagcommref.py

@@ -0,0 +1,22 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from xml.etree import ElementTree
+
+from .exceptions import odxrequire
+from .odxlink import OdxDocFragment, OdxLinkRef
+from .utils import dataclass_fields_asdict
+
+
+@dataclass
+class RelatedDiagCommRef(OdxLinkRef):
+    relation_type: str
+
+    @staticmethod
+    def from_et(  # type: ignore[override]
+            et_element: ElementTree.Element,
+            doc_frags: list[OdxDocFragment]) -> "RelatedDiagCommRef":
+        kwargs = dataclass_fields_asdict(odxrequire(OdxLinkRef.from_et(et_element, doc_frags)))
+
+        relation_type = odxrequire(et_element.findtext("RELATION-TYPE"))
+
+        return RelatedDiagCommRef(relation_type=relation_type, **kwargs)

odxtools/relateddoc.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
+from typing import Any
 from xml.etree import ElementTree
 
 from .description import Description
@@ -11,12 +11,12 @@ from .xdoc import XDoc
 
 @dataclass
 class RelatedDoc:
-    xdoc: Optional[XDoc]
-    description: Optional[Description]
+    xdoc: XDoc | None
+    description: Description | None
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "RelatedDoc":
-        xdoc: Optional[XDoc] = None
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "RelatedDoc":
+        xdoc: XDoc | None = None
         if (xdoc_elem := et_element.find("XDOC")) is not None:
             xdoc = XDoc.from_et(xdoc_elem, doc_frags)
         description = Description.from_et(et_element.find("DESC"), doc_frags)
@@ -26,7 +26,7 @@ class RelatedDoc:
             description=description,
         )
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = {}
 
         if self.xdoc:

odxtools/request.py

@@ -1,12 +1,14 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, cast
+from typing import Any, cast
 from xml.etree import ElementTree
 
 from .admindata import AdminData
-from .codec import (composite_codec_decode_from_pdu, composite_codec_encode_into_pdu,
-                    composite_codec_get_coded_const_prefix, composite_codec_get_free_parameters,
-                    composite_codec_get_required_parameters, composite_codec_get_static_bit_length)
+from .compositecodec import (composite_codec_decode_from_pdu, composite_codec_encode_into_pdu,
+                             composite_codec_get_coded_const_prefix,
+                             composite_codec_get_free_parameters,
+                             composite_codec_get_required_parameters,
+                             composite_codec_get_static_bit_length)
 from .decodestate import DecodeState
 from .element import IdentifiableElement
 from .encodestate import EncodeState
@@ -27,20 +29,20 @@ class Request(IdentifiableElement):
 
     This class implements the `CompositeCodec` interface.
     """
-    admin_data: Optional[AdminData]
+    admin_data: AdminData | None
     parameters: NamedItemList[Parameter]
-    sdgs: List[SpecialDataGroup]
+    sdgs: list[SpecialDataGroup]
 
     @property
-    def required_parameters(self) -> List[Parameter]:
+    def required_parameters(self) -> list[Parameter]:
         return composite_codec_get_required_parameters(self)
 
     @property
-    def free_parameters(self) -> List[Parameter]:
+    def free_parameters(self) -> list[Parameter]:
         return composite_codec_get_free_parameters(self)
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Request":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "Request":
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
 
         admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), doc_frags)
@@ -54,7 +56,7 @@ class Request(IdentifiableElement):
 
         return Request(admin_data=admin_data, parameters=parameters, sdgs=sdgs, **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = {self.odx_id: self}
 
         if self.admin_data is not None:
@@ -94,7 +96,7 @@ class Request(IdentifiableElement):
         context.request = None
         context.parameters = None
 
-    def get_static_bit_length(self) -> Optional[int]:
+    def get_static_bit_length(self) -> int | None:
         return composite_codec_get_static_bit_length(self)
 
     def print_free_parameters_info(self) -> None:
@@ -121,7 +123,7 @@ class Request(IdentifiableElement):
 
         return cast(ParameterValueDict, param_values)
 
-    def encode_into_pdu(self, physical_value: Optional[ParameterValue],
+    def encode_into_pdu(self, physical_value: ParameterValue | None,
                         encode_state: EncodeState) -> None:
         composite_codec_encode_into_pdu(self, physical_value, encode_state)
 

odxtools/response.py

@@ -1,13 +1,15 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
 from enum import Enum
-from typing import Any, Dict, List, Optional, cast
+from typing import Any, cast
 from xml.etree import ElementTree
 
 from .admindata import AdminData
-from .codec import (composite_codec_decode_from_pdu, composite_codec_encode_into_pdu,
-                    composite_codec_get_coded_const_prefix, composite_codec_get_free_parameters,
-                    composite_codec_get_required_parameters, composite_codec_get_static_bit_length)
+from .compositecodec import (composite_codec_decode_from_pdu, composite_codec_encode_into_pdu,
+                             composite_codec_get_coded_const_prefix,
+                             composite_codec_get_free_parameters,
+                             composite_codec_get_required_parameters,
+                             composite_codec_get_static_bit_length)
 from .decodestate import DecodeState
 from .element import IdentifiableElement
 from .encodestate import EncodeState
@@ -37,12 +39,12 @@ class Response(IdentifiableElement):
 
     response_type: ResponseType
 
-    admin_data: Optional[AdminData]
+    admin_data: AdminData | None
     parameters: NamedItemList[Parameter]
-    sdgs: List[SpecialDataGroup]
+    sdgs: list[SpecialDataGroup]
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Response":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "Response":
         """Reads a response."""
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
 
@@ -68,7 +70,7 @@ class Response(IdentifiableElement):
             sdgs=sdgs,
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = {self.odx_id: self}
 
         if self.admin_data is not None:
@@ -108,7 +110,7 @@ class Response(IdentifiableElement):
         context.response = None
         context.parameters = None
 
-    def encode(self, coded_request: Optional[bytes] = None, **kwargs: ParameterValue) -> bytearray:
+    def encode(self, coded_request: bytes | None = None, **kwargs: ParameterValue) -> bytearray:
         encode_state = EncodeState(triggering_request=coded_request, is_end_of_pdu=True)
 
         self.encode_into_pdu(physical_value=kwargs, encode_state=encode_state)
@@ -124,22 +126,22 @@ class Response(IdentifiableElement):
 
         return cast(ParameterValueDict, param_values)
 
-    def encode_into_pdu(self, physical_value: Optional[ParameterValue],
+    def encode_into_pdu(self, physical_value: ParameterValue | None,
                         encode_state: EncodeState) -> None:
         composite_codec_encode_into_pdu(self, physical_value, encode_state)
 
     def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
         return composite_codec_decode_from_pdu(self, decode_state)
 
-    def get_static_bit_length(self) -> Optional[int]:
+    def get_static_bit_length(self) -> int | None:
         return composite_codec_get_static_bit_length(self)
 
     @property
-    def required_parameters(self) -> List[Parameter]:
+    def required_parameters(self) -> list[Parameter]:
         return composite_codec_get_required_parameters(self)
 
     @property
-    def free_parameters(self) -> List[Parameter]:
+    def free_parameters(self) -> list[Parameter]:
         return composite_codec_get_free_parameters(self)
 
     def print_free_parameters_info(self) -> None:

odxtools/scaleconstr.py

@@ -1,7 +1,5 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from enum import Enum
-from typing import List, Optional
 from xml.etree import ElementTree
 
 from .compumethods.limit import Limit
@@ -9,13 +7,7 @@ from .description import Description
 from .exceptions import odxraise, odxrequire
 from .odxlink import OdxDocFragment
 from .odxtypes import DataType
-
-
-class ValidType(Enum):
-    VALID = "VALID"
-    NOT_VALID = "NOT-VALID"
-    NOT_DEFINED = "NOT-DEFINED"
-    NOT_AVAILABLE = "NOT-AVAILABLE"
+from .validtype import ValidType
 
 
 @dataclass
@@ -23,15 +15,15 @@ class ScaleConstr:
     """This class represents a SCALE-CONSTR.
     """
 
-    short_label: Optional[str]
-    description: Optional[Description]
+    short_label: str | None
+    description: Description | None
     lower_limit: Limit
     upper_limit: Limit
     validity: ValidType
     value_type: DataType
 
     @staticmethod
-    def scale_constr_from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment], *,
+    def scale_constr_from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment], *,
                              value_type: DataType) -> "ScaleConstr":
         short_label = et_element.findtext("SHORT-LABEL")
         description = Description.from_et(et_element.find("DESC"), doc_frags)

odxtools/servicebinner.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
+from collections.abc import Iterable, Iterator
 from io import StringIO
-from typing import Dict, Iterable, Iterator, Optional
 
 from . import obd, uds
 from .diagservice import DiagService
@@ -21,7 +21,7 @@ class ServiceBinner:
     """
 
     def __init__(self, services: Iterable[DiagService]):
-        service_groups: Dict[Optional[int], NamedItemList[DiagService]] = {}
+        service_groups: dict[int | None, NamedItemList[DiagService]] = {}
         for service in services:
             SID = self.__extract_sid(service)
 
@@ -32,7 +32,7 @@ class ServiceBinner:
 
         self._service_groups = service_groups
 
-    def __extract_sid(self, service: DiagService) -> Optional[int]:
+    def __extract_sid(self, service: DiagService) -> int | None:
         # diagnostic services without requests are possible; just like
         # aircraft without wings...
         if service.request is None:
@@ -96,10 +96,10 @@ class ServiceBinner:
 
         return result.getvalue()
 
-    def __iter__(self) -> Iterator[Optional[int]]:
+    def __iter__(self) -> Iterator[int | None]:
         return iter(self._service_groups)
 
-    def __getitem__(self, sid: Optional[int]) -> NamedItemList[DiagService]:
+    def __getitem__(self, sid: int | None) -> NamedItemList[DiagService]:
         if sid is None:
             return self._service_groups.get(sid, NamedItemList())
 

odxtools/singleecujob.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List
+from typing import Any
 from xml.etree import ElementTree
 
 from .diagcomm import DiagComm
@@ -30,13 +30,13 @@ class SingleEcuJob(DiagComm):
     standard.
     """
 
-    prog_codes: List[ProgCode]
+    prog_codes: list[ProgCode]
     input_params: NamedItemList[InputParam]
     output_params: NamedItemList[OutputParam]
     neg_output_params: NamedItemList[NegOutputParam]
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "SingleEcuJob":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "SingleEcuJob":
         kwargs = dataclass_fields_asdict(DiagComm.from_et(et_element, doc_frags))
 
         prog_codes = [
@@ -64,7 +64,7 @@ class SingleEcuJob(DiagComm):
             neg_output_params=neg_output_params,
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = super()._build_odxlinks()
 
         for prog_code in self.prog_codes:

odxtools/snrefcontext.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, List, Optional
+from typing import TYPE_CHECKING, Optional
 
 if TYPE_CHECKING:
     from .database import Database
@@ -25,5 +25,5 @@ class SnRefContext:
     single_ecu_job: Optional["SingleEcuJob"] = None
     request: Optional["Request"] = None
     response: Optional["Response"] = None
-    parameters: Optional[List["Parameter"]] = None
+    parameters: list["Parameter"] | None = None
     state_chart: Optional["StateChart"] = None

odxtools/specialdata.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
+from typing import Any
 from xml.etree import ElementTree
 
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
@@ -10,12 +10,12 @@ from .snrefcontext import SnRefContext
 @dataclass
 class SpecialData:
     """This corresponds to the SD XML tag"""
-    semantic_info: Optional[str]  # the "SI" attribute
-    text_identifier: Optional[str]  # the "TI" attribute, specifies the language used
+    semantic_info: str | None  # the "SI" attribute
+    text_identifier: str | None  # the "TI" attribute, specifies the language used
     value: str
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "SpecialData":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "SpecialData":
         semantic_info = et_element.get("SI")
         text_identifier = et_element.get("TI")
         value = et_element.text or ""
@@ -23,7 +23,7 @@ class SpecialData:
         return SpecialData(
             semantic_info=semantic_info, text_identifier=text_identifier, value=value)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:

odxtools/specialdatagroup.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Union
 from xml.etree import ElementTree
 
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
@@ -12,14 +12,14 @@ from .specialdatagroupcaption import SpecialDataGroupCaption
 @dataclass
 class SpecialDataGroup:
     """This corresponds to the SDG XML tag"""
-    sdg_caption: Optional[SpecialDataGroupCaption]
-    sdg_caption_ref: Optional[OdxLinkRef]
-    values: List[Union["SpecialDataGroup", SpecialData]]
-    semantic_info: Optional[str]  # the "SI" attribute
+    sdg_caption: SpecialDataGroupCaption | None
+    sdg_caption_ref: OdxLinkRef | None
+    values: list[Union["SpecialDataGroup", SpecialData]]
+    semantic_info: str | None  # the "SI" attribute
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "SpecialDataGroup":
+                doc_frags: list[OdxDocFragment]) -> "SpecialDataGroup":
 
         sdg_caption = None
         if caption_elem := et_element.find("SDG-CAPTION"):
@@ -31,9 +31,9 @@ class SpecialDataGroup:
 
         semantic_info = et_element.get("SI")
 
-        values: List[Union[SpecialData, SpecialDataGroup]] = []
+        values: list[SpecialData | SpecialDataGroup] = []
         for value_elem in et_element:
-            next_entry: Optional[Union[SpecialData, SpecialDataGroup]] = None
+            next_entry: SpecialData | SpecialDataGroup | None = None
             if value_elem.tag == "SDG":
                 next_entry = SpecialDataGroup.from_et(value_elem, doc_frags)
             elif value_elem.tag == "SD":
@@ -49,7 +49,7 @@ class SpecialDataGroup:
             values=values,
         )
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = {}
 
         if self.sdg_caption_ref is None and self.sdg_caption is not None: