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

odxtools/externflashdata.py

@@ -0,0 +1,34 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any
+from xml.etree import ElementTree
+
+from .datafile import Datafile
+from .exceptions import odxrequire
+from .flashdata import Flashdata
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
+from .utils import dataclass_fields_asdict
+
+
+@dataclass(kw_only=True)
+class ExternFlashdata(Flashdata):
+    datafile: Datafile
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "ExternFlashdata":
+        kwargs = dataclass_fields_asdict(Flashdata.from_et(et_element, context))
+
+        datafile = Datafile.from_et(odxrequire(et_element.find("DATAFILE")), context)
+
+        return ExternFlashdata(datafile=datafile, **kwargs)
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        return super()._build_odxlinks()
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        super()._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)

odxtools/filter.py

@@ -0,0 +1,32 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any
+from xml.etree import ElementTree
+
+from .exceptions import odxrequire
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
+from .utils import read_hex_binary
+
+
+@dataclass(kw_only=True)
+class Filter:
+    filter_start: int
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Filter":
+        filter_start = odxrequire(read_hex_binary(et_element.find("FILTER-START")))
+
+        return Filter(filter_start=filter_start)
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        odxlinks: dict[OdxLinkId, Any] = {}
+
+        return odxlinks
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        pass
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        pass

odxtools/flash.py

