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

odxtools/specialdatagroupcaption.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 .element import IdentifiableElement
@@ -14,12 +14,12 @@ class SpecialDataGroupCaption(IdentifiableElement):
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "SpecialDataGroupCaption":
+                doc_frags: list[OdxDocFragment]) -> "SpecialDataGroupCaption":
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
 
         return SpecialDataGroupCaption(**kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = {self.odx_id: self}
 
         result[self.odx_id] = self

odxtools/standardlengthtype.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Literal, Optional
+from typing import Literal
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -14,12 +14,12 @@ from .odxtypes import AtomicOdxType, BytesTypes, DataType, odxstr_to_bool
 from .utils import dataclass_fields_asdict, read_hex_binary
 
 
-@dataclass
+@dataclass(kw_only=True)
 class StandardLengthType(DiagCodedType):
 
     bit_length: int
-    bit_mask: Optional[int]
-    is_condensed_raw: Optional[bool]
+    bit_mask: int | None = None
+    is_condensed_raw: bool | None = None
 
     @property
     def dct_type(self) -> DctType:
@@ -32,7 +32,7 @@ class StandardLengthType(DiagCodedType):
     @staticmethod
     @override
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "StandardLengthType":
+                doc_frags: list[OdxDocFragment]) -> "StandardLengthType":
         kwargs = dataclass_fields_asdict(DiagCodedType.from_et(et_element, doc_frags))
 
         bit_length = int(odxrequire(et_element.findtext("BIT-LENGTH")))
@@ -50,7 +50,7 @@ class StandardLengthType(DiagCodedType):
                 'Can not apply a bit_mask on a value of type {self.base_data_type}',
             )
 
