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

odxtools/response.py

@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from enum import Enum
 from typing import Any, cast
 from xml.etree import ElementTree
@@ -15,7 +15,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
@@ -30,7 +31,7 @@ class ResponseType(Enum):
     GLOBAL_NEGATIVE = "GLOBAL-NEG-RESPONSE"
 
 
-@dataclass
+@dataclass(kw_only=True)
 class Response(IdentifiableElement):
     """Represents all information related to an UDS response
 
@@ -39,14 +40,14 @@ class Response(IdentifiableElement):
 
     response_type: ResponseType
 
-    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)
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "Response":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Response":
         """Reads a response."""
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
 
         try:
             response_type = ResponseType(et_element.tag)
@@ -54,14 +55,12 @@ class Response(IdentifiableElement):
             response_type = cast(ResponseType, None)
             odxraise(f"Encountered unknown response type '{et_element.tag}'")
 
-        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 Response(
             response_type=response_type,

odxtools/scaleconstr.py

@@ -5,32 +5,32 @@ from xml.etree import ElementTree
 from .compumethods.limit import Limit
 from .description import Description
 from .exceptions import odxraise, odxrequire
-from .odxlink import OdxDocFragment
+from .odxdoccontext import OdxDocContext
 from .odxtypes import DataType
 from .validtype import ValidType
 
 
-@dataclass
+@dataclass(kw_only=True)
 class ScaleConstr:
     """This class represents a SCALE-CONSTR.
     """
 
-    short_label: str | None
-    description: Description | None
+    short_label: str | None = None
+    description: Description | None = None
     lower_limit: Limit
     upper_limit: Limit
     validity: ValidType
     value_type: DataType
 
     @staticmethod
-    def scale_constr_from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment], *,
+    def scale_constr_from_et(et_element: ElementTree.Element, context: OdxDocContext, *,
                              value_type: DataType) -> "ScaleConstr":
         short_label = et_element.findtext("SHORT-LABEL")
-        description = Description.from_et(et_element.find("DESC"), doc_frags)
+        description = Description.from_et(et_element.find("DESC"), context)
         lower_limit = Limit.limit_from_et(
-            odxrequire(et_element.find("LOWER-LIMIT")), doc_frags, value_type=value_type)
+            odxrequire(et_element.find("LOWER-LIMIT")), context, value_type=value_type)
         upper_limit = Limit.limit_from_et(
-            odxrequire(et_element.find("UPPER-LIMIT")), doc_frags, value_type=value_type)
+            odxrequire(et_element.find("UPPER-LIMIT")), context, value_type=value_type)
 
         validity_str = odxrequire(et_element.get("VALIDITY"))
         try:

odxtools/singleecujob.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,14 +7,15 @@ from .diagcomm import DiagComm
 from .inputparam import InputParam
 from .nameditemlist import NamedItemList
 from .negoutputparam import NegOutputParam
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
 from .outputparam import OutputParam
 from .progcode import ProgCode
 from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class SingleEcuJob(DiagComm):
     """A single ECU job is a diagnostic communication primitive.
 
@@ -30,30 +31,30 @@ class SingleEcuJob(DiagComm):
     standard.
     """
 
-    prog_codes: list[ProgCode]
-    input_params: NamedItemList[InputParam]
-    output_params: NamedItemList[OutputParam]
-    neg_output_params: NamedItemList[NegOutputParam]
+    prog_codes: list[ProgCode] = field(default_factory=list)
+    input_params: NamedItemList[InputParam] = field(default_factory=NamedItemList)
+    output_params: NamedItemList[OutputParam] = field(default_factory=NamedItemList)
+    neg_output_params: NamedItemList[NegOutputParam] = field(default_factory=NamedItemList)
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "SingleEcuJob":
-        kwargs = dataclass_fields_asdict(DiagComm.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "SingleEcuJob":
+        kwargs = dataclass_fields_asdict(DiagComm.from_et(et_element, context))
 
         prog_codes = [
-            ProgCode.from_et(pc_elem, doc_frags)
+            ProgCode.from_et(pc_elem, context)
             for pc_elem in et_element.iterfind("PROG-CODES/PROG-CODE")
         ]
 
         input_params = NamedItemList([
-            InputParam.from_et(el, doc_frags)
+            InputParam.from_et(el, context)
             for el in et_element.iterfind("INPUT-PARAMS/INPUT-PARAM")
         ])
         output_params = NamedItemList([
-            OutputParam.from_et(el, doc_frags)
+            OutputParam.from_et(el, context)
             for el in et_element.iterfind("OUTPUT-PARAMS/OUTPUT-PARAM")
         ])
         neg_output_params = NamedItemList([
-            NegOutputParam.from_et(el, doc_frags)
+            NegOutputParam.from_et(el, context)
             for el in et_element.iterfind("NEG-OUTPUT-PARAMS/NEG-OUTPUT-PARAM")
         ])
 

odxtools/snrefcontext.py

@@ -13,7 +13,7 @@ if TYPE_CHECKING:
     from .statechart import StateChart
 
 
-@dataclass
+@dataclass(kw_only=True)
 class SnRefContext:
     """Represents the context for which a short name reference ought
     to be resolved

odxtools/specialdata.py

@@ -3,19 +3,20 @@ from dataclasses import dataclass
 from typing import 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
 
 
-@dataclass
+@dataclass(kw_only=True)
 class SpecialData:
     """This corresponds to the SD XML tag"""
-    semantic_info: str | None  # the "SI" attribute
-    text_identifier: str | None  # the "TI" attribute, specifies the language used
+    semantic_info: str | None = None  # the "SI" attribute
+    text_identifier: str | None = None  # the "TI" attribute, specifies the language used
     value: str
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "SpecialData":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "SpecialData":
         semantic_info = et_element.get("SI")
         text_identifier = et_element.get("TI")
         value = et_element.text or ""

odxtools/specialdatagroup.py

@@ -1,33 +1,33 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Any, Union
 from xml.etree import ElementTree
 
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .snrefcontext import SnRefContext
 from .specialdata import SpecialData
 from .specialdatagroupcaption import SpecialDataGroupCaption
 
 
-@dataclass
+@dataclass(kw_only=True)
 class SpecialDataGroup:
     """This corresponds to the SDG XML tag"""
-    sdg_caption: SpecialDataGroupCaption | None
-    sdg_caption_ref: OdxLinkRef | None
-    values: list[Union["SpecialDataGroup", SpecialData]]
-    semantic_info: str | None  # the "SI" attribute
+    sdg_caption: SpecialDataGroupCaption | None = None
+    sdg_caption_ref: OdxLinkRef | None = None
+    values: list[Union["SpecialDataGroup", SpecialData]] = field(default_factory=list)
+    semantic_info: str | None = None  # the "SI" attribute
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "SpecialDataGroup":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "SpecialDataGroup":
 
         sdg_caption = None
         if caption_elem := et_element.find("SDG-CAPTION"):
-            sdg_caption = SpecialDataGroupCaption.from_et(caption_elem, doc_frags)
+            sdg_caption = SpecialDataGroupCaption.from_et(caption_elem, context)
 
         sdg_caption_ref = None
         if (caption_ref_elem := et_element.find("SDG-CAPTION-REF")) is not None:
-            sdg_caption_ref = OdxLinkRef.from_et(caption_ref_elem, doc_frags)
+            sdg_caption_ref = OdxLinkRef.from_et(caption_ref_elem, context)
 
         semantic_info = et_element.get("SI")
 
@@ -35,9 +35,9 @@ class SpecialDataGroup:
         for value_elem in et_element:
             next_entry: SpecialData | SpecialDataGroup | None = None
             if value_elem.tag == "SDG":
-                next_entry = SpecialDataGroup.from_et(value_elem, doc_frags)
+                next_entry = SpecialDataGroup.from_et(value_elem, context)
             elif value_elem.tag == "SD":
-                next_entry = SpecialData.from_et(value_elem, doc_frags)
+                next_entry = SpecialData.from_et(value_elem, context)
 
             if next_entry is not None:
                 values.append(next_entry)

odxtools/specialdatagroupcaption.py

@@ -4,18 +4,19 @@ 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 SpecialDataGroupCaption(IdentifiableElement):
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "SpecialDataGroupCaption":
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+                context: OdxDocContext) -> "SpecialDataGroupCaption":
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
 
         return SpecialDataGroupCaption(**kwargs)
 

odxtools/standardlengthtype.py

@@ -9,7 +9,7 @@ from .decodestate import DecodeState
 from .diagcodedtype import DctType, DiagCodedType
 from .encodestate import EncodeState
 from .exceptions import odxassert, odxraise, odxrequire
-from .odxlink import OdxDocFragment
+from .odxdoccontext import OdxDocContext
 from .odxtypes import AtomicOdxType, BytesTypes, DataType, odxstr_to_bool
 from .utils import dataclass_fields_asdict, read_hex_binary
 
@@ -31,9 +31,8 @@ class StandardLengthType(DiagCodedType):
 
     @staticmethod
     @override
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "StandardLengthType":
-        kwargs = dataclass_fields_asdict(DiagCodedType.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "StandardLengthType":
+        kwargs = dataclass_fields_asdict(DiagCodedType.from_et(et_element, context))
 
         bit_length = int(odxrequire(et_element.findtext("BIT-LENGTH")))
         bit_mask = read_hex_binary(et_element.find("BIT-MASK"))
@@ -72,11 +71,7 @@ class StandardLengthType(DiagCodedType):
         if self.is_condensed:
             # if a condensed bitmask is specified, the number of bits
             # set to one in the bit mask are used in the PDU
-
-            # TODO: this is pretty slow. replace it by
-            # `self.bit_mask.bit_count()` once we require python >=
-            # 3.10.
-            bit_sz = bin(self.bit_mask).count("1")
+            bit_sz = self.bit_mask.bit_count()
             used_mask = (1 << bit_sz) - 1
 
             return used_mask.to_bytes((bit_sz + 7) // 8, endianness)
@@ -171,10 +166,7 @@ class StandardLengthType(DiagCodedType):
 
     def get_static_bit_length(self) -> int | None:
         if self.bit_mask is not None and self.is_condensed:
-            # TODO: this is pretty slow. replace it by
-            # `self.bit_mask.bit_count()` once we require python >=
-            # 3.10.
-            return bin(self.bit_mask).count("1")
+            return self.bit_mask.bit_count()
 
         return self.bit_length
 

odxtools/state.py

@@ -4,20 +4,21 @@ 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 State(IdentifiableElement):
     """
     Corresponds to STATE.
     """
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "State":
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "State":
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
 
         return State(**kwargs)
 

odxtools/statechart.py

@@ -1,40 +1,41 @@
 # 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 .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, resolve_snref
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, resolve_snref
 from .snrefcontext import SnRefContext
 from .state import State
 from .statetransition import StateTransition
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class StateChart(IdentifiableElement):
     """
     Corresponds to STATE-CHART.
     """
     semantic: str
-    state_transitions: list[StateTransition]
+    state_transitions: list[StateTransition] = field(default_factory=list)
     start_state_snref: str
-    states: NamedItemList[State]
+    states: NamedItemList[State] = field(default_factory=NamedItemList)
 
     @property
     def start_state(self) -> State:
         return self._start_state
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "StateChart":
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "StateChart":
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
 
         semantic: str = odxrequire(et_element.findtext("SEMANTIC"))
 
         state_transitions = [
-            StateTransition.from_et(st_elem, doc_frags)
+            StateTransition.from_et(st_elem, context)
             for st_elem in et_element.iterfind("STATE-TRANSITIONS/STATE-TRANSITION")
         ]
 
@@ -42,7 +43,7 @@ class StateChart(IdentifiableElement):
         start_state_snref = start_state_snref_elem.attrib["SHORT-NAME"]
 
         states = [
-            State.from_et(st_elem, doc_frags) for st_elem in et_element.iterfind("STATES/STATE")
+            State.from_et(st_elem, context) for st_elem in et_element.iterfind("STATES/STATE")
         ]
 
         return StateChart(

odxtools/statemachine.py

@@ -13,7 +13,7 @@ if TYPE_CHECKING:
     from .diagservice import DiagService
 
 
-@dataclass
+@dataclass(kw_only=True)
 class StateMachine:
     """Objects of this class represent the runtime state of a state chart
 
@@ -160,7 +160,7 @@ class StateMachine:
 
         if raw_resp is None:
             raise RuntimeError("The calling code must send back a reply")
-        elif isinstance(raw_resp, bytes | bytearray):
+        elif isinstance(raw_resp, (bytes, bytearray)):
             for decoded_resp_msg in self.diag_layer.decode_response(raw_resp, raw_req):
                 for stransref in service.state_transition_refs:
                     # we only execute the first applicable state

odxtools/statetransition.py

@@ -6,20 +6,21 @@ from xml.etree import ElementTree
 from .element import IdentifiableElement
 from .exceptions import odxrequire
 from .externalaccessmethod import ExternalAccessMethod
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, resolve_snref
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, resolve_snref
 from .snrefcontext import SnRefContext
 from .state import State
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class StateTransition(IdentifiableElement):
     """
     Corresponds to STATE-TRANSITION.
     """
     source_snref: str
     target_snref: str
-    external_access_method: ExternalAccessMethod | None
+    external_access_method: ExternalAccessMethod | None = None
 
     @property
     def source_state(self) -> State:
@@ -30,10 +31,9 @@ class StateTransition(IdentifiableElement):
         return self._target_state
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "StateTransition":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "StateTransition":
 
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
 
         source_snref_elem = odxrequire(et_element.find("SOURCE-SNREF"))
         source_snref = odxrequire(source_snref_elem.attrib["SHORT-NAME"])
@@ -43,7 +43,7 @@ class StateTransition(IdentifiableElement):
 
         external_access_method = None
         if (eam_elem := et_element.find("EXTERNAL-ACCESS-METHOD")) is not None:
-            external_access_method = ExternalAccessMethod.from_et(eam_elem, doc_frags)
+            external_access_method = ExternalAccessMethod.from_et(eam_elem, context)
         return StateTransition(
             source_snref=source_snref,
             target_snref=target_snref,

odxtools/statetransitionref.py

@@ -6,7 +6,8 @@ from xml.etree import ElementTree
 from .basicstructure import BasicStructure
 from .dataobjectproperty import DataObjectProperty
 from .exceptions import odxassert, 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, ParameterValueDict
 from .parameters.codedconstparameter import CodedConstParameter
 from .parameters.parameter import Parameter
@@ -108,13 +109,13 @@ def _check_applies(ref: Union["StateTransitionRef",
         return False
     elif not isinstance(
             param,
-            CodedConstParameter | PhysicalConstantParameter | TableKeyParameter | ValueParameter):
+        (CodedConstParameter, PhysicalConstantParameter, TableKeyParameter, ValueParameter)):
         # see checker rule 194 in section B.2 of the spec
         odxraise(f"Parameter referenced by state transition ref is of "
                  f"invalid type {type(param).__name__}")
         return False
-    elif isinstance(param, CodedConstParameter | PhysicalConstantParameter
-                    | TableKeyParameter) and ref.value is not None:
+    elif isinstance(param, (CodedConstParameter, PhysicalConstantParameter,
+                            TableKeyParameter)) and ref.value is not None:
         # see checker rule 193 in section B.2 of the spec. Why can
         # no values for constant parameters be specified? (This
         # seems to be rather inconvenient...)
@@ -146,7 +147,7 @@ def _check_applies(ref: Union["StateTransitionRef",
     return True
 
 
-@dataclass
+@dataclass(kw_only=True)
 class StateTransitionRef(OdxLinkRef):
     """Describes a state transition that is to be potentially taken if
     a diagnostic communication is executed
@@ -155,10 +156,10 @@ class StateTransitionRef(OdxLinkRef):
     may also be conditional on the observed response of the ECU.
 
     """
-    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_transition(self) -> StateTransition:
@@ -170,9 +171,8 @@ class StateTransitionRef(OdxLinkRef):
 
     @staticmethod
     def from_et(  # type: ignore[override]
-            et_element: ElementTree.Element,
-            doc_frags: list[OdxDocFragment]) -> "StateTransitionRef":
-        kwargs = dataclass_fields_asdict(OdxLinkRef.from_et(et_element, doc_frags))
+            et_element: ElementTree.Element, context: OdxDocContext) -> "StateTransitionRef":
+        kwargs = dataclass_fields_asdict(OdxLinkRef.from_et(et_element, context))
 
         value = et_element.findtext("VALUE")
 

odxtools/staticfield.py

@@ -10,13 +10,14 @@ from .decodestate import DecodeState
 from .encodestate import EncodeState
 from .exceptions import odxassert, odxraise, odxrequire
 from .field import Field
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
 from .odxtypes import ParameterValue
 from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class StaticField(Field):
     """Array of a fixed number of structure objects"""
     fixed_number_of_items: int
@@ -24,8 +25,8 @@ class StaticField(Field):
 
     @staticmethod
     @override
-    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "StaticField":
-        kwargs = dataclass_fields_asdict(Field.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "StaticField":
+        kwargs = dataclass_fields_asdict(Field.from_et(et_element, context))
 
         fixed_number_of_items = int(odxrequire(et_element.findtext('FIXED-NUMBER-OF-ITEMS')))
         item_byte_size = int(odxrequire(et_element.findtext('ITEM-BYTE-SIZE')))

odxtools/structure.py

@@ -3,23 +3,23 @@ from dataclasses import dataclass
 from xml.etree import ElementTree
 
 from .basicstructure import BasicStructure
-from .odxlink import OdxDocFragment
+from .odxdoccontext import OdxDocContext
 from .odxtypes import odxstr_to_bool
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class Structure(BasicStructure):
-    is_visible_raw: bool | None
+    is_visible_raw: bool | None = None
 
     @property
     def is_visible(self) -> bool:
         return self.is_visible_raw in (True, None)
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "Structure":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Structure":
         """Read a STRUCTURE element from XML."""
-        kwargs = dataclass_fields_asdict(BasicStructure.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(BasicStructure.from_et(et_element, context))
 
         is_visible_raw = odxstr_to_bool(et_element.get("IS-VISIBLE"))