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

odxtools/parameters/tablekeyparameter.py

@@ -8,7 +8,8 @@ from typing_extensions import final, override
 from ..decodestate import DecodeState
 from ..encodestate import EncodeState
 from ..exceptions import DecodeError, EncodeError, odxraise, odxrequire
-from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from ..odxdoccontext import OdxDocContext
+from ..odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from ..odxtypes import ParameterValue
 from ..snrefcontext import SnRefContext
 from ..utils import dataclass_fields_asdict
@@ -19,35 +20,34 @@ if TYPE_CHECKING:
     from ..tablerow import TableRow
 
 
-@dataclass
+@dataclass(kw_only=True)
 class TableKeyParameter(Parameter):
 
     odx_id: OdxLinkId
 
     # the spec mandates that exactly one of the two attributes must
     # be non-None
-    table_ref: OdxLinkRef | None
-    table_snref: str | None
+    table_ref: OdxLinkRef | None = None
+    table_snref: str | None = None
 
     # the spec mandates that exactly one of the two attributes must
     # be non-None
-    table_row_ref: OdxLinkRef | None
-    table_row_snref: str | None
+    table_row_ref: OdxLinkRef | None = None
+    table_row_snref: str | None = None
 
     @staticmethod
     @override
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "TableKeyParameter":
-        kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "TableKeyParameter":
+        kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, context))
 
-        odx_id = odxrequire(OdxLinkId.from_et(et_element, doc_frags))
+        odx_id = odxrequire(OdxLinkId.from_et(et_element, context))
 
-        table_ref = OdxLinkRef.from_et(et_element.find("TABLE-REF"), doc_frags)
+        table_ref = OdxLinkRef.from_et(et_element.find("TABLE-REF"), context)
         table_snref = None
         if (table_snref_elem := et_element.find("TABLE-SNREF")) is not None:
             table_snref = odxrequire(table_snref_elem.get("SHORT-NAME"))
 
-        table_row_ref = OdxLinkRef.from_et(et_element.find("TABLE-ROW-REF"), doc_frags)
+        table_row_ref = OdxLinkRef.from_et(et_element.find("TABLE-ROW-REF"), context)
         table_row_snref = None
         if (table_row_snref_elem := et_element.find("TABLE-ROW-SNREF")) is not None:
             table_row_snref = odxrequire(table_row_snref_elem.get("SHORT-NAME"))

odxtools/parameters/tablestructparameter.py

@@ -8,7 +8,8 @@ from typing_extensions import override
 from ..decodestate import DecodeState
 from ..encodestate import EncodeState
 from ..exceptions import DecodeError, EncodeError, odxraise, odxrequire
-from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from ..odxdoccontext import OdxDocContext
+from ..odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from ..odxtypes import ParameterValue
 from ..snrefcontext import SnRefContext
 from ..utils import dataclass_fields_asdict
@@ -19,10 +20,10 @@ if TYPE_CHECKING:
     from ..table import Table
 
 
-@dataclass
+@dataclass(kw_only=True)
 class TableStructParameter(Parameter):
-    table_key_ref: OdxLinkRef | None
-    table_key_snref: str | None
+    table_key_ref: OdxLinkRef | None = None
+    table_key_snref: str | None = None
 
     @property
     @override
@@ -49,12 +50,11 @@ class TableStructParameter(Parameter):
 
     @staticmethod
     @override
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "TableStructParameter":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "TableStructParameter":
 
-        kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, context))
 
-        table_key_ref = OdxLinkRef.from_et(et_element.find("TABLE-KEY-REF"), doc_frags)
+        table_key_ref = OdxLinkRef.from_et(et_element.find("TABLE-KEY-REF"), context)
         table_key_snref = None
         if (table_key_snref_elem := et_element.find("TABLE-KEY-SNREF")) is not None:
             table_key_snref = odxrequire(table_key_snref_elem.get("SHORT-NAME"))
@@ -89,7 +89,7 @@ class TableStructParameter(Parameter):
     def _encode_positioned_into_pdu(self, physical_value: ParameterValue | None,
                                     encode_state: EncodeState) -> None:
 
-        if not isinstance(physical_value, tuple|list) or \
+        if not isinstance(physical_value, (tuple, list)) or \
            len(physical_value) != 2 or \
            not isinstance(physical_value[0], str):
             odxraise(

odxtools/parameters/valueparameter.py

@@ -8,7 +8,8 @@ from typing_extensions import override
 from ..dataobjectproperty import DataObjectProperty
 from ..encodestate import EncodeState
 from ..exceptions import EncodeError, odxraise, odxrequire
-from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from ..odxdoccontext import OdxDocContext
+from ..odxlink import OdxLinkDatabase, OdxLinkId
 from ..odxtypes import AtomicOdxType, ParameterValue
 from ..snrefcontext import SnRefContext
 from ..utils import dataclass_fields_asdict
@@ -16,9 +17,9 @@ from .parameter import ParameterType
 from .parameterwithdop import ParameterWithDOP
 
 
-@dataclass
+@dataclass(kw_only=True)
 class ValueParameter(ParameterWithDOP):
-    physical_default_value_raw: str | None
+    physical_default_value_raw: str | None = None
 
     @property
     @override
@@ -41,10 +42,9 @@ class ValueParameter(ParameterWithDOP):
 
     @staticmethod
     @override
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "ValueParameter":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "ValueParameter":
 
-        kwargs = dataclass_fields_asdict(ParameterWithDOP.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(ParameterWithDOP.from_et(et_element, context))
 
         physical_default_value_raw = et_element.findtext("PHYSICAL-DEFAULT-VALUE")
 

odxtools/paramlengthinfotype.py

@@ -9,7 +9,8 @@ from .decodestate import DecodeState
 from .diagcodedtype import DctType, DiagCodedType
 from .encodestate import EncodeState
 from .exceptions import EncodeError, odxraise, odxrequire
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .odxtypes import AtomicOdxType, DataType
 from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
@@ -18,7 +19,7 @@ if TYPE_CHECKING:
     from .parameters.lengthkeyparameter import LengthKeyParameter
 
 
-@dataclass
+@dataclass(kw_only=True)
 class ParamLengthInfoType(DiagCodedType):
     length_key_ref: OdxLinkRef
 
@@ -32,12 +33,10 @@ class ParamLengthInfoType(DiagCodedType):
 
     @staticmethod
     @override
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "ParamLengthInfoType":
-        kwargs = dataclass_fields_asdict(DiagCodedType.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "ParamLengthInfoType":
+        kwargs = dataclass_fields_asdict(DiagCodedType.from_et(et_element, context))
 
-        length_key_ref = odxrequire(
-            OdxLinkRef.from_et(et_element.find("LENGTH-KEY-REF"), doc_frags))
+        length_key_ref = odxrequire(OdxLinkRef.from_et(et_element.find("LENGTH-KEY-REF"), context))
 
         return ParamLengthInfoType(length_key_ref=length_key_ref, **kwargs)
 

odxtools/parentref.py

@@ -1,11 +1,12 @@
 # SPDX-License-Identifier: MIT
 from copy import deepcopy
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any
 from xml.etree import ElementTree
 
 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
 
@@ -13,23 +14,24 @@ if TYPE_CHECKING:
     from .diaglayers.diaglayer import DiagLayer
 
 
-@dataclass
+@dataclass(kw_only=True)
 class ParentRef:
     layer_ref: OdxLinkRef
-    not_inherited_diag_comms: list[str]  # short_name references
-    not_inherited_variables: list[str]  # short_name references
-    not_inherited_dops: list[str]  # short_name references
-    not_inherited_tables: list[str]  # short_name references
-    not_inherited_global_neg_responses: list[str]  # short_name references
+    not_inherited_diag_comms: list[str] = field(default_factory=list)  # short_name references
+    not_inherited_variables: list[str] = field(default_factory=list)  # short_name references
+    not_inherited_dops: list[str] = field(default_factory=list)  # short_name references
+    not_inherited_tables: list[str] = field(default_factory=list)  # short_name references
+    not_inherited_global_neg_responses: list[str] = field(
+        default_factory=list)  # short_name references
 
     @property
     def layer(self) -> "DiagLayer":
         return self._layer
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "ParentRef":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "ParentRef":
 
-        layer_ref = odxrequire(OdxLinkRef.from_et(et_element, doc_frags))
+        layer_ref = odxrequire(OdxLinkRef.from_et(et_element, context))
 
         not_inherited_diag_comms = [
             odxrequire(el.get("SHORT-NAME"))

odxtools/physicaldimension.py

@@ -4,12 +4,13 @@ from typing import Any
 from xml.etree import ElementTree
 
 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 PhysicalDimension(IdentifiableElement):
     """A physical dimension is a formal definition of a unit.
 
@@ -41,18 +42,17 @@ class PhysicalDimension(IdentifiableElement):
     )
     ```
     """
-    length_exp: int | None
-    mass_exp: int | None
-    time_exp: int | None
-    current_exp: int | None
-    temperature_exp: int | None
-    molar_amount_exp: int | None
-    luminous_intensity_exp: int | None
+    length_exp: int | None = None
+    mass_exp: int | None = None
+    time_exp: int | None = None
+    current_exp: int | None = None
+    temperature_exp: int | None = None
+    molar_amount_exp: int | None = None
+    luminous_intensity_exp: int | None = None
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "PhysicalDimension":
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "PhysicalDimension":
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
 
         def read_optional_int(element: ElementTree.Element, name: str) -> int | None:
             if (val_str := element.findtext(name)) is not None:

odxtools/physicaltype.py

@@ -3,12 +3,12 @@ from dataclasses import dataclass
 from xml.etree import ElementTree
 
 from .exceptions import odxraise
-from .odxlink import OdxDocFragment
+from .odxdoccontext import OdxDocContext
 from .odxtypes import DataType
 from .radix import Radix
 
 
-@dataclass
+@dataclass(kw_only=True)
 class PhysicalType:
     """The physical type describes the base data type of a parameter.
 
@@ -31,20 +31,20 @@ class PhysicalType:
     PhysicalType(DataType.A_FLOAT64, precision=2)
     """
 
-    precision: int | None
+    precision: int | None = None
     """Number of digits after the decimal point to display to the user
     The precision is only applicable if the base data type is A_FLOAT32 or A_FLOAT64.
     """
 
     base_data_type: DataType
 
-    display_radix: Radix | None
+    display_radix: Radix | None = None
     """The display radix defines how integers are displayed to the user.
     The display radix is only applicable if the base data type is A_UINT32.
     """
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "PhysicalType":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "PhysicalType":
         precision_str = et_element.findtext("PRECISION")
         precision = int(precision_str) if precision_str is not None else None
 

odxtools/posresponsesuppressible.py

@@ -3,31 +3,31 @@ from dataclasses import dataclass
 from xml.etree import ElementTree
 
 from .exceptions import odxrequire
-from .odxlink import OdxDocFragment
+from .odxdoccontext import OdxDocContext
 from .utils import read_hex_binary
 
 
 # note that the spec has a typo here: it calls the corresponding
 # XML tag POS-RESPONSE-SUPPRESSABLE...
-@dataclass
+@dataclass(kw_only=True)
 class PosResponseSuppressible:
     bit_mask: int
 
-    coded_const_snref: str | None
-    coded_const_snpathref: str | None
+    coded_const_snref: str | None = None
+    coded_const_snpathref: str | None = None
 
-    value_snref: str | None
-    value_snpathref: str | None
+    value_snref: str | None = None
+    value_snpathref: str | None = None
 
-    phys_const_snref: str | None
-    phys_const_snpathref: str | None
+    phys_const_snref: str | None = None
+    phys_const_snpathref: str | None = None
 
-    table_key_snref: str | None
-    table_key_snpathref: str | None
+    table_key_snref: str | None = None
+    table_key_snpathref: str | None = None
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "PosResponseSuppressible":
+                context: OdxDocContext) -> "PosResponseSuppressible":
 
         bit_mask = odxrequire(read_hex_binary(et_element.find("BIT-MASK")))
 

odxtools/preconditionstateref.py

@@ -4,7 +4,8 @@ from typing import TYPE_CHECKING, Any
 from xml.etree import ElementTree
 
 from .exceptions import odxassert, odxrequire
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .odxtypes import ParameterValueDict
 from .parameters.parameter import Parameter
 from .snrefcontext import SnRefContext
@@ -16,15 +17,15 @@ if TYPE_CHECKING:
     from .statemachine import StateMachine
 
 
-@dataclass
+@dataclass(kw_only=True)
 class PreConditionStateRef(OdxLinkRef):
     """
     This class represents the PRE-CONDITION-STATE-REF XML tag.
     """
-    value: str | None
+    value: str | None = None
 
-    in_param_if_snref: str | None
-    in_param_if_snpathref: str | None
+    in_param_if_snref: str | None = None
+    in_param_if_snpathref: str | None = None
 
     @property
     def state(self) -> "State":
@@ -32,9 +33,8 @@ class PreConditionStateRef(OdxLinkRef):
 
     @staticmethod
     def from_et(  # type: ignore[override]
-            et_element: ElementTree.Element,
-            doc_frags: list[OdxDocFragment]) -> "PreConditionStateRef":
-        kwargs = dataclass_fields_asdict(OdxLinkRef.from_et(et_element, doc_frags))
+            et_element: ElementTree.Element, context: OdxDocContext) -> "PreConditionStateRef":
+        kwargs = dataclass_fields_asdict(OdxLinkRef.from_et(et_element, context))
 
         value = et_element.findtext("VALUE")
 

odxtools/progcode.py

@@ -1,24 +1,25 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Any, cast
 from xml.etree import ElementTree
 
 from .exceptions import odxraise, odxrequire
 from .library import Library
 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
 
 
-@dataclass
+@dataclass(kw_only=True)
 class ProgCode:
     """A reference to code that is executed by a single ECU job"""
     code_file: str
-    encryption: str | None
+    encryption: str | None = None
     syntax: str
     revision: str
-    entrypoint: str | None
-    library_refs: list[OdxLinkRef]
+    entrypoint: str | None = None
+    library_refs: list[OdxLinkRef] = field(default_factory=list)
 
     @property
     def code(self) -> bytes:
@@ -29,7 +30,7 @@ class ProgCode:
         return self._libraries
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "ProgCode":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "ProgCode":
         code_file = odxrequire(et_element.findtext("CODE-FILE"))
         encryption = et_element.findtext("ENCRYPTION")
         syntax = odxrequire(et_element.findtext("SYNTAX"))
@@ -37,7 +38,7 @@ class ProgCode:
         entrypoint = et_element.findtext("ENTRYPOINT")
 
         library_refs = [
-            odxrequire(OdxLinkRef.from_et(el, doc_frags))
+            odxrequire(OdxLinkRef.from_et(el, context))
             for el in et_element.iterfind("LIBRARY-REFS/LIBRARY-REF")
         ]
 

odxtools/protstack.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,30 +7,31 @@ from .comparamsubset import ComparamSubset
 from .element import IdentifiableElement
 from .exceptions import 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 .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class ProtStack(IdentifiableElement):
     # mandatory in ODX 2.2, but non existent in ODX 2.0
     pdu_protocol_type: str
     physical_link_type: str
-    comparam_subset_refs: list[OdxLinkRef]
+    comparam_subset_refs: list[OdxLinkRef] = field(default_factory=list)
 
     @property
     def comparam_subsets(self) -> NamedItemList[ComparamSubset]:
         return self._comparam_subsets
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "ProtStack":
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "ProtStack":
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
 
         pdu_protocol_type = odxrequire(et_element.findtext("PDU-PROTOCOL-TYPE"))
         physical_link_type = odxrequire(et_element.findtext("PHYSICAL-LINK-TYPE"))
         comparam_subset_refs = [
-            OdxLinkRef.from_et(csr_element, doc_frags)
+            OdxLinkRef.from_et(csr_element, context)
             for csr_element in et_element.iterfind("COMPARAM-SUBSET-REFS/"
                                                    "COMPARAM-SUBSET-REF")
         ]

odxtools/relateddiagcommref.py

@@ -3,19 +3,19 @@ from dataclasses import dataclass
 from xml.etree import ElementTree
 
 from .exceptions import 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 RelatedDiagCommRef(OdxLinkRef):
     relation_type: str
 
     @staticmethod
     def from_et(  # type: ignore[override]
-            et_element: ElementTree.Element,
-            doc_frags: list[OdxDocFragment]) -> "RelatedDiagCommRef":
-        kwargs = dataclass_fields_asdict(odxrequire(OdxLinkRef.from_et(et_element, doc_frags)))
+            et_element: ElementTree.Element, context: OdxDocContext) -> "RelatedDiagCommRef":
+        kwargs = dataclass_fields_asdict(odxrequire(OdxLinkRef.from_et(et_element, context)))
 
         relation_type = odxrequire(et_element.findtext("RELATION-TYPE"))
 

odxtools/relateddoc.py

@@ -4,22 +4,23 @@ from typing import Any
 from xml.etree import ElementTree
 
 from .description import Description
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
 from .snrefcontext import SnRefContext
 from .xdoc import XDoc
 
 
-@dataclass
+@dataclass(kw_only=True)
 class RelatedDoc:
-    xdoc: XDoc | None
-    description: Description | None
+    xdoc: XDoc | None = None
+    description: Description | None = None
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "RelatedDoc":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "RelatedDoc":
         xdoc: XDoc | None = None
         if (xdoc_elem := et_element.find("XDOC")) is not None:
-            xdoc = XDoc.from_et(xdoc_elem, doc_frags)
-        description = Description.from_et(et_element.find("DESC"), doc_frags)
+            xdoc = XDoc.from_et(xdoc_elem, context)
+        description = Description.from_et(et_element.find("DESC"), context)
 
         return RelatedDoc(
             xdoc=xdoc,

odxtools/request.py

@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Any, cast
 from xml.etree import ElementTree
 
@@ -14,7 +14,8 @@ from .element import IdentifiableElement
 from .encodestate import EncodeState
 from .exceptions import odxraise
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
 from .odxtypes import ParameterValue, ParameterValueDict
 from .parameters.createanyparameter import create_any_parameter_from_et
 from .parameters.parameter import Parameter
@@ -23,15 +24,15 @@ from .specialdatagroup import SpecialDataGroup
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class Request(IdentifiableElement):
     """Represents all information related to an UDS request
 
     This class implements the `CompositeCodec` interface.
     """
-    admin_data: AdminData | None
-    parameters: NamedItemList[Parameter]
-    sdgs: list[SpecialDataGroup]
+    admin_data: AdminData | None = None
+    parameters: NamedItemList[Parameter] = field(default_factory=NamedItemList)
+    sdgs: list[SpecialDataGroup] = field(default_factory=list)
 
     @property
     def required_parameters(self) -> list[Parameter]:
@@ -42,17 +43,15 @@ class Request(IdentifiableElement):
         return composite_codec_get_free_parameters(self)
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "Request":
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Request":
+        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)
         parameters = NamedItemList([
-            create_any_parameter_from_et(et_parameter, doc_frags)
+            create_any_parameter_from_et(et_parameter, context)
             for et_parameter in et_element.iterfind("PARAMS/PARAM")
         ])
-        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 Request(admin_data=admin_data, parameters=parameters, sdgs=sdgs, **kwargs)