odxtools 10.2.1__py3-none-any.whl → 10.4.0__py3-none-any.whl

odxtools/cli/browse.py

@@ -255,8 +255,10 @@ def encode_message_from_string_values(
                     print(f"The value specified for parameter {inner_param_sn} is not a string")
                     continue
 
-                typed_dict[inner_param_sn] = _convert_string_to_odx_type(
-                    inner_param_value, inner_param.physical_type.base_data_type)
+                if isinstance(inner_param,
+                              ParameterWithDOP) and inner_param.physical_type is not None:
+                    typed_dict[inner_param_sn] = _convert_string_to_odx_type(
+                        inner_param_value, inner_param.physical_type.base_data_type)
             parameter_values[parameter.short_name] = typed_dict
         else:
             if not isinstance(parameter_value, str):

odxtools/cli/compare.py

@@ -425,10 +425,10 @@ class Comparison(Display):
             changed_parameters_of_service=services_with_param_changes)
         dl1_service_names = [service.short_name for service in dl1.services]
 
-        dl1_request_prefixes: list[bytes | None] = [
+        dl1_request_prefixes: list[bytes | bytearray | None] = [
             None if s.request is None else s.request.coded_const_prefix() for s in dl1.services
         ]
-        dl2_request_prefixes: list[bytes | None] = [
+        dl2_request_prefixes: list[bytes | bytearray | None] = [
             None if s.request is None else s.request.coded_const_prefix() for s in dl2.services
         ]
 
@@ -436,7 +436,7 @@ class Comparison(Display):
         for service1 in dl1.services:
 
             # check for added diagnostic services
-            rq_prefix: bytes
+            rq_prefix: bytes | bytearray
             if service1.request is not None:
                 rq_prefix = service1.request.coded_const_prefix()
 

odxtools/compositecodec.py

@@ -79,7 +79,7 @@ def composite_codec_get_free_parameters(codec: CompositeCodec) -> list[Parameter
 
 
 def composite_codec_get_coded_const_prefix(codec: CompositeCodec,
-                                           request_prefix: bytes = b'') -> bytes:
+                                           request_prefix: bytes = b'') -> bytearray:
     encode_state = EncodeState(coded_message=bytearray(), triggering_request=request_prefix)
 
     for param in codec.parameters:

odxtools/configdata.py

@@ -0,0 +1,70 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass, field
+from typing import Any
+from xml.etree import ElementTree
+
+from .configrecord import ConfigRecord
+from .element import NamedElement
+from .nameditemlist import NamedItemList
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
+from .specialdatagroup import SpecialDataGroup
+from .utils import dataclass_fields_asdict
+from .validbasevariant import ValidBaseVariant
+
+
+@dataclass(kw_only=True)
+class ConfigData(NamedElement):
+    """This class represents a CONFIG-DATA."""
+    valid_base_variants: list[ValidBaseVariant]
+    config_records: NamedItemList[ConfigRecord]
+    sdgs: list[SpecialDataGroup] = field(default_factory=list)
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "ConfigData":
+        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, context))
+
+        valid_base_variants = [
+            ValidBaseVariant.from_et(vbv_elem, context)
+            for vbv_elem in et_element.iterfind("VALID-BASE-VARIANTS/VALID-BASE-VARIANT")
+        ]
+        config_records = NamedItemList([
+            ConfigRecord.from_et(cr_elem, context)
+            for cr_elem in et_element.iterfind("CONFIG-RECORDS/CONFIG-RECORD")
+        ])
+        sdgs = [SpecialDataGroup.from_et(sdge, context) for sdge in et_element.iterfind("SDGS/SDG")]
+
+        return ConfigData(
+            valid_base_variants=valid_base_variants,
+            config_records=config_records,
+            sdgs=sdgs,
+            **kwargs)
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        result = {}
+
+        for valid_base_variant in self.valid_base_variants:
+            result.update(valid_base_variant._build_odxlinks())
+        for config_record in self.config_records:
+            result.update(config_record._build_odxlinks())
+        for sdg in self.sdgs:
+            result.update(sdg._build_odxlinks())
+
+        return result
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        for valid_base_variant in self.valid_base_variants:
+            valid_base_variant._resolve_odxlinks(odxlinks)
+        for config_record in self.config_records:
+            config_record._resolve_odxlinks(odxlinks)
+        for sdg in self.sdgs:
+            sdg._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        for valid_base_variant in self.valid_base_variants:
+            valid_base_variant._resolve_snrefs(context)
+        for config_record in self.config_records:
+            config_record._resolve_snrefs(context)
+        for sdg in self.sdgs:
+            sdg._resolve_snrefs(context)

odxtools/configdatadictionaryspec.py

@@ -0,0 +1,57 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass, field
+from typing import Any
+from xml.etree import ElementTree
+
+from .dataobjectproperty import DataObjectProperty
+from .nameditemlist import NamedItemList
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
+from .unitspec import UnitSpec
+
+
+@dataclass(kw_only=True)
+class ConfigDataDictionarySpec:
+    data_object_props: NamedItemList[DataObjectProperty] = field(default_factory=NamedItemList)
+    unit_spec: UnitSpec | None = None
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                context: OdxDocContext) -> "ConfigDataDictionarySpec":
+        data_object_props = NamedItemList([
+            DataObjectProperty.from_et(dop_element, context)
+            for dop_element in et_element.iterfind("DATA-OBJECT-PROPS/DATA-OBJECT-PROP")
+        ])
+
+        if (spec_elem := et_element.find("UNIT-SPEC")) is not None:
+            unit_spec = UnitSpec.from_et(spec_elem, context)
+        else:
+            unit_spec = None
+
+        return ConfigDataDictionarySpec(
+            data_object_props=data_object_props,
+            unit_spec=unit_spec,
+        )
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        odxlinks = {}
+
+        for data_object_prop in self.data_object_props:
+            odxlinks.update(data_object_prop._build_odxlinks())
+        if self.unit_spec is not None:
+            odxlinks.update(self.unit_spec._build_odxlinks())
+
+        return odxlinks
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        for data_object_prop in self.data_object_props:
+            data_object_prop._resolve_odxlinks(odxlinks)
+        if self.unit_spec is not None:
+            self.unit_spec._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        for data_object_prop in self.data_object_props:
+            data_object_prop._resolve_snrefs(context)
+        if self.unit_spec is not None:
+            self.unit_spec._resolve_snrefs(context)

odxtools/configiditem.py

@@ -0,0 +1,18 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from xml.etree import ElementTree
+
+from .configitem import ConfigItem
+from .odxdoccontext import OdxDocContext
+from .utils import dataclass_fields_asdict
+
+
+@dataclass(kw_only=True)
+class ConfigIdItem(ConfigItem):
+    """This class represents a CONFIG-ID-ITEM."""
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "ConfigIdItem":
+        kwargs = dataclass_fields_asdict(ConfigItem.from_et(et_element, context))
+
+        return ConfigIdItem(**kwargs)

odxtools/configitem.py

@@ -0,0 +1,85 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass, field
+from typing import Any
+from xml.etree import ElementTree
+
+from .dopbase import DopBase
+from .element import NamedElement
+from .exceptions import odxrequire
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from .snrefcontext import SnRefContext
+from .specialdatagroup import SpecialDataGroup
+from .utils import dataclass_fields_asdict
+
+
+@dataclass(kw_only=True)
+class ConfigItem(NamedElement):
+    """This class represents a CONFIG-ITEM.
+
+    CONFIG-ITEM is the base class for CONFIG-ID-ITEM, DATA-ID-ITEM,
+    OPTION-ITEM, and SYSTEM-ITEM.
+    """
+    byte_position: int | None = None
+    bit_position: int | None = None
+
+    # according to the spec exactly one of the following two
+    # attributes is not None...x
+    data_object_prop_ref: OdxLinkRef | None = None
+    data_object_prop_snref: str | None = None
+    sdgs: list[SpecialDataGroup] = field(default_factory=list)
+
+    @property
+    def data_object_prop(self) -> DopBase:
+        return self._data_object_prop
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "ConfigItem":
+        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, context))
+
+        byte_position = None
+        if (byte_pos_elem := et_element.findtext("BYTE-POSITION")) is not None:
+            byte_position = int(byte_pos_elem)
+
+        bit_position = None
+        if (bit_pos_elem := et_element.findtext("BIT-POSITION")) is not None:
+            bit_position = int(bit_pos_elem)
+
+        data_object_prop_ref = OdxLinkRef.from_et(et_element.find("DATA-OBJECT-PROP-REF"), context)
+        data_object_prop_snref = None
+        if (data_object_prop_snref_elem := et_element.find("DATA-OBJECT-PROP-SNREF")) is not None:
+            data_object_prop_snref = odxrequire(
+                data_object_prop_snref_elem.attrib.get("SHORT-NAME"))
+        sdgs = [SpecialDataGroup.from_et(sdge, context) for sdge in et_element.iterfind("SDGS/SDG")]
+
+        return ConfigItem(
+            byte_position=byte_position,
+            bit_position=bit_position,
+            data_object_prop_ref=data_object_prop_ref,
+            data_object_prop_snref=data_object_prop_snref,
+            sdgs=sdgs,
+            **kwargs)
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        result = {}
+
+        for sdg in self.sdgs:
+            result.update(sdg._build_odxlinks())
+
+        return result
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        if self.data_object_prop_ref is not None:
+            self._data_object_prop = odxlinks.resolve(self.data_object_prop_ref, DopBase)
+
+        for sdg in self.sdgs:
+            sdg._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        if self.data_object_prop_snref is not None:
+            ddds = odxrequire(context.diag_layer).diag_data_dictionary_spec
+            self._data_object_prop = resolve_snref(self.data_object_prop_snref,
+                                                   ddds.all_data_object_properties, DopBase)
+
+        for sdg in self.sdgs:
+            sdg._resolve_snrefs(context)

odxtools/configrecord.py

@@ -0,0 +1,146 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass, field
+from typing import Any
+from xml.etree import ElementTree
+
+from .audience import Audience
+from .configiditem import ConfigIdItem
+from .dataiditem import DataIdItem
+from .datarecord import DataRecord
+from .diagcommdataconnector import DiagCommDataConnector
+from .element import NamedElement
+from .exceptions import odxrequire
+from .identvalue import IdentValue
+from .nameditemlist import NamedItemList
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .optionitem import OptionItem
+from .snrefcontext import SnRefContext
+from .specialdatagroup import SpecialDataGroup
+from .systemitem import SystemItem
+from .utils import dataclass_fields_asdict
+
+
+@dataclass(kw_only=True)
+class ConfigRecord(NamedElement):
+    """This class represents a CONFIG-RECORD."""
+    config_id_item: ConfigIdItem | None = None
+    diag_comm_data_connectors: list[DiagCommDataConnector] = field(default_factory=list)
+    config_id: IdentValue | None = None
+    data_records: NamedItemList[DataRecord] = field(default_factory=NamedItemList)
+    audience: Audience | None = None
+    system_items: NamedItemList[SystemItem] = field(default_factory=NamedItemList)
+    data_id_item: DataIdItem | None = None
+    option_items: NamedItemList[OptionItem] = field(default_factory=NamedItemList)
+    default_data_record_snref: str | None = None
+    sdgs: list[SpecialDataGroup] = field(default_factory=list)
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "ConfigRecord":
+        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, context))
+
+        config_id_item = None
+        if (cid_elem := et_element.find("CONFIG-ID-ITEM")) is not None:
+            config_id_item = ConfigIdItem.from_et(cid_elem, context)
+        diag_comm_data_connectors = [
+            DiagCommDataConnector.from_et(dcdc_elem, context) for dcdc_elem in et_element.iterfind(
+                "DIAG-COMM-DATA-CONNECTORS/DIAG-COMM-DATA-CONNECTOR")
+        ]
+        config_id = None
+        if (cid_elem := et_element.find("CONFIG-ID")) is not None:
+            config_id = IdentValue.from_et(cid_elem, context)
+        data_records = NamedItemList([
+            DataRecord.from_et(dr_elem, context)
+            for dr_elem in et_element.iterfind("DATA-RECORDS/DATA-RECORD")
+        ])
+        audience = None
+        if (aud_elem := et_element.find("AUDIENCE")) is not None:
+            audience = Audience.from_et(aud_elem, context)
+        system_items = NamedItemList([
+            SystemItem.from_et(si_elem, context)
+            for si_elem in et_element.iterfind("SYSTEM-ITEMS/SYSTEM-ITEM")
+        ])
+        data_id_item = None
+        if (dii_elem := et_element.find("DATA-ID-ITEM")) is not None:
+            data_id_item = DataIdItem.from_et(dii_elem, context)
+        option_items = NamedItemList([
+            OptionItem.from_et(si_elem, context)
+            for si_elem in et_element.iterfind("OPTION-ITEMS/OPTION-ITEM")
+        ])
+        default_data_record_snref = None
+        if (default_data_record_snref_elem :=
+                et_element.find("DEFAULT-DATA-RECORD-SNREF")) is not None:
+            default_data_record_snref = odxrequire(
+                default_data_record_snref_elem.attrib.get("SHORT-NAME"))
+        sdgs = [SpecialDataGroup.from_et(sdge, context) for sdge in et_element.iterfind("SDGS/SDG")]
+
+        return ConfigRecord(
+            config_id_item=config_id_item,
+            diag_comm_data_connectors=diag_comm_data_connectors,
+            config_id=config_id,
+            data_records=data_records,
+            audience=audience,
+            system_items=system_items,
+            data_id_item=data_id_item,
+            option_items=option_items,
+            default_data_record_snref=default_data_record_snref,
+            sdgs=sdgs,
+            **kwargs)
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        result = {}
+
+        if self.config_id_item is not None:
+            result.update(self.config_id_item._build_odxlinks())
+        for diag_comm_data_connector in self.diag_comm_data_connectors:
+            result.update(diag_comm_data_connector._build_odxlinks())
+        for data_record in self.data_records:
+            result.update(data_record._build_odxlinks())
+        if self.audience is not None:
+            result.update(self.audience._build_odxlinks())
+        for system_item in self.system_items:
+            result.update(system_item._build_odxlinks())
+        if self.data_id_item is not None:
+            result.update(self.data_id_item._build_odxlinks())
+        for option_item in self.option_items:
+            result.update(option_item._build_odxlinks())
+        for sdg in self.sdgs:
+            result.update(sdg._build_odxlinks())
+
+        return result
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        if self.config_id_item is not None:
+            self.config_id_item._resolve_odxlinks(odxlinks)
+        for diag_comm_data_connector in self.diag_comm_data_connectors:
+            diag_comm_data_connector._resolve_odxlinks(odxlinks)
+        for data_record in self.data_records:
+            data_record._resolve_odxlinks(odxlinks)
+        if self.audience is not None:
+            self.audience._resolve_odxlinks(odxlinks)
+        for system_item in self.system_items:
+            system_item._resolve_odxlinks(odxlinks)
+        if self.data_id_item is not None:
+            self.data_id_item._resolve_odxlinks(odxlinks)
+        for option_item in self.option_items:
+            option_item._resolve_odxlinks(odxlinks)
+        for sdg in self.sdgs:
+            sdg._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        if self.config_id_item is not None:
+            self.config_id_item._resolve_snrefs(context)
+        for diag_comm_data_connector in self.diag_comm_data_connectors:
+            diag_comm_data_connector._resolve_snrefs(context)
+        for data_record in self.data_records:
+            data_record._resolve_snrefs(context)
+        if self.audience is not None:
+            self.audience._resolve_snrefs(context)
+        for system_item in self.system_items:
+            system_item._resolve_snrefs(context)
+        if self.data_id_item is not None:
+            self.data_id_item._resolve_snrefs(context)
+        for option_item in self.option_items:
+            option_item._resolve_snrefs(context)
+        for sdg in self.sdgs:
+            sdg._resolve_snrefs(context)

odxtools/database.py

@@ -18,8 +18,10 @@ from .diaglayers.ecushareddata import EcuSharedData
 from .diaglayers.ecuvariant import EcuVariant
 from .diaglayers.functionalgroup import FunctionalGroup
 from .diaglayers.protocol import Protocol
+from .ecuconfig import EcuConfig
 from .exceptions import odxraise, odxrequire
 from .flash import Flash
+from .multipleecujobspec import MultipleEcuJobSpec
 from .nameditemlist import NamedItemList
 from .odxdoccontext import OdxDocContext
 from .odxlink import DocType, OdxDocFragment, OdxLinkDatabase, OdxLinkId
@@ -40,7 +42,9 @@ class Database:
         self._diag_layer_containers = NamedItemList[DiagLayerContainer]()
         self._comparam_subsets = NamedItemList[ComparamSubset]()
         self._comparam_specs = NamedItemList[ComparamSpec]()
+        self._ecu_configs = NamedItemList[EcuConfig]()
         self._flashs = NamedItemList[Flash]()
+        self._multiple_ecu_job_specs = NamedItemList[MultipleEcuJobSpec]()
         self._short_name = "odx_database"
 
     def add_pdx_file(self, pdx_file: Union[str, "PathLike[Any]", IO[bytes], ZipFile]) -> None:
@@ -114,9 +118,17 @@ class Database:
                 self._comparam_subsets.append(ComparamSubset.from_et(category_et, context))
             else:
                 self._comparam_specs.append(ComparamSpec.from_et(category_et, context))
+        elif category_tag == "ECU-CONFIG":
+            context = OdxDocContext(model_version,
+                                    (OdxDocFragment(category_sn, DocType.ECU_CONFIG),))
+            self._ecu_configs.append(EcuConfig.from_et(category_et, context))
         elif category_tag == "FLASH":
             context = OdxDocContext(model_version, (OdxDocFragment(category_sn, DocType.FLASH),))
             self._flashs.append(Flash.from_et(category_et, context))
