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

odxtools/physmem.py

@@ -0,0 +1,52 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any
+from xml.etree import ElementTree
+
+from .addrdefphyssegment import AddrdefPhysSegment
+from .element import IdentifiableElement
+from .globals import xsi
+from .nameditemlist import NamedItemList
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .physsegment import PhysSegment
+from .sizedefphyssegment import SizedefPhysSegment
+from .snrefcontext import SnRefContext
+from .utils import dataclass_fields_asdict
+
+
+@dataclass(kw_only=True)
+class PhysMem(IdentifiableElement):
+    phys_segments: NamedItemList[PhysSegment]
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "PhysMem":
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
+
+        phys_segments: NamedItemList[PhysSegment] = NamedItemList()
+        for phys_segment_elem in et_element.iterfind("PHYS-SEGMENTS/PHYS-SEGMENT"):
+            phys_segment_type = phys_segment_elem.attrib.get(f"{xsi}type")
+            if phys_segment_type == "ADDRDEF-PHYS-SEGMENT":
+                phys_segments.append(AddrdefPhysSegment.from_et(phys_segment_elem, context))
+            elif phys_segment_type == "SIZEDEF-PHYS-SEGMENT":
+                phys_segments.append(SizedefPhysSegment.from_et(phys_segment_elem, context))
+            else:
+                phys_segments.append(PhysSegment.from_et(phys_segment_elem, context))
+
+        return PhysMem(phys_segments=phys_segments, **kwargs)
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        odxlinks = {self.odx_id: self}
+
+        for phys_segment in self.phys_segments:
+            odxlinks.update(phys_segment._build_odxlinks())
+
+        return odxlinks
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        for phys_segment in self.phys_segments:
+            phys_segment._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        for phys_segment in self.phys_segments:
+            phys_segment._resolve_snrefs(context)

odxtools/physsegment.py