-    def __get_used_mask(self, internal_value: AtomicOdxType) -> Optional[bytes]:
+    def __get_used_mask(self, internal_value: AtomicOdxType) -> bytes | None:
         """Returns a byte field where all bits that are used by the
         DiagCoded type are set and all unused ones are not set.
 
@@ -118,7 +118,7 @@ class StandardLengthType(DiagCodedType):
                 mask_bit += 1
 
             if isinstance(internal_value, BytesTypes):
-                return result.to_bytes(len(internal_value), 'big')
+                return result.to_bytes(len(bytes(internal_value)), 'big')
 
             return result
 
@@ -156,7 +156,7 @@ class StandardLengthType(DiagCodedType):
                 mask_bit += 1
 
             if isinstance(raw_value, BytesTypes):
-                return result.to_bytes(len(raw_value), 'big')
+                return result.to_bytes(len(bytes(raw_value)), 'big')
 
             return result
         if isinstance(raw_value, int):
@@ -164,12 +164,12 @@ class StandardLengthType(DiagCodedType):
         if isinstance(raw_value, BytesTypes):
             int_value = int.from_bytes(raw_value, 'big')
             int_value &= self.bit_mask
-            return int_value.to_bytes(len(raw_value), 'big')
+            return int_value.to_bytes(len(bytes(raw_value)), 'big')
 
         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]:
+    def get_static_bit_length(self) -> int | None:
         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 >=

odxtools/state.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 .element import IdentifiableElement
@@ -16,12 +16,12 @@ class State(IdentifiableElement):
     """
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "State":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "State":
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
 
         return State(**kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {self.odx_id: self}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:

odxtools/statechart.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 .element import IdentifiableElement
@@ -19,7 +19,7 @@ class StateChart(IdentifiableElement):
     Corresponds to STATE-CHART.
     """
     semantic: str
-    state_transitions: List[StateTransition]
+    state_transitions: list[StateTransition]
     start_state_snref: str
     states: NamedItemList[State]
 
@@ -28,7 +28,7 @@ class StateChart(IdentifiableElement):
         return self._start_state
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "StateChart":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "StateChart":
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
 
         semantic: str = odxrequire(et_element.findtext("SEMANTIC"))
@@ -52,7 +52,7 @@ class StateChart(IdentifiableElement):
             states=NamedItemList(states),
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         odxlinks = {self.odx_id: self}
 
         for strans in self.state_transitions:

odxtools/statemachine.py

@@ -1,6 +1,7 @@
 # SPDX-License-Identifier: MIT
+from collections.abc import Generator
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Generator, Union
+from typing import TYPE_CHECKING, Any
 
 from .exceptions import odxraise
 from .odxtypes import ParameterValueDict
@@ -97,7 +98,7 @@ class StateMachine:
         self._active_state = state_chart.start_state
 
     def execute(self, service: "DiagService", **service_params: Any
-               ) -> Generator[bytes, Union[bytes, bytearray, ParameterValueDict], None]:
+               ) -> Generator[bytes, bytes | bytearray | ParameterValueDict, None]:
         """Run a diagnostic service and update the state machine
         depending on the outcome.
 
@@ -159,7 +160,7 @@ class StateMachine:
 
         if raw_resp is None:
             raise RuntimeError("The calling code must send back a reply")
-        elif isinstance(raw_resp, (bytes, bytearray)):
+        elif isinstance(raw_resp, bytes | bytearray):
             for decoded_resp_msg in self.diag_layer.decode_response(raw_resp, raw_req):
                 for stransref in service.state_transition_refs:
                     # we only execute the first applicable state

odxtools/statetransition.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 .element import IdentifiableElement
@@ -19,7 +19,7 @@ class StateTransition(IdentifiableElement):
     """
     source_snref: str
     target_snref: str
-    external_access_method: Optional[ExternalAccessMethod]
+    external_access_method: ExternalAccessMethod | None
 
     @property
     def source_state(self) -> State:
@@ -31,7 +31,7 @@ class StateTransition(IdentifiableElement):
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "StateTransition":
+                doc_frags: list[OdxDocFragment]) -> "StateTransition":
 
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
 
@@ -50,7 +50,7 @@ class StateTransition(IdentifiableElement):
             external_access_method=external_access_method,
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {self.odx_id: self}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:

odxtools/statetransitionref.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Union
+from typing import TYPE_CHECKING, Any, Union
 from xml.etree import ElementTree
 
 from .basicstructure import BasicStructure
@@ -27,11 +27,11 @@ if TYPE_CHECKING:
 
 
 def _resolve_in_param(
-    in_param_if_snref: Optional[str],
-    in_param_if_snpathref: Optional[str],
-    params: List[Parameter],
+    in_param_if_snref: str | None,
+    in_param_if_snpathref: str | None,
+    params: list[Parameter],
     param_dict: ParameterValueDict,
-) -> Tuple[Optional[Parameter], Optional[ParameterValue]]:
+) -> tuple[Parameter | None, ParameterValue | None]:
 
     if in_param_if_snref is not None:
         path_chunks = [in_param_if_snref]
@@ -44,10 +44,10 @@ def _resolve_in_param(
 
 
 def _resolve_in_param_helper(
-    params: List[Parameter],
+    params: list[Parameter],
     param_dict: ParameterValueDict,
-    path_chunks: List[str],
-) -> Tuple[Optional[Parameter], Optional[ParameterValue]]:
+    path_chunks: list[str],
+) -> tuple[Parameter | None, ParameterValue | None]:
 
     inner_param = resolve_snref(path_chunks[0], params, Parameter, lenient=True)
     if inner_param is None:
@@ -90,7 +90,7 @@ def _resolve_in_param_helper(
 
 def _check_applies(ref: Union["StateTransitionRef",
                               "PreConditionStateRef"], state_machine: "StateMachine",
-                   params: List[Parameter], param_value_dict: ParameterValueDict) -> bool:
+                   params: list[Parameter], param_value_dict: ParameterValueDict) -> bool:
     if state_machine.active_state != ref.state:
         # if the active state of the state machine is not the
         # specified one, the precondition does not apply
@@ -108,13 +108,13 @@ def _check_applies(ref: Union["StateTransitionRef",
         return False
     elif not isinstance(
             param,
-        (CodedConstParameter, PhysicalConstantParameter, TableKeyParameter, ValueParameter)):
+            CodedConstParameter | PhysicalConstantParameter | TableKeyParameter | ValueParameter):
         # see checker rule 194 in section B.2 of the spec
         odxraise(f"Parameter referenced by state transition ref is of "
                  f"invalid type {type(param).__name__}")
         return False
-    elif isinstance(param, (CodedConstParameter, PhysicalConstantParameter,
-                            TableKeyParameter)) and ref.value is not None:
+    elif isinstance(param, CodedConstParameter | PhysicalConstantParameter
+                    | TableKeyParameter) and ref.value is not None:
         # see checker rule 193 in section B.2 of the spec. Why can
         # no values for constant parameters be specified? (This
         # seems to be rather inconvenient...)
@@ -155,10 +155,10 @@ class StateTransitionRef(OdxLinkRef):
     may also be conditional on the observed response of the ECU.
 
     """
-    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_transition(self) -> StateTransition:
@@ -171,7 +171,7 @@ class StateTransitionRef(OdxLinkRef):
     @staticmethod
     def from_et(  # type: ignore[override]
             et_element: ElementTree.Element,
-            doc_frags: List[OdxDocFragment]) -> "StateTransitionRef":
+            doc_frags: list[OdxDocFragment]) -> "StateTransitionRef":
         kwargs = dataclass_fields_asdict(OdxLinkRef.from_et(et_element, doc_frags))
 
         value = et_element.findtext("VALUE")
