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

odxtools/additionalaudience.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
@@ -17,12 +17,12 @@ class AdditionalAudience(IdentifiableElement):
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "AdditionalAudience":
+                doc_frags: list[OdxDocFragment]) -> "AdditionalAudience":
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
 
         return AdditionalAudience(**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/admindata.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
+from typing import Any, Optional
 from xml.etree import ElementTree
 
 from .companydocinfo import CompanyDocInfo
@@ -11,13 +11,13 @@ from .snrefcontext import SnRefContext
 
 @dataclass
 class AdminData:
-    language: Optional[str]
-    company_doc_infos: List[CompanyDocInfo]
-    doc_revisions: List[DocRevision]
+    language: str | None
+    company_doc_infos: list[CompanyDocInfo]
+    doc_revisions: list[DocRevision]
 
     @staticmethod
-    def from_et(et_element: Optional[ElementTree.Element],
-                doc_frags: List[OdxDocFragment]) -> Optional["AdminData"]:
+    def from_et(et_element: ElementTree.Element | None,
+                doc_frags: list[OdxDocFragment]) -> Optional["AdminData"]:
 
         if et_element is None:
             return None
@@ -37,8 +37,8 @@ class AdminData:
         return AdminData(
             language=language, company_doc_infos=company_doc_infos, doc_revisions=doc_revisions)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
-        result: Dict[OdxLinkId, Any] = {}
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        result: dict[OdxLinkId, Any] = {}
 
         for cdi in self.company_doc_infos:
             result.update(cdi._build_odxlinks())

odxtools/audience.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 .additionalaudience import AdditionalAudience
@@ -12,14 +12,14 @@ from .snrefcontext import SnRefContext
 
 @dataclass
 class Audience:
-    enabled_audience_refs: List[OdxLinkRef]
-    disabled_audience_refs: List[OdxLinkRef]
+    enabled_audience_refs: list[OdxLinkRef]
+    disabled_audience_refs: list[OdxLinkRef]
 
-    is_supplier_raw: Optional[bool]
-    is_development_raw: Optional[bool]
-    is_manufacturing_raw: Optional[bool]
-    is_aftersales_raw: Optional[bool]
-    is_aftermarket_raw: Optional[bool]
+    is_supplier_raw: bool | None
+    is_development_raw: bool | None
+    is_manufacturing_raw: bool | None
+    is_aftersales_raw: bool | None
+    is_aftermarket_raw: bool | None
 
     @property
     def is_supplier(self) -> bool:
@@ -50,7 +50,7 @@ class Audience:
         return self._disabled_audiences
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Audience":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "Audience":
 
         enabled_audience_refs = [
             OdxLinkRef.from_et(ref, doc_frags)
@@ -78,7 +78,7 @@ class Audience:
             is_aftermarket_raw=is_aftermarket_raw,
         )
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:

odxtools/basecomparam.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 .element import IdentifiableElement
@@ -16,11 +16,11 @@ from .utils import dataclass_fields_asdict
 class BaseComparam(IdentifiableElement):
     param_class: str
     cptype: StandardizationLevel
-    display_level: Optional[int]
-    cpusage: Optional[Usage]  # Required in ODX 2.2, missing in ODX 2.0
+    display_level: int | None
+    cpusage: Usage | None  # Required in ODX 2.2, missing in ODX 2.0
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "BaseComparam":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "BaseComparam":
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
 
         param_class = odxrequire(et_element.attrib.get("PARAM-CLASS"))
@@ -52,7 +52,7 @@ class BaseComparam(IdentifiableElement):
             cpusage=cpusage,
             **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/basevariantpattern.py

@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Union
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -17,11 +16,11 @@ class BaseVariantPattern(VariantPattern):
     """Base variant patterns are variant patterns used to identify the
     base variant of an ECU.
     """
-    matching_base_variant_parameters: List[MatchingBaseVariantParameter]
+    matching_base_variant_parameters: list[MatchingBaseVariantParameter]
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "BaseVariantPattern":
+                doc_frags: list[OdxDocFragment]) -> "BaseVariantPattern":
 
         matching_base_variant_parameters = [
             MatchingBaseVariantParameter.from_et(mbvp_el, doc_frags)
@@ -33,6 +32,6 @@ class BaseVariantPattern(VariantPattern):
         return BaseVariantPattern(matching_base_variant_parameters=matching_base_variant_parameters)
 
     @override
-    def get_matching_parameters(
-            self) -> Union[List[MatchingParameter], List[MatchingBaseVariantParameter]]:
+    def get_matching_parameters(self
+                               ) -> list[MatchingParameter] | list[MatchingBaseVariantParameter]:
         return self.matching_base_variant_parameters

odxtools/basicstructure.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 typing_extensions import override
@@ -30,20 +30,20 @@ class BasicStructure(ComplexDop):
     data objects. All structure-like objects adhere to the
     `CompositeCodec` type protocol.
     """
-    byte_size: Optional[int]
+    byte_size: int | None
     parameters: NamedItemList[Parameter]
 
     @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]) -> "BasicStructure":
+                doc_frags: list[OdxDocFragment]) -> "BasicStructure":
         """Read a BASIC-STRUCTURE."""
         kwargs = dataclass_fields_asdict(ComplexDop.from_et(et_element, doc_frags))
 
@@ -56,7 +56,7 @@ class BasicStructure(ComplexDop):
 
         return BasicStructure(byte_size=byte_size, parameters=parameters, **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = super()._build_odxlinks()
 
         for param in self.parameters:
@@ -79,7 +79,7 @@ class BasicStructure(ComplexDop):
 
         context.parameters = None
 
-    def get_static_bit_length(self) -> Optional[int]:
+    def get_static_bit_length(self) -> int | None:
         # Explicit size was specified, so we do not need to look at
         # the list of parameters
         if self.byte_size is not None:
@@ -96,7 +96,7 @@ class BasicStructure(ComplexDop):
         print(parameter_info(self.free_parameters), end="")
 
     @override
-    def encode_into_pdu(self, physical_value: Optional[ParameterValue],
+    def encode_into_pdu(self, physical_value: ParameterValue | None,
                         encode_state: EncodeState) -> None:
         orig_pos = encode_state.cursor_byte_position
 

odxtools/cli/_print_utils.py

@@ -1,7 +1,6 @@
 # SPDX-License-Identifier: MIT
 import re
 import textwrap
-from typing import List, Optional, Tuple, Union
 
 import markdownify
 from rich import print as rich_print
@@ -113,9 +112,9 @@ def print_service_parameters(service: DiagService,
     rich_print("\n")
 
 
-def extract_service_tabulation_data(services: List[DiagService],
+def extract_service_tabulation_data(services: list[DiagService],
                                     *,
-                                    additional_columns: Optional[List[Tuple[str, List[str]]]] = None
+                                    additional_columns: list[tuple[str, list[str]]] | None = None
                                    ) -> RichTable:
     """Extracts data of diagnostic services into Dictionary which can
     be printed by tabulate module
@@ -125,9 +124,9 @@ def extract_service_tabulation_data(services: List[DiagService],
     table = RichTable(
         title="", show_header=True, header_style="bold cyan", border_style="blue", show_lines=True)
 
-    name_column: List[str] = []
-    semantic_column: List[str] = []
-    request_column: List[str] = []
+    name_column: list[str] = []
+    semantic_column: list[str] = []
+    request_column: list[str] = []
 
     for service in services:
         name_column.append(service.short_name)
@@ -147,15 +146,19 @@ def extract_service_tabulation_data(services: List[DiagService],
         for ac_title, _ in additional_columns:
             table.add_column(ac_title, justify="left", style="white")
 
-        rows = zip(name_column, semantic_column, request_column,
-                   *[ac[1] for ac in additional_columns])
+        rows = zip(
+            name_column,
+            semantic_column,
+            request_column,
+            *[ac[1] for ac in additional_columns],
+            strict=False)
         for row in rows:
             table.add_row(*map(str, row))
 
     return table
 
 
-def extract_parameter_tabulation_data(parameters: List[Parameter]) -> RichTable:
+def extract_parameter_tabulation_data(parameters: list[Parameter]) -> RichTable:
     # extracts data of parameters of diagnostic services into
     # a RichTable object that can be printed
 
@@ -174,15 +177,15 @@ def extract_parameter_tabulation_data(parameters: List[Parameter]) -> RichTable:
     table.add_column("Value Type", justify="left", style="white")
     table.add_column("Linked DOP", justify="left", style="white")
 
-    name_column: List[str] = []
-    byte_column: List[str] = []
-    bit_length_column: List[str] = []
-    semantic_column: List[str] = []
-    param_type_column: List[str] = []
-    value_column: List[str] = []
-    value_type_column: List[str] = []
-    data_type_column: List[str] = []
-    dop_column: List[str] = []
+    name_column: list[str] = []
+    byte_column: list[str] = []
+    bit_length_column: list[str] = []
+    semantic_column: list[str] = []
+    param_type_column: list[str] = []
+    value_column: list[str] = []
+    value_type_column: list[str] = []
+    data_type_column: list[str] = []
+    dop_column: list[str] = []
 
     for param in parameters:
         name_column.append(param.short_name)
@@ -211,7 +214,7 @@ def extract_parameter_tabulation_data(parameters: List[Parameter]) -> RichTable:
             value_column.append(str(param.coded_values))
             value_type_column.append('coded values')
             dop_column.append("")
-        elif isinstance(param, (PhysicalConstantParameter, SystemParameter, ValueParameter)):
+        elif isinstance(param, PhysicalConstantParameter | SystemParameter | ValueParameter):
             # this is a hack to make this routine work for parameters
             # which reference DOPs of a type that a is not yet
             # internalized. (all parameter objects of the tested types
@@ -250,15 +253,24 @@ def extract_parameter_tabulation_data(parameters: List[Parameter]) -> RichTable:
             dop_column.append("")
 
     # Add all rows at once by zipping dictionary values
-    rows = zip(name_column, byte_column, bit_length_column, semantic_column, param_type_column,
-               data_type_column, value_column, value_type_column, dop_column)
+    rows = zip(
+        name_column,
+        byte_column,
+        bit_length_column,
+        semantic_column,
+        param_type_column,
+        data_type_column,
+        value_column,
+        value_type_column,
+        dop_column,
+        strict=False)
     for row in rows:
         table.add_row(*map(str, row))
 
     return table
 
 
-def print_dl_metrics(variants: List[DiagLayer]) -> None:
+def print_dl_metrics(variants: list[DiagLayer]) -> None:
     """
     Print diagnostic layer metrics using Rich tables.
     Args:
@@ -278,7 +290,7 @@ def print_dl_metrics(variants: List[DiagLayer]) -> None:
     # Process each variant
     for variant in variants:
         assert isinstance(variant, DiagLayer)
-        all_services: List[Union[DiagService, SingleEcuJob]] = sorted(
+        all_services: list[DiagService | SingleEcuJob] = sorted(
             variant.services, key=lambda x: x.short_name)
         ddds = variant.diag_data_dictionary_spec
 

odxtools/cli/browse.py

@@ -2,7 +2,7 @@
 import argparse
 import logging
 import sys
-from typing import List, Optional, Union, cast
+from typing import cast
 
 import InquirerPy.prompt as IP_prompt
 
@@ -66,7 +66,7 @@ def _validate_string_value(input: str, parameter: Parameter) -> bool:
         return input != ""
 
 
-def prompt_single_parameter_value(parameter: Parameter) -> Optional[AtomicOdxType]:
+def prompt_single_parameter_value(parameter: Parameter) -> AtomicOdxType | None:
     if not isinstance(parameter, ValueParameter):
         odxraise("Only the value of ValueParameters can be queried")
     if parameter.physical_type is None:
@@ -113,7 +113,7 @@ def prompt_single_parameter_value(parameter: Parameter) -> Optional[AtomicOdxTyp
         return cast(str, answer.get(parameter.short_name))
 
 
-def encode_message_interactively(codec: Union[Request, Response],
+def encode_message_interactively(codec: Request | Response,
                                  ask_user_confirmation: bool = False) -> None:
     if sys.__stdin__ is None or sys.__stdout__ is None or not sys.__stdin__.isatty(
     ) or not sys.__stdout__.isatty():
@@ -168,7 +168,7 @@ def encode_message_interactively(codec: Union[Request, Response],
             if (inner_params := getattr(dop := getattr(param, "dop", None), "parameters",
                                         None)) is not None:
                 assert isinstance(dop, DopBase)
-                inner_params = cast(List[Parameter], inner_params)
+                inner_params = cast(list[Parameter], inner_params)
                 # param refers to a complex DOP, i.e., the required
                 # value is a key-value dict
                 print(
@@ -201,8 +201,8 @@ def encode_message_interactively(codec: Union[Request, Response],
 
 
 def encode_message_from_string_values(
-    sub_service: Union[Request, Response],
-    parameter_values: Optional[ParameterValueDict] = None,
+    sub_service: Request | Response,
+    parameter_values: ParameterValueDict | None = None,
 ) -> None:
     if parameter_values is None:
         parameter_values = {}
@@ -243,7 +243,7 @@ def encode_message_from_string_values(
             inner_params = getattr(dop, "parameters", None)
             assert isinstance(dop, ComplexDop)
             assert isinstance(inner_params, list)
-            inner_params = cast(List[Parameter], inner_params)
+            inner_params = cast(list[Parameter], inner_params)
 
             typed_dict = parameter_value.copy()
             for inner_param_sn, inner_param_value in parameter_value.items():
@@ -316,7 +316,7 @@ def browse(odxdb: Database) -> None:
             )
 
         while True:
-            services: List[DiagService] = [
+            services: list[DiagService] = [
                 s for s in variant.services if isinstance(s, DiagService)
             ]
             # Select a service of the ECU
@@ -370,7 +370,7 @@ def browse(odxdb: Database) -> None:
 
             codec = answer.get("message_type")
             if codec is not None:
-                assert isinstance(codec, (Request, Response))
+                assert isinstance(codec, Request | Response)
                 table = extract_parameter_tabulation_data(codec.parameters)
                 print(table)
 

odxtools/cli/compare.py

@@ -3,7 +3,7 @@
 
 import argparse
 import os
-from typing import Any, Dict, List, Optional, Set, Union, cast
+from typing import Any, cast
 
 from rich import print as rich_print
 from rich.padding import Padding as RichPadding
@@ -29,18 +29,18 @@ _odxtools_tool_name_ = "compare"
 
 VariantName = str
 VariantType = str
-NewServices = List[DiagService]
-DeletedServices = List[DiagService]
-RenamedServices = List[List[Union[str, DiagService]]]
-ServicesWithParamChanges = List[List[Union[str, DiagService]]]
+NewServices = list[DiagService]
+DeletedServices = list[DiagService]
+RenamedServices = list[list[str | DiagService]]
+ServicesWithParamChanges = list[list[str | DiagService]]
 
-SpecsServiceDict = Dict[str, Union[VariantName, VariantType, NewServices, DeletedServices,
-                                   RenamedServices, ServicesWithParamChanges]]
+SpecsServiceDict = dict[str, VariantName | VariantType | NewServices | DeletedServices
+                        | RenamedServices | ServicesWithParamChanges]
 
-NewVariants = List[DiagLayer]
-DeletedVariants = List[DiagLayer]
+NewVariants = list[DiagLayer]
+DeletedVariants = list[DiagLayer]
 
-SpecsChangesVariants = Dict[str, Union[NewVariants, DeletedVariants, SpecsServiceDict]]
+SpecsChangesVariants = dict[str, NewVariants | DeletedVariants | SpecsServiceDict]
 
 
 class Display:
@@ -71,13 +71,13 @@ class Display:
                 f"Changed diagnostic services for diagnostic layer '{service_dict['diag_layer']}' ({service_dict['diag_layer_type']}):"
             )
         if service_dict["new_services"]:
-            assert isinstance(service_dict["new_services"], List)
+            assert isinstance(service_dict["new_services"], list)
             rich_print()
             rich_print(" [blue]New services[/blue]")
             rich_print(extract_service_tabulation_data(
                 service_dict["new_services"]))  # type: ignore[arg-type]
         if service_dict["deleted_services"]:
-            assert isinstance(service_dict["deleted_services"], List)
+            assert isinstance(service_dict["deleted_services"], list)
             rich_print()
             rich_print(" [blue]Deleted services[/blue]")
             rich_print(extract_service_tabulation_data(
@@ -123,7 +123,7 @@ class Display:
                             show_lines=True)
                         for header in detailed_info:
                             table.add_column(header)
-                        rows = zip(*detailed_info.values())
+                        rows = zip(*detailed_info.values(), strict=False)
                         for row in rows:
                             table.add_row(*map(str, row))
 
@@ -159,9 +159,9 @@ class Display:
 
 
 class Comparison(Display):
-    databases: List[Database] = []  # storage of database objects
-    diagnostic_layers: List[DiagLayer] = []  # storage of DiagLayer objects
-    diagnostic_layer_names: Set[str] = set()  # storage of diagnostic layer names
+    databases: list[Database] = []  # storage of database objects
+    diagnostic_layers: list[DiagLayer] = []  # storage of DiagLayer objects
+    diagnostic_layer_names: set[str] = set()  # storage of diagnostic layer names
 
     db_indicator_1: int
     db_indicator_2: int
@@ -169,7 +169,7 @@ class Comparison(Display):
     def __init__(self) -> None:
         pass
 
-    def compare_parameters(self, param1: Parameter, param2: Parameter) -> Dict[str, Any]:
+    def compare_parameters(self, param1: Parameter, param2: Parameter) -> dict[str, Any]:
         # checks whether properties of param1 and param2 differ
         # checked properties: Name, Byte Position, Bit Length, Semantic, Parameter Type, Value (Coded, Constant, Default etc.), Data Type, Data Object Property (Name, Physical Data Type, Unit)
 
@@ -177,8 +177,8 @@ class Comparison(Display):
         old = []
         new = []
 
-        def append_list(property_name: str, new_property_value: Optional[AtomicOdxType],
-                        old_property_value: Optional[AtomicOdxType]) -> None:
+        def append_list(property_name: str, new_property_value: AtomicOdxType | None,
+                        old_property_value: AtomicOdxType | None) -> None:
             property.append(property_name)
             old.append(old_property_value)
             new.append(new_property_value)
@@ -277,10 +277,10 @@ class Comparison(Display):
         return {"Property": property, "Old Value": old, "New Value": new}
 
     def compare_services(self, service1: DiagService,
-                         service2: DiagService) -> List[SpecsServiceDict]:
+                         service2: DiagService) -> list[SpecsServiceDict]:
         # compares request, positive response and negative response parameters of two diagnostic services
 
-        information: List[Union[str, Dict[str, Any]]] = [
+        information: list[str | dict[str, Any]] = [
         ]  # information = [infotext1, table1, infotext2, table2, ...]
         changed_params = ""
 
@@ -438,10 +438,10 @@ class Comparison(Display):
 
         # extract the constant prefixes for the requests of all
         # services (used for duck-typed rename detection)
-        dl1_request_prefixes: List[Optional[bytes]] = [
+        dl1_request_prefixes: list[bytes | None] = [
             None if s.request is None else s.request.coded_const_prefix() for s in dl1.services
         ]
-        dl2_request_prefixes: List[Optional[bytes]] = [
+        dl2_request_prefixes: list[bytes | None] = [
             None if s.request is None else s.request.coded_const_prefix() for s in dl2.services
         ]
 
@@ -449,7 +449,7 @@ class Comparison(Display):
         for service1 in dl1.services:
 
             # check for added diagnostic services
-            rq_prefix: Optional[bytes] = None
+            rq_prefix: bytes | None = None
             if service1.request is not None:
                 rq_prefix = service1.request.coded_const_prefix()
 

odxtools/cli/decode.py

@@ -1,7 +1,6 @@
 # SPDX-License-Identifier: MIT
 import argparse
 import re
-from typing import Dict, List, Optional
 
 from ..database import Database
 from ..diagservice import DiagService
@@ -26,13 +25,13 @@ def get_display_value(v: ParameterValue) -> str:
 
 def print_summary(
     odxdb: Database,
-    ecu_variants: Optional[List[str]] = None,
+    ecu_variants: list[str] | None = None,
     data: bytes = b'',
     decode: bool = False,
 ) -> None:
     ecu_names = ecu_variants if ecu_variants else [ecu.short_name for ecu in odxdb.ecus]
-    service_db: Dict[str, DiagService] = {}
-    service_ecus: Dict[str, List[str]] = {}
+    service_db: dict[str, DiagService] = {}
+    service_ecus: dict[str, list[str]] = {}
     for ecu_name in ecu_names:
         ecu = odxdb.ecus[ecu_name]
         if not ecu:

odxtools/cli/find.py

@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: MIT
 import argparse
-from typing import Dict, List, Optional
 
 from ..database import Database
 from ..diagservice import DiagService
@@ -24,13 +23,13 @@ def get_display_value(v: ParameterValue) -> str:
 
 
 def print_summary(odxdb: Database,
-                  service_names: List[str],
-                  ecu_variants: Optional[List[str]] = None,
+                  service_names: list[str],
+                  ecu_variants: list[str] | None = None,
                   allow_unknown_bit_lengths: bool = False,
                   print_params: bool = False) -> None:
     ecu_names = ecu_variants if ecu_variants else [ecu.short_name for ecu in odxdb.ecus]
-    service_db: Dict[str, DiagService] = {}
-    service_ecus: Dict[str, List[str]] = {}
+    service_db: dict[str, DiagService] = {}
+    service_ecus: dict[str, list[str]] = {}
     for ecu_name in ecu_names:
         ecu = odxdb.ecus[ecu_name]
         if not ecu:

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