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

odxtools/table.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Union
+from dataclasses import dataclass, field
+from typing import Any
 from xml.etree import ElementTree
 
 from .admindata import AdminData
@@ -8,7 +8,8 @@ from .dataobjectproperty import DataObjectProperty
 from .element import IdentifiableElement
 from .exceptions import odxassert
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .snrefcontext import SnRefContext
 from .specialdatagroup import SpecialDataGroup
 from .tablediagcommconnector import TableDiagCommConnector
@@ -16,20 +17,20 @@ from .tablerow import TableRow
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class Table(IdentifiableElement):
     """This class represents a TABLE."""
-    key_label: Optional[str]
-    struct_label: Optional[str]
-    admin_data: Optional[AdminData]
-    key_dop_ref: Optional[OdxLinkRef]
-    table_rows_raw: List[Union[TableRow, OdxLinkRef]]
-    table_diag_comm_connectors: List[TableDiagCommConnector]
-    sdgs: List[SpecialDataGroup]
-    semantic: Optional[str]
+    key_label: str | None = None
+    struct_label: str | None = None
+    admin_data: AdminData | None = None
+    key_dop_ref: OdxLinkRef | None = None
+    table_rows_raw: list[TableRow | OdxLinkRef] = field(default_factory=list)
+    table_diag_comm_connectors: list[TableDiagCommConnector] = field(default_factory=list)
+    sdgs: list[SpecialDataGroup] = field(default_factory=list)
+    semantic: str | None = None
 
     @property
-    def key_dop(self) -> Optional[DataObjectProperty]:
+    def key_dop(self) -> DataObjectProperty | None:
         """The key data object property associated with this table."""
         return self._key_dop
 
@@ -39,31 +40,29 @@ class Table(IdentifiableElement):
         return self._table_rows
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Table":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Table":
         """Reads a TABLE."""
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
         odx_id = kwargs["odx_id"]
         key_label = et_element.findtext("KEY-LABEL")
         struct_label = et_element.findtext("STRUCT-LABEL")
-        admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), doc_frags)
-        key_dop_ref = OdxLinkRef.from_et(et_element.find("KEY-DOP-REF"), doc_frags)
+        admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), context)
+        key_dop_ref = OdxLinkRef.from_et(et_element.find("KEY-DOP-REF"), context)
 
-        table_rows_raw: List[Union[OdxLinkRef, TableRow]] = []
+        table_rows_raw: list[OdxLinkRef | TableRow] = []
         for sub_elem in et_element:
             if sub_elem.tag == "TABLE-ROW":
                 table_rows_raw.append(
                     TableRow.tablerow_from_et(
-                        sub_elem, doc_frags, table_ref=OdxLinkRef.from_id(odx_id)))
+                        sub_elem, context, table_ref=OdxLinkRef.from_id(odx_id)))
             elif sub_elem.tag == "TABLE-ROW-REF":
-                table_rows_raw.append(OdxLinkRef.from_et(sub_elem, doc_frags))
+                table_rows_raw.append(OdxLinkRef.from_et(sub_elem, context))
 
         table_diag_comm_connectors = [
-            TableDiagCommConnector.from_et(dcc_elem, doc_frags) for dcc_elem in et_element.iterfind(
+            TableDiagCommConnector.from_et(dcc_elem, context) for dcc_elem in et_element.iterfind(
                 "TABLE-DIAG-COMM-CONNECTORS/TABLE-DIAG-COMM-CONNECTOR")
         ]
-        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")]
         semantic = et_element.get("SEMANTIC")
 
         return Table(
@@ -77,7 +76,7 @@ class Table(IdentifiableElement):
             semantic=semantic,
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = {self.odx_id: self}
 
         for table_row_wrapper in self.table_rows_raw:
@@ -93,7 +92,7 @@ class Table(IdentifiableElement):
         return result
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        self._key_dop: Optional[DataObjectProperty] = None
+        self._key_dop: DataObjectProperty | None = None
         if self.key_dop_ref is not None:
             self._key_dop = odxlinks.resolve(self.key_dop_ref, DataObjectProperty)
 

odxtools/tablediagcommconnector.py

@@ -1,20 +1,21 @@
 # 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 .diagcomm import DiagComm
 from .exceptions import odxrequire
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from .snrefcontext import SnRefContext
 
 
-@dataclass
+@dataclass(kw_only=True)
 class TableDiagCommConnector:
     semantic: str
 
-    diag_comm_ref: Optional[OdxLinkRef]
-    diag_comm_snref: Optional[str]
+    diag_comm_ref: OdxLinkRef | None = None
+    diag_comm_snref: str | None = None
 
     @property
     def diag_comm(self) -> DiagComm:
@@ -22,11 +23,11 @@ class TableDiagCommConnector:
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "TableDiagCommConnector":
+                context: OdxDocContext) -> "TableDiagCommConnector":
 
         semantic = odxrequire(et_element.findtext("SEMANTIC"))
 
-        diag_comm_ref = OdxLinkRef.from_et(et_element.find("DIAG-COMM-REF"), doc_frags)
+        diag_comm_ref = OdxLinkRef.from_et(et_element.find("DIAG-COMM-REF"), context)
         diag_comm_snref = None
         if (dc_snref_elem := et_element.find("DIAG-COMM-SNREF")) is not None:
             diag_comm_snref = odxrequire(dc_snref_elem.get("SHORT-NAME"))
@@ -34,7 +35,7 @@ class TableDiagCommConnector:
         return TableDiagCommConnector(
             semantic=semantic, diag_comm_ref=diag_comm_ref, diag_comm_snref=diag_comm_snref)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:

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 dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any, cast
 from xml.etree import ElementTree
 
 from .admindata import AdminData
@@ -11,7 +11,8 @@ from .element import IdentifiableElement
 from .exceptions import odxassert, odxraise, odxrequire
 from .functionalclass import FunctionalClass
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from .odxtypes import AtomicOdxType, odxstr_to_bool
 from .preconditionstateref import PreConditionStateRef
 from .snrefcontext import SnRefContext
@@ -24,7 +25,7 @@ if TYPE_CHECKING:
     from .table import Table
 
 
-@dataclass
+@dataclass(kw_only=True)
 class TableRow(IdentifiableElement):
     """This class represents a TABLE-ROW."""
     table_ref: OdxLinkRef
@@ -33,22 +34,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 = None
+    dop_snref: str | None = None
+    structure_ref: OdxLinkRef | None = None
+    structure_snref: str | None = None
+
+    sdgs: list[SpecialDataGroup] = field(default_factory=list)
+    audience: Audience | None = None
+    functional_class_refs: list[OdxLinkRef] = field(default_factory=list)
+    state_transition_refs: list[StateTransitionRef] = field(default_factory=list)
+    pre_condition_state_refs: list[PreConditionStateRef] = field(default_factory=list)
+    admin_data: AdminData | None = None
+
+    is_executable_raw: bool | None = None
+    semantic: str | None = None
+    is_mandatory_raw: bool | None = None
+    is_final_raw: bool | None = None
 
     @property
     def table(self) -> "Table":
@@ -57,16 +58,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,52 +88,50 @@ 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, context: OdxDocContext) -> 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, context: OdxDocContext, *,
                          table_ref: OdxLinkRef) -> "TableRow":
         """Reads a TABLE-ROW."""
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
 
         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_ref = OdxLinkRef.from_et(et_element.find("DATA-OBJECT-PROP-REF"), context)
+        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_ref = OdxLinkRef.from_et(et_element.find("STRUCTURE-REF"), context)
+        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"]
 
-        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")]
 
         audience = None
         if (audience_elem := et_element.find("AUDIENCE")) is not None:
-            audience = Audience.from_et(audience_elem, doc_frags)
+            audience = Audience.from_et(audience_elem, context)
 
         functional_class_refs = [
-            odxrequire(OdxLinkRef.from_et(el, doc_frags))
+            odxrequire(OdxLinkRef.from_et(el, context))
             for el in et_element.iterfind("FUNCT-CLASS-REFS/FUNCT-CLASS-REF")
         ]
 
         state_transition_refs = [
-            StateTransitionRef.from_et(el, doc_frags)
+            StateTransitionRef.from_et(el, context)
             for el in et_element.iterfind("STATE-TRANSITION-REFS/STATE-TRANSITION-REF")
         ]
 
         pre_condition_state_refs = [
-            PreConditionStateRef.from_et(el, doc_frags)
+            PreConditionStateRef.from_et(el, context)
             for el in et_element.iterfind("PRE-CONDITION-STATE-REFS/PRE-CONDITION-STATE-REF")
         ]
 
-        admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), doc_frags)
+        admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), context)
 
         is_executable_raw = odxstr_to_bool(et_element.attrib.get("IS-EXECUTABLE"))
         semantic = et_element.attrib.get("SEMANTIC")
@@ -159,8 +158,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 +173,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:
@@ -258,7 +257,29 @@ 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
+        return _reconstruct_tablerow, (self.__class__, state)
+
+    def __setstate__(self, state: dict[str, Any]) -> None:
+        """
+        Restore the object's internal state.
+
+        This method is called during the unpickling, it updates
+        the instance's __dict__ with the saved state.
+        """
+        self.__dict__.update(state)
+
+
+def _reconstruct_tablerow(cls: Any, state: dict[str, Any]) -> TableRow:
+    """
+    Reconstruct a TableRow instance from pickled state.
+
+    This function is used during unpickling to bypass the `__init__`
+    constructor, which would normally enforce `kw_only=True` arguments.
+    Instead, it creates an uninitialized object and restores its state.
+    """
+    obj = cls.__new__(cls)
+    obj.__setstate__(state)
+    return cast(TableRow, obj)

