odxtools 9.7.0__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

@@ -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 NamedElement
@@ -27,7 +27,7 @@ class TableRowConnector(NamedElement):
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "TableRowConnector":
+                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))
@@ -36,7 +36,7 @@ class TableRowConnector(NamedElement):
 
         return TableRowConnector(table_ref=table_ref, table_row_snref=table_row_snref, **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:

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/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/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,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 NamedElement
@@ -20,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"))
@@ -46,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/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/utils.py

@@ -1,7 +1,7 @@
 # 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
@@ -12,7 +12,7 @@ if TYPE_CHECKING:
     from .snrefcontext import SnRefContext
 
 
-def read_hex_binary(et_element: Optional[ElementTree.Element]) -> Optional[int]:
+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:
@@ -76,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/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.7.0'
-__version_tuple__ = version_tuple = (9, 7, 0)
+__version__ = version = '10.0.0'
+__version_tuple__ = version_tuple = (10, 0, 0)

odxtools/writepdxfile.py

@@ -5,7 +5,7 @@ import mimetypes
 import os
 import time
 import zipfile
-from typing import Any, Dict, Optional
+from typing import Any
 
 import jinja2
 
@@ -14,7 +14,7 @@ import odxtools
 from .database import Database
 from .odxtypes import bool_to_odxstr
 
-odxdatabase: Optional[Database] = None
+odxdatabase: Database | None = None
 
 
 def jinja2_odxraise_helper(msg: str) -> None:
@@ -39,14 +39,14 @@ def get_parent_container_name(dl_short_name: str) -> str:
                        f"container for diagnostic layer '{dl_short_name}'.")
 
 
-def make_xml_attrib(attrib_name: str, attrib_val: Optional[Any]) -> str:
+def make_xml_attrib(attrib_name: str, attrib_val: Any | None) -> str:
     if attrib_val is None:
         return ""
 
     return f' {attrib_name}="{attrib_val}"'
 
 
-def make_bool_xml_attrib(attrib_name: str, attrib_val: Optional[bool]) -> str:
+def make_bool_xml_attrib(attrib_name: str, attrib_val: bool | None) -> str:
     if attrib_val is None:
         return ""
 
@@ -147,7 +147,7 @@ def write_pdx_file(
         jinja_env.globals["make_bool_xml_attrib"] = make_bool_xml_attrib
         jinja_env.globals["get_parent_container_name"] = get_parent_container_name
 
-        vars: Dict[str, Any] = {}
+        vars: dict[str, Any] = {}
         vars["odxtools_version"] = odxtools.__version__
         vars["database"] = database
 

odxtools/xdoc.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 NamedElement
@@ -11,15 +11,15 @@ from .utils import dataclass_fields_asdict
 
 @dataclass
 class XDoc(NamedElement):
-    number: Optional[str]
-    state: Optional[str]
-    date: Optional[str]
-    publisher: Optional[str]
-    url: Optional[str]
-    position: Optional[str]
+    number: str | None
+    state: str | None
+    date: str | None
+    publisher: str | None
+    url: str | None
+    position: str | None
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "XDoc":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "XDoc":
         kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
         number = et_element.findtext("NUMBER")
         state = et_element.findtext("STATE")
@@ -37,7 +37,7 @@ class XDoc(NamedElement):
             position=position,
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:

{odxtools-9.7.0.dist-info → odxtools-10.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: odxtools
-Version: 9.7.0
+Version: 10.0.0
 Summary: Utilities to work with the ODX standard for automotive diagnostics
 Author-email: Katrin Bauer <katrin.bauer@mbition.io>, Andreas Lauser <andreas.lauser@mbition.io>, Ayoub Kaanich <kayoub5@live.com>
 Maintainer-email: Andreas Lauser <andreas.lauser@mbition.io>, Ayoub Kaanich <kayoub5@live.com>
@@ -10,16 +10,16 @@ Project-URL: Bug Tracker, https://github.com/mercedes-benz/odxtools/issues
 Project-URL: Repository, https://github.com/mercedes-benz/odxtools
 Keywords: can,can bus,DoIP,odx,pdx,obd,uds,automotive,diagnostics
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: bitstruct>=8.17
@@ -35,7 +35,6 @@ Provides-Extra: browse-tool
 Requires-Dist: InquirerPy>=0.3.4; extra == "browse-tool"
 Provides-Extra: test
 Requires-Dist: mypy>=1.5; extra == "test"
-Requires-Dist: types-tabulate>=0.9.0.3; extra == "test"
 Requires-Dist: ruff>=0.0.290; extra == "test"
 Requires-Dist: pytest>=7.4; extra == "test"
 Requires-Dist: coverage>=7.3; extra == "test"