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

odxtools/subcomponent.py

@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Any
 from xml.etree import ElementTree
 
@@ -7,7 +7,8 @@ from .dtcconnector import DtcConnector
 from .element import IdentifiableElement
 from .envdataconnector import EnvDataConnector
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
 from .snrefcontext import SnRefContext
 from .subcomponentparamconnector import SubComponentParamConnector
 from .subcomponentpattern import SubComponentPattern
@@ -15,7 +16,7 @@ from .tablerowconnector import TableRowConnector
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class SubComponent(IdentifiableElement):
     """Sub-components describe collections of related diagnostic variables
 
@@ -25,38 +26,39 @@ class SubComponent(IdentifiableElement):
 
     """
 
-    sub_component_patterns: list[SubComponentPattern]
-    sub_component_param_connectors: NamedItemList[SubComponentParamConnector]
-    table_row_connectors: NamedItemList[TableRowConnector]
-    env_data_connectors: NamedItemList[EnvDataConnector]
-    dtc_connectors: NamedItemList[DtcConnector]
+    sub_component_patterns: list[SubComponentPattern] = field(default_factory=list)
+    sub_component_param_connectors: NamedItemList[SubComponentParamConnector] = field(
+        default_factory=NamedItemList)
+    table_row_connectors: NamedItemList[TableRowConnector] = field(default_factory=NamedItemList)
+    env_data_connectors: NamedItemList[EnvDataConnector] = field(default_factory=NamedItemList)
+    dtc_connectors: NamedItemList[DtcConnector] = field(default_factory=NamedItemList)
 
-    semantic: str | None
+    semantic: str | None = None
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "SubComponent":
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "SubComponent":
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
 
         semantic = et_element.get("SEMANTIC")
 
         sub_component_patterns = [
-            SubComponentPattern.from_et(el, doc_frags)
+            SubComponentPattern.from_et(el, context)
             for el in et_element.iterfind("SUB-COMPONENT-PATTERNS/SUB-COMPONENT-PATTERN")
         ]
         sub_component_param_connectors = [
-            SubComponentParamConnector.from_et(el, doc_frags) for el in et_element.iterfind(
+            SubComponentParamConnector.from_et(el, context) for el in et_element.iterfind(
                 "SUB-COMPONENT-PARAM-CONNECTORS/SUB-COMPONENT-PARAM-CONNECTOR")
         ]
         table_row_connectors = [
-            TableRowConnector.from_et(el, doc_frags)
+            TableRowConnector.from_et(el, context)
             for el in et_element.iterfind("TABLE-ROW-CONNECTORS/TABLE-ROW-CONNECTOR")
         ]
         env_data_connectors = [
-            EnvDataConnector.from_et(el, doc_frags)
+            EnvDataConnector.from_et(el, context)
             for el in et_element.iterfind("ENV-DATA-CONNECTORS/ENV-DATA-CONNECTOR")
         ]
         dtc_connectors = [
-            DtcConnector.from_et(el, doc_frags)
+            DtcConnector.from_et(el, context)
             for el in et_element.iterfind("DTC-CONNECTORS/DTC-CONNECTOR")
         ]
 

odxtools/subcomponentparamconnector.py

@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Any
 from xml.etree import ElementTree
 
@@ -7,19 +7,20 @@ from .diagservice import DiagService
 from .element import IdentifiableElement
 from .exceptions import odxassert, odxraise, odxrequire
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, resolve_snref
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, resolve_snref
 from .parameters.parameter import Parameter
 from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class SubComponentParamConnector(IdentifiableElement):
     diag_comm_snref: str
 
     # TODO: we currently only support SNREFs, not SNPATHREFs
-    out_param_if_refs: list[str]
-    in_param_if_refs: list[str]
+    out_param_if_refs: list[str] = field(default_factory=list)
+    in_param_if_refs: list[str] = field(default_factory=list)
 
     @property
     def service(self) -> DiagService:
@@ -35,8 +36,8 @@ class SubComponentParamConnector(IdentifiableElement):
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "SubComponentParamConnector":
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+                context: OdxDocContext) -> "SubComponentParamConnector":
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
 
         diag_comm_snref = odxrequire(
             odxrequire(et_element.find("DIAG-COMM-SNREF")).get("SHORT-NAME"))

odxtools/subcomponentpattern.py

@@ -1,26 +1,26 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any
 from xml.etree import ElementTree
 
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
 from .snrefcontext import SnRefContext
 
 if TYPE_CHECKING:
     from .matchingparameter import MatchingParameter
 
 
-@dataclass
+@dataclass(kw_only=True)
 class SubComponentPattern:
-    matching_parameters: list["MatchingParameter"]
+    matching_parameters: list["MatchingParameter"] = field(default_factory=list)
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "SubComponentPattern":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "SubComponentPattern":
         from .matchingparameter import MatchingParameter
 
         matching_parameters = [
-            MatchingParameter.from_et(el, doc_frags)
+            MatchingParameter.from_et(el, context)
             for el in et_element.iterfind("MATCHING-PARAMETERS/MATCHING-PARAMETER")
         ]
 

odxtools/swvariable.py

@@ -3,18 +3,18 @@ from dataclasses import dataclass
 from xml.etree import ElementTree
 
 from .element import NamedElement
-from .odxlink import OdxDocFragment
+from .odxdoccontext import OdxDocContext
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class SwVariable(NamedElement):
-    origin: str | None
-    oid: str | None
+    origin: str | None = None
+    oid: str | None = None
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "SwVariable":
-        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "SwVariable":
+        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, context))
 
         origin = et_element.findtext("ORIGIN")
         oid = et_element.attrib.get("OID")

odxtools/table.py

@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Any
 from xml.etree import ElementTree
 
@@ -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,17 +17,17 @@ 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: str | None
-    struct_label: str | None
-    admin_data: AdminData | None
-    key_dop_ref: OdxLinkRef | None
-    table_rows_raw: list[TableRow | OdxLinkRef]
-    table_diag_comm_connectors: list[TableDiagCommConnector]
-    sdgs: list[SpecialDataGroup]
-    semantic: str | None
+    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) -> DataObjectProperty | None:
@@ -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[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(

odxtools/tablediagcommconnector.py

@@ -5,16 +5,17 @@ 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: OdxLinkRef | None
-    diag_comm_snref: str | None
+    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"))

odxtools/tablerow.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass, fields
-from typing import TYPE_CHECKING, Any
+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: 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
+    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":
@@ -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_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_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")
@@ -199,7 +198,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 +242,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:
@@ -261,4 +260,26 @@ class TableRow(IdentifiableElement):
     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

@@ -5,14 +5,15 @@ 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,11 +27,10 @@ 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"))
 

odxtools/teammember.py

@@ -1,29 +1,30 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
+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: 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
+    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")

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,16 +1,16 @@
 from dataclasses import dataclass
 from xml.etree import ElementTree
 
-from .odxlink import OdxDocFragment
+from .odxdoccontext import OdxDocContext
 
 
-@dataclass
+@dataclass(kw_only=True)
 class Text:
     text: str
-    text_identifier: str | None
+    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/unit.py

@@ -5,13 +5,14 @@ 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,17 +54,17 @@ class Unit(IdentifiableElement):
     ```
     """
     display_name: str
-    factor_si_to_unit: float | None
-    offset_si_to_unit: float | None
-    physical_dimension_ref: OdxLinkRef | None
+    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) -> 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"))
 
@@ -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,