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

odxtools/tablerow.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass, fields
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple
+from typing import TYPE_CHECKING, Any
 from xml.etree import ElementTree
 
 from .admindata import AdminData
@@ -33,22 +33,22 @@ class TableRow(IdentifiableElement):
     # The spec mandates that either a structure or a non-complex DOP
     # must be referenced here, i.e., exactly one of the four
     # attributes below is not None
-    dop_ref: Optional[OdxLinkRef]
-    dop_snref: Optional[str]
-    structure_ref: Optional[OdxLinkRef]
-    structure_snref: Optional[str]
-
-    sdgs: List[SpecialDataGroup]
-    audience: Optional[Audience]
-    functional_class_refs: List[OdxLinkRef]
-    state_transition_refs: List[StateTransitionRef]
-    pre_condition_state_refs: List[PreConditionStateRef]
-    admin_data: Optional[AdminData]
-
-    is_executable_raw: Optional[bool]
-    semantic: Optional[str]
-    is_mandatory_raw: Optional[bool]
-    is_final_raw: Optional[bool]
+    dop_ref: OdxLinkRef | None
+    dop_snref: str | None
+    structure_ref: OdxLinkRef | None
+    structure_snref: str | None
+
+    sdgs: list[SpecialDataGroup]
+    audience: Audience | None
+    functional_class_refs: list[OdxLinkRef]
+    state_transition_refs: list[StateTransitionRef]
+    pre_condition_state_refs: list[PreConditionStateRef]
+    admin_data: AdminData | None
+
+    is_executable_raw: bool | None
+    semantic: str | None
+    is_mandatory_raw: bool | None
+    is_final_raw: bool | None
 
     @property
     def table(self) -> "Table":
@@ -57,16 +57,16 @@ class TableRow(IdentifiableElement):
     # the value of the key expressed in the type represented by the
     # referenced DOP
     @property
-    def key(self) -> Optional[AtomicOdxType]:
+    def key(self) -> AtomicOdxType | None:
         return self._key
 
     @property
-    def dop(self) -> Optional[DataObjectProperty]:
+    def dop(self) -> DataObjectProperty | None:
         """The data object property object resolved by dop_ref."""
         return self._dop
 
     @property
-    def structure(self) -> Optional[Structure]:
+    def structure(self) -> Structure | None:
         """The structure associated with this table row."""
         return self._structure
 
@@ -87,12 +87,12 @@ class TableRow(IdentifiableElement):
         return self.is_final_raw is True
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> Any:
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> Any:
         raise RuntimeError(
             "Calling TableRow.from_et() is not allowed. Use TableRow.tablerow_from_et().")
 
     @staticmethod
-    def tablerow_from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment], *,
+    def tablerow_from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment], *,
                          table_ref: OdxLinkRef) -> "TableRow":
         """Reads a TABLE-ROW."""
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
@@ -100,12 +100,12 @@ class TableRow(IdentifiableElement):
         key_raw = odxrequire(et_element.findtext("KEY"))
 
         dop_ref = OdxLinkRef.from_et(et_element.find("DATA-OBJECT-PROP-REF"), doc_frags)
-        dop_snref: Optional[str] = None
+        dop_snref: str | None = None
         if (dop_snref_elem := et_element.find("DATA-OBJECT-PROP-SNREF")) is not None:
             dop_snref = dop_snref_elem.attrib["SHORT-NAME"]
 
         structure_ref = OdxLinkRef.from_et(et_element.find("STRUCTURE-REF"), doc_frags)
-        structure_snref: Optional[str] = None
+        structure_snref: str | None = None
         if (structure_snref_elem := et_element.find("STRUCTURE-SNREF")) is not None:
             structure_snref = structure_snref_elem.attrib["SHORT-NAME"]
 
@@ -159,8 +159,8 @@ class TableRow(IdentifiableElement):
             **kwargs)
 
     def __post_init__(self) -> None:
-        self._dop: Optional[DataObjectProperty] = None
-        self._structure: Optional[Structure] = None
+        self._dop: DataObjectProperty | None = None
+        self._structure: Structure | None = None
 
         n = sum([0 if x is None else 1 for x in (self.dop_ref, self.dop_snref)])
         odxassert(
@@ -174,7 +174,7 @@ class TableRow(IdentifiableElement):
             f"Table row {self.short_name}: The structure can either be defined using ODXLINK or SNREF but not both."
         )
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = {self.odx_id: self}
 
         for sdg in self.sdgs:
@@ -199,7 +199,7 @@ class TableRow(IdentifiableElement):
 
         if self.dop_ref is not None:
             self._dop = odxlinks.resolve(self.dop_ref)
-            if not isinstance(self._dop, (DataObjectProperty, DtcDop)):
+            if not isinstance(self._dop, DataObjectProperty | DtcDop):
                 odxraise("The DOP-REF of TABLE-ROWs must reference a simple DOP!")
         if self.structure_ref is not None:
             self._structure = odxlinks.resolve(self.structure_ref, Structure)
@@ -243,7 +243,7 @@ class TableRow(IdentifiableElement):
             self._structure = resolve_snref(self.structure_snref, ddd_spec.structures, Structure)
         if self.dop_snref is not None:
             self._dop = resolve_snref(self.dop_snref, ddd_spec.data_object_props)
-            if not isinstance(self._dop, (DataObjectProperty, DtcDop)):
+            if not isinstance(self._dop, DataObjectProperty | DtcDop):
                 odxraise("The DOP-SNREF of TABLE-ROWs must reference a simple DOP!")
 
         if self.audience is not None:
@@ -258,7 +258,7 @@ class TableRow(IdentifiableElement):
         for pc_ref in self.pre_condition_state_refs:
             pc_ref._resolve_snrefs(context)
 
-    def __reduce__(self) -> Tuple[Any, ...]:
+    def __reduce__(self) -> tuple[Any, ...]:
         """This ensures that the object can be correctly reconstructed during unpickling."""
         state = self.__dict__.copy()
         return self.__class__, tuple([getattr(self, x.name) for x in fields(self)]), state

odxtools/tablerowconnector.py

@@ -0,0 +1,46 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any
+from xml.etree import ElementTree
+
+from .element import NamedElement
+from .exceptions import odxrequire
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from .snrefcontext import SnRefContext
+from .table import Table
+from .tablerow import TableRow
+from .utils import dataclass_fields_asdict
+
+
+@dataclass
+class TableRowConnector(NamedElement):
+    table_ref: OdxLinkRef
+    table_row_snref: str
+
+    @property
+    def table(self) -> Table:
+        return self._table
+
+    @property
+    def table_row(self) -> TableRow:
+        return self._table_row
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: list[OdxDocFragment]) -> "TableRowConnector":
+        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
+
+        table_ref = odxrequire(OdxLinkRef.from_et(et_element.find("TABLE-REF"), doc_frags))
+        table_row_snref_el = odxrequire(et_element.find("TABLE-ROW-SNREF"))
+        table_row_snref = odxrequire(table_row_snref_el.get("SHORT-NAME"))
+
+        return TableRowConnector(table_ref=table_ref, table_row_snref=table_row_snref, **kwargs)
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        return {}
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        self._table = odxlinks.resolve(self.table_ref, Table)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        self._table_row = resolve_snref(self.table_row_snref, self._table.table_rows, TableRow)

odxtools/teammember.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
@@ -12,17 +12,17 @@ from .utils import dataclass_fields_asdict
 
 @dataclass
 class TeamMember(IdentifiableElement):