+        elif category_tag == "MULTIPLE-ECU-JOB-SPEC":
+            context = OdxDocContext(model_version,
+                                    (OdxDocFragment(category_sn, DocType.MULTIPLE_ECU_JOB_SPEC),))
+            self._multiple_ecu_job_specs.append(MultipleEcuJobSpec.from_et(category_et, context))
 
     def refresh(self) -> None:
         # Create wrapper objects
@@ -148,9 +160,15 @@ class Database:
         for dlc in self.diag_layer_containers:
             dlc._resolve_odxlinks(self._odxlinks)
 
+        for ecu_config in self.ecu_configs:
+            ecu_config._resolve_odxlinks(self._odxlinks)
+
         for flash in self.flashs:
             flash._resolve_odxlinks(self._odxlinks)
 
+        for multiple_ecu_job_spec in self.multiple_ecu_job_specs:
+            multiple_ecu_job_spec._resolve_odxlinks(self._odxlinks)
+
         # resolve short name references for containers which do not do
         # inheritance (we can call directly call _resolve_snrefs())
         context = SnRefContext()
@@ -163,8 +181,12 @@ class Database:
             spec._finalize_init(self, self._odxlinks)
         for dlc in self.diag_layer_containers:
             dlc._finalize_init(self, self._odxlinks)
+        for ecu_config in self.ecu_configs:
+            ecu_config._finalize_init(self, self._odxlinks)
         for flash in self.flashs:
             flash._finalize_init(self, self._odxlinks)
+        for multiple_ecu_job_spec in self.multiple_ecu_job_specs:
+            multiple_ecu_job_spec._finalize_init(self, self._odxlinks)
 
         for subset in self.comparam_subsets:
             subset._resolve_snrefs(context)
@@ -172,8 +194,12 @@ class Database:
             spec._resolve_snrefs(context)
         for dlc in self.diag_layer_containers:
             dlc._resolve_snrefs(context)
+        for ecu_config in self.ecu_configs:
+            ecu_config._resolve_snrefs(context)
         for flash in self.flashs:
             flash._resolve_snrefs(context)
+        for multiple_ecu_job_spec in self.multiple_ecu_job_specs:
+            multiple_ecu_job_spec._resolve_snrefs(context)
 
     def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result: dict[OdxLinkId, Any] = {}
@@ -187,8 +213,13 @@ class Database:
         for dlc in self.diag_layer_containers:
             result.update(dlc._build_odxlinks())
 
+        for ecu_config in self.ecu_configs:
+            result.update(ecu_config._build_odxlinks())
+
         for flash in self.flashs:
             result.update(flash._build_odxlinks())
+        for multiple_ecu_job_spec in self.multiple_ecu_job_specs:
+            result.update(multiple_ecu_job_spec._build_odxlinks())
 
         return result
 
@@ -263,10 +294,18 @@ class Database:
     def comparam_specs(self) -> NamedItemList[ComparamSpec]:
         return self._comparam_specs
 
+    @property
+    def ecu_configs(self) -> NamedItemList[EcuConfig]:
+        return self._ecu_configs
+
     @property
     def flashs(self) -> NamedItemList[Flash]:
         return self._flashs
 
+    @property
+    def multiple_ecu_job_specs(self) -> NamedItemList[MultipleEcuJobSpec]:
+        return self._multiple_ecu_job_specs
+
     def __repr__(self) -> str:
         return f"Database(model_version={self.model_version}, " \
             f"protocols={[x.short_name for x in self.protocols]}, " \
@@ -274,4 +313,5 @@ class Database:
             f"diag_layer_containers={repr(self.diag_layer_containers)}, " \
             f"comparam_subsets={repr(self.comparam_subsets)}, " \
             f"comparam_specs={repr(self.comparam_specs)}, " \
+            f"ecu_configs={repr(self.ecu_configs)}, " \
             f"flashs={repr(self.flashs)})"

odxtools/dataiditem.py

@@ -0,0 +1,18 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from xml.etree import ElementTree
+
+from .configitem import ConfigItem
+from .odxdoccontext import OdxDocContext
+from .utils import dataclass_fields_asdict
+
+
+@dataclass(kw_only=True)
+class DataIdItem(ConfigItem):
+    """This class represents a DATA-ID-ITEM."""
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "DataIdItem":
+        kwargs = dataclass_fields_asdict(ConfigItem.from_et(et_element, context))
+
+        return DataIdItem(**kwargs)