@@ -195,7 +195,7 @@ class StateTransitionRef(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:
@@ -204,7 +204,7 @@ class StateTransitionRef(OdxLinkRef):
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass
 
-    def execute(self, state_machine: StateMachine, params: List[Parameter],
+    def execute(self, state_machine: StateMachine, params: list[Parameter],
                 param_value_dict: ParameterValueDict) -> bool:
         """Update a StateMachine object if the state transition ought
         to be executed based on the response received after executing a

odxtools/staticfield.py

@@ -1,6 +1,7 @@
 # SPDX-License-Identifier: MIT
+from collections.abc import Sequence
 from dataclasses import dataclass
-from typing import Any, Dict, List, Sequence
+from typing import Any
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -23,7 +24,7 @@ class StaticField(Field):
 
     @staticmethod
     @override
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "StaticField":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "StaticField":
         kwargs = dataclass_fields_asdict(Field.from_et(et_element, doc_frags))
 
         fixed_number_of_items = int(odxrequire(et_element.findtext('FIXED-NUMBER-OF-ITEMS')))
@@ -33,7 +34,7 @@ class StaticField(Field):
             fixed_number_of_items=fixed_number_of_items, item_byte_size=item_byte_size, **kwargs)
 
     @override
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         odxlinks = super()._build_odxlinks()
         return odxlinks
 
@@ -89,7 +90,7 @@ class StaticField(Field):
         orig_origin = decode_state.origin_byte_position
         decode_state.origin_byte_position = decode_state.cursor_byte_position
 
-        result: List[ParameterValue] = []
+        result: list[ParameterValue] = []
         for _ in range(self.fixed_number_of_items):
             orig_cursor = decode_state.cursor_byte_position
 

odxtools/structure.py

@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Optional
 from xml.etree import ElementTree
 
 from .basicstructure import BasicStructure
@@ -11,14 +10,14 @@ from .utils import dataclass_fields_asdict
 
 @dataclass
 class Structure(BasicStructure):
-    is_visible_raw: Optional[bool]
+    is_visible_raw: bool | None
 
     @property
     def is_visible(self) -> bool:
         return self.is_visible_raw in (True, None)
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Structure":
+    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))
 

odxtools/subcomponent.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 .dtcconnector import DtcConnector
@@ -25,16 +25,16 @@ class SubComponent(IdentifiableElement):
 
     """
 
-    sub_component_patterns: List[SubComponentPattern]
+    sub_component_patterns: list[SubComponentPattern]
     sub_component_param_connectors: NamedItemList[SubComponentParamConnector]
     table_row_connectors: NamedItemList[TableRowConnector]
     env_data_connectors: NamedItemList[EnvDataConnector]
     dtc_connectors: NamedItemList[DtcConnector]
 
-    semantic: Optional[str]
+    semantic: str | None
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "SubComponent":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "SubComponent":
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
 
         semantic = et_element.get("SEMANTIC")
@@ -69,7 +69,7 @@ class SubComponent(IdentifiableElement):
             dtc_connectors=NamedItemList(dtc_connectors),
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = {}
 
         for scp in self.sub_component_patterns:

odxtools/subcomponentparamconnector.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 .diagservice import DiagService
@@ -18,8 +18,8 @@ class SubComponentParamConnector(IdentifiableElement):
     diag_comm_snref: str
 
     # TODO: we currently only support SNREFs, not SNPATHREFs
-    out_param_if_refs: List[str]
-    in_param_if_refs: List[str]
+    out_param_if_refs: list[str]
+    in_param_if_refs: list[str]
 
     @property
     def service(self) -> DiagService:
@@ -35,7 +35,7 @@ class SubComponentParamConnector(IdentifiableElement):
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "SubComponentParamConnector":
+                doc_frags: list[OdxDocFragment]) -> "SubComponentParamConnector":
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
 
         diag_comm_snref = odxrequire(
@@ -65,7 +65,7 @@ class SubComponentParamConnector(IdentifiableElement):
             in_param_if_refs=in_param_if_refs,
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:

odxtools/subcomponentpattern.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List
+from typing import TYPE_CHECKING, Any
 from xml.etree import ElementTree
 
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
@@ -12,11 +12,11 @@ if TYPE_CHECKING:
 
 @dataclass
 class SubComponentPattern:
-    matching_parameters: List["MatchingParameter"]
+    matching_parameters: list["MatchingParameter"]
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "SubComponentPattern":
+                doc_frags: list[OdxDocFragment]) -> "SubComponentPattern":
         from .matchingparameter import MatchingParameter
 
         matching_parameters = [
@@ -26,7 +26,7 @@ class SubComponentPattern:
 
         return SubComponentPattern(matching_parameters=matching_parameters)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = {}
         for mp in self.matching_parameters:
             result.update(mp._build_odxlinks())

odxtools/swvariable.py

@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Optional
 from xml.etree import ElementTree
 
 from .element import NamedElement
@@ -10,11 +9,11 @@ from .utils import dataclass_fields_asdict
 
 @dataclass
 class SwVariable(NamedElement):
-    origin: Optional[str]
-    oid: Optional[str]
+    origin: str | None
+    oid: str | None
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "SwVariable":
+    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")

odxtools/table.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
 from xml.etree import ElementTree
 
 from .admindata import AdminData
@@ -19,17 +19,17 @@ from .utils import dataclass_fields_asdict
 @dataclass
 class Table(IdentifiableElement):
     """This class represents a TABLE."""
-    key_label: Optional[str]
-    struct_label: Optional[str]
-    admin_data: Optional[AdminData]
-    key_dop_ref: Optional[OdxLinkRef]
-    table_rows_raw: List[Union[TableRow, OdxLinkRef]]
-    table_diag_comm_connectors: List[TableDiagCommConnector]
-    sdgs: List[SpecialDataGroup]
-    semantic: Optional[str]
+    key_label: str | None
+    struct_label: str | None
+    admin_data: AdminData | None
+    key_dop_ref: OdxLinkRef | None
+    table_rows_raw: list[TableRow | OdxLinkRef]
+    table_diag_comm_connectors: list[TableDiagCommConnector]
+    sdgs: list[SpecialDataGroup]
+    semantic: str | None
 
     @property
-    def key_dop(self) -> Optional[DataObjectProperty]:
+    def key_dop(self) -> DataObjectProperty | None:
         """The key data object property associated with this table."""
         return self._key_dop
 
@@ -39,7 +39,7 @@ class Table(IdentifiableElement):
         return self._table_rows
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Table":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "Table":
         """Reads a TABLE."""
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
         odx_id = kwargs["odx_id"]
@@ -48,7 +48,7 @@ class Table(IdentifiableElement):
         admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), doc_frags)
         key_dop_ref = OdxLinkRef.from_et(et_element.find("KEY-DOP-REF"), doc_frags)
 