@@ -0,0 +1,88 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+from xml.etree import ElementTree
+
+from .additionalaudience import AdditionalAudience
+from .ecumem import EcuMem
+from .ecumemconnector import EcuMemConnector
+from .nameditemlist import NamedItemList
+from .odxcategory import OdxCategory
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
+from .utils import dataclass_fields_asdict
+
+if TYPE_CHECKING:
+    from .database import Database
+
+
+@dataclass(kw_only=True)
+class Flash(OdxCategory):
+    ecu_mems: NamedItemList[EcuMem] = field(default_factory=NamedItemList)
+    ecu_mem_connectors: NamedItemList[EcuMemConnector] = field(default_factory=NamedItemList)
+    additional_audiences: NamedItemList[AdditionalAudience] = field(default_factory=NamedItemList)
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Flash":
+
+        base_obj = OdxCategory.from_et(et_element, context)
+        kwargs = dataclass_fields_asdict(base_obj)
+
+        ecu_mems = NamedItemList(
+            [EcuMem.from_et(el, context) for el in et_element.iterfind("ECU-MEMS/ECU-MEM")])
+        ecu_mem_connectors = NamedItemList([
+            EcuMemConnector.from_et(el, context)
+            for el in et_element.iterfind("ECU-MEM-CONNECTORS/ECU-MEM-CONNECTOR")
+        ])
+        additional_audiences = NamedItemList([
+            AdditionalAudience.from_et(el, context)
+            for el in et_element.iterfind("ADDITIONAL-AUDIENCES/ADDITIONAL-AUDIENCE")
+        ])
+
+        return Flash(
+            ecu_mems=ecu_mems,
+            ecu_mem_connectors=ecu_mem_connectors,
+            additional_audiences=additional_audiences,
+            **kwargs)
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        odxlinks = super()._build_odxlinks()
+
+        for ecu_mem in self.ecu_mems:
+            odxlinks.update(ecu_mem._build_odxlinks())
+
+        for ecu_mem_connector in self.ecu_mem_connectors:
+            odxlinks.update(ecu_mem_connector._build_odxlinks())
+
+        for additional_audiences in self.additional_audiences:
+            odxlinks.update(additional_audiences._build_odxlinks())
+
+        return odxlinks
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        super()._resolve_odxlinks(odxlinks)
+
+        for ecu_mem in self.ecu_mems:
+            ecu_mem._resolve_odxlinks(odxlinks)
+
+        for ecu_mem_connector in self.ecu_mem_connectors:
+            ecu_mem_connector._resolve_odxlinks(odxlinks)
+
+        for additional_audiences in self.additional_audiences:
+            additional_audiences._resolve_odxlinks(odxlinks)
+
+    def _finalize_init(self, database: "Database", odxlinks: OdxLinkDatabase) -> None:
+        super()._finalize_init(database, odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
+
+        for ecu_mem in self.ecu_mems:
+            ecu_mem._resolve_snrefs(context)
+
+        for ecu_mem_connector in self.ecu_mem_connectors:
+            ecu_mem_connector._resolve_snrefs(context)
+
+        for additional_audiences in self.additional_audiences:
+            additional_audiences._resolve_snrefs(context)

odxtools/flashclass.py

@@ -0,0 +1,32 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any
+from xml.etree import ElementTree
+
+from .element import IdentifiableElement
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
+from .utils import dataclass_fields_asdict
+
+
+@dataclass(kw_only=True)
+class FlashClass(IdentifiableElement):
+    """
+    Corresponds to FLASH-CLASS.
+    """
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "FlashClass":
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
+
+        return FlashClass(**kwargs)
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        return {self.odx_id: self}
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        pass
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        pass

odxtools/flashdata.py

@@ -0,0 +1,70 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any
+from xml.etree import ElementTree
+
+from .dataformat import Dataformat
+from .element import IdentifiableElement
+from .encryptcompressmethod import EncryptCompressMethod
+from .exceptions import odxrequire
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
+from .utils import dataclass_fields_asdict
+
+
+@dataclass(kw_only=True)
+class Flashdata(IdentifiableElement):
+    size_length: int | None = None
+    address_length: int | None = None
+    dataformat: Dataformat
+    encrypt_compress_method: EncryptCompressMethod | None = None
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Flashdata":
+
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
+
+        size_length = None
+        if (size_length_str := et_element.findtext("SIZE-LENGTH")) is not None:
+            size_length = int(size_length_str)
+
+        address_length = None
+        if (address_length_str := et_element.findtext("ADDRESS-LENGTH")) is not None:
+            address_length = int(address_length_str)
+
+        dataformat = Dataformat.from_et(odxrequire(et_element.find("DATAFORMAT")), context)
+
+        encrypt_compress_method = None
+        if (encrypt_compress_method_elem := et_element.find("ENCRYPT-COMPRESS-METHOD")) is not None:
+            encrypt_compress_method = EncryptCompressMethod.from_et(encrypt_compress_method_elem,
+                                                                    context)
+
+        return Flashdata(
+            size_length=size_length,
+            address_length=address_length,
+            dataformat=dataformat,
+            encrypt_compress_method=encrypt_compress_method,
+            **kwargs)
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        odxlinks = {self.odx_id: self}
+
+        if self.dataformat is not None:
+            odxlinks.update(self.dataformat._build_odxlinks())
+        if self.encrypt_compress_method is not None:
+            odxlinks.update(self.encrypt_compress_method._build_odxlinks())
+
+        return odxlinks
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        if self.dataformat is not None:
+            self.dataformat._resolve_odxlinks(odxlinks)
+        if self.encrypt_compress_method is not None:
+            self.encrypt_compress_method._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        if self.dataformat is not None:
+            self.dataformat._resolve_snrefs(context)
+        if self.encrypt_compress_method is not None:
+            self.encrypt_compress_method._resolve_snrefs(context)

odxtools/fwchecksum.py

@@ -0,0 +1,7 @@
+# SPDX-License-Identifier: MIT
+from .validityfor import ValidityFor
+
+# Note that the ODX specification specifies a separate tag for this,
+# but this tag is identical to VALIDITY-FOR, so let's use a type alias
+# to reduce the amount of copy-and-pasted code
+FwChecksum = ValidityFor

odxtools/fwsignature.py

@@ -0,0 +1,7 @@
+# SPDX-License-Identifier: MIT
+from .validityfor import ValidityFor
+
+# Note that the ODX specification specifies a separate tag for this,
+# but this tag is identical to VALIDITY-FOR, so let's use a type alias
+# to reduce the amount of copy-and-pasted code
+FwSignature = ValidityFor

odxtools/identdesc.py

@@ -0,0 +1,54 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any
+from xml.etree import ElementTree
+
+from .exceptions import odxrequire
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
+
+
+@dataclass(kw_only=True)
+class IdentDesc:
+    diag_comm_snref: str
+    ident_if_snref: str
+
+    # exactly one of the two attributes below must be defined
+    out_param_if_snref: str | None = None
+    out_param_if_snpathref: str | None = None
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "IdentDesc":
+        diag_comm_snref = odxrequire(
+            odxrequire(et_element.find("DIAG-COMM-SNREF")).attrib.get("SHORT-NAME"))
+        ident_if_snref = odxrequire(
+            odxrequire(et_element.find("IDENT-IF-SNREF")).attrib.get("SHORT-NAME"))
+        out_param_if_snref = None
+        if (out_param_if_snref_elem := et_element.find("OUT-PARAM-IF-SNREF")) is not None:
+            out_param_if_snref = odxrequire(out_param_if_snref_elem.attrib.get("SHORT-NAME"))
+
+        out_param_if_snpathref = None
+        if (out_param_if_snpathref_elem := et_element.find("OUT-PARAM-IF-SNPATHREF")) is not None:
+            out_param_if_snpathref = odxrequire(
+                out_param_if_snpathref_elem.attrib.get("SHORT-NAME-PATH"))
+
+        return IdentDesc(
+            diag_comm_snref=diag_comm_snref,
+            ident_if_snref=ident_if_snref,
+            out_param_if_snref=out_param_if_snref,
+            out_param_if_snpathref=out_param_if_snpathref,
+        )
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        odxlinks: dict[OdxLinkId, Any] = {}
+
+        return odxlinks
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        pass
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        # TODO: resolve the short name references. for IdentDesc this
+        # is (probably) not possible ahead of time...
+        pass

odxtools/identvalue.py

@@ -0,0 +1,32 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from xml.etree import ElementTree
+
+from .exceptions import odxraise
+from .identvaluetype import IdentValueType
+from .odxdoccontext import OdxDocContext
+
+
+@dataclass(kw_only=True)
+class IdentValue:
+    """
+    Corresponds to IDENT-VALUE.
+    """
+
+    value: str
+
+    # note that the spec says this attribute is named "TYPE", but in
+    # python, "type" is a build-in function...
+    value_type: IdentValueType
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "IdentValue":
+        value = et_element.text or ""
+
+        try:
+            value_type = IdentValueType(et_element.attrib["TYPE"])
+        except Exception as e:
+            odxraise(f"Cannot parse IDENT-VALUE-TYPE: {e}")
+            value_type = None
+
+        return IdentValue(value=value, value_type=value_type)

odxtools/identvaluetype.py

@@ -0,0 +1,14 @@
+# SPDX-License-Identifier: MIT
+from enum import Enum
+
+from .odxtypes import DataType
+
+
+class IdentValueType(Enum):
+    A_UINT32 = "A_UINT32"
+    A_BYTEFIELD = "A_BYTEFIELD"
+    A_ASCIISTRING = "A_ASCIISTRING"
+
+    @property
+    def data_type(self) -> DataType:
+        return DataType(self.value)

odxtools/internflashdata.py

@@ -0,0 +1,33 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any
+from xml.etree import ElementTree
+
+from .exceptions import odxrequire
+from .flashdata import Flashdata
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
+from .utils import dataclass_fields_asdict
+
+
+@dataclass(kw_only=True)
+class InternFlashdata(Flashdata):
+    data: str
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "InternFlashdata":
+        kwargs = dataclass_fields_asdict(Flashdata.from_et(et_element, context))
+
+        data = odxrequire(et_element.findtext("DATA"))
+
+        return InternFlashdata(data=data, **kwargs)
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        return super()._build_odxlinks()
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        super()._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)

odxtools/loadfile.py

@@ -23,7 +23,7 @@ def load_odx_d_file(odx_d_file_name: str | Path) -> Database:
 def load_file(file_name: str | Path) -> Database:
     if str(file_name).lower().endswith(".pdx"):
         return load_pdx_file(str(file_name))
-    elif str(file_name).lower().endswith(".odx-d"):
+    elif Path(file_name).suffix.lower().startswith(".odx"):
         return load_odx_d_file(str(file_name))
     else:
         raise RuntimeError(f"Could not guess the file format of file '{file_name}'!")

odxtools/mem.py

@@ -0,0 +1,80 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any
+from xml.etree import ElementTree
+
+from .datablock import Datablock
+from .exceptions import odxraise
+from .externflashdata import ExternFlashdata
+from .flashdata import Flashdata
+from .globals import xsi
+from .internflashdata import InternFlashdata
+from .nameditemlist import NamedItemList
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .session import Session
+from .snrefcontext import SnRefContext
+
+
+@dataclass(kw_only=True)
+class Mem:
+    sessions: NamedItemList[Session]
+    datablocks: NamedItemList[Datablock]
+    flashdatas: NamedItemList[Flashdata]
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Mem":
+        sessions = NamedItemList([
+            Session.from_et(sess_elem, context)
+            for sess_elem in et_element.iterfind("SESSIONS/SESSION")
+        ])
+
+        datablocks = NamedItemList([
+            Datablock.from_et(db_elem, context)
+            for db_elem in et_element.iterfind("DATABLOCKS/DATABLOCK")
+        ])
+
+        flashdatas: NamedItemList[Flashdata] = NamedItemList()
+        for flashdata_elem in et_element.iterfind("FLASHDATAS/FLASHDATA"):
+            flashdata_type = flashdata_elem.attrib.get(f"{xsi}type")
+            if flashdata_type == "INTERN-FLASHDATA":
+                flashdatas.append(InternFlashdata.from_et(flashdata_elem, context))
+            elif flashdata_type == "EXTERN-FLASHDATA":
+                flashdatas.append(ExternFlashdata.from_et(flashdata_elem, context))
+            else:
+                odxraise(f"Encountered unknown flashdata type {flashdata_type}")
+                flashdatas.append(Flashdata.from_et(flashdata_elem, context))
+
+        return Mem(
+            sessions=sessions,
+            datablocks=datablocks,
+            flashdatas=flashdatas,
+        )
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        odxlinks = {}
+
+        for session in self.sessions:
+            odxlinks.update(session._build_odxlinks())
+        for datablock in self.datablocks:
+            odxlinks.update(datablock._build_odxlinks())
+        for flashdata in self.flashdatas:
+            odxlinks.update(flashdata._build_odxlinks())
+
+        return odxlinks
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        for session in self.sessions:
+            session._resolve_odxlinks(odxlinks)
+        for datablock in self.datablocks:
+            datablock._resolve_odxlinks(odxlinks)
+        for flashdata in self.flashdatas:
+            flashdata._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        for session in self.sessions:
+            session._resolve_snrefs(context)
+        for datablock in self.datablocks:
+            datablock._resolve_snrefs(context)
+        for flashdata in self.flashdatas:
+            flashdata._resolve_snrefs(context)

