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

odxtools/addrdeffilter.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 .filter import Filter
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
+from .utils import dataclass_fields_asdict, read_hex_binary
+
+
+@dataclass(kw_only=True)
+class AddrdefFilter(Filter):
+    filter_end: int
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "AddrdefFilter":
+        kwargs = dataclass_fields_asdict(Filter.from_et(et_element, context))
+
+        filter_end = odxrequire(read_hex_binary(et_element.find("FILTER-END")))
+
+        return AddrdefFilter(filter_end=filter_end, **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/addrdefphyssegment.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 .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .physsegment import PhysSegment
+from .snrefcontext import SnRefContext
+from .utils import dataclass_fields_asdict, read_hex_binary
+
+
+@dataclass(kw_only=True)
+class AddrdefPhysSegment(PhysSegment):
+    end_address: int
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "AddrdefPhysSegment":
+        kwargs = dataclass_fields_asdict(PhysSegment.from_et(et_element, context))
+
+        end_address = odxrequire(read_hex_binary(et_element.find("END-ADDRESS")))
+
+        return AddrdefPhysSegment(end_address=end_address, **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/checksum.py

@@ -0,0 +1,67 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any
+from xml.etree import ElementTree
+
+from .checksumresult import ChecksumResult
+from .element import IdentifiableElement
+from .exceptions import odxrequire
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
+from .utils import dataclass_fields_asdict, read_hex_binary
+
+
+@dataclass(kw_only=True)
+class Checksum(IdentifiableElement):
+    fillbyte: int | None = None
+    source_start_address: int
+    compressed_size: int | None = None
+    checksum_alg: str | None = None
+
+    # exactly one of the two next fields must be not None
+    source_end_address: int | None = None
+    uncompressed_size: int | None = None
+
+    checksum_result: ChecksumResult
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Checksum":
+
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
+
+        fillbyte = read_hex_binary(et_element.find("FILLBYTE"))
+        source_start_address = odxrequire(read_hex_binary(et_element.find("SOURCE-START-ADDRESS")))
+        compressed_size = None
+        if (cs_elem := et_element.find("COMPRESSED-SIZE")) is not None:
+            compressed_size = int(odxrequire(cs_elem.text) or "0")
+        checksum_alg = et_element.findtext("CHECKSUM-ALG")
+
+        # exactly one of the two next fields must be not None
+        source_end_address = read_hex_binary(et_element.find("SOURCE-END-ADDRESS"))
+        uncompressed_size = None
+        if (ucs_elem := et_element.find("UNCOMPRESSED-SIZE")) is not None:
+            uncompressed_size = int(odxrequire(ucs_elem.text) or "0")
+        checksum_result = ChecksumResult.from_et(
+            odxrequire(et_element.find("CHECKSUM-RESULT")), context)
+
+        return Checksum(
+            fillbyte=fillbyte,
+            source_start_address=source_start_address,
+            compressed_size=compressed_size,
+            checksum_alg=checksum_alg,
+            source_end_address=source_end_address,
+            uncompressed_size=uncompressed_size,
+            checksum_result=checksum_result,
+            **kwargs)
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        odxlinks = {self.odx_id: self}
+
+        return odxlinks
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        pass
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        pass

odxtools/checksumresult.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
+ChecksumResult = ValidityFor

odxtools/database.py

@@ -19,6 +19,7 @@ from .diaglayers.ecuvariant import EcuVariant
 from .diaglayers.functionalgroup import FunctionalGroup
 from .diaglayers.protocol import Protocol
 from .exceptions import odxraise, odxrequire
+from .flash import Flash
 from .nameditemlist import NamedItemList
 from .odxdoccontext import OdxDocContext
 from .odxlink import DocType, OdxDocFragment, OdxLinkDatabase, OdxLinkId
@@ -39,6 +40,7 @@ class Database:
         self._diag_layer_containers = NamedItemList[DiagLayerContainer]()
         self._comparam_subsets = NamedItemList[ComparamSubset]()
         self._comparam_specs = NamedItemList[ComparamSpec]()
+        self._flashs = NamedItemList[Flash]()
         self._short_name = "odx_database"
 
     def add_pdx_file(self, pdx_file: Union[str, "PathLike[Any]", IO[bytes], ZipFile]) -> None:
@@ -57,7 +59,7 @@ class Database:
             p = Path(zip_member)
             if p.suffix.lower().startswith(".odx"):
                 root = ElementTree.parse(pdx_zip.open(zip_member)).getroot()
-                self._process_xml_tree(root)
+                self.add_xml_tree(root)
             elif p.name.lower() == "index.xml":
                 root = ElementTree.parse(pdx_zip.open(zip_member)).getroot()
                 db_short_name = odxrequire(root.findtext("SHORT-NAME"))
@@ -66,7 +68,7 @@ class Database:
                 self.add_auxiliary_file(zip_member, pdx_zip.open(zip_member))
 
     def add_odx_file(self, odx_file_name: Union[str, "PathLike[Any]"]) -> None:
-        self._process_xml_tree(ElementTree.parse(odx_file_name).getroot())
+        self.add_xml_tree(ElementTree.parse(odx_file_name).getroot())
 
     def add_auxiliary_file(self,
                            aux_file_name: Union[str, "PathLike[Any]"],
@@ -76,7 +78,7 @@ class Database:
 
         self.auxiliary_files[str(aux_file_name)] = aux_file_obj
 
-    def _process_xml_tree(self, root: ElementTree.Element) -> None:
+    def add_xml_tree(self, root: ElementTree.Element) -> None:
         # ODX spec version
         model_version = Version(root.attrib.get("MODEL-VERSION", "2.0"))
         if self.model_version is not None and self.model_version != model_version:
@@ -112,6 +114,9 @@ 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 == "FLASH":
+            context = OdxDocContext(model_version, (OdxDocFragment(category_sn, DocType.FLASH),))
+            self._flashs.append(Flash.from_et(category_et, context))
 
     def refresh(self) -> None:
         # Create wrapper objects
@@ -143,6 +148,9 @@ class Database:
         for dlc in self.diag_layer_containers:
             dlc._resolve_odxlinks(self._odxlinks)
 
+        for flash in self.flashs:
+            flash._resolve_odxlinks(self._odxlinks)
+
         # resolve short name references for containers which do not do
         # inheritance (we can call directly call _resolve_snrefs())
         context = SnRefContext()
@@ -155,6 +163,8 @@ class Database:
             spec._finalize_init(self, self._odxlinks)
         for dlc in self.diag_layer_containers:
             dlc._finalize_init(self, self._odxlinks)
+        for flash in self.flashs:
+            flash._finalize_init(self, self._odxlinks)
 
         for subset in self.comparam_subsets:
             subset._resolve_snrefs(context)
@@ -162,6 +172,8 @@ class Database:
             spec._resolve_snrefs(context)
         for dlc in self.diag_layer_containers:
             dlc._resolve_snrefs(context)
+        for flash in self.flashs:
+            flash._resolve_snrefs(context)
 
     def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result: dict[OdxLinkId, Any] = {}
@@ -175,6 +187,9 @@ class Database:
         for dlc in self.diag_layer_containers:
             result.update(dlc._build_odxlinks())
 
+        for flash in self.flashs:
+            result.update(flash._build_odxlinks())
+
         return result
 
     @property
@@ -248,10 +263,15 @@ class Database:
     def comparam_specs(self) -> NamedItemList[ComparamSpec]:
         return self._comparam_specs
 
+    @property
+    def flashs(self) -> NamedItemList[Flash]:
+        return self._flashs
+
     def __repr__(self) -> str:
         return f"Database(model_version={self.model_version}, " \
             f"protocols={[x.short_name for x in self.protocols]}, " \
             f"ecus={[x.short_name for x in self.ecus]}, " \
             f"diag_layer_containers={repr(self.diag_layer_containers)}, " \
             f"comparam_subsets={repr(self.comparam_subsets)}, " \
-            f"comparam_specs={repr(self.comparam_specs)})"
+            f"comparam_specs={repr(self.comparam_specs)}, " \
+            f"flashs={repr(self.flashs)})"

odxtools/datablock.py

@@ -0,0 +1,153 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass, field
+from typing import Any
+from xml.etree import ElementTree
+
+from .addrdeffilter import AddrdefFilter
+from .audience import Audience
+from .element import IdentifiableElement
+from .exceptions import odxraise, odxrequire
+from .filter import Filter
+from .flashdata import Flashdata
+from .globals import xsi
+from .nameditemlist import NamedItemList
+from .negoffset import NegOffset
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .ownident import OwnIdent
+from .posoffset import PosOffset
+from .security import Security
+from .segment import Segment
+from .sizedeffilter import SizedefFilter
+from .snrefcontext import SnRefContext
+from .specialdatagroup import SpecialDataGroup
+from .targetaddroffset import TargetAddrOffset
+from .utils import dataclass_fields_asdict, read_hex_binary
+
+
+@dataclass(kw_only=True)
+class Datablock(IdentifiableElement):
+    logical_block_index: int | None = None
+    flashdata_ref: OdxLinkRef | None = None
+    filters: list[Filter] = field(default_factory=list)
+    segments: NamedItemList[Segment] = field(default_factory=NamedItemList)
+
+    # the specification does not define the content of
+    # TARGET-ADDR-OFFSET, i.e., if it is defined, it must be one of
+    # its specializations
+    target_addr_offset: TargetAddrOffset | None = None
+
+    own_idents: NamedItemList[OwnIdent] = field(default_factory=NamedItemList)
+    securities: list[Security] = field(default_factory=list)
+    sdgs: list[SpecialDataGroup] = field(default_factory=list)
+    audience: Audience | None = None
+
+    # note that the spec says this attribute is named "TYPE", but in
+    # python, "type" is a build-in function...
+    data_type: str
+
+    @property
+    def flashdata(self) -> Flashdata | None:
+        return self._flashdata
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Datablock":
+
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
+
+        logical_block_index = read_hex_binary(et_element.find("LOGICAL-BLOCK-INDEX"))
+        flashdata_ref = OdxLinkRef.from_et(et_element.find("FLASHDATA-REF"), context)
+        filters: list[Filter] = []
+        for filter_elem in et_element.iterfind("FILTERS/FILTER"):
+            filter_type = filter_elem.attrib.get(f"{xsi}type")
+            if filter_type == "ADDRDEF-FILTER":
+                filters.append(AddrdefFilter.from_et(filter_elem, context))
+            elif filter_type == "SIZEDEF-FILTER":
+                filters.append(SizedefFilter.from_et(filter_elem, context))
+            else:
+                odxraise(f"Encountered filter of illegal type {filter_type}")
+                filters.append(Filter.from_et(filter_elem, context))
+        segments = NamedItemList([
+            Segment.from_et(segment_elem, context)
+            for segment_elem in et_element.iterfind("SEGMENTS/SEGMENT")
+        ])
+        target_addr_offset: TargetAddrOffset | None = None
+        if (tao_elem := et_element.find("TARGET-ADDR-OFFSET")) is not None:
+            tao_type = tao_elem.attrib.get(f"{xsi}type")
+            if tao_type == "POS-OFFSET":
+                target_addr_offset = PosOffset.from_et(tao_elem, context)
+            elif tao_type == "NEG-OFFSET":
+                target_addr_offset = NegOffset.from_et(tao_elem, context)
+            else:
+                odxraise(f"Unknown TARGET-ADDR-OFFSET type '{tao_type}'")
+
+        own_idents = NamedItemList([
+            OwnIdent.from_et(own_ident_elem, context)
+            for own_ident_elem in et_element.iterfind("OWN-IDENTS/OWN-IDENT")
+        ])
+        securities = [
+            Security.from_et(security_elem, context)
+            for security_elem in et_element.iterfind("SECURITYS/SECURITY")
+        ]
+        sdgs = [SpecialDataGroup.from_et(sdge, context) for sdge in et_element.iterfind("SDGS/SDG")]
+        audience = None
+        if (audience_elem := et_element.find("AUDIENCE")) is not None:
+            audience = Audience.from_et(audience_elem, context)
+        data_type = odxrequire(et_element.attrib.get("TYPE"))
+
+        return Datablock(
+            logical_block_index=logical_block_index,
+            flashdata_ref=flashdata_ref,
+            filters=filters,
+            segments=segments,
+            own_idents=own_idents,
+            securities=securities,
+            target_addr_offset=target_addr_offset,
+            sdgs=sdgs,
+            audience=audience,
+            data_type=data_type,
+            **kwargs)
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        odxlinks = {self.odx_id: self}
+
+        for odxfilter in self.filters:
+            odxlinks.update(odxfilter._build_odxlinks())
+        for segment in self.segments:
+            odxlinks.update(segment._build_odxlinks())
+        for own_indent in self.own_idents:
+            odxlinks.update(own_indent._build_odxlinks())
+        for sdg in self.sdgs:
+            odxlinks.update(sdg._build_odxlinks())
+        if self.audience is not None:
+            odxlinks.update(self.audience._build_odxlinks())
+
+        return odxlinks
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        self._flashdata = None
+        if self.flashdata_ref is not None:
+            self._flashdata = odxlinks.resolve(self.flashdata_ref, Flashdata)
+
+        for odxfilter in self.filters:
+            odxfilter._resolve_odxlinks(odxlinks)
+        for segment in self.segments:
+            segment._resolve_odxlinks(odxlinks)
+        for own_indent in self.own_idents:
+            own_indent._resolve_odxlinks(odxlinks)
+        for sdg in self.sdgs:
+            sdg._resolve_odxlinks(odxlinks)
+        if self.audience is not None:
+            self.audience._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        for odxfilter in self.filters:
+            odxfilter._resolve_snrefs(context)
+        for segment in self.segments:
+            segment._resolve_snrefs(context)
+        for own_indent in self.own_idents:
+            own_indent._resolve_snrefs(context)
+        for sdg in self.sdgs:
+            sdg._resolve_snrefs(context)
+        if self.audience is not None:
+            self.audience._resolve_snrefs(context)

odxtools/datafile.py

@@ -0,0 +1,23 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from xml.etree import ElementTree
+
+from .exceptions import odxrequire
+from .odxdoccontext import OdxDocContext
+from .odxtypes import odxstr_to_bool
+
+
+@dataclass(kw_only=True)
+class Datafile:
+    value: str
+    latebound_datafile: bool
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Datafile":
+        value = et_element.text or ""
+        latebound_datafile = odxrequire(odxstr_to_bool(et_element.attrib.get("LATEBOUND-DATAFILE")))
+
+        return Datafile(
+            value=value,
+            latebound_datafile=latebound_datafile,
+        )

odxtools/dataformat.py

@@ -0,0 +1,39 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any, cast
+from xml.etree import ElementTree
+
+from .dataformatselection import DataformatSelection
+from .exceptions import odxraise, odxrequire
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
+
+
+@dataclass(kw_only=True)
+class Dataformat:
+    selection: DataformatSelection
+    user_selection: str | None = None
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Dataformat":
+        selection_str = odxrequire(et_element.attrib.get("SELECTION"))
+        try:
+            selection = DataformatSelection(selection_str)
+        except ValueError:
+            selection = cast(DataformatSelection, None)
+            odxraise(f"Encountered unknown data format selection '{selection_str}'")
+        user_selection = et_element.attrib.get("USER-SELECTION")
+
+        return Dataformat(selection=selection, user_selection=user_selection)
+
+    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/dataformatselection.py

@@ -0,0 +1,9 @@
+# SPDX-License-Identifier: MIT
+from enum import Enum
+
+
+class DataformatSelection(Enum):
+    INTEL_HEX = "INTEL-HEX"
+    MOTOROLA_S = "MOTOROLA-S"
+    BINARY = "BINARY"
+    USER_DEFINED = "USER-DEFINED"

odxtools/description.py

@@ -5,6 +5,7 @@ from xml.etree import ElementTree
 from .exceptions import odxrequire
 from .externaldoc import ExternalDoc
 from .odxdoccontext import OdxDocContext
+from .utils import strip_indent
 
 
 @dataclass(kw_only=True)
@@ -27,11 +28,7 @@ class Description:
                 break
             raw_string += ElementTree.tostring(e, encoding="unicode")
 
-        # remove white spaces at the beginning and at the end of all
-        # extracted lines
-        stripped_lines = [x.strip() for x in raw_string.split("\n")]
-
-        text = "\n".join(stripped_lines).strip()
+        text = strip_indent(raw_string)
 
         external_docs = \
             [

odxtools/diagdatadictionaryspec.py

@@ -46,9 +46,7 @@ class DiagDataDictionarySpec:
     @staticmethod
     def from_et(et_element: ElementTree.Element,
                 context: OdxDocContext) -> "DiagDataDictionarySpec":
-        admin_data = None
-        if (admin_data_elem := et_element.find("ADMIN-DATA")) is not None:
-            admin_data = AdminData.from_et(admin_data_elem, context)
+        admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), context)
 
         dtc_dops = NamedItemList([
             DtcDop.from_et(dtc_dop_elem, context)

odxtools/direction.py

@@ -0,0 +1,7 @@
+# SPDX-License-Identifier: MIT
+from enum import Enum
+
+
+class Direction(Enum):
+    UPLOAD = "UPLOAD"
+    DOWNLOAD = "DOWNLOAD"

odxtools/ecumem.py

@@ -0,0 +1,71 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass, field
+from typing import Any
+from xml.etree import ElementTree
+
+from .admindata import AdminData
+from .element import IdentifiableElement
+from .exceptions import odxrequire
+from .mem import Mem
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .physmem import PhysMem
+from .snrefcontext import SnRefContext
+from .specialdatagroup import SpecialDataGroup
+from .utils import dataclass_fields_asdict
+
+
+@dataclass(kw_only=True)
+class EcuMem(IdentifiableElement):
+    admin_data: AdminData | None = None
+    mem: Mem
+    phys_mem: PhysMem | None = None
+    sdgs: list[SpecialDataGroup] = field(default_factory=list)
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "EcuMem":
+
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
+
+        admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), context)
+        mem = Mem.from_et(odxrequire(et_element.find("MEM")), context)
+        phys_mem = None
+        if (phys_mem_elem := et_element.find("PHYS-MEM")) is not None:
+            phys_mem = PhysMem.from_et(phys_mem_elem, context)
+        sdgs = [SpecialDataGroup.from_et(sdge, context) for sdge in et_element.iterfind("SDGS/SDG")]
+
+        return EcuMem(admin_data=admin_data, mem=mem, phys_mem=phys_mem, sdgs=sdgs, **kwargs)
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        odxlinks = {self.odx_id: self}
+
+        if self.admin_data is not None:
+            odxlinks.update(self.admin_data._build_odxlinks())
+
+        odxlinks.update(self.mem._build_odxlinks())
+        if self.phys_mem is not None:
+            odxlinks.update(self.phys_mem._build_odxlinks())
+        for sdg in self.sdgs:
+            odxlinks.update(sdg._build_odxlinks())
+
+        return odxlinks
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        if self.admin_data is not None:
+            self.admin_data._resolve_odxlinks(odxlinks)
+
+        self.mem._resolve_odxlinks(odxlinks)
+        if self.phys_mem is not None:
+            self.phys_mem._resolve_odxlinks(odxlinks)
+        for sdg in self.sdgs:
+            sdg._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        if self.admin_data is not None:
+            self.admin_data._resolve_snrefs(context)
+
+        self.mem._resolve_snrefs(context)
+        if self.phys_mem is not None:
+            self.phys_mem._resolve_snrefs(context)
+        for sdg in self.sdgs:
+            sdg._resolve_snrefs(context)