-        table_rows_raw: List[Union[OdxLinkRef, TableRow]] = []
+        table_rows_raw: list[OdxLinkRef | TableRow] = []
         for sub_elem in et_element:
             if sub_elem.tag == "TABLE-ROW":
                 table_rows_raw.append(
@@ -77,7 +77,7 @@ class Table(IdentifiableElement):
             semantic=semantic,
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = {self.odx_id: self}
 
         for table_row_wrapper in self.table_rows_raw:
@@ -93,7 +93,7 @@ class Table(IdentifiableElement):
         return result
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        self._key_dop: Optional[DataObjectProperty] = None
+        self._key_dop: DataObjectProperty | None = None
         if self.key_dop_ref is not None:
             self._key_dop = odxlinks.resolve(self.key_dop_ref, DataObjectProperty)
 

odxtools/tablediagcommconnector.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 .diagcomm import DiagComm
@@ -13,8 +13,8 @@ from .snrefcontext import SnRefContext
 class TableDiagCommConnector:
     semantic: str
 
-    diag_comm_ref: Optional[OdxLinkRef]
-    diag_comm_snref: Optional[str]
+    diag_comm_ref: OdxLinkRef | None
+    diag_comm_snref: str | None
 
     @property
     def diag_comm(self) -> DiagComm:
@@ -22,7 +22,7 @@ class TableDiagCommConnector:
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "TableDiagCommConnector":
+                doc_frags: list[OdxDocFragment]) -> "TableDiagCommConnector":
 
         semantic = odxrequire(et_element.findtext("SEMANTIC"))
 
@@ -34,7 +34,7 @@ class TableDiagCommConnector:
         return TableDiagCommConnector(
             semantic=semantic, diag_comm_ref=diag_comm_ref, diag_comm_snref=diag_comm_snref)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None: