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

odxtools/unitspec.py

@@ -1,11 +1,12 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
+from dataclasses import dataclass, field
+from typing import Any
 from xml.etree import ElementTree
 
 from .admindata import AdminData
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
 from .physicaldimension import PhysicalDimension
 from .snrefcontext import SnRefContext
 from .specialdatagroup import SpecialDataGroup
@@ -13,7 +14,7 @@ from .unit import Unit
 from .unitgroup import UnitGroup
 
 
-@dataclass
+@dataclass(kw_only=True)
 class UnitSpec:
     """
     A unit spec encapsulates three lists:
@@ -25,11 +26,11 @@ class UnitSpec:
     The following odx elements are not internalized: ADMIN-DATA, SDGS
     """
 
-    admin_data: Optional[AdminData]
-    unit_groups: NamedItemList[UnitGroup]
-    units: NamedItemList[Unit]
-    physical_dimensions: NamedItemList[PhysicalDimension]
-    sdgs: List[SpecialDataGroup]
+    admin_data: AdminData | None = None
+    unit_groups: NamedItemList[UnitGroup] = field(default_factory=NamedItemList)
+    units: NamedItemList[Unit] = field(default_factory=NamedItemList)
+    physical_dimensions: NamedItemList[PhysicalDimension] = field(default_factory=NamedItemList)
+    sdgs: list[SpecialDataGroup] = field(default_factory=list)
 
     def __post_init__(self) -> None:
         self.unit_groups = NamedItemList(self.unit_groups)
@@ -37,21 +38,19 @@ 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, context: OdxDocContext) -> "UnitSpec":
 
-        admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), doc_frags)
+        admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), context)
         unit_groups = NamedItemList([
-            UnitGroup.from_et(el, doc_frags) for el in et_element.iterfind("UNIT-GROUPS/UNIT-GROUP")
+            UnitGroup.from_et(el, context) for el in et_element.iterfind("UNIT-GROUPS/UNIT-GROUP")
         ])
         units = NamedItemList(
-            [Unit.from_et(el, doc_frags) for el in et_element.iterfind("UNITS/UNIT")])
+            [Unit.from_et(el, context) for el in et_element.iterfind("UNITS/UNIT")])
         physical_dimensions = NamedItemList([
-            PhysicalDimension.from_et(el, doc_frags)
+            PhysicalDimension.from_et(el, context)
             for el in et_element.iterfind("PHYSICAL-DIMENSIONS/PHYSICAL-DIMENSION")
         ])
-        sdgs = [
-            SpecialDataGroup.from_et(sdge, doc_frags) for sdge in et_element.iterfind("SDGS/SDG")
-        ]
+        sdgs = [SpecialDataGroup.from_et(sdge, context) for sdge in et_element.iterfind("SDGS/SDG")]
 
         return UnitSpec(
             admin_data=admin_data,
@@ -60,8 +59,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,12 +1,12 @@
 # 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
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment
+from .odxdoccontext import OdxDocContext
 from .utils import dataclass_fields_asdict
 
 if TYPE_CHECKING:
@@ -21,12 +21,11 @@ class HasVariableGroups(typing.Protocol):
         ...
 
 
-@dataclass
+@dataclass(kw_only=True)
 class VariableGroup(IdentifiableElement):
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "VariableGroup":
-        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "VariableGroup":
+        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, context))
 
         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,18 +1,18 @@
 # 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
 from .matchingparameter import MatchingParameter
-from .odxlink import OdxDocFragment
+from .odxdoccontext import OdxDocContext
 
 if TYPE_CHECKING:
     from .matchingbasevariantparameter import MatchingBaseVariantParameter
     from .matchingparameter import MatchingParameter
 
 
-@dataclass
+@dataclass(kw_only=True)
 class VariantPattern:
     """Variant patterns are used to identify the concrete variant of an ECU
 
@@ -26,13 +26,12 @@ 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)
         return []
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "VariantPattern":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "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.1.0'
+__version_tuple__ = version_tuple = (10, 1, 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,39 +14,21 @@ 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:
     raise Exception(msg)
 
 
-def get_parent_container_name(dl_short_name: str) -> str:
-    """
-    Given the short name of a diagnostic layer, return the name of a container
-    which the layer is part of.
-
-    If no such container exists, a `RuntimeException` is thrown.
-    """
-
-    assert odxdatabase is not None
-
-    for dlc in odxdatabase.diag_layer_containers:
-        if dl_short_name in [dl.short_name for dl in dlc.diag_layers]:
-            return dlc.short_name
-
-    raise RuntimeError(f"get_parent_container_name() could not determine a "
-                       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 ""
 
@@ -145,9 +127,8 @@ def write_pdx_file(
         jinja_env.globals["odxraise"] = jinja2_odxraise_helper
         jinja_env.globals["make_xml_attrib"] = make_xml_attrib
         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,26 +1,27 @@
 # 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
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
 from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class XDoc(NamedElement):
-    number: Optional[str]
-    state: Optional[str]
-    date: Optional[str]
-    publisher: Optional[str]
-    url: Optional[str]
-    position: Optional[str]
+    number: str | None = None
+    state: str | None = None
+    date: str | None = None
+    publisher: str | None = None
+    url: str | None = None
+    position: str | None = None
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "XDoc":
-        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "XDoc":
+        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, context))
         number = et_element.findtext("NUMBER")
         state = et_element.findtext("STATE")
         date = et_element.findtext("DATE")
@@ -37,7 +38,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.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: odxtools
-Version: 9.7.0
+Version: 10.1.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"