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

odxtools/cli/list.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 import argparse
-from typing import Callable, List, Optional
+from collections.abc import Callable
 
 import rich
 
@@ -32,11 +32,11 @@ def print_summary(odxdb: Database,
                   print_state_transitions: bool = False,
                   print_audiences: bool = False,
                   allow_unknown_bit_lengths: bool = False,
-                  variants: Optional[List[str]] = None,
+                  variants: list[str] | None = None,
                   service_filter: Callable[[DiagComm], bool] = lambda x: True) -> None:
 
     diag_layer_names = [dl.short_name for dl in odxdb.diag_layers]
-    diag_layers: List[DiagLayer] = []
+    diag_layers: list[DiagLayer] = []
 
     if variants is None:
         variants = diag_layer_names
@@ -59,9 +59,9 @@ def print_summary(odxdb: Database,
         rich.print(f"Diagnostic layer: '{dl.short_name}'")
         rich.print(f" Variant Type: {dl.variant_type.value}")
 
-        all_services: List[DiagComm] = sorted(dl.services, key=lambda x: x.short_name)
+        all_services: list[DiagComm] = sorted(dl.services, key=lambda x: x.short_name)
 
-        if isinstance(dl, (BaseVariant, EcuVariant)):
+        if isinstance(dl, BaseVariant | EcuVariant):
             for proto in dl.protocols:
                 if (can_rx_id := dl.get_can_receive_id(proto.short_name)) is not None:
                     rich.print(
@@ -99,7 +99,7 @@ def print_summary(odxdb: Database,
                     else:
                         rich.print(f" Unidentifiable service: {service}")
         ddd_spec = dl.diag_data_dictionary_spec
-        data_object_properties: List[
+        data_object_properties: list[
             DataObjectProperty] = [] if ddd_spec is None else ddd_spec.data_object_props
         if print_dops and len(data_object_properties) > 0:
             rich.print("\n")
@@ -108,7 +108,7 @@ def print_summary(odxdb: Database,
                     data_object_properties, key=lambda x: (type(x).__name__, x.short_name)):
                 rich.print("  " + str(dop.short_name).replace("\n", "\n  "))
 
-        comparam_refs: List[ComparamInstance] = []
+        comparam_refs: list[ComparamInstance] = []
         if isinstance(dl, HierarchyElement):
             comparam_refs = dl.comparam_refs
 

odxtools/cli/main.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: MIT
 import argparse
 import importlib
-from typing import Any, List
+from typing import Any
 
 import odxtools
 import odxtools.exceptions
@@ -11,7 +11,7 @@ from .dummy_sub_parser import DummyTool
 
 # import the tool modules which can be loaded. if a tool
 # can't be loaded, add a dummy one
-tool_modules: List[Any] = []
+tool_modules: list[Any] = []
 for tool_name in ["list", "browse", "snoop", "find", "decode", "compare"]:
     try:
         tool_modules.append(importlib.import_module(f".{tool_name}", package="odxtools.cli"))

odxtools/cli/snoop.py

@@ -4,7 +4,7 @@
 import argparse
 import asyncio
 import sys
-from typing import Any, List, Optional, Type
+from typing import Any
 
 import can
 
@@ -103,7 +103,7 @@ def handle_telegram(telegram_id: int, payload: bytes) -> None:
               f"({payload!r}, {len(payload)} bytes)")
 
 
-def init_verbose_state_machine(BaseClass: Type[IsoTpStateMachine], *args: Any,
+def init_verbose_state_machine(BaseClass: type[IsoTpStateMachine], *args: Any,
                                **kwargs: Any) -> IsoTpStateMachine:
 
     class InformativeIsoTpDecoder(BaseClass):  # type: ignore[valid-type, misc]
@@ -246,7 +246,7 @@ def run(args: argparse.Namespace) -> None:
 
     protocol_name = args.protocol
     if odx_diag_layer is not None and protocol_name is not None:
-        protocols: Optional[List[Protocol]] = getattr(odx_diag_layer, "protocols", None)
+        protocols: list[Protocol] | None = getattr(odx_diag_layer, "protocols", None)
 
         if protocols is None:
             print(f"ECU variant {odx_diag_layer.short_name} is of type "

odxtools/codec.py

@@ -1,15 +1,10 @@
 # SPDX-License-Identifier: MIT
 import typing
-from typing import List, Optional, runtime_checkable
+from typing import runtime_checkable
 
 from .decodestate import DecodeState
 from .encodestate import EncodeState
-from .exceptions import EncodeError, odxraise
 from .odxtypes import ParameterValue
-from .parameters.codedconstparameter import CodedConstParameter
-from .parameters.matchingrequestparameter import MatchingRequestParameter
-from .parameters.parameter import Parameter
-from .parameters.physicalconstantparameter import PhysicalConstantParameter
 
 
 @runtime_checkable
@@ -22,190 +17,12 @@ class Codec(typing.Protocol):
     def short_name(self) -> str:
         return ""
 
-    def encode_into_pdu(self, physical_value: Optional[ParameterValue],
+    def encode_into_pdu(self, physical_value: ParameterValue | None,
                         encode_state: EncodeState) -> None:
         ...
 
     def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
         ...
 
-    def get_static_bit_length(self) -> Optional[int]:
+    def get_static_bit_length(self) -> int | None:
         ...
-
-
-@runtime_checkable
-class CompositeCodec(Codec, typing.Protocol):
-    """Any object which can be en- or decoded to be transferred over
-    the wire which is composed of multiple parameter implements this
-    API.
-
-    """
-
-    @property
-    def parameters(self) -> List[Parameter]:
-        return []
-
-    @property
-    def required_parameters(self) -> List[Parameter]:
-        return []
-
-    @property
-    def free_parameters(self) -> List[Parameter]:
-        return []
-
-
-# some helper functions useful for composite codec objects
-def composite_codec_get_static_bit_length(codec: CompositeCodec) -> Optional[int]:
-    """Compute the length of a composite codec object in bits
-
-    This is basically the sum of the lengths of all parameters. If the
-    length of any parameter can only determined at runtime, `None` is
-    returned.
-    """
-
-    cursor = 0
-    byte_length = 0
-    for param in codec.parameters:
-        param_bit_length = param.get_static_bit_length()
-        if param_bit_length is None:
-            # We were not able to calculate a static bit length
-            return None
-        elif param.byte_position is not None:
-            cursor = param.byte_position
-
-        cursor += ((param.bit_position or 0) + param_bit_length + 7) // 8
-        byte_length = max(byte_length, cursor)
-
-    return byte_length * 8
-
-
-def composite_codec_get_required_parameters(codec: CompositeCodec) -> List[Parameter]:
-    """Return the list of parameters which are required to be
-    specified for encoding the composite codec object
-
-    I.e., all free parameters that do not exhibit a default value.
-    """
-    return [p for p in codec.parameters if p.is_required]
-
-
-def composite_codec_get_free_parameters(codec: CompositeCodec) -> List[Parameter]:
-    """Return the list of parameters which can be freely specified by
-    the user when encoding the composite codec object
-
-    This means all required parameters plus parameters that can be
-    omitted because they specify a default.
-    """
-    return [p for p in codec.parameters if p.is_settable]
-
-
-def composite_codec_get_coded_const_prefix(codec: CompositeCodec,
-                                           request_prefix: bytes = b'') -> bytes:
-    encode_state = EncodeState(coded_message=bytearray(), triggering_request=request_prefix)
-
-    for param in codec.parameters:
-        if (isinstance(param, MatchingRequestParameter) and param.request_byte_position < len(request_prefix)) or \
-            isinstance(param, (CodedConstParameter, PhysicalConstantParameter)):
-            param.encode_into_pdu(physical_value=None, encode_state=encode_state)
-        else:
-            break
-
-    return encode_state.coded_message
-
-
-def composite_codec_encode_into_pdu(codec: CompositeCodec, physical_value: Optional[ParameterValue],
-                                    encode_state: EncodeState) -> None:
-    from .parameters.lengthkeyparameter import LengthKeyParameter
-    from .parameters.tablekeyparameter import TableKeyParameter
-
-    if not isinstance(physical_value, dict):
-        odxraise(
-            f"Expected a dictionary for the values of {codec.short_name}, "
-            f"got {type(physical_value).__name__}", EncodeError)
-    elif encode_state.cursor_bit_position != 0:
-        odxraise(
-            f"Compositional codec objecs must be byte aligned, but "
-            f"{codec.short_name} requested to be at bit position "
-            f"{encode_state.cursor_bit_position}", EncodeError)
-        encode_state.bit_position = 0
-
-    orig_origin = encode_state.origin_byte_position
-    encode_state.origin_byte_position = encode_state.cursor_byte_position
-
-    orig_is_end_of_pdu = encode_state.is_end_of_pdu
-    encode_state.is_end_of_pdu = False
-
-    # ensure that no values for unknown parameters are specified.
-    if not encode_state.allow_unknown_parameters:
-        param_names = {param.short_name for param in codec.parameters}
-        for param_value_name in physical_value:
-            if param_value_name not in param_names:
-                odxraise(f"Value for unknown parameter '{param_value_name}' specified "
-                         f"for composite codec object {codec.short_name}")
-
-    for param in codec.parameters:
-        if id(param) == id(codec.parameters[-1]):
-            # The last parameter of the composite codec object is at
-            # the end of the PDU if the codec object itself is at the
-            # end of the PDU.
-            #
-            # TODO: This assumes that the last parameter specified in
-            # the ODX is located last in the PDU...
-            encode_state.is_end_of_pdu = orig_is_end_of_pdu
-
-        if isinstance(param, (LengthKeyParameter, TableKeyParameter)):
-            # At this point, we encode a placeholder value for length-
-            # and table keys, since these can be specified
-            # implicitly (i.e., by means of parameters that use
-            # these keys). To avoid getting an "overlapping
-            # parameter" warning, we must encode a value of zero
-            # into the PDU here and add the real value of the
-            # parameter in a post-processing step.
-            param.encode_placeholder_into_pdu(
-                physical_value=physical_value.get(param.short_name), encode_state=encode_state)
-
-            continue
-
-        if param.is_required and param.short_name not in physical_value:
-            odxraise(f"No value for required parameter {param.short_name} specified", EncodeError)
-
-        param_phys_value = physical_value.get(param.short_name)
-        param.encode_into_pdu(physical_value=param_phys_value, encode_state=encode_state)
-
-        encode_state.journal.append((param, param_phys_value))
-
-    encode_state.is_end_of_pdu = False
-
-    # encode the length- and table keys. This cannot be done above
-    # because we allow these to be defined implicitly (i.e. they
-    # are defined by their respective users)
-    for param in codec.parameters:
-        if not isinstance(param, (LengthKeyParameter, TableKeyParameter)):
-            # the current parameter is neither a length- nor a table key
-            continue
-
-        # Encode the value of the key parameter into the message
-        param.encode_value_into_pdu(encode_state=encode_state)
-
-    encode_state.origin_byte_position = orig_origin
-
-
-def composite_codec_decode_from_pdu(codec: CompositeCodec,
-                                    decode_state: DecodeState) -> ParameterValue:
-    # move the origin since positions specified by sub-parameters of
-    # composite codec objects are relative to the beginning of the
-    # object.
-    orig_origin = decode_state.origin_byte_position
-    decode_state.origin_byte_position = decode_state.cursor_byte_position
-
-    result = {}
-    for param in codec.parameters:
-        value = param.decode_from_pdu(decode_state)
-
-        decode_state.journal.append((param, value))
-        result[param.short_name] = value
-
-    # decoding of the composite codec object finished. go back the
-    # original origin.
-    decode_state.origin_byte_position = orig_origin
-
-    return result

odxtools/commrelation.py

@@ -1,10 +1,10 @@
 # SPDX-License-Identifier: MIT
 import warnings
 from dataclasses import dataclass
-from enum import Enum
-from typing import Any, Dict, List, Optional
+from typing import Any
 from xml.etree import ElementTree
 
+from .commrelationvaluetype import CommRelationValueType
 from .description import Description
 from .diagcomm import DiagComm
 from .diagservice import DiagService
@@ -14,35 +14,28 @@ from .parameters.parameter import Parameter
 from .snrefcontext import SnRefContext
 
 
-class CommRelationValueType(Enum):
-    CURRENT = "CURRENT"
-    STORED = "STORED"
-    STATIC = "STATIC"
-    SUBSTITUTED = "SUBSTITUTED"
-
-
 @dataclass
 class CommRelation:
-    description: Optional[Description]
+    description: Description | None
     relation_type: str
-    diag_comm_ref: Optional[OdxLinkRef]
-    diag_comm_snref: Optional[str]
-    in_param_if_snref: Optional[str]
+    diag_comm_ref: OdxLinkRef | None
+    diag_comm_snref: str | None
+    in_param_if_snref: str | None
     #in_param_if_snpathref: Optional[str] # TODO
-    out_param_if_snref: Optional[str]
+    out_param_if_snref: str | None
     #out_param_if_snpathref: Optional[str] # TODO
-    value_type_raw: Optional[CommRelationValueType]
+    value_type_raw: CommRelationValueType | None
 
     @property
     def diag_comm(self) -> DiagComm:
         return self._diag_comm
 
     @property
-    def in_param_if(self) -> Optional[Parameter]:
+    def in_param_if(self) -> Parameter | None:
         return self._in_param_if
 
     @property
-    def out_param_if(self) -> Optional[Parameter]:
+    def out_param_if(self) -> Parameter | None:
         return self._out_param_if
 
     @property
@@ -53,7 +46,7 @@ class CommRelation:
         return self.value_type_raw
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "CommRelation":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "CommRelation":
         description = Description.from_et(et_element.find("DESC"), doc_frags)
         relation_type = odxrequire(et_element.findtext("RELATION-TYPE"))
 
@@ -92,7 +85,7 @@ class CommRelation:
             out_param_if_snref=out_param_if_snref,
             value_type_raw=value_type_raw)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:

odxtools/commrelationvaluetype.py

@@ -0,0 +1,9 @@
+# SPDX-License-Identifier: MIT
+from enum import Enum
+
+
+class CommRelationValueType(Enum):
+    CURRENT = "CURRENT"
+    STORED = "STORED"
+    STATIC = "STATIC"
+    SUBSTITUTED = "SUBSTITUTED"

odxtools/companydata.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 .companyspecificinfo import CompanySpecificInfo
@@ -15,12 +15,12 @@ from .utils import dataclass_fields_asdict
 
 @dataclass
 class CompanyData(IdentifiableElement):
-    roles: List[str]
+    roles: list[str]
     team_members: NamedItemList[TeamMember]
-    company_specific_info: Optional[CompanySpecificInfo]
+    company_specific_info: CompanySpecificInfo | None
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "CompanyData":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "CompanyData":
 
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
 
@@ -43,7 +43,7 @@ class CompanyData(IdentifiableElement):
             **kwargs,
         )
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = {self.odx_id: self}
 
         for tm in self.team_members:

odxtools/companydocinfo.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 .companydata import CompanyData
@@ -14,21 +14,21 @@ from .teammember import TeamMember
 @dataclass
 class CompanyDocInfo:
     company_data_ref: OdxLinkRef
-    team_member_ref: Optional[OdxLinkRef]
-    doc_label: Optional[str]
-    sdgs: List[SpecialDataGroup]
+    team_member_ref: OdxLinkRef | None
+    doc_label: str | None
+    sdgs: list[SpecialDataGroup]
 
     @property
     def company_data(self) -> CompanyData:
         return self._company_data
 
     @property
-    def team_member(self) -> Optional[TeamMember]:
+    def team_member(self) -> TeamMember | None:
         return self._team_member
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "CompanyDocInfo":
+                doc_frags: list[OdxDocFragment]) -> "CompanyDocInfo":
         # the company data reference is mandatory
         company_data_ref = odxrequire(
             OdxLinkRef.from_et(et_element.find("COMPANY-DATA-REF"), doc_frags))
@@ -45,7 +45,7 @@ class CompanyDocInfo:
             sdgs=sdgs,
         )
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = {}
 
         for sdg in self.sdgs:
@@ -56,7 +56,7 @@ class CompanyDocInfo:
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         self._company_data = odxlinks.resolve(self.company_data_ref, CompanyData)
 
-        self._team_member: Optional[TeamMember] = None
+        self._team_member: TeamMember | None = None
         if self.team_member_ref is not None:
             self._team_member = odxlinks.resolve(self.team_member_ref, TeamMember)
 

odxtools/companyrevisioninfo.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 .companydata import CompanyData
@@ -12,8 +12,8 @@ from .snrefcontext import SnRefContext
 @dataclass
 class CompanyRevisionInfo:
     company_data_ref: OdxLinkRef
-    revision_label: Optional[str]
-    state: Optional[str]
+    revision_label: str | None
+    state: str | None
 
     @property
     def company_data(self) -> CompanyData:
@@ -21,7 +21,7 @@ class CompanyRevisionInfo:
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "CompanyRevisionInfo":
+                doc_frags: list[OdxDocFragment]) -> "CompanyRevisionInfo":
 
         company_data_ref = odxrequire(
             OdxLinkRef.from_et(et_element.find("COMPANY-DATA-REF"), doc_frags))
@@ -31,7 +31,7 @@ class CompanyRevisionInfo:
         return CompanyRevisionInfo(
             company_data_ref=company_data_ref, revision_label=revision_label, state=state)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:

odxtools/companyspecificinfo.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 .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
@@ -11,12 +11,12 @@ from .specialdatagroup import SpecialDataGroup
 
 @dataclass
 class CompanySpecificInfo:
-    related_docs: List[RelatedDoc]
-    sdgs: List[SpecialDataGroup]
+    related_docs: list[RelatedDoc]
+    sdgs: list[SpecialDataGroup]
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "CompanySpecificInfo":
+                doc_frags: list[OdxDocFragment]) -> "CompanySpecificInfo":
         related_docs = [
             RelatedDoc.from_et(rd, doc_frags)
             for rd in et_element.iterfind("RELATED-DOCS/RELATED-DOC")
@@ -28,7 +28,7 @@ class CompanySpecificInfo:
 
         return CompanySpecificInfo(related_docs=related_docs, sdgs=sdgs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = {}
 
         for rd in self.related_docs:

odxtools/comparam.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 .basecomparam import BaseComparam
@@ -27,7 +27,7 @@ class Comparam(BaseComparam):
         return self._dop
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Comparam":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "Comparam":
         kwargs = dataclass_fields_asdict(BaseComparam.from_et(et_element, doc_frags))
 
         physical_default_value_raw = odxrequire(et_element.findtext("PHYSICAL-DEFAULT-VALUE"))
@@ -36,7 +36,7 @@ class Comparam(BaseComparam):
         return Comparam(
             dop_ref=dop_ref, physical_default_value_raw=physical_default_value_raw, **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return super()._build_odxlinks()
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:

odxtools/comparaminstance.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: MIT
 import warnings
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Union
+from typing import Any
 from xml.etree import ElementTree
 
 from .basecomparam import BaseComparam
@@ -20,10 +20,10 @@ class ComparamInstance:
 
     Be aware that the ODX specification calls this class COMPARAM-REF!
     """
-    value: Union[str, ComplexValue]
-    description: Optional[Description]
-    protocol_snref: Optional[str]
-    prot_stack_snref: Optional[str]
+    value: str | ComplexValue
+    description: Description | None
+    protocol_snref: str | None
+    prot_stack_snref: str | None
     spec_ref: OdxLinkRef
 
     @property
@@ -36,13 +36,13 @@ class ComparamInstance:
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "ComparamInstance":
+                doc_frags: list[OdxDocFragment]) -> "ComparamInstance":
         spec_ref = odxrequire(OdxLinkRef.from_et(et_element, doc_frags))
 
         # ODX standard v2.0.0 defined only VALUE. ODX v2.0.1 decided
         # to break things and change it to a choice between SIMPLE-VALUE
         # and COMPLEX-VALUE
-        value: Union[str, List[Union[str, ComplexValue]]]
+        value: str | list[str | ComplexValue]
         if et_element.find("VALUE") is not None:
             value = odxrequire(et_element.findtext("VALUE"))
         elif et_element.find("SIMPLE-VALUE") is not None:
@@ -68,7 +68,7 @@ class ComparamInstance:
             prot_stack_snref=prot_stack_snref,
         )
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
@@ -98,7 +98,7 @@ class ComparamInstance:
 
         return result
 
-    def get_subvalue(self, subparam_name: str) -> Optional[str]:
+    def get_subvalue(self, subparam_name: str) -> str | None:
         """Retrieve the value of a complex communication parameter's sub-parameter by name
 
         This takes the default value of the comparam (if any) into
@@ -133,7 +133,7 @@ class ComparamInstance:
             return None
 
         result = value_list[idx]
-        if result is None and isinstance(subparam, (Comparam, ComplexComparam)):
+        if result is None and isinstance(subparam, Comparam | ComplexComparam):
             result = subparam.physical_default_value
         if not isinstance(result, str):
             odxraise()

odxtools/comparamspec.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 .nameditemlist import NamedItemList
@@ -20,7 +20,7 @@ class ComparamSpec(OdxCategory):
     prot_stacks: NamedItemList[ProtStack]
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "ComparamSpec":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "ComparamSpec":
 
         base_obj = OdxCategory.category_from_et(
             et_element, doc_frags, doc_type=DocType.COMPARAM_SPEC)
@@ -34,7 +34,7 @@ class ComparamSpec(OdxCategory):
 
         return ComparamSpec(prot_stacks=prot_stacks, **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         odxlinks = super()._build_odxlinks()
 
         for ps in self.prot_stacks: