odxtools 6.7.0__py3-none-any.whl → 9.3.0__py3-none-any.whl

odxtools/subcomponent.py

@@ -0,0 +1,288 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
+from xml.etree import ElementTree
+
+from .diagnostictroublecode import DiagnosticTroubleCode
+from .diagservice import DiagService
+from .dtcdop import DtcDop
+from .element import IdentifiableElement, NamedElement
+from .environmentdata import EnvironmentData
+from .environmentdatadescription import EnvironmentDataDescription
+from .exceptions import odxraise, odxrequire
+from .matchingparameter import MatchingParameter
+from .nameditemlist import NamedItemList
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from .parameters.parameter import Parameter
+from .snrefcontext import SnRefContext
+from .table import Table
+from .tablerow import TableRow
+from .utils import dataclass_fields_asdict
+
+
+@dataclass
+class SubComponentPattern:
+    matching_parameters: List[MatchingParameter]
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "SubComponentPattern":
+
+        matching_parameters = [
+            MatchingParameter.from_et(el, doc_frags)
+            for el in et_element.iterfind("MATCHING-PARAMETERS/MATCHING-PARAMETER")
+        ]
+
+        return SubComponentPattern(matching_parameters=matching_parameters)
+
+
+@dataclass
+class SubComponentParamConnector(IdentifiableElement):
+    diag_comm_snref: str
+
+    # TODO: we currently only support SNREFs, not SNPATHREFs
+    out_param_if_refs: List[str]
+    in_param_if_refs: List[str]
+
+    @property
+    def service(self) -> DiagService:
+        return self._service
+
+    @property
+    def out_param_ifs(self) -> NamedItemList[Parameter]:
+        return self._out_param_ifs
+
+    @property
+    def in_param_ifs(self) -> NamedItemList[Parameter]:
+        return self._in_param_ifs
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "SubComponentParamConnector":
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+
+        diag_comm_snref = odxrequire(
+            odxrequire(et_element.find("DIAG-COMM-SNREF")).get("SHORT-NAME"))
+
+        out_param_if_refs = []
+        for elem in et_element.find("OUT-PARAM-IF-REFS") or []:
+            if elem.tag != "OUT-PARAM-IF-SNREF":
+                odxraise("Currently, only SNREFS are supported for OUT-PARAM-IF-REFS")
+                continue
+
+            out_param_if_refs.append(odxrequire(elem.get("SHORT-NAME")))
+
+        in_param_if_refs = []
+        for elem in et_element.find("IN-PARAM-IF-REFS") or []:
+            if elem.tag != "IN-PARAM-IF-SNREF":
+                odxraise("Currently, only SNREFS are supported for IN-PARAM-IF-REFS")
+                continue
+
+            in_param_if_refs.append(odxrequire(elem.get("SHORT-NAME")))
+
+        return SubComponentParamConnector(
+            diag_comm_snref=diag_comm_snref,
+            out_param_if_refs=out_param_if_refs,
+            in_param_if_refs=in_param_if_refs,
+            **kwargs)
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        return {}
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        pass
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        service = resolve_snref(self.diag_comm_snref,
+                                odxrequire(context.diag_layer).diag_comms, DiagService)
+        self._service = service
+
+        if self._service.request is not None:
+            odxraise()
+            return
+        if not self._service.positive_responses:
+            odxraise()
+            return
+        request = odxrequire(service.request)
+        response = service.positive_responses[0]
+
+        in_param_ifs = []
+        for x in self.in_param_if_refs:
+            in_param_ifs.append(resolve_snref(x, request.parameters, Parameter))
+
+        out_param_ifs = []
+        for x in self.out_param_if_refs:
+            out_param_ifs.append(resolve_snref(x, response.parameters, Parameter))
+
+        self._in_param_ifs = NamedItemList(in_param_ifs)
+        self._out_param_ifs = NamedItemList(out_param_ifs)
+
+
+@dataclass
+class TableRowConnector(NamedElement):
+    table_ref: OdxLinkRef
+    table_row_snref: str
+
+    @property
+    def table(self) -> Table:
+        return self._table
+
+    @property
+    def table_row(self) -> TableRow:
+        return self._table_row
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "TableRowConnector":
+        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
+
+        table_ref = odxrequire(OdxLinkRef.from_et(et_element.find("TABLE-REF"), doc_frags))
+        table_row_snref_el = odxrequire(et_element.find("TABLE-ROW-SNREF"))
+        table_row_snref = odxrequire(table_row_snref_el.get("SHORT-NAME"))
+
+        return TableRowConnector(table_ref=table_ref, table_row_snref=table_row_snref, **kwargs)
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        return {}
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        self._table = odxlinks.resolve(self.table_ref, Table)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        self._table_row = resolve_snref(self.table_row_snref, self._table.table_rows, TableRow)
+
+
+@dataclass
+class DtcConnector(NamedElement):
+    dtc_dop_ref: OdxLinkRef
+    dtc_snref: str
+
+    @property
+    def dtc_dop(self) -> DtcDop:
+        return self._dtc_dop
+
+    @property
+    def dtc(self) -> DiagnosticTroubleCode:
+        return self._dtc
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "DtcConnector":
+        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
+
+        dtc_dop_ref = odxrequire(OdxLinkRef.from_et(et_element.find("DTC-DOP-REF"), doc_frags))
+        dtc_snref_el = odxrequire(et_element.find("DTC-SNREF"))
+        dtc_snref = odxrequire(dtc_snref_el.get("SHORT-NAME"))
+
+        return DtcConnector(dtc_dop_ref=dtc_dop_ref, dtc_snref=dtc_snref, **kwargs)
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        return {}
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        self._dtc_dop = odxlinks.resolve(self.dtc_dop_ref, DtcDop)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        self._dtc = resolve_snref(self.dtc_snref, self._dtc_dop.dtcs, DiagnosticTroubleCode)
+
+
+@dataclass
+class EnvDataConnector(NamedElement):
+    env_data_desc_ref: OdxLinkRef
+    env_data_snref: str
+
+    @property
+    def env_data_desc(self) -> EnvironmentDataDescription:
+        return self._env_data_desc
+
+    @property
+    def env_data(self) -> EnvironmentData:
+        return self._env_data
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "EnvDataConnector":
+        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
+
+        env_data_desc_ref = odxrequire(
+            OdxLinkRef.from_et(et_element.find("ENV-DATA-DESC-REF"), doc_frags))
+        env_data_snref_el = odxrequire(et_element.find("ENV-DATA-SNREF"))
+        env_data_snref = odxrequire(env_data_snref_el.get("SHORT-NAME"))
+
+        return EnvDataConnector(
+            env_data_desc_ref=env_data_desc_ref, env_data_snref=env_data_snref, **kwargs)
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        return {}
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        self._env_data_desc = odxlinks.resolve(self.env_data_desc_ref, EnvironmentDataDescription)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        self._env_data = resolve_snref(self.env_data_snref, self._env_data_desc.env_datas,
+                                       EnvironmentData)
+
+
+@dataclass
+class SubComponent(IdentifiableElement):
+    """Sub-components describe collections of related diagnostic variables
+
+    Note that the communication paradigm via diagnostic variables is
+    somewhat uncommon. If your ECU does not define any, there's no
+    need for it to define sub-components.
+
+    """
+
+    #sub_component_patterns: NamedItemList[SubComponentPattern]
+    sub_component_param_connectors: NamedItemList[SubComponentParamConnector]
+    table_row_connectors: NamedItemList[TableRowConnector]
+    env_data_connectors: NamedItemList[EnvDataConnector]
+    dtc_connectors: NamedItemList[DtcConnector]
+
+    semantic: Optional[str]
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "SubComponent":
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+
+        semantic = et_element.get("SEMANTIC")
+
+        sub_component_param_connectors = [
+            SubComponentParamConnector.from_et(el, doc_frags) for el in et_element.iterfind(
+                "SUB-COMPONENT-PARAM-CONNECTORS/SUB-COMPONENT-PARAM-CONNECTOR")
+        ]
+        table_row_connectors = [
+            TableRowConnector.from_et(el, doc_frags)
+            for el in et_element.iterfind("TABLE-ROW-CONNECTORS/TABLE-ROW-CONNECTOR")
+        ]
+        env_data_connectors = [
+            EnvDataConnector.from_et(el, doc_frags)
+            for el in et_element.iterfind("ENV-DATA-CONNECTORS/ENV-DATA-CONNECTOR")
+        ]
+        dtc_connectors = [
+            DtcConnector.from_et(el, doc_frags)
+            for el in et_element.iterfind("DTC-CONNECTORS/DTC-CONNECTOR")
+        ]
+
+        return SubComponent(
+            semantic=semantic,
+            sub_component_param_connectors=NamedItemList(sub_component_param_connectors),
+            table_row_connectors=NamedItemList(table_row_connectors),
+            env_data_connectors=NamedItemList(env_data_connectors),
+            dtc_connectors=NamedItemList(dtc_connectors),
+            **kwargs)
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        result = {}
+
+        for dtc_conn in self.dtc_connectors:
+            result.update(dtc_conn._build_odxlinks())
+
+        return result
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        for dtc_conn in self.dtc_connectors:
+            dtc_conn._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        for dtc_conn in self.dtc_connectors:
+            dtc_conn._resolve_snrefs(context)

odxtools/swvariable.py

@@ -0,0 +1,21 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import List, Optional
+from xml.etree import ElementTree
+
+from .element import NamedElement
+from .odxlink import OdxDocFragment
+from .utils import dataclass_fields_asdict
+
+
+@dataclass
+class SwVariable(NamedElement):
+    origin: Optional[str]
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "SwVariable":
+        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
+
+        origin = et_element.findtext("ORIGIN")
+
+        return SwVariable(origin=origin, **kwargs)

odxtools/table.py

@@ -1,22 +1,19 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Union
 from xml.etree import ElementTree
 
 from .admindata import AdminData
-from .createsdgs import create_sdgs_from_et
 from .dataobjectproperty import DataObjectProperty
 from .element import IdentifiableElement
 from .exceptions import odxassert
 from .nameditemlist import NamedItemList
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .snrefcontext import SnRefContext
 from .specialdatagroup import SpecialDataGroup
 from .tablerow import TableRow
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class Table(IdentifiableElement):
@@ -50,7 +47,9 @@ class Table(IdentifiableElement):
             elif sub_elem.tag == "TABLE-ROW-REF":
                 table_rows_raw.append(OdxLinkRef.from_et(sub_elem, doc_frags))
 
-        sdgs = create_sdgs_from_et(et_element.find("SDGS"), doc_frags)
+        sdgs = [
+            SpecialDataGroup.from_et(sdge, doc_frags) for sdge in et_element.iterfind("SDGS/SDG")
+        ]
 
         return Table(
             semantic=semantic,
@@ -99,7 +98,7 @@ class Table(IdentifiableElement):
 
         self._table_rows = NamedItemList(table_rows)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         for table_row_wrapper in self.table_rows_raw:
             if isinstance(table_row_wrapper, TableRow):
-                table_row_wrapper._resolve_snrefs(diag_layer)
+                table_row_wrapper._resolve_snrefs(context)

odxtools/tablerow.py

@@ -1,21 +1,20 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from dataclasses import dataclass, fields
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple
 from xml.etree import ElementTree
 
 from .basicstructure import BasicStructure
-from .createsdgs import create_sdgs_from_et
 from .dataobjectproperty import DataObjectProperty
 from .dtcdop import DtcDop
 from .element import IdentifiableElement
 from .exceptions import odxassert, odxraise, odxrequire
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from .odxtypes import AtomicOdxType
+from .snrefcontext import SnRefContext
 from .specialdatagroup import SpecialDataGroup
 from .utils import dataclass_fields_asdict
 
 if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
     from .table import Table
 
 
@@ -70,7 +69,9 @@ class TableRow(IdentifiableElement):
         dop_snref: Optional[str] = None
         if (dop_snref_elem := et_element.find("DATA-OBJECT-PROP-SNREF")) is not None:
             dop_snref = dop_snref_elem.attrib["SHORT-NAME"]
-        sdgs = create_sdgs_from_et(et_element.find("SDGS"), doc_frags)
+        sdgs = [
+            SpecialDataGroup.from_et(sdge, doc_frags) for sdge in et_element.iterfind("SDGS/SDG")
+        ]
 
         return TableRow(
             table_ref=table_ref,
@@ -107,7 +108,7 @@ class TableRow(IdentifiableElement):
         for sdg in self.sdgs:
             sdg._resolve_odxlinks(odxlinks)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         # convert the raw key into the proper internal
         # representation. note that we cannot do this earlier because
         # the table's ODXLINKs must be resolved and the order of
@@ -125,15 +126,17 @@ class TableRow(IdentifiableElement):
         else:
             self._key = key_dop.physical_type.base_data_type.from_string(self.key_raw)
 
-        ddd_spec = diag_layer.diag_data_dictionary_spec
+        ddd_spec = odxrequire(context.diag_layer).diag_data_dictionary_spec
 
         if self.structure_snref is not None:
-            self._structure = odxrequire(ddd_spec.structures.get(self.structure_snref))
+            self._structure = resolve_snref(self.structure_snref, ddd_spec.structures,
+                                            BasicStructure)
         if self.dop_snref is not None:
-            self._dop = odxrequire(ddd_spec.data_object_props.get(self.dop_snref))
+            self._dop = resolve_snref(self.dop_snref, ddd_spec.data_object_props,
+                                      DataObjectProperty)
 
         for sdg in self.sdgs:
-            sdg._resolve_snrefs(diag_layer)
+            sdg._resolve_snrefs(context)
 
     @property
     def table(self) -> "Table":
@@ -154,3 +157,8 @@ class TableRow(IdentifiableElement):
     def dop(self) -> Optional[DataObjectProperty]:
         """The data object property object resolved by dop_ref."""
         return self._dop
+
+    def __reduce__(self) -> Tuple[Any, ...]:
+        """This ensures that the object can be correctly reconstructed during unpickling."""
+        state = self.__dict__.copy()
+        return self.__class__, tuple([getattr(self, x.name) for x in fields(self)]), state

odxtools/teammember.py

@@ -1,16 +1,14 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
 from .element import IdentifiableElement
 from .exceptions import odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class TeamMember(IdentifiableElement):
@@ -55,5 +53,5 @@ class TeamMember(IdentifiableElement):
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         pass
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass

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

@@ -5,35 +5,15 @@
  # This template writes an .odx-c file for a communication
  # parameter specification.
 -#}
-{%- import('macros/printAdminData.xml.jinja2') as pad -%}
-{%- import('macros/printCompanyData.xml.jinja2') as pcd -%}
+{%- import('macros/printOdxCategory.xml.jinja2') as poc %}
 {%- import('macros/printProtStack.xml.jinja2') as pps %}
 {#- -#}
 
 <?xml version="1.0" encoding="UTF-8" standalone="no" ?>
-<ODX MODEL-VERSION="2.2.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="odx.xsd">
 <!-- Written using odxtools {{odxtools_version}} -->
- <COMPARAM-SPEC ID="{{comparam_spec.odx_id.local_id}}">
-   <SHORT-NAME>{{comparam_spec.short_name}}</SHORT-NAME>
-   {%- if comparam_spec.long_name is not none %}
-   <LONG-NAME>{{comparam_spec.long_name|e}}</LONG-NAME>
-   {%- endif %}
-   {%- if comparam_spec.description and comparam_spec.description.strip() %}
-   <DESC>
-     {{comparam_spec.description}}
-   </DESC>
-   {%- endif %}
-   {%- if comparam_spec.admin_data is not none %}
-   {{- pad.printAdminData(comparam_spec.admin_data) | indent(3) }}
-   {%- endif %}
-   {%- if comparam_spec.company_datas %}
-   <COMPANY-DATAS>
-    {%- for cd in comparam_spec.company_datas %}
-     {{- pcd.printCompanyData(cd) | indent(5) -}}
-    {%- endfor %}
-   </COMPANY-DATAS>
-   {%- endif %}
-
+<ODX MODEL-VERSION="2.2.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="odx.xsd">
+ <COMPARAM-SPEC  {{- poc.printOdxCategoryAttribs(comparam_spec) }}>
+   {{- poc.printOdxCategorySubtags(comparam_spec)|indent(3) }}
    {%- if comparam_spec.prot_stacks %}
    <PROT-STACKS>
     {%- for ps in comparam_spec.prot_stacks %}

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

@@ -5,39 +5,18 @@
  # This template writes an .odx-cs file for a communication
  # parameter subset.
 -#}
+{%- import('macros/printOdxCategory.xml.jinja2') as poc %}
 {%- import('macros/printComparam.xml.jinja2') as pcp -%}
-{%- import('macros/printAdminData.xml.jinja2') as pad -%}
-{%- import('macros/printCompanyData.xml.jinja2') as pcd -%}
 {%- import('macros/printDOP.xml.jinja2') as pdop %}
 {%- import('macros/printUnitSpec.xml.jinja2') as pus %}
-{%- import('macros/printSpecialData.xml.jinja2') as psd %}
+{%- import('macros/printDescription.xml.jinja2') as pd %}
 {#- -#}
 
 <?xml version="1.0" encoding="UTF-8" standalone="no" ?>
-<ODX MODEL-VERSION="2.2.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="odx.xsd">
 <!-- Written using odxtools {{odxtools_version}} -->
- <COMPARAM-SUBSET ID="{{comparam_subset.odx_id.local_id}}"
-                  CATEGORY="{{comparam_subset.category}}" >
-   <SHORT-NAME>{{comparam_subset.short_name}}</SHORT-NAME>
-   {%- if comparam_subset.long_name is not none %}
-   <LONG-NAME>{{comparam_subset.long_name|e}}</LONG-NAME>
-   {%- endif %}
-   {%- if comparam_subset.description and comparam_subset.description.strip() %}
-   <DESC>
-     {{comparam_subset.description}}
-   </DESC>
-   {%- endif %}
-   {%- if comparam_subset.admin_data is not none %}
-   {{- pad.printAdminData(comparam_subset.admin_data) | indent(3) }}
-   {%- endif %}
-   {%- if comparam_subset.company_datas %}
-   <COMPANY-DATAS>
-     {%- for cd in comparam_subset.company_datas %}
-     {{- pcd.printCompanyData(cd) | indent(5, first=True) }}
-     {%- endfor %}
-   </COMPANY-DATAS>
-   {%- endif %}
-   {{- psd.printSpecialDataGroups(comparam_subset.sdgs)|indent(3, first=True) }}
+<ODX MODEL-VERSION="2.2.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="odx.xsd">
+ <COMPARAM-SUBSET  {{- poc.printOdxCategoryAttribs(comparam_subset) }} {{make_xml_attrib("CATEGORY", comparam_subset.category)}}>
+   {{- poc.printOdxCategorySubtags(comparam_subset)|indent(3) }}
    {%- if comparam_subset.comparams %}
    <COMPARAMS>
      {%- for cp in comparam_subset.comparams %}

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

@@ -2,68 +2,52 @@
  #
  # SPDX-License-Identifier: MIT
 -#}
-{%- import('macros/printVariant.xml.jinja2') as pv -%}
-{%- import('macros/printAdminData.xml.jinja2') as pad -%}
-{%- import('macros/printCompanyData.xml.jinja2') as pcd -%}
-{%- import('macros/printSpecialData.xml.jinja2') as psd %}
+{%- import('macros/printOdxCategory.xml.jinja2') as poc %}
+{%- import('macros/printEcuSharedData.xml.jinja2') as pecusd -%}
+{%- import('macros/printProtocol.xml.jinja2') as pprot %}
+{%- import('macros/printFunctionalGroup.xml.jinja2') as pfuncgroup %}
+{%- import('macros/printEcuSharedData.xml.jinja2') as pecusd %}
+{%- import('macros/printBaseVariant.xml.jinja2') as pbv %}
+{%- import('macros/printEcuVariant.xml.jinja2') as pecuv %}
 {#- -#}
 
 <?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">
- <!-- Written using odxtools {{odxtools_version}} -->
- <DIAG-LAYER-CONTAINER ID="{{dlc.odx_id.local_id}}">
-  <SHORT-NAME>{{dlc.short_name}}</SHORT-NAME>
-{%- if dlc.long_name %}
-  <LONG-NAME>{{dlc.long_name|e}}</LONG-NAME>
-{%- endif %}
-{%- if dlc.description %}
-  <DESC>
-{{dlc.description}}
-  </DESC>
-{%- endif %}
-{%- if dlc.admin_data %}
-  {{pad.printAdminData(dlc.admin_data)|indent(2)}}
-{%- endif %}
-{%- if dlc.company_datas %}
-  <COMPANY-DATAS>
- {%- for cd in dlc.company_datas %}
-   {{pcd.printCompanyData(cd)|indent(3)}}
- {%- endfor %}
-  </COMPANY-DATAS>
-{%- endif %}
-  {{- psd.printSpecialDataGroups(dlc.sdgs)|indent(2, first=True) }}
+ <DIAG-LAYER-CONTAINER {{- poc.printOdxCategoryAttribs(dlc) }}>
+  {{- poc.printOdxCategorySubtags(dlc)|indent(3) }}
 {%- if dlc.protocols %}
   <PROTOCOLS>
  {%- for dl in dlc.protocols %}
-   {{pv.printVariant(dl)|indent(3)}}
+   {{pprot.printProtocol(dl)|indent(3)}}
  {%- endfor %}
   </PROTOCOLS>
 {%- endif %}
 {%- if dlc.functional_groups %}
   <FUNCTIONAL-GROUPS>
  {%- for dl in dlc.functional_groups %}
-  {{pv.printVariant(dl)|indent(3)}}
+  {{pfuncgroup.printFunctionalGroup(dl)|indent(3)}}
  {%- endfor %}
   </FUNCTIONAL-GROUPS>
 {%- endif %}
 {%- if dlc.ecu_shared_datas %}
   <ECU-SHARED-DATAS>
  {%- for dl in dlc.ecu_shared_datas %}
-  {{pv.printVariant(dl)|indent(3)}}
+  {{pecusd.printEcuSharedData(dl)|indent(3)}}
  {%- endfor %}
   </ECU-SHARED-DATAS>
 {%- endif %}
 {%- if dlc.base_variants %}
   <BASE-VARIANTS>
  {%- for dl in dlc.base_variants %}
-  {{pv.printVariant(dl)|indent(3)}}
+  {{pbv.printBaseVariant(dl)|indent(3)}}
  {%- endfor %}
   </BASE-VARIANTS>
 {%- endif %}
 {%- if  dlc.ecu_variants %}
   <ECU-VARIANTS>
  {%- for dl in dlc.ecu_variants %}
-  {{pv.printVariant(dl)|indent(3)}}
+  {{pecuv.printEcuVariant(dl)|indent(3)}}
  {%- endfor %}
   </ECU-VARIANTS>
 {%- endif %}

odxtools/templates/{index.xml.xml.jinja2 → index.xml.jinja2}

@@ -4,7 +4,7 @@
 -#}
 <?xml version="1.0" encoding="UTF-8"?>
 <CATALOG xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" F-DTD-VERSION="ODX-2.2.0" xsi:noNamespaceSchemaLocation="odx-cc.xsd">
-  <SHORT-NAME>{{ecu_name}}</SHORT-NAME>
+  <SHORT-NAME>{{database.short_name}}</SHORT-NAME>
   <ABLOCKS>
 {%- for file_name, creation_date, mime_type in file_index %}
     <ABLOCK UPD="UNCHANGED">

odxtools/templates/macros/printAudience.xml.jinja2

@@ -6,7 +6,7 @@
 {%- import('macros/printElementId.xml.jinja2') as peid %}
 
 {%- macro printAdditionalAudience(audience) -%}
-<ADDITIONAL-AUDIENCE ID="{{audience.odx_id.local_id}}">
+<ADDITIONAL-AUDIENCE {{-peid.printElementIdAttribs(audience)}}>
  {{ peid.printElementIdSubtags(audience)|indent(1) }}
 </ADDITIONAL-AUDIENCE>
 {%- endmacro -%}