-    roles: List[str]
-    department: Optional[str]
-    address: Optional[str]
-    zipcode: Optional[str]  # the tag for this is "ZIP", but `zip` is a keyword in python
-    city: Optional[str]
-    phone: Optional[str]
-    fax: Optional[str]
-    email: Optional[str]
+    roles: list[str]
+    department: str | None
+    address: str | None
+    zipcode: str | None  # the tag for this is "ZIP", but `zip` is a keyword in python
+    city: str | None
+    phone: str | None
+    fax: str | None
+    email: str | None
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "TeamMember":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "TeamMember":
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
 
         roles = [odxrequire(role_elem.text) for role_elem in et_element.iterfind("ROLES/ROLE")]
@@ -45,7 +45,7 @@ class TeamMember(IdentifiableElement):
             email=email,
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = {self.odx_id: self}
 
         return result

odxtools/templates/macros/printService.xml.jinja2

@@ -8,7 +8,8 @@
 
 {%- macro printPosResponseSuppressible(prs) -%}
 <POS-RESPONSE-SUPPRESSABLE>
-  <BIT-MASK>{{ hex(prs.bit_mask).lower() }}</BIT-MASK>
+  {%- set num_nibbles = (prs.bit_mask.bit_length() + 7) // 8 * 2 %}
+  <BIT-MASK>{{ ("%%0%dX" | format(num_nibbles | int)) | format(prs.bit_mask | int) }}</BIT-MASK>
   {%- if prs.coded_const_snref is not none %}
   <CODED-CONST-SNREF SHORT-NAME="{{ prs.coded_const_snref }}" />
   {%- endif %}

odxtools/termination.py

@@ -0,0 +1,8 @@
+# SPDX-License-Identifier: MIT
+from enum import Enum
+
+
+class Termination(Enum):
+    END_OF_PDU = "END-OF-PDU"
+    ZERO = "ZERO"
+    HEX_FF = "HEX-FF"

odxtools/text.py

@@ -1,5 +1,4 @@
 from dataclasses import dataclass
-from typing import List, Optional
 from xml.etree import ElementTree
 
 from .odxlink import OdxDocFragment
@@ -8,10 +7,10 @@ from .odxlink import OdxDocFragment
 @dataclass
 class Text:
     text: str
-    text_identifier: Optional[str]
+    text_identifier: str | None
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Text":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "Text":
         # Extract the contents of the tag as a string.
         raw_string = et_element.text or ""
         for e in et_element:

odxtools/transmode.py

@@ -0,0 +1,9 @@
+# SPDX-License-Identifier: MIT
+from enum import Enum
+
+
+class TransMode(Enum):
+    SEND_ONLY = "SEND-ONLY"
+    RECEIVE_ONLY = "RECEIVE-ONLY"
+    SEND_AND_RECEIVE = "SEND-AND-RECEIVE"
+    SEND_OR_RECEIVE = "SEND-OR-RECEIVE"

odxtools/uds.py

@@ -1,7 +1,6 @@
 # SPDX-License-Identifier: MIT
 from enum import IntEnum
 from itertools import chain
-from typing import Optional
 
 import odxtools.obd as obd
 
@@ -82,7 +81,7 @@ _sid_to_name = {
 SID = IntEnum("UdsSID", ((i.name, i.value) for i in chain(obd.SID, UDSSID)))  # type: ignore[misc]
 
 
-def sid_to_name(sid: int) -> Optional[str]:
+def sid_to_name(sid: int) -> str | None:
     if sid in _sid_to_name:
         return _sid_to_name[sid]
     elif 0x81 <= sid and sid <= 0x82:
@@ -142,7 +141,7 @@ def negative_response_id(service_id: int) -> int:
     return NegativeResponseId
 
 
-def is_response_pending(telegram_payload: bytes, request_sid: Optional[int] = None) -> bool:
+def is_response_pending(telegram_payload: bytes, request_sid: int | None = None) -> bool:
     # "response pending" responses exhibit at least three bytes
     if len(telegram_payload) < 3:
         return False

odxtools/unit.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
@@ -53,21 +53,21 @@ class Unit(IdentifiableElement):
     ```
     """
     display_name: str
-    factor_si_to_unit: Optional[float]
-    offset_si_to_unit: Optional[float]
-    physical_dimension_ref: Optional[OdxLinkRef]
+    factor_si_to_unit: float | None
+    offset_si_to_unit: float | None
+    physical_dimension_ref: OdxLinkRef | None
 
     @property
-    def physical_dimension(self) -> Optional[PhysicalDimension]:
+    def physical_dimension(self) -> PhysicalDimension | None:
         return self._physical_dimension
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Unit":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "Unit":
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
 
         display_name = odxrequire(et_element.findtext("DISPLAY-NAME"))
 
-        def read_optional_float(element: ElementTree.Element, name: str) -> Optional[float]:
+        def read_optional_float(element: ElementTree.Element, name: str) -> float | None:
             if (elem_str := element.findtext(name)) is not None:
                 return float(elem_str)
             else:
@@ -85,11 +85,11 @@ class Unit(IdentifiableElement):
             physical_dimension_ref=physical_dimension_ref,
             **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:
-        self._physical_dimension: Optional[PhysicalDimension] = None
+        self._physical_dimension: PhysicalDimension | None = None
         if self.physical_dimension_ref:
             self._physical_dimension = odxlinks.resolve(self.physical_dimension_ref,
                                                         PhysicalDimension)

odxtools/unitgroup.py

@@ -1,7 +1,6 @@
 # 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 .element import NamedElement
@@ -10,14 +9,10 @@ from .nameditemlist import NamedItemList
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .snrefcontext import SnRefContext
 from .unit import Unit
+from .unitgroupcategory import UnitGroupCategory
 from .utils import dataclass_fields_asdict
 
 
-class UnitGroupCategory(Enum):
-    COUNTRY = "COUNTRY"
-    EQUIV_UNITS = "EQUIV-UNITS"
-
-
 @dataclass
 class UnitGroup(NamedElement):
     """A group of units.
@@ -25,15 +20,15 @@ class UnitGroup(NamedElement):
     There are two categories of groups: COUNTRY and EQUIV-UNITS.
     """
     category: UnitGroupCategory
-    unit_refs: List[OdxLinkRef]
-    oid: Optional[str]
+    unit_refs: list[OdxLinkRef]
+    oid: str | None
 
     @property
     def units(self) -> NamedItemList[Unit]:
         return self._units
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "UnitGroup":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "UnitGroup":
         kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
 
         category_str = odxrequire(et_element.findtext("CATEGORY"))
@@ -51,7 +46,7 @@ class UnitGroup(NamedElement):
 
         return UnitGroup(category=category, unit_refs=unit_refs, oid=oid, **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:

odxtools/unitgroupcategory.py

@@ -0,0 +1,7 @@
+# SPDX-License-Identifier: MIT
+from enum import Enum
+
+
+class UnitGroupCategory(Enum):
+    COUNTRY = "COUNTRY"
+    EQUIV_UNITS = "EQUIV-UNITS"

odxtools/unitspec.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 .admindata import AdminData
@@ -25,11 +25,11 @@ class UnitSpec:
     The following odx elements are not internalized: ADMIN-DATA, SDGS
     """
 
-    admin_data: Optional[AdminData]
+    admin_data: AdminData | None
     unit_groups: NamedItemList[UnitGroup]
     units: NamedItemList[Unit]
     physical_dimensions: NamedItemList[PhysicalDimension]
-    sdgs: List[SpecialDataGroup]
+    sdgs: list[SpecialDataGroup]
 
     def __post_init__(self) -> None:
         self.unit_groups = NamedItemList(self.unit_groups)
@@ -37,7 +37,7 @@ class UnitSpec:
         self.physical_dimensions = NamedItemList(self.physical_dimensions)
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "UnitSpec":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "UnitSpec":
 
         admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), doc_frags)
         unit_groups = NamedItemList([
@@ -60,8 +60,8 @@ class UnitSpec:
             physical_dimensions=physical_dimensions,
             sdgs=sdgs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
-        odxlinks: Dict[OdxLinkId, Any] = {}
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        odxlinks: dict[OdxLinkId, Any] = {}
         for unit in self.units:
             odxlinks.update(unit._build_odxlinks())
         for dim in self.physical_dimensions:

odxtools/usage.py

@@ -0,0 +1,9 @@
+# SPDX-License-Identifier: MIT
+from enum import Enum
+
+
+class Usage(Enum):
+    ECU_SOFTWARE = "ECU-SOFTWARE"
+    ECU_COMM = "ECU-COMM"
+    APPLICATION = "APPLICATION"
+    TESTER = "TESTER"

odxtools/utils.py

@@ -1,7 +1,10 @@
 # SPDX-License-Identifier: MIT
 import dataclasses
 import re
-from typing import TYPE_CHECKING, Any, Dict, Optional
+from typing import TYPE_CHECKING, Any, Optional
+from xml.etree import ElementTree
+
+from .exceptions import odxraise
 
 if TYPE_CHECKING:
     from .database import Database
@@ -9,6 +12,32 @@ if TYPE_CHECKING:
     from .snrefcontext import SnRefContext
 
 
+def read_hex_binary(et_element: ElementTree.Element | None) -> int | None:
+    """Convert the contents of an xsd:hexBinary to an integer
+    """
+    if et_element is None:
+        return None
+
+    if (bytes_str := et_element.text) is None:
+        # tag exists but is immediately terminated ("<FOO />"). we
+        # treat this like an empty string.
+        return 0
+
+    # The XSD uses the type xsd:hexBinary and xsd:hexBinary allows for
+    # leading/trailing whitespace and empty strings whilst `int(x,
+    # 16)` raises an exception if one of these things happen.
+    bytes_str = bytes_str.strip()
+    if len(bytes_str) == 0:
+        return 0
+
+    try:
+        return int(bytes_str, 16)
+    except Exception as e:
+        odxraise(f"Caught exception while parsing hex string `{bytes_str}`"
+                 f" of {et_element.tag}: {e}")
+        return None
+
+
 def retarget_snrefs(database: "Database",
                     diag_layer: "DiagLayer",
                     context: Optional["SnRefContext"] = None) -> None:
@@ -47,7 +76,7 @@ def retarget_snrefs(database: "Database",
             retarget_snrefs(database, pr.layer, context)
 
 
-def dataclass_fields_asdict(obj: Any) -> Dict[str, Any]:
+def dataclass_fields_asdict(obj: Any) -> dict[str, Any]:
     """Extract all attributes from a dataclass object that are fields.
 
     This is a non-recursive version of `dataclasses.asdict()`. Its

odxtools/validtype.py

@@ -0,0 +1,9 @@
+# SPDX-License-Identifier: MIT
+from enum import Enum
+
+
+class ValidType(Enum):
+    VALID = "VALID"
+    NOT_VALID = "NOT-VALID"
+    NOT_DEFINED = "NOT-DEFINED"
+    NOT_AVAILABLE = "NOT-AVAILABLE"

odxtools/variablegroup.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: MIT
 import typing
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, List, runtime_checkable
+from typing import TYPE_CHECKING, runtime_checkable
 from xml.etree import ElementTree
 
 from .element import IdentifiableElement, NamedElement
@@ -26,7 +26,7 @@ class VariableGroup(IdentifiableElement):
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "VariableGroup":
+                doc_frags: list[OdxDocFragment]) -> "VariableGroup":
         kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
 
         return VariableGroup(**kwargs)

odxtools/variantmatcher.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: MIT
+from collections.abc import Generator
 from copy import copy
 from enum import Enum
-from typing import Dict, Generator, List, Optional, Tuple, Union
 
 from .diaglayers.basevariant import BaseVariant
 from .diaglayers.ecuvariant import EcuVariant
@@ -56,18 +56,18 @@ class VariantMatcher:
         MATCH = 2
 
     def __init__(self,
-                 variant_candidates: Union[List[EcuVariant], List[BaseVariant]],
+                 variant_candidates: list[EcuVariant] | list[BaseVariant],
                  use_cache: bool = True):
 
         self.variant_candidates = variant_candidates
         self.use_cache = use_cache
-        self.req_resp_cache: Dict[bytes, bytes] = {}
-        self._recent_ident_response: Optional[bytes] = None
+        self.req_resp_cache: dict[bytes, bytes] = {}
+        self._recent_ident_response: bytes | None = None
 
         self._state = VariantMatcher.State.PENDING
-        self._matching_variant: Optional[Union[EcuVariant, BaseVariant]] = None
+        self._matching_variant: EcuVariant | BaseVariant | None = None
 
-    def request_loop(self) -> Generator[Tuple[bool, bytes], None, None]:
+    def request_loop(self) -> Generator[tuple[bool, bytes], None, None]:
         """The request loop yielding tuples of byte sequences of
         requests and the whether physical addressing ought to be used
         to send them
@@ -86,7 +86,7 @@ class VariantMatcher:
 
         self._matching_variant = None
         for variant in self.variant_candidates:
-            variant_patterns: Union[List[EcuVariantPattern], List[BaseVariantPattern]]
+            variant_patterns: list[EcuVariantPattern] | list[BaseVariantPattern]
             if isinstance(variant, EcuVariant):
                 variant_patterns = variant.ecu_variant_patterns
             elif isinstance(variant, BaseVariant):
@@ -158,13 +158,13 @@ class VariantMatcher:
         return self._state == VariantMatcher.State.MATCH
 
     @property
-    def matching_variant(self) -> Optional[Union[EcuVariant, BaseVariant]]:
+    def matching_variant(self) -> EcuVariant | BaseVariant | None:
         """Returns the matched, i.e., active ecu variant if such a variant has been found."""
         return self._matching_variant
 
     def _ident_response_matches(
         self,
-        variant: Union[EcuVariant, BaseVariant],
+        variant: EcuVariant | BaseVariant,
         matching_param: MatchingParameter,
         response_bytes: bytes,
     ) -> bool:
@@ -175,7 +175,7 @@ class VariantMatcher:
 
         # ISO 22901 requires that snref or snpathref is resolvable in
         # at least one POS-RESPONSE or NEG-RESPONSE
-        all_responses: List[Response] = []
+        all_responses: list[Response] = []
         all_responses.extend(service.positive_responses)
         all_responses.extend(service.negative_responses)
         all_responses.extend(variant.global_negative_responses)

odxtools/variantpattern.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, List, Union
+from typing import TYPE_CHECKING
 from xml.etree import ElementTree
 
 from .exceptions import odxraise
@@ -26,7 +26,7 @@ class VariantPattern:
     """
 
     def get_matching_parameters(
-            self) -> Union[List["MatchingParameter"], List["MatchingBaseVariantParameter"]]:
+            self) -> list["MatchingParameter"] | list["MatchingBaseVariantParameter"]:
         odxraise(
             f"VariantPattern subclass `{type(self).__name__}` does not "
             f"implement `.get_match_parameters()`", RuntimeError)
@@ -34,5 +34,5 @@ class VariantPattern:
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "VariantPattern":
+                doc_frags: list[OdxDocFragment]) -> "VariantPattern":
         return VariantPattern()

odxtools/version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '9.6.1'
-__version_tuple__ = version_tuple = (9, 6, 1)
+__version__ = version = '10.0.0'
+__version_tuple__ = version_tuple = (10, 0, 0)