@@ -0,0 +1,42 @@
+# 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 .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 PhysSegment(IdentifiableElement):
+    fillbyte: int | None = None
+    block_size: int | None = None
+    start_address: int
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "PhysSegment":
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
+
+        fillbyte = read_hex_binary(et_element.find("FILLBYTE"))
+        block_size = 0
+        if (bs_elem := et_element.find("BLOCK-SIZE")) is not None:
+            block_size = int(odxrequire(bs_elem.text) or "0")
+        start_address = odxrequire(read_hex_binary(et_element.find("START-ADDRESS")))
+
+        return PhysSegment(
+            fillbyte=fillbyte, block_size=block_size, start_address=start_address, **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/posoffset.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 PosOffset(TargetAddrOffset):
+    positive_offset: int
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "PosOffset":
+        kwargs = dataclass_fields_asdict(TargetAddrOffset.from_et(et_element, context))
+
+        positive_offset = odxrequire(read_hex_binary(et_element.find("POSITIVE-OFFSET")))
+
+        return PosOffset(positive_offset=positive_offset, **kwargs)

odxtools/security.py

@@ -0,0 +1,42 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from xml.etree import ElementTree
+
+from .fwchecksum import FwChecksum
+from .fwsignature import FwSignature
+from .odxdoccontext import OdxDocContext
+from .securitymethod import SecurityMethod
+from .validityfor import ValidityFor
+
+
+@dataclass(kw_only=True)
+class Security:
+    security_method: SecurityMethod | None = None
+    fw_signature: FwSignature | None = None
+    fw_checksum: FwChecksum | None = None
+    validity_for: ValidityFor | None = None
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Security":
+        security_method = None
+        if (sm_elem := et_element.find("SECURITY-METHOD")) is not None:
+            security_method = SecurityMethod.from_et(sm_elem, context)
+
+        fw_signature = None
+        if (fws_elem := et_element.find("FW-SIGNATURE")) is not None:
+            fw_signature = FwSignature.from_et(fws_elem, context)
+
+        fw_checksum = None
+        if (fwcs_elem := et_element.find("FW-CHECKSUM")) is not None:
+            fw_checksum = FwChecksum.from_et(fwcs_elem, context)
+
+        validity_for = None
+        if (val_elem := et_element.find("VALIDITY-FOR")) is not None:
+            validity_for = ValidityFor.from_et(val_elem, context)
+
+        return Security(
+            security_method=security_method,
+            fw_signature=fw_signature,
+            fw_checksum=fw_checksum,
+            validity_for=validity_for,
+        )

odxtools/securitymethod.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
+SecurityMethod = ValidityFor

odxtools/segment.py

@@ -0,0 +1,63 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any
+from xml.etree import ElementTree
+
+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, read_hex_binary
+
+
+@dataclass(kw_only=True)
+class Segment(IdentifiableElement):
+    source_start_address: int
+    compressed_size: int | None = None
+
+    # exactly one of the two next fields must be not None
+    uncompressed_size: int | None = None
+    source_end_address: int | None = None
+
+    encrypt_compress_method: EncryptCompressMethod | None = None
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Segment":
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
+
+        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")
+
+        # exactly one of the two next fields must be not None
+        uncompressed_size = None
+        if (ucs_elem := et_element.find("UNCOMPRESSED-SIZE")) is not None:
+            uncompressed_size = int(odxrequire(ucs_elem.text) or "0")
+        source_end_address = read_hex_binary(et_element.find("SOURCE-END-ADDRESS"))
+
+        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 Segment(
+            source_start_address=source_start_address,
+            compressed_size=compressed_size,
+            uncompressed_size=uncompressed_size,
+            source_end_address=source_end_address,
+            encrypt_compress_method=encrypt_compress_method,
+            **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/session.py

@@ -0,0 +1,88 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass, field
+from typing import Any
+from xml.etree import ElementTree
+
+from .checksum import Checksum
+from .datablock import Datablock
+from .element import IdentifiableElement
+from .expectedident import ExpectedIdent
+from .nameditemlist import NamedItemList
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .security import Security
+from .snrefcontext import SnRefContext
+from .specialdatagroup import SpecialDataGroup
+from .utils import dataclass_fields_asdict
+
+
+@dataclass(kw_only=True)
+class Session(IdentifiableElement):
+    expected_idents: NamedItemList[ExpectedIdent] = field(default_factory=NamedItemList)
+    checksums: NamedItemList[Checksum] = field(default_factory=NamedItemList)
+    securities: list[Security] = field(default_factory=list)
+    datablock_refs: list[OdxLinkRef] = field(default_factory=list)
+    sdgs: list[SpecialDataGroup] = field(default_factory=list)
+
+    @property
+    def datablocks(self) -> NamedItemList[Datablock]:
+        return self._datablocks
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Session":
+
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
+
+        expected_idents = NamedItemList([
+            ExpectedIdent.from_et(el, context)
+            for el in et_element.iterfind("EXPECTED-IDENTS/EXPECTED-IDENT")
+        ])
+        checksums = NamedItemList(
+            [Checksum.from_et(el, context) for el in et_element.iterfind("CHECKSUMS/CHECKSUM")])
+        securities = [
+            Security.from_et(el, context) for el in et_element.iterfind("SECURITYS/SECURITY")
+        ]
+        datablock_refs = [
+            OdxLinkRef.from_et(el, context)
+            for el in et_element.iterfind("DATABLOCK-REFS/DATABLOCK-REF")
+        ]
+        sdgs = [SpecialDataGroup.from_et(sdge, context) for sdge in et_element.iterfind("SDGS/SDG")]
+
+        return Session(
+            expected_idents=expected_idents,
+            checksums=checksums,
+            securities=securities,
+            datablock_refs=datablock_refs,
+            sdgs=sdgs,
+            **kwargs)
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        odxlinks = {self.odx_id: self}
+
+        for ei in self.expected_idents:
+            odxlinks.update(ei._build_odxlinks())
+        for cs in self.checksums:
+            odxlinks.update(cs._build_odxlinks())
+        for sdg in self.sdgs:
+            odxlinks.update(sdg._build_odxlinks())
+
+        return odxlinks
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        self._datablocks = NamedItemList(
+            [odxlinks.resolve(ref, Datablock) for ref in self.datablock_refs])
+
+        for ei in self.expected_idents:
+            ei._resolve_odxlinks(odxlinks)
+        for cs in self.checksums:
+            cs._resolve_odxlinks(odxlinks)
+        for sdg in self.sdgs:
+            sdg._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        for ei in self.expected_idents:
+            ei._resolve_snrefs(context)
+        for cs in self.checksums:
+            cs._resolve_snrefs(context)
+        for sdg in self.sdgs:
+            sdg._resolve_snrefs(context)

odxtools/sessiondesc.py

@@ -0,0 +1,101 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass, field
+from typing import Any, cast
+from xml.etree import ElementTree
+
+from .audience import Audience
+from .direction import Direction
+from .element import NamedElement
+from .exceptions import odxraise, odxrequire
+from .flashclass import FlashClass
+from .nameditemlist import NamedItemList
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .ownident import OwnIdent
+from .snrefcontext import SnRefContext
+from .specialdatagroup import SpecialDataGroup
+from .utils import dataclass_fields_asdict
+
+
+@dataclass(kw_only=True)
+class SessionDesc(NamedElement):
+    partnumber: str | None = None
+    priority: int | None = None
+    session_snref: str
+    diag_comm_snref: str | None = None
+    flash_class_refs: list[OdxLinkRef] = field(default_factory=list)
+    sdgs: list[SpecialDataGroup] = field(default_factory=list)
+    audience: Audience | None = None
+    own_ident: OwnIdent | None = None
+    oid: str | None = None
+    direction: Direction
+
+    @property
+    def flash_classes(self) -> NamedItemList[FlashClass]:
+        return self._flash_classes
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "SessionDesc":
+
+        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, context))
+
+        partnumber = et_element.findtext("PARTNUMBER")
+        priority = None
+        if (priority_str := et_element.findtext("PRIORITY")) is not None:
+            try:
+                priority = int(priority_str)
+            except Exception as e:
+                odxraise(f"Cannot parse PRIORITY: {e}")
+        session_snref = None
+        if (session_snref_elem := odxrequire(et_element.find("SESSION-SNREF"))) is not None:
+            session_snref = odxrequire(session_snref_elem.attrib.get("SHORT-NAME"))
+        diag_comm_snref = None
+        if (diag_comm_snref_elem := et_element.find("DIAG-COMM-SNREF")) is not None:
+            diag_comm_snref = odxrequire(diag_comm_snref_elem.attrib.get("SHORT-NAME"))
+        flash_class_refs = [
+            OdxLinkRef.from_et(el, context)
+            for el in et_element.iterfind("FLASH-CLASS-REFS/FLASH-CLASS-REF")
+        ]
+        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)
+        own_ident = None
+        if (own_ident_elem := et_element.find("OWN-IDENT")) is not None:
+            own_ident = OwnIdent.from_et(own_ident_elem, context)
+        direction_str = odxrequire(et_element.attrib.get("DIRECTION"))
+        try:
+            direction = Direction(direction_str)
+        except ValueError:
+            odxraise(f"Encountered unknown DIRECTION '{direction_str}'")
+            direction = cast(Direction, None)
+        oid = et_element.attrib.get("OID")
+
+        return SessionDesc(
+            partnumber=partnumber,
+            priority=priority,
+            session_snref=session_snref,
+            diag_comm_snref=diag_comm_snref,
+            flash_class_refs=flash_class_refs,
+            sdgs=sdgs,
+            audience=audience,
+            own_ident=own_ident,
+            direction=direction,
+            oid=oid,
+            **kwargs)
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        odxlinks: dict[OdxLinkId, Any] = {}
+
+        if self.own_ident is not None:
+            odxlinks.update(self.own_ident._build_odxlinks())
+
+        return odxlinks
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        self._flash_classes = NamedItemList(
+            [odxlinks.resolve(ref, FlashClass) for ref in self.flash_class_refs])
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        # TODO: resolve session_snref and diag_comm_snref
+        pass

odxtools/sessionsubelemtype.py

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

odxtools/sizedeffilter.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
+
+
+@dataclass(kw_only=True)
+class SizedefFilter(Filter):
+    filter_size: int
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "SizedefFilter":
+        kwargs = dataclass_fields_asdict(Filter.from_et(et_element, context))
+
+        filter_size = int(odxrequire(et_element.findtext("FILTER-SIZE")) or "0")
+
+        return SizedefFilter(filter_size=filter_size, **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/sizedefphyssegment.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
+
+
+@dataclass(kw_only=True)
+class SizedefPhysSegment(PhysSegment):
+    size: int
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "SizedefPhysSegment":
+        kwargs = dataclass_fields_asdict(PhysSegment.from_et(et_element, context))
+
+        size = int(odxrequire(et_element.findtext("SIZE")) or "0")
+
+        return SizedefPhysSegment(size=size, **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/specialdata.py

@@ -6,6 +6,7 @@ from xml.etree import ElementTree
 from .odxdoccontext import OdxDocContext
 from .odxlink import OdxLinkDatabase, OdxLinkId
 from .snrefcontext import SnRefContext
+from .utils import strip_indent
 
 
 @dataclass(kw_only=True)
@@ -19,7 +20,7 @@ class SpecialData:
     def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "SpecialData":
         semantic_info = et_element.get("SI")
         text_identifier = et_element.get("TI")
-        value = et_element.text or ""
+        value = strip_indent(et_element.text) or ""
 
         return SpecialData(
             semantic_info=semantic_info, text_identifier=text_identifier, value=value)

odxtools/targetaddroffset.py

@@ -0,0 +1,13 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from xml.etree import ElementTree
+
+from .odxdoccontext import OdxDocContext
+
+
+@dataclass(kw_only=True)
+class TargetAddrOffset:
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "TargetAddrOffset":
+        return TargetAddrOffset()

odxtools/templates/comparam-spec.odx-c.xml.jinja2

@@ -12,6 +12,7 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no" ?>
 <!-- Written using odxtools {{odxtools_version}} -->
 <ODX MODEL-VERSION="2.2.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="odx.xsd">
+ {{- set_category_docfrag(comparam_spec.short_name, "COMPARAM-SPEC") }}
  <COMPARAM-SPEC  {{- poc.printOdxCategoryAttribs(comparam_spec) }}>
    {{- poc.printOdxCategorySubtags(comparam_spec)|indent(3) }}
    {%- if comparam_spec.prot_stacks %}

odxtools/templates/comparam-subset.odx-cs.xml.jinja2

@@ -15,6 +15,7 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no" ?>
 <!-- Written using odxtools {{odxtools_version}} -->
 <ODX MODEL-VERSION="2.2.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="odx.xsd">
+ {{- set_category_docfrag(comparam_subset.short_name, "COMPARAM-SUBSET") }}
  <COMPARAM-SUBSET  {{- poc.printOdxCategoryAttribs(comparam_subset) }} {{make_xml_attrib("CATEGORY", comparam_subset.category)}}>
    {{- poc.printOdxCategorySubtags(comparam_subset)|indent(3) }}
    {%- if comparam_subset.comparams %}

odxtools/templates/diag_layer_container.odx-d.xml.jinja2

@@ -14,6 +14,7 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no" ?>
 <!-- Written using odxtools {{odxtools_version}} -->
 <ODX MODEL-VERSION="2.2.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="odx.xsd">
+ {{- set_category_docfrag(dlc.short_name, "CONTAINER") }}
  <DIAG-LAYER-CONTAINER {{- poc.printOdxCategoryAttribs(dlc) }}>
   {{- poc.printOdxCategorySubtags(dlc)|indent(3) }}
 {%- if dlc.protocols %}
@@ -44,7 +45,7 @@
  {%- endfor %}
   </BASE-VARIANTS>
 {%- endif %}
-{%- if  dlc.ecu_variants %}
+{%- if dlc.ecu_variants %}
   <ECU-VARIANTS>
  {%- for dl in dlc.ecu_variants %}
   {{pecuv.printEcuVariant(dl)|indent(3)}}

odxtools/templates/flash.odx-f.xml.jinja2

@@ -0,0 +1,42 @@
+{#- -*- mode: sgml; tab-width: 1; indent-tabs-mode: nil -*-
+ #
+ # SPDX-License-Identifier: MIT
+ #
+ # This template writes an .odx-cs file for a communication
+ # parameter subset.
+-#}
+{%- import('macros/printOdxCategory.xml.jinja2') as poc %}
+{%- import('macros/printEcuMem.xml.jinja2') as pem %}
+{%- import('macros/printEcuMemConnector.xml.jinja2') as pemc %}
+{%- import('macros/printAudience.xml.jinja2') as paud %}
+{#- -#}
+
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<!-- Written using odxtools {{odxtools_version}} -->
+<ODX MODEL-VERSION="2.2.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="odx.xsd">
+  {{- set_category_docfrag(flash.short_name, "FLASH") }}
+  <FLASH {{- poc.printOdxCategoryAttribs(flash) }}>
+    {{- poc.printOdxCategorySubtags(flash)|indent(4) }}
+    {%- if flash.ecu_mems %}
+    <ECU-MEMS>
+      {%- for ecu_mem in flash.ecu_mems %}
+      {{ pem.printEcuMem(ecu_mem) | indent(6) }}
+      {%- endfor %}
+    </ECU-MEMS>
+    {%- endif %}
+    {%- if flash.ecu_mem_connectors %}
+    <ECU-MEM-CONNECTORS>
+      {%- for ecu_mem_connector in flash.ecu_mem_connectors %}
+      {{ pemc.printEcuMemConnector(ecu_mem_connector) | indent(6) }}
+      {%- endfor %}
+    </ECU-MEM-CONNECTORS>
+    {%- endif %}
+    {%- if flash.additional_audiences %}
+    <ADDITIONAL-AUDIENCES>
+      {%- for audience in flash.additional_audiences %}
+      {{ paud.printAdditionalAudience(audience) | indent(6) }}
+      {%- endfor %}
+    </ADDITIONAL-AUDIENCES>
+    {%- endif %}
+  </FLASH>
+</ODX>

odxtools/templates/macros/printAdminData.xml.jinja2

@@ -14,9 +14,9 @@
  <COMPANY-DOC-INFOS>
   {%- for cdi in admin_data.company_doc_infos %}
   <COMPANY-DOC-INFO>
-    <COMPANY-DATA-REF ID-REF="{{cdi.company_data_ref.ref_id}}" />
+    <COMPANY-DATA-REF {{make_ref_attribs(cdi.company_data_ref)}} />
    {%- if cdi.team_member_ref is not none %}
-    <TEAM-MEMBER-REF ID-REF="{{cdi.team_member_ref.ref_id}}" />
+    <TEAM-MEMBER-REF {{make_ref_attribs(cdi.team_member_ref)}} />
     {%- endif %}
    {%- if cdi.doc_label is not none %}
     <DOC-LABEL>{{cdi.doc_label|e}}</DOC-LABEL>
@@ -31,7 +31,7 @@
   {%- for doc_revision in admin_data.doc_revisions %}
   <DOC-REVISION>
    {%- if doc_revision.team_member_ref is not none %}
-   <TEAM-MEMBER-REF ID-REF="{{doc_revision.team_member_ref.ref_id}}" />
+   <TEAM-MEMBER-REF {{make_ref_attribs(doc_revision.team_member_ref)}} />
    {%- endif %}
    {%- if doc_revision.revision_label is not none %}
    <REVISION-LABEL>{{doc_revision.revision_label|e}}</REVISION-LABEL>
@@ -47,7 +47,7 @@
    <COMPANY-REVISION-INFOS>
      {%- for cri in doc_revision.company_revision_infos %}
      <COMPANY-REVISION-INFO>
-       <COMPANY-DATA-REF ID-REF="{{cri.company_data_ref.ref_id}}" />
+       <COMPANY-DATA-REF {{make_ref_attribs(cri.company_data_ref)}} />
        {%- if cri.revision_label is not none %}
        <REVISION-LABEL>{{cri.revision_label|e}}</REVISION-LABEL>
        {%- endif %}

odxtools/templates/macros/printAudience.xml.jinja2

@@ -7,7 +7,7 @@
 
 {%- macro printAdditionalAudience(audience) -%}
 <ADDITIONAL-AUDIENCE {{-peid.printElementIdAttribs(audience)}}>
- {{ peid.printElementIdSubtags(audience)|indent(1) }}
+  {{ peid.printElementIdSubtags(audience)|indent(2) }}
 </ADDITIONAL-AUDIENCE>
 {%- endmacro -%}
 
@@ -20,14 +20,14 @@
 {%- if audience.enabled_audience_refs %}
  <ENABLED-AUDIENCE-REFS>
 {%- for ref in audience.enabled_audience_refs %}
-  <ENABLED-AUDIENCE-REF ID-REF="{{ref.ref_id}}" />
+  <ENABLED-AUDIENCE-REF {{make_ref_attribs(ref)}} />
 {%- endfor %}
  </ENABLED-AUDIENCE-REFS>
 {%- endif%}
 {%- if audience.disabled_audience_refs %}
  <DISABLED-AUDIENCE-REFS>
 {%- for ref in audience.disabled_audience_refs %}
-  <DISABLED-AUDIENCE-REF ID-REF="{{ref.ref_id}}" />
+  <DISABLED-AUDIENCE-REF {{make_ref_attribs(ref)}} />
 {%- endfor %}
  </DISABLED-AUDIENCE-REFS>
 {%- endif%}