odxtools/modification.py

@@ -7,6 +7,7 @@ from .exceptions import odxrequire
 from .odxdoccontext import OdxDocContext
 from .odxlink import OdxLinkDatabase, OdxLinkId
 from .snrefcontext import SnRefContext
+from .utils import strip_indent
 
 
 @dataclass(kw_only=True)
@@ -16,8 +17,8 @@ class Modification:
 
     @staticmethod
     def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Modification":
-        change = odxrequire(et_element.findtext("CHANGE"))
-        reason = et_element.findtext("REASON")
+        change = odxrequire(strip_indent(et_element.findtext("CHANGE")))
+        reason = strip_indent(et_element.findtext("REASON"))
 
         return Modification(change=change, reason=reason)
 

odxtools/negoffset.py

@@ -0,0 +1,21 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from xml.etree import ElementTree
+
+from .exceptions import odxrequire
+from .odxdoccontext import OdxDocContext
+from .targetaddroffset import TargetAddrOffset
+from .utils import dataclass_fields_asdict, read_hex_binary
+
+
+@dataclass(kw_only=True)
+class NegOffset(TargetAddrOffset):
+    negative_offset: int
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "NegOffset":
+        kwargs = dataclass_fields_asdict(TargetAddrOffset.from_et(et_element, context))
+
+        negative_offset = odxrequire(read_hex_binary(et_element.find("NEGATIVE-OFFSET")))
+
+        return NegOffset(negative_offset=negative_offset, **kwargs)

odxtools/ownident.py

@@ -0,0 +1,38 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any
+from xml.etree import ElementTree
+
+from .element import IdentifiableElement
+from .exceptions import odxrequire
+from .identvalue import IdentValue
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
+from .utils import dataclass_fields_asdict
+
+
+@dataclass(kw_only=True)
+class OwnIdent(IdentifiableElement):
+    """
+    Corresponds to OWN-IDENT.
+    """
+
+    ident_value: IdentValue
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "OwnIdent":
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
+
+        ident_value = IdentValue.from_et(odxrequire(et_element.find("IDENT-VALUE")), context)
+
+        return OwnIdent(ident_value=ident_value, **kwargs)
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        return {self.odx_id: self}
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        pass
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        pass

odxtools/physicaltype.py

@@ -2,7 +2,7 @@
 from dataclasses import dataclass
 from xml.etree import ElementTree
 
-from .exceptions import odxraise
+from .exceptions import odxraise, odxrequire
 from .odxdoccontext import OdxDocContext
 from .odxtypes import DataType
 from .radix import Radix
@@ -31,27 +31,29 @@ class PhysicalType:
     PhysicalType(DataType.A_FLOAT64, precision=2)
     """
 
+    #: 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.
     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
 
+    #: 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.
     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, context: OdxDocContext) -> "PhysicalType":
         precision_str = et_element.findtext("PRECISION")
         precision = int(precision_str) if precision_str is not None else None
 
-        base_data_type_str = et_element.get("BASE-DATA-TYPE")
-        if base_data_type_str not in DataType.__members__:
+        base_data_type_str = odxrequire(et_element.attrib.get("BASE-DATA-TYPE"))
+        try:
+            base_data_type = DataType(base_data_type_str)
+        except ValueError:
             odxraise(f"Encountered unknown base data type '{base_data_type_str}'")
-        base_data_type = DataType(base_data_type_str)
+            base_data_type = None
 
         display_radix_str = et_element.get("DISPLAY-RADIX")
         if display_radix_str is not None: