odxtools 9.5.0__py3-none-any.whl → 9.6.0__py3-none-any.whl

odxtools/diaglayercontainer.py

@@ -22,12 +22,16 @@ if TYPE_CHECKING:
 
 @dataclass
 class DiagLayerContainer(OdxCategory):
-    ecu_shared_datas: NamedItemList[EcuSharedData]
     protocols: NamedItemList[Protocol]
     functional_groups: NamedItemList[FunctionalGroup]
+    ecu_shared_datas: NamedItemList[EcuSharedData]
     base_variants: NamedItemList[BaseVariant]
     ecu_variants: NamedItemList[EcuVariant]
 
+    @property
+    def diag_layers(self) -> NamedItemList[DiagLayer]:
+        return self._diag_layers
+
     @property
     def ecus(self) -> NamedItemList[EcuVariant]:
         """ECU variants defined in the container
@@ -35,15 +39,6 @@ class DiagLayerContainer(OdxCategory):
         This property is an alias for `.ecu_variants`"""
         return self.ecu_variants
 
-    def __post_init__(self) -> None:
-        self._diag_layers = NamedItemList[DiagLayer](chain(
-            self.ecu_shared_datas,
-            self.protocols,
-            self.functional_groups,
-            self.base_variants,
-            self.ecu_variants,
-        ),)
-
     @staticmethod
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "DiagLayerContainer":
@@ -52,10 +47,6 @@ class DiagLayerContainer(OdxCategory):
         doc_frags = cat.odx_id.doc_fragments
         kwargs = dataclass_fields_asdict(cat)
 
-        ecu_shared_datas = NamedItemList([
-            EcuSharedData.from_et(dl_element, doc_frags)
-            for dl_element in et_element.iterfind("ECU-SHARED-DATAS/ECU-SHARED-DATA")
-        ])
         protocols = NamedItemList([
             Protocol.from_et(dl_element, doc_frags)
             for dl_element in et_element.iterfind("PROTOCOLS/PROTOCOL")
@@ -64,6 +55,10 @@ class DiagLayerContainer(OdxCategory):
             FunctionalGroup.from_et(dl_element, doc_frags)
             for dl_element in et_element.iterfind("FUNCTIONAL-GROUPS/FUNCTIONAL-GROUP")
         ])
+        ecu_shared_datas = NamedItemList([
+            EcuSharedData.from_et(dl_element, doc_frags)
+            for dl_element in et_element.iterfind("ECU-SHARED-DATAS/ECU-SHARED-DATA")
+        ])
         base_variants = NamedItemList([
             BaseVariant.from_et(dl_element, doc_frags)
             for dl_element in et_element.iterfind("BASE-VARIANTS/BASE-VARIANT")
@@ -74,22 +69,31 @@ class DiagLayerContainer(OdxCategory):
         ])
 
         return DiagLayerContainer(
-            ecu_shared_datas=ecu_shared_datas,
             protocols=protocols,
             functional_groups=functional_groups,
+            ecu_shared_datas=ecu_shared_datas,
             base_variants=base_variants,
             ecu_variants=ecu_variants,
             **kwargs)
 
+    def __post_init__(self) -> None:
+        self._diag_layers = NamedItemList[DiagLayer](chain(
+            self.protocols,
+            self.functional_groups,
+            self.ecu_shared_datas,
+            self.base_variants,
+            self.ecu_variants,
+        ),)
+
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         result = super()._build_odxlinks()
 
-        for ecu_shared_data in self.ecu_shared_datas:
-            result.update(ecu_shared_data._build_odxlinks())
         for protocol in self.protocols:
             result.update(protocol._build_odxlinks())
         for functional_group in self.functional_groups:
             result.update(functional_group._build_odxlinks())
+        for ecu_shared_data in self.ecu_shared_datas:
+            result.update(ecu_shared_data._build_odxlinks())
         for base_variant in self.base_variants:
             result.update(base_variant._build_odxlinks())
         for ecu_variant in self.ecu_variants:
@@ -100,12 +104,12 @@ class DiagLayerContainer(OdxCategory):
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         super()._resolve_odxlinks(odxlinks)
 
-        for ecu_shared_data in self.ecu_shared_datas:
-            ecu_shared_data._resolve_odxlinks(odxlinks)
         for protocol in self.protocols:
             protocol._resolve_odxlinks(odxlinks)
         for functional_group in self.functional_groups:
             functional_group._resolve_odxlinks(odxlinks)
+        for ecu_shared_data in self.ecu_shared_datas:
+            ecu_shared_data._resolve_odxlinks(odxlinks)
         for base_variant in self.base_variants:
             base_variant._resolve_odxlinks(odxlinks)
         for ecu_variant in self.ecu_variants:
@@ -114,12 +118,12 @@ class DiagLayerContainer(OdxCategory):
     def _finalize_init(self, database: "Database", odxlinks: OdxLinkDatabase) -> None:
         super()._finalize_init(database, odxlinks)
 
-        for ecu_shared_data in self.ecu_shared_datas:
-            ecu_shared_data._finalize_init(database, odxlinks)
         for protocol in self.protocols:
             protocol._finalize_init(database, odxlinks)
         for functional_group in self.functional_groups:
             functional_group._finalize_init(database, odxlinks)
+        for ecu_shared_data in self.ecu_shared_datas:
+            ecu_shared_data._finalize_init(database, odxlinks)
         for base_variant in self.base_variants:
             base_variant._finalize_init(database, odxlinks)
         for ecu_variant in self.ecu_variants:
@@ -128,9 +132,5 @@ class DiagLayerContainer(OdxCategory):
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         super()._resolve_snrefs(context)
 
-    @property
-    def diag_layers(self) -> NamedItemList[DiagLayer]:
-        return self._diag_layers
-
     def __getitem__(self, key: Union[int, str]) -> DiagLayer:
         return self.diag_layers[key]

odxtools/diaglayers/diaglayerraw.py

@@ -88,15 +88,15 @@ class DiagLayerRaw(IdentifiableElement):
         if (admin_data_elem := et_element.find("ADMIN-DATA")) is not None:
             admin_data = AdminData.from_et(admin_data_elem, doc_frags)
 
-        company_datas = [
+        company_datas = NamedItemList([
             CompanyData.from_et(cd_el, doc_frags)
             for cd_el in et_element.iterfind("COMPANY-DATAS/COMPANY-DATA")
-        ]
+        ])
 
-        functional_classes = [
+        functional_classes = NamedItemList([
             FunctionalClass.from_et(fc_el, doc_frags)
             for fc_el in et_element.iterfind("FUNCT-CLASSS/FUNCT-CLASS")
-        ]
+        ])
 
         diag_data_dictionary_spec = None
         if (ddds_elem := et_element.find("DIAG-DATA-DICTIONARY-SPEC")) is not None:
@@ -141,24 +141,23 @@ class DiagLayerRaw(IdentifiableElement):
             for el in et_element.iterfind("IMPORT-REFS/IMPORT-REF")
         ]
 
-        state_charts = [
+        state_charts = NamedItemList([
             StateChart.from_et(el, doc_frags)
             for el in et_element.iterfind("STATE-CHARTS/STATE-CHART")
-        ]
+        ])
 
-        additional_audiences = [
+        additional_audiences = NamedItemList([
             AdditionalAudience.from_et(el, doc_frags)
             for el in et_element.iterfind("ADDITIONAL-AUDIENCES/ADDITIONAL-AUDIENCE")
-        ]
-
-        libraries = [
-            Library.from_et(el, doc_frags) for el in et_element.iterfind("LIBRARYS/LIBRARY")
-        ]
+        ])
 
-        sub_components = [
+        sub_components = NamedItemList([
             SubComponent.from_et(el, doc_frags)
             for el in et_element.iterfind("SUB-COMPONENTS/SUB-COMPONENT")
-        ]
+        ])
+
+        libraries = NamedItemList(
+            [Library.from_et(el, doc_frags) for el in et_element.iterfind("LIBRARYS/LIBRARY")])
 
         sdgs = [
             SpecialDataGroup.from_et(sdge, doc_frags) for sdge in et_element.iterfind("SDGS/SDG")
@@ -168,19 +167,19 @@ class DiagLayerRaw(IdentifiableElement):
         return DiagLayerRaw(
             variant_type=variant_type,
             admin_data=admin_data,
-            company_datas=NamedItemList(company_datas),
-            functional_classes=NamedItemList(functional_classes),
+            company_datas=company_datas,
+            functional_classes=functional_classes,
             diag_data_dictionary_spec=diag_data_dictionary_spec,
             diag_comms_raw=diag_comms_raw,
             requests=requests,
             positive_responses=positive_responses,
             negative_responses=negative_responses,
-            global_negative_responses=NamedItemList(global_negative_responses),
+            global_negative_responses=global_negative_responses,
             import_refs=import_refs,
-            state_charts=NamedItemList(state_charts),
-            additional_audiences=NamedItemList(additional_audiences),
-            libraries=NamedItemList(libraries),
-            sub_components=NamedItemList(sub_components),
+            state_charts=state_charts,
+            additional_audiences=additional_audiences,
+            sub_components=sub_components,
+            libraries=libraries,
             sdgs=sdgs,
             **kwargs)
 
@@ -213,10 +212,10 @@ class DiagLayerRaw(IdentifiableElement):
             odxlinks.update(state_chart._build_odxlinks())
         for additional_audience in self.additional_audiences:
             odxlinks.update(additional_audience._build_odxlinks())
-        for library in self.libraries:
-            odxlinks.update(library._build_odxlinks())
         for sub_comp in self.sub_components:
             odxlinks.update(sub_comp._build_odxlinks())
+        for library in self.libraries:
+            odxlinks.update(library._build_odxlinks())
         for sdg in self.sdgs:
             odxlinks.update(sdg._build_odxlinks())
 
@@ -269,10 +268,10 @@ class DiagLayerRaw(IdentifiableElement):
             state_chart._resolve_odxlinks(odxlinks)
         for additional_audience in self.additional_audiences:
             additional_audience._resolve_odxlinks(odxlinks)
-        for library in self.libraries:
-            library._resolve_odxlinks(odxlinks)
         for sub_component in self.sub_components:
             sub_component._resolve_odxlinks(odxlinks)
+        for library in self.libraries:
+            library._resolve_odxlinks(odxlinks)
         for sdg in self.sdgs:
             sdg._resolve_odxlinks(odxlinks)
 
@@ -303,9 +302,9 @@ class DiagLayerRaw(IdentifiableElement):
             state_chart._resolve_snrefs(context)
         for additional_audience in self.additional_audiences:
             additional_audience._resolve_snrefs(context)
-        for library in self.libraries:
-            library._resolve_snrefs(context)
         for sub_component in self.sub_components:
             sub_component._resolve_snrefs(context)
+        for library in self.libraries:
+            library._resolve_snrefs(context)
         for sdg in self.sdgs:
             sdg._resolve_snrefs(context)

odxtools/diagnostictroublecode.py

@@ -9,18 +9,20 @@ from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from .odxtypes import odxstr_to_bool
 from .snrefcontext import SnRefContext
 from .specialdatagroup import SpecialDataGroup
+from .text import Text
 from .utils import dataclass_fields_asdict
 
 
 @dataclass
 class DiagnosticTroubleCode(IdentifiableElement):
     trouble_code: int
-    text: str
     display_trouble_code: Optional[str]
+    text: Text
     level: Optional[int]
-    is_temporary_raw: Optional[bool]
     sdgs: List[SpecialDataGroup]
 
+    is_temporary_raw: Optional[bool]
+
     @property
     def is_temporary(self) -> bool:
         return self.is_temporary_raw is True
@@ -29,31 +31,32 @@ class DiagnosticTroubleCode(IdentifiableElement):
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "DiagnosticTroubleCode":
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
-        display_trouble_code = et_element.findtext("DISPLAY-TROUBLE-CODE")
 
+        trouble_code = int(odxrequire(et_element.findtext("TROUBLE-CODE")))
+        display_trouble_code = et_element.findtext("DISPLAY-TROUBLE-CODE")
+        text = Text.from_et(odxrequire(et_element.find("TEXT")), doc_frags)
         level = None
         if (level_str := et_element.findtext("LEVEL")) is not None:
             level = int(level_str)
-
-        is_temporary_raw = odxstr_to_bool(et_element.get("IS-TEMPORARY"))
         sdgs = [
             SpecialDataGroup.from_et(sdge, doc_frags) for sdge in et_element.iterfind("SDGS/SDG")
         ]
 
+        is_temporary_raw = odxstr_to_bool(et_element.attrib.get("IS-TEMPORARY"))
+
         return DiagnosticTroubleCode(
-            trouble_code=int(odxrequire(et_element.findtext("TROUBLE-CODE"))),
-            text=odxrequire(et_element.findtext("TEXT")),
+            trouble_code=trouble_code,
+            text=text,
             display_trouble_code=display_trouble_code,
             level=level,
-            is_temporary_raw=is_temporary_raw,
             sdgs=sdgs,
+            is_temporary_raw=is_temporary_raw,
             **kwargs)
 
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         result: Dict[OdxLinkId, Any] = {}
 
-        if self.odx_id is not None:
-            result[self.odx_id] = self
+        result[self.odx_id] = self
 
         for sdg in self.sdgs:
             result.update(sdg._build_odxlinks())

odxtools/diagservice.py

@@ -102,11 +102,9 @@ class DiagService(DiagComm):
     """
 
     comparam_refs: List[ComparamInstance]
-
     request_ref: OdxLinkRef
     pos_response_refs: List[OdxLinkRef]
     neg_response_refs: List[OdxLinkRef]
-
     pos_response_suppressible: Optional[PosResponseSuppressible]
 
     is_cyclic_raw: Optional[bool]
@@ -114,6 +112,45 @@ class DiagService(DiagComm):
     addressing_raw: Optional[Addressing]
     transmission_mode_raw: Optional[TransMode]
 
+    @property
+    def comparams(self) -> NamedItemList[ComparamInstance]:
+        return self._comparams
+
+    @property
+    def request(self) -> Optional[Request]:
+        return self._request
+
+    @property
+    def positive_responses(self) -> NamedItemList[Response]:
+        return self._positive_responses
+
+    @property
+    def negative_responses(self) -> NamedItemList[Response]:
+        return self._negative_responses
+
+    @property
+    def is_cyclic(self) -> bool:
+        return self.is_cyclic_raw is True
+
+    @property
+    def is_multiple(self) -> bool:
+        return self.is_multiple_raw is True
+
+    @property
+    def addressing(self) -> Addressing:
+        return self.addressing_raw or Addressing.PHYSICAL
+
+    @property
+    def transmission_mode(self) -> TransMode:
+        return self.transmission_mode_raw or TransMode.SEND_AND_RECEIVE
+
+    @property
+    def free_parameters(self) -> List[Parameter]:
+        """Return the list of parameters which can be freely specified by
+        the user when encoding the service's request.
+        """
+        return self.request.free_parameters if self.request is not None else []
+
     @staticmethod
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "DiagService":
 
@@ -171,54 +208,6 @@ class DiagService(DiagComm):
             transmission_mode_raw=transmission_mode_raw,
             **kwargs)
 
-    @property
-    def request(self) -> Optional[Request]:
-        return self._request
-
-    @property
-    def free_parameters(self) -> List[Parameter]:
-        """Return the list of parameters which can be freely specified by
-        the user when encoding the service's request.
-        """
-        return self.request.free_parameters if self.request is not None else []
-
-    def print_free_parameters_info(self) -> None:
-        """Return a human readable description of the service's
-        request's free parameters.
-        """
-        if self.request is None:
-            return
-
-        self.request.print_free_parameters_info()
-
-    @property
-    def positive_responses(self) -> NamedItemList[Response]:
-        return self._positive_responses
-
-    @property
-    def negative_responses(self) -> NamedItemList[Response]:
-        return self._negative_responses
-
-    @property
-    def comparams(self) -> NamedItemList[ComparamInstance]:
-        return self._comparams
-
-    @property
-    def addressing(self) -> Addressing:
-        return self.addressing_raw or Addressing.PHYSICAL
-
-    @property
-    def transmission_mode(self) -> TransMode:
-        return self.transmission_mode_raw or TransMode.SEND_AND_RECEIVE
-
-    @property
-    def is_cyclic(self) -> bool:
-        return self.is_cyclic_raw is True
-
-    @property
-    def is_multiple(self) -> bool:
-        return self.is_multiple_raw is True
-
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         result = super()._build_odxlinks()
 
@@ -256,6 +245,15 @@ class DiagService(DiagComm):
 
         context.diag_service = None
 
+    def print_free_parameters_info(self) -> None:
+        """Return a human readable description of the service's
+        request's free parameters.
+        """
+        if self.request is None:
+            return
+
+        self.request.print_free_parameters_info()
+
     def decode_message(self, raw_message: bytes) -> Message:
         request_prefix = b''
         candidate_coding_objects: List[Union[Request, Response]] = [

odxtools/diagvariable.py

@@ -46,6 +46,7 @@ class DiagVariable(IdentifiableElement):
     table_row_snref: Optional[str]
 
     sdgs: List[SpecialDataGroup]
+
     is_read_before_write_raw: Optional[bool]
 
     @property
@@ -91,6 +92,7 @@ class DiagVariable(IdentifiableElement):
         sdgs = [
             SpecialDataGroup.from_et(sdge, doc_frags) for sdge in et_element.iterfind("SDGS/SDG")
         ]
+
         is_read_before_write_raw = odxstr_to_bool(et_element.get("IS-READ-BEFORE-WRITE"))
 
         return DiagVariable(
@@ -119,26 +121,23 @@ class DiagVariable(IdentifiableElement):
         return result
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        if self.admin_data is not None:
+            self.admin_data._resolve_odxlinks(odxlinks)
+
         self._variable_group = None
         if self.variable_group_ref is not None:
             self._variable_group = odxlinks.resolve(self.variable_group_ref, VariableGroup)
 
-        if self.admin_data is not None:
-            self.admin_data._resolve_odxlinks(odxlinks)
+        for cr in self.comm_relations:
+            cr._resolve_odxlinks(odxlinks)
 
         for sdg in self.sdgs:
             sdg._resolve_odxlinks(odxlinks)
 
-        for cr in self.comm_relations:
-            cr._resolve_odxlinks(odxlinks)
-
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         if self.admin_data is not None:
             self.admin_data._resolve_snrefs(context)
 
-        for sdg in self.sdgs:
-            sdg._resolve_snrefs(context)
-
         for cr in self.comm_relations:
             cr._resolve_snrefs(context)
 
@@ -149,3 +148,6 @@ class DiagVariable(IdentifiableElement):
             self._table = resolve_snref(self.table_snref, ddds.tables, Table)
             self._table_row = resolve_snref(
                 odxrequire(self.table_row_snref), self._table.table_rows, TableRow)
+
+        for sdg in self.sdgs:
+            sdg._resolve_snrefs(context)

odxtools/docrevision.py

@@ -17,10 +17,10 @@ class DocRevision:
     Representation of a single revision of the relevant object.
     """
 
-    date: str
     team_member_ref: Optional[OdxLinkRef]
     revision_label: Optional[str]
     state: Optional[str]
+    date: str
     tool: Optional[str]
     company_revision_infos: List[CompanyRevisionInfo]
     modifications: List[Modification]
@@ -38,13 +38,13 @@ class DocRevision:
         date = odxrequire(et_element.findtext("DATE"))
         tool = et_element.findtext("TOOL")
 
-        crilist = [
+        company_revision_infos = [
             CompanyRevisionInfo.from_et(cri_elem, doc_frags)
             for cri_elem in et_element.iterfind("COMPANY-REVISION-INFOS/"
                                                 "COMPANY-REVISION-INFO")
         ]
 
-        modlist = [
+        modifications = [
             Modification.from_et(mod_elem, doc_frags)
             for mod_elem in et_element.iterfind("MODIFICATIONS/MODIFICATION")
         ]
@@ -55,8 +55,8 @@ class DocRevision:
             state=state,
             date=date,
             tool=tool,
-            company_revision_infos=crilist,
-            modifications=modlist,
+            company_revision_infos=company_revision_infos,
+            modifications=modifications,
         )
 
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:

odxtools/dtcdop.py

@@ -27,6 +27,10 @@ class LinkedDtcDop:
     not_inherited_dtc_snrefs: List[str]
     dtc_dop_ref: OdxLinkRef
 
+    @property
+    def not_inherited_dtcs(self) -> NamedItemList[DiagnosticTroubleCode]:
+        return self._not_inherited_dtcs
+
     @property
     def dtc_dop(self) -> "DtcDop":
         return self._dtc_dop
@@ -35,10 +39,6 @@ class LinkedDtcDop:
     def short_name(self) -> str:
         return self._dtc_dop.short_name
 
-    @property
-    def not_inherited_dtcs(self) -> NamedItemList[DiagnosticTroubleCode]:
-        return self._not_inherited_dtcs
-
     @staticmethod
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "LinkedDtcDop":
         not_inherited_dtc_snrefs = [
@@ -79,8 +79,17 @@ class DtcDop(DopBase):
     linked_dtc_dops_raw: List[LinkedDtcDop]
     is_visible_raw: Optional[bool]
 
-    def __post_init__(self) -> None:
-        self._init_finished = False
+    @property
+    def dtcs(self) -> NamedItemList[DiagnosticTroubleCode]:
+        return self._dtcs
+
+    @property
+    def linked_dtc_dops(self) -> NamedItemList[LinkedDtcDop]:
+        return self._linked_dtc_dops
+
+    @property
+    def is_visible(self) -> bool:
+        return self.is_visible_raw is True
 
     @staticmethod
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "DtcDop":
@@ -121,17 +130,8 @@ class DtcDop(DopBase):
             is_visible_raw=is_visible_raw,
             **kwargs)
 
-    @property
-    def dtcs(self) -> NamedItemList[DiagnosticTroubleCode]:
-        return self._dtcs
-
-    @property
-    def linked_dtc_dops(self) -> NamedItemList[LinkedDtcDop]:
-        return self._linked_dtc_dops
-
-    @property
-    def is_visible(self) -> bool:
-        return self.is_visible_raw is True
+    def __post_init__(self) -> None:
+        self._init_finished = False
 
     @override
     def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:

odxtools/dynamicendmarkerfield.py

@@ -23,6 +23,14 @@ class DynamicEndmarkerField(Field):
 
     dyn_end_dop_ref: DynEndDopRef
 
+    @property
+    def dyn_end_dop(self) -> DataObjectProperty:
+        return self._dyn_end_dop
+
+    @property
+    def termination_value(self) -> AtomicOdxType:
+        return self._termination_value
+
     @staticmethod
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "DynamicEndmarkerField":
@@ -52,14 +60,6 @@ class DynamicEndmarkerField(Field):
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         super()._resolve_snrefs(context)
 
-    @property
-    def dyn_end_dop(self) -> DataObjectProperty:
-        return self._dyn_end_dop
-
-    @property
-    def termination_value(self) -> AtomicOdxType:
-        return self._termination_value
-
     @override
     def encode_into_pdu(self, physical_value: ParameterValue, encode_state: EncodeState) -> None:
 

odxtools/dynamiclengthfield.py

@@ -26,11 +26,13 @@ class DynamicLengthField(Field):
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "DynamicLengthField":
         kwargs = dataclass_fields_asdict(Field.from_et(et_element, doc_frags))
+
         offset = int(odxrequire(et_element.findtext('OFFSET')))
         determine_number_of_items = DetermineNumberOfItems.from_et(
             odxrequire(et_element.find('DETERMINE-NUMBER-OF-ITEMS')),
             doc_frags,
         )
+
         return DynamicLengthField(
             offset=offset, determine_number_of_items=determine_number_of_items, **kwargs)