odxtools/tablerowconnector.py

@@ -1,18 +1,19 @@
 # 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
 from .exceptions import odxrequire
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from .snrefcontext import SnRefContext
 from .table import Table
 from .tablerow import TableRow
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class TableRowConnector(NamedElement):
     table_ref: OdxLinkRef
     table_row_snref: str
@@ -26,17 +27,16 @@ class TableRowConnector(NamedElement):
         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))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "TableRowConnector":
+        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, context))
 
-        table_ref = odxrequire(OdxLinkRef.from_et(et_element.find("TABLE-REF"), doc_frags))
+        table_ref = odxrequire(OdxLinkRef.from_et(et_element.find("TABLE-REF"), context))
         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]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:

odxtools/teammember.py

@@ -1,29 +1,30 @@
 # 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 .element import IdentifiableElement
 from .exceptions import odxrequire
-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 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] = field(default_factory=list)
+    department: str | None = None
+    address: str | None = None
+    zipcode: str | None = None  # the tag for this is "ZIP", but `zip` is a keyword in python
+    city: str | None = None
+    phone: str | None = None
+    fax: str | None = None
+    email: str | None = None
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "TeamMember":
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "TeamMember":
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
 
         roles = [odxrequire(role_elem.text) for role_elem in et_element.iterfind("ROLES/ROLE")]
         department = et_element.findtext("DEPARTMENT")
@@ -45,7 +46,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/printParentRef.xml.jinja2

@@ -5,8 +5,10 @@
 
 {%- macro printParentRef(par) -%}
 <PARENT-REF ID-REF="{{par.layer.odx_id.local_id}}"
-            DOCREF="{{get_parent_container_name(par.layer.short_name)}}"
+{%- if par.layer_ref.ref_docs|length == 1 %}
+            DOCREF="{{par.layer_ref.ref_docs[0].doc_name}}"
             DOCTYPE="CONTAINER"
+{%- endif %}
             xsi:type="{{par.layer.variant_type.value}}-REF">
 {%- if par.not_inherited_diag_comms %}
  <NOT-INHERITED-DIAG-COMMS>

odxtools/text.py

@@ -1,17 +1,16 @@
 from dataclasses import dataclass
-from typing import List, Optional
 from xml.etree import ElementTree
 
-from .odxlink import OdxDocFragment
+from .odxdoccontext import OdxDocContext
 
 
-@dataclass
+@dataclass(kw_only=True)
 class Text:
     text: str
-    text_identifier: Optional[str]
+    text_identifier: str | None = None
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Text":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "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,17 +1,18 @@
 # 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
 from .exceptions import odxrequire
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .physicaldimension import PhysicalDimension
 from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class Unit(IdentifiableElement):
     """
     A unit consists of an ID, short name and a display name.
@@ -53,21 +54,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 = None
+    offset_si_to_unit: float | None = None
+    physical_dimension_ref: OdxLinkRef | None = 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":
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Unit":
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
 
         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:
@@ -76,7 +77,7 @@ class Unit(IdentifiableElement):
         factor_si_to_unit = read_optional_float(et_element, "FACTOR-SI-TO-UNIT")
         offset_si_to_unit = read_optional_float(et_element, "OFFSET-SI-TO-UNIT")
         physical_dimension_ref = OdxLinkRef.from_et(
-            et_element.find("PHYSICAL-DIMENSION-REF"), doc_frags)
+            et_element.find("PHYSICAL-DIMENSION-REF"), context)
 
         return Unit(
             display_name=display_name,
@@ -85,11 +86,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,35 +1,36 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, cast
+from dataclasses import dataclass, field
+from typing import Any, cast
 from xml.etree import ElementTree
 
 from .element import NamedElement
 from .exceptions import odxraise, odxrequire
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .snrefcontext import SnRefContext
 from .unit import Unit
 from .unitgroupcategory import UnitGroupCategory
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class UnitGroup(NamedElement):
     """A group of units.
 
     There are two categories of groups: COUNTRY and EQUIV-UNITS.
     """
     category: UnitGroupCategory
-    unit_refs: List[OdxLinkRef]
-    oid: Optional[str]
+    unit_refs: list[OdxLinkRef] = field(default_factory=list)
+    oid: str | None = None
 
     @property
     def units(self) -> NamedItemList[Unit]:
         return self._units
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "UnitGroup":
-        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "UnitGroup":
+        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, context))
 
         category_str = odxrequire(et_element.findtext("CATEGORY"))
         try:
@@ -39,14 +40,14 @@ class UnitGroup(NamedElement):
             odxraise(f"Encountered unknown unit group category '{category_str}'")
 
         unit_refs = [
-            odxrequire(OdxLinkRef.from_et(el, doc_frags))
+            odxrequire(OdxLinkRef.from_et(el, context))
             for el in et_element.iterfind("UNIT-REFS/UNIT-REF")
         ]
         oid = et_element.get("OID")
 
         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: