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

odxtools/dynenddopref.py

@@ -4,34 +4,34 @@ from typing import Optional, overload
 from xml.etree import ElementTree
 
 from .exceptions import odxraise, odxrequire
-from .odxlink import OdxDocFragment, OdxLinkRef
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkRef
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class DynEndDopRef(OdxLinkRef):
     termination_value_raw: str
 
     @staticmethod
     @overload
-    def from_et(et_element: None, source_doc_frags: list[OdxDocFragment]) -> None:
+    def from_et(et_element: None, context: OdxDocContext) -> None:
         ...
 
     @staticmethod
     @overload
-    def from_et(et_element: ElementTree.Element,
-                source_doc_frags: list[OdxDocFragment]) -> "DynEndDopRef":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "DynEndDopRef":
         ...
 
     @staticmethod
     def from_et(et_element: ElementTree.Element | None,
-                source_doc_frags: list[OdxDocFragment]) -> Optional["DynEndDopRef"]:
+                context: OdxDocContext) -> Optional["DynEndDopRef"]:
 
         if et_element is None:
             odxraise("Mandatory DYN-END-DOP-REF tag is missing")
             return None
 
-        kwargs = dataclass_fields_asdict(OdxLinkRef.from_et(et_element, source_doc_frags))
+        kwargs = dataclass_fields_asdict(OdxLinkRef.from_et(et_element, context))
 
         termination_value_raw = odxrequire(et_element.findtext("TERMINATION-VALUE"))
 

odxtools/dyniddefmodeinfo.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,26 +7,27 @@ from .diagclasstype import DiagClassType
 from .diagcomm import DiagComm
 from .exceptions import odxassert, odxraise, odxrequire
 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 .snrefcontext import SnRefContext
 from .table import Table
 
 
-@dataclass
+@dataclass(kw_only=True)
 class DynIdDefModeInfo:
     def_mode: str
 
-    clear_dyn_def_message_ref: OdxLinkRef | None
-    clear_dyn_def_message_snref: str | None
+    clear_dyn_def_message_ref: OdxLinkRef | None = None
+    clear_dyn_def_message_snref: str | None = None
 
-    read_dyn_def_message_ref: OdxLinkRef | None
-    read_dyn_def_message_snref: str | None
+    read_dyn_def_message_ref: OdxLinkRef | None = None
+    read_dyn_def_message_snref: str | None = None
 
-    dyn_def_message_ref: OdxLinkRef | None
-    dyn_def_message_snref: str | None
+    dyn_def_message_ref: OdxLinkRef | None = None
+    dyn_def_message_snref: str | None = None
 
-    supported_dyn_ids: list[bytes]
-    selection_table_refs: list[OdxLinkRef | str]
+    supported_dyn_ids: list[bytes] = field(default_factory=list)
+    selection_table_refs: list[OdxLinkRef | str] = field(default_factory=list)
 
     @property
     def clear_dyn_def_message(self) -> DiagComm:
@@ -45,23 +46,22 @@ class DynIdDefModeInfo:
         return self._selection_tables
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "DynIdDefModeInfo":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "DynIdDefModeInfo":
         def_mode = odxrequire(et_element.findtext("DEF-MODE"))
 
         clear_dyn_def_message_ref = OdxLinkRef.from_et(
-            et_element.find("CLEAR-DYN-DEF-MESSAGE-REF"), doc_frags)
+            et_element.find("CLEAR-DYN-DEF-MESSAGE-REF"), context)
         clear_dyn_def_message_snref = None
         if (snref_elem := et_element.find("CLEAR-DYN-DEF-MESSAGE-SNREF")) is not None:
             clear_dyn_def_message_snref = odxrequire(snref_elem.attrib.get("SHORT-NAME"))
 
         read_dyn_def_message_ref = OdxLinkRef.from_et(
-            et_element.find("READ-DYN-DEF-MESSAGE-REF"), doc_frags)
+            et_element.find("READ-DYN-DEF-MESSAGE-REF"), context)
         read_dyn_def_message_snref = None
         if (snref_elem := et_element.find("READ-DYN-DEF-MESSAGE-SNREF")) is not None:
             read_dyn_def_message_snref = odxrequire(snref_elem.attrib.get("SHORT-NAME"))
 
-        dyn_def_message_ref = OdxLinkRef.from_et(et_element.find("DYN-DEF-MESSAGE-REF"), doc_frags)
+        dyn_def_message_ref = OdxLinkRef.from_et(et_element.find("DYN-DEF-MESSAGE-REF"), context)
         dyn_def_message_snref = None
         if (snref_elem := et_element.find("DYN-DEF-MESSAGE-SNREF")) is not None:
             dyn_def_message_snref = odxrequire(snref_elem.attrib.get("SHORT-NAME"))
@@ -75,7 +75,7 @@ class DynIdDefModeInfo:
         if (st_elems := et_element.find("SELECTION-TABLE-REFS")) is not None:
             for st_elem in st_elems:
                 if st_elem.tag == "SELECTION-TABLE-REF":
-                    selection_table_refs.append(OdxLinkRef.from_et(st_elem, doc_frags))
+                    selection_table_refs.append(OdxLinkRef.from_et(st_elem, context))
                 elif st_elem.tag == "SELECTION-TABLE-SNREF":
                     selection_table_refs.append(odxrequire(st_elem.get("SHORT-NAME")))
                 else:

odxtools/ecuvariantpattern.py

@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -7,16 +7,16 @@ from typing_extensions import override
 from .exceptions import odxassert
 from .matchingbasevariantparameter import MatchingBaseVariantParameter
 from .matchingparameter import MatchingParameter
-from .odxlink import OdxDocFragment
+from .odxdoccontext import OdxDocContext
 from .variantpattern import VariantPattern
 
 
-@dataclass
+@dataclass(kw_only=True)
 class EcuVariantPattern(VariantPattern):
     """ECU variant patterns are variant patterns used to identify the
     concrete variant of an ECU.
     """
-    matching_parameters: list[MatchingParameter]
+    matching_parameters: list[MatchingParameter] = field(default_factory=list)
 
     @override
     def get_matching_parameters(self
@@ -24,11 +24,10 @@ class EcuVariantPattern(VariantPattern):
         return self.matching_parameters
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "EcuVariantPattern":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "EcuVariantPattern":
 
         matching_parameters = [
-            MatchingParameter.from_et(mp_el, doc_frags)
+            MatchingParameter.from_et(mp_el, context)
             for mp_el in et_element.iterfind("MATCHING-PARAMETERS/"
                                              "MATCHING-PARAMETER")
         ]

odxtools/element.py

@@ -3,38 +3,38 @@ from xml.etree import ElementTree
 
 from .description import Description
 from .exceptions import odxrequire
-from .odxlink import OdxDocFragment, OdxLinkId
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkId
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class NamedElement:
     short_name: str
-    long_name: str | None
-    description: Description | None
+    long_name: str | None = None
+    description: Description | None = None
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "NamedElement":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "NamedElement":
 
         return NamedElement(
             short_name=odxrequire(et_element.findtext("SHORT-NAME")),
             long_name=et_element.findtext("LONG-NAME"),
-            description=Description.from_et(et_element.find("DESC"), doc_frags),
+            description=Description.from_et(et_element.find("DESC"), context),
         )
 
 
-@dataclass
+@dataclass(kw_only=True)
 class IdentifiableElement(NamedElement):
     odx_id: OdxLinkId
-    oid: str | None
+    oid: str | None = None
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "IdentifiableElement":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "IdentifiableElement":
 
-        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, context))
 
-        odx_id = odxrequire(OdxLinkId.from_et(et_element, doc_frags))
+        odx_id = odxrequire(OdxLinkId.from_et(et_element, context))
         oid = et_element.get("OID")
 
         return IdentifiableElement(**kwargs, odx_id=odx_id, oid=oid)

odxtools/endofpdufield.py

@@ -9,21 +9,20 @@ from .decodestate import DecodeState
 from .encodestate import EncodeState
 from .exceptions import EncodeError, odxassert, odxraise
 from .field import Field
-from .odxlink import OdxDocFragment
+from .odxdoccontext import OdxDocContext
 from .odxtypes import ParameterValue
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class EndOfPduField(Field):
     """End of PDU fields are structures that are repeated until the end of the PDU"""
-    max_number_of_items: int | None
-    min_number_of_items: int | None
+    max_number_of_items: int | None = None
+    min_number_of_items: int | None = None
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "EndOfPduField":
-        kwargs = dataclass_fields_asdict(Field.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "EndOfPduField":
+        kwargs = dataclass_fields_asdict(Field.from_et(et_element, context))
 
         if (max_n_str := et_element.findtext("MAX-NUMBER-OF-ITEMS")) is not None:
             max_number_of_items = int(max_n_str)

odxtools/envdataconnector.py

@@ -7,12 +7,13 @@ from .element import NamedElement
 from .environmentdata import EnvironmentData
 from .environmentdatadescription import EnvironmentDataDescription
 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 .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class EnvDataConnector(NamedElement):
     env_data_desc_ref: OdxLinkRef
     env_data_snref: str
@@ -26,12 +27,11 @@ class EnvDataConnector(NamedElement):
         return self._env_data
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "EnvDataConnector":
-        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "EnvDataConnector":
+        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, context))
 
         env_data_desc_ref = odxrequire(
-            OdxLinkRef.from_et(et_element.find("ENV-DATA-DESC-REF"), doc_frags))
+            OdxLinkRef.from_et(et_element.find("ENV-DATA-DESC-REF"), context))
         env_data_snref_el = odxrequire(et_element.find("ENV-DATA-SNREF"))
         env_data_snref = odxrequire(env_data_snref_el.get("SHORT-NAME"))
 

odxtools/environmentdata.py

@@ -1,14 +1,14 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from xml.etree import ElementTree
 
 from .basicstructure import BasicStructure
 from .exceptions import odxrequire
-from .odxlink import OdxDocFragment
+from .odxdoccontext import OdxDocContext
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class EnvironmentData(BasicStructure):
     """This class represents Environment Data that describes the
     circumstances in which the error occurred.
@@ -19,14 +19,13 @@ class EnvironmentData(BasicStructure):
     sense, it is quite similar to NRC-CONST parameters.)
     """
 
-    all_value: bool | None
-    dtc_values: list[int]
+    all_value: bool | None = None
+    dtc_values: list[int] = field(default_factory=list)
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "EnvironmentData":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "EnvironmentData":
         """Reads Environment Data from Diag Layer."""
-        kwargs = dataclass_fields_asdict(BasicStructure.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(BasicStructure.from_et(et_element, context))
 
         all_value_elem = et_element.find("ALL-VALUE")
         all_value = None if all_value_elem is None else True

odxtools/environmentdatadescription.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
 
@@ -13,7 +13,8 @@ from .encodestate import EncodeState
 from .environmentdata import EnvironmentData
 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 .odxtypes import DataType, ParameterValue, ParameterValueDict
 from .parameters.codedconstparameter import CodedConstParameter
 from .parameters.parameter import Parameter
@@ -24,7 +25,7 @@ from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class EnvironmentDataDescription(ComplexDop):
     """This class represents environment data descriptions
 
@@ -35,20 +36,20 @@ class EnvironmentDataDescription(ComplexDop):
 
     """
 
-    param_snref: str | None
-    param_snpathref: str | None
+    param_snref: str | None = None
+    param_snpathref: str | None = None
 
     # in ODX 2.0.0, ENV-DATAS seems to be a mandatory
     # sub-element of ENV-DATA-DESC, in ODX 2.2 it is not
     # present
-    env_datas: NamedItemList[EnvironmentData]
-    env_data_refs: list[OdxLinkRef]
+    env_datas: NamedItemList[EnvironmentData] = field(default_factory=NamedItemList)
+    env_data_refs: list[OdxLinkRef] = field(default_factory=list)
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "EnvironmentDataDescription":
+                context: OdxDocContext) -> "EnvironmentDataDescription":
         """Reads Environment Data Description from Diag Layer."""
-        kwargs = dataclass_fields_asdict(ComplexDop.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(ComplexDop.from_et(et_element, context))
 
         param_snref = None
         if (param_snref_elem := et_element.find("PARAM-SNREF")) is not None:
@@ -63,11 +64,11 @@ class EnvironmentDataDescription(ComplexDop):
         # empty and one non-empty list here. (Which is which depends
         # on the version of the standard used by the file.)
         env_datas = NamedItemList([
-            EnvironmentData.from_et(env_data_elem, doc_frags)
+            EnvironmentData.from_et(env_data_elem, context)
             for env_data_elem in et_element.iterfind("ENV-DATAS/ENV-DATA")
         ])
         env_data_refs = [
-            odxrequire(OdxLinkRef.from_et(env_data_ref, doc_frags))
+            odxrequire(OdxLinkRef.from_et(env_data_ref, context))
             for env_data_ref in et_element.iterfind("ENV-DATA-REFS/ENV-DATA-REF")
         ]
 
@@ -207,7 +208,7 @@ class EnvironmentDataDescription(ComplexDop):
                                           param_value: ParameterValue | None) -> int:
         if isinstance(param, ParameterWithDOP):
             dop = param.dop
-            if not isinstance(dop, DataObjectProperty | DtcDop):
+            if not isinstance(dop, (DataObjectProperty, DtcDop)):
                 odxraise(f"The DOP of the parameter referenced by environment data descriptions "
                          f"must use either be DataObjectProperty or a DtcDop (encountered "
                          f"{type(param).__name__} for parameter '{param.short_name}' "

odxtools/externalaccessmethod.py

@@ -4,18 +4,17 @@ from xml.etree import ElementTree
 
 from .element import IdentifiableElement
 from .exceptions import odxrequire
-from .odxlink import OdxDocFragment
+from .odxdoccontext import OdxDocContext
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class ExternalAccessMethod(IdentifiableElement):
     method: str
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "ExternalAccessMethod":
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "ExternalAccessMethod":
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
 
         method = odxrequire(et_element.findtext("METHOD"))
 

odxtools/externaldoc.py

@@ -3,17 +3,17 @@ from typing import Optional
 from xml.etree import ElementTree
 
 from .exceptions import odxrequire
-from .odxlink import OdxDocFragment
+from .odxdoccontext import OdxDocContext
 
 
-@dataclass
+@dataclass(kw_only=True)
 class ExternalDoc:
-    description: str | None
+    description: str | None = None
     href: str
 
     @staticmethod
     def from_et(et_element: ElementTree.Element | None,
-                doc_frags: list[OdxDocFragment]) -> Optional["ExternalDoc"]:
+                context: OdxDocContext) -> Optional["ExternalDoc"]:
         if et_element is None:
             return None
 

odxtools/field.py

@@ -6,19 +6,20 @@ from .basicstructure import BasicStructure
 from .complexdop import ComplexDop
 from .environmentdatadescription import EnvironmentDataDescription
 from .exceptions import odxassert, odxrequire
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkRef, resolve_snref
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkRef, resolve_snref
 from .odxtypes import odxstr_to_bool
 from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class Field(ComplexDop):
-    structure_ref: OdxLinkRef | None
-    structure_snref: str | None
-    env_data_desc_ref: OdxLinkRef | None
-    env_data_desc_snref: str | None
-    is_visible_raw: bool | None
+    structure_ref: OdxLinkRef | None = None
+    structure_snref: str | None = None
+    env_data_desc_ref: OdxLinkRef | None = None
+    env_data_desc_snref: str | None = None
+    is_visible_raw: bool | None = None
 
     @property
     def structure(self) -> BasicStructure:
@@ -30,15 +31,15 @@ class Field(ComplexDop):
         return self.is_visible_raw in (None, True)
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "Field":
-        kwargs = dataclass_fields_asdict(ComplexDop.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Field":
+        kwargs = dataclass_fields_asdict(ComplexDop.from_et(et_element, context))
 
-        structure_ref = OdxLinkRef.from_et(et_element.find("BASIC-STRUCTURE-REF"), doc_frags)
+        structure_ref = OdxLinkRef.from_et(et_element.find("BASIC-STRUCTURE-REF"), context)
         structure_snref = None
         if (edsnr_elem := et_element.find("BASIC-STRUCTURE-SNREF")) is not None:
             structure_snref = edsnr_elem.get("SHORT-NAME")
 
-        env_data_desc_ref = OdxLinkRef.from_et(et_element.find("ENV-DATA-DESC-REF"), doc_frags)
+        env_data_desc_ref = OdxLinkRef.from_et(et_element.find("ENV-DATA-DESC-REF"), context)
         env_data_desc_snref = None
         if (edsnr_elem := et_element.find("ENV-DATA-DESC-SNREF")) is not None:
             env_data_desc_snref = edsnr_elem.get("SHORT-NAME")

odxtools/functionalclass.py

@@ -5,26 +5,26 @@ from xml.etree import ElementTree
 
 from .admindata import AdminData
 from .element import IdentifiableElement
-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 FunctionalClass(IdentifiableElement):
     """
     Corresponds to FUNCT-CLASS.
     """
 
-    admin_data: AdminData | None
+    admin_data: AdminData | None = None
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "FunctionalClass":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "FunctionalClass":
 
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
 
-        admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), doc_frags)
+        admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), context)
 
         return FunctionalClass(admin_data=admin_data, **kwargs)
 

odxtools/inputparam.py

@@ -8,17 +8,18 @@ from deprecation import deprecated
 from .dopbase import DopBase
 from .element import NamedElement
 from .exceptions import odxrequire
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class InputParam(NamedElement):
-    physical_default_value: str | None
+    physical_default_value: str | None = None
     dop_base_ref: OdxLinkRef
-    oid: str | None
-    semantic: str | None
+    oid: str | None = None
+    semantic: str | None = None
 
     @property
     def dop(self) -> DopBase:
@@ -30,11 +31,11 @@ class InputParam(NamedElement):
         return self._dop
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "InputParam":
-        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "InputParam":
+        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, context))
 
         physical_default_value = et_element.findtext("PHYSICAL-DEFAULT-VALUE")
-        dop_base_ref = odxrequire(OdxLinkRef.from_et(et_element.find("DOP-BASE-REF"), doc_frags))
+        dop_base_ref = odxrequire(OdxLinkRef.from_et(et_element.find("DOP-BASE-REF"), context))
 
         oid = et_element.get("OID")
         semantic = et_element.get("SEMANTIC")

odxtools/internalconstr.py

@@ -1,37 +1,37 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from xml.etree import ElementTree
 
 from .compumethods.limit import Limit
-from .odxlink import OdxDocFragment
+from .odxdoccontext import OdxDocContext
 from .odxtypes import DataType
 from .scaleconstr import ScaleConstr
 
 
-@dataclass
+@dataclass(kw_only=True)
 class InternalConstr:
     """This class represents INTERNAL-CONSTR objects.
     """
 
     # TODO: Enforce the internal and physical constraints.
 
-    lower_limit: Limit | None
-    upper_limit: Limit | None
-    scale_constrs: list[ScaleConstr]
+    lower_limit: Limit | None = None
+    upper_limit: Limit | None = None
+    scale_constrs: list[ScaleConstr] = field(default_factory=list)
 
     value_type: DataType
 
     @staticmethod
-    def constr_from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment], *,
+    def constr_from_et(et_element: ElementTree.Element, context: OdxDocContext, *,
                        value_type: DataType) -> "InternalConstr":
 
         lower_limit = Limit.limit_from_et(
-            et_element.find("LOWER-LIMIT"), doc_frags, value_type=value_type)
+            et_element.find("LOWER-LIMIT"), context, value_type=value_type)
         upper_limit = Limit.limit_from_et(
-            et_element.find("UPPER-LIMIT"), doc_frags, value_type=value_type)
+            et_element.find("UPPER-LIMIT"), context, value_type=value_type)
 
         scale_constrs = [
-            ScaleConstr.scale_constr_from_et(sc_el, doc_frags, value_type=value_type)
+            ScaleConstr.scale_constr_from_et(sc_el, context, value_type=value_type)
             for sc_el in et_element.iterfind("SCALE-CONSTRS/SCALE-CONSTR")
         ]
 

odxtools/leadinglengthinfotype.py

@@ -8,12 +8,12 @@ from .decodestate import DecodeState
 from .diagcodedtype import DctType, DiagCodedType
 from .encodestate import EncodeState
 from .exceptions import EncodeError, odxassert, odxraise, odxrequire
-from .odxlink import OdxDocFragment
+from .odxdoccontext import OdxDocContext
 from .odxtypes import AtomicOdxType, DataType
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class LeadingLengthInfoType(DiagCodedType):
     #: bit length of the length specifier field
     #:
@@ -28,9 +28,8 @@ class LeadingLengthInfoType(DiagCodedType):
 
     @staticmethod
     @override
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "LeadingLengthInfoType":
-        kwargs = dataclass_fields_asdict(DiagCodedType.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "LeadingLengthInfoType":
+        kwargs = dataclass_fields_asdict(DiagCodedType.from_et(et_element, context))
 
         bit_length = int(odxrequire(et_element.findtext("BIT-LENGTH")))
 
@@ -52,7 +51,7 @@ class LeadingLengthInfoType(DiagCodedType):
     @override
     def encode_into_pdu(self, internal_value: AtomicOdxType, encode_state: EncodeState) -> None:
 
-        if not isinstance(internal_value, str | bytes):
+        if not isinstance(internal_value, (str, bytes)):
             odxraise(
                 f"LEADING-LENGTH-INFO types can only be used for strings and byte fields, "
                 f"not {type(internal_value).__name__}", EncodeError)