odxtools 8.3.4__py3-none-any.whl → 9.1.0__py3-none-any.whl

odxtools/odxcategory.py

@@ -0,0 +1,83 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from xml.etree import ElementTree
+
+from .admindata import AdminData
+from .companydata import CompanyData
+from .element import IdentifiableElement
+from .exceptions import odxrequire
+from .nameditemlist import NamedItemList
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
+from .specialdatagroup import SpecialDataGroup
+from .utils import dataclass_fields_asdict
+
+if TYPE_CHECKING:
+    from .database import Database
+
+
+@dataclass
+class OdxCategory(IdentifiableElement):
+    """This is the base class for all top-level container classes in ODX"""
+
+    admin_data: Optional[AdminData]
+    company_datas: NamedItemList[CompanyData]
+    sdgs: List[SpecialDataGroup]
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "OdxCategory":
+        raise Exception("Calling `._from_et()` is not allowed for OdxCategory. "
+                        "Use `OdxCategory.category_from_et()`!")
+
+    @staticmethod
+    def category_from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment], *,
+                         doc_type: str) -> "OdxCategory":
+
+        short_name = odxrequire(et_element.findtext("SHORT-NAME"))
+        # create the current ODX "document fragment" (description of the
+        # current document for references and IDs)
+        doc_frags = [OdxDocFragment(short_name, doc_type)]
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+
+        admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), doc_frags)
+        company_datas = NamedItemList([
+            CompanyData.from_et(cde, doc_frags)
+            for cde in et_element.iterfind("COMPANY-DATAS/COMPANY-DATA")
+        ])
+        sdgs = [
+            SpecialDataGroup.from_et(sdge, doc_frags) for sdge in et_element.iterfind("SDGS/SDG")
+        ]
+
+        return OdxCategory(admin_data=admin_data, company_datas=company_datas, sdgs=sdgs, **kwargs)
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        result = {self.odx_id: self}
+
+        if self.admin_data is not None:
+            result.update(self.admin_data._build_odxlinks())
+        for cd in self.company_datas:
+            result.update(cd._build_odxlinks())
+        for sdg in self.sdgs:
+            result.update(sdg._build_odxlinks())
+
+        return result
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        if self.admin_data is not None:
+            self.admin_data._resolve_odxlinks(odxlinks)
+        for cd in self.company_datas:
+            cd._resolve_odxlinks(odxlinks)
+        for sdg in self.sdgs:
+            sdg._resolve_odxlinks(odxlinks)
+
+    def _finalize_init(self, database: "Database", odxlinks: OdxLinkDatabase) -> None:
+        pass
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        if self.admin_data is not None:
+            self.admin_data._resolve_snrefs(context)
+        for cd in self.company_datas:
+            cd._resolve_snrefs(context)
+        for sdg in self.sdgs:
+            sdg._resolve_snrefs(context)

odxtools/outputparam.py

@@ -3,8 +3,6 @@ from dataclasses import dataclass
 from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
-from deprecation import deprecated
-
 from .dopbase import DopBase
 from .element import IdentifiableElement
 from .exceptions import odxrequire
@@ -40,8 +38,3 @@ class OutputParam(IdentifiableElement):
     def dop_base(self) -> DopBase:
         """The data object property describing this parameter."""
         return self._dop_base
-
-    @property
-    @deprecated(details="use .dop_base")  # type: ignore[misc]
-    def dop(self) -> DopBase:
-        return self._dop_base

odxtools/parameterinfo.py

@@ -34,36 +34,36 @@ from .staticfield import StaticField
 
 def _get_linear_segment_info(segment: LinearSegment) -> str:
     ll = segment.physical_lower_limit
-    ul = segment.physical_upper_limit
     if ll is None or ll.interval_type == IntervalType.INFINITE:
         ll_str = "(-inf"
     else:
         ll_delim = '(' if ll.interval_type == IntervalType.OPEN else '['
         ll_str = f"{ll_delim}{ll._value!r}"
 
-        if ul is None or ul.interval_type == IntervalType.INFINITE:
-            ul_str = "inf)"
-        else:
-            ul_delim = ')' if ul.interval_type == IntervalType.OPEN else ']'
-            ul_str = f"{ul._value!r}{ul_delim}"
+    ul = segment.physical_upper_limit
+    if ul is None or ul.interval_type == IntervalType.INFINITE:
+        ul_str = "inf)"
+    else:
+        ul_delim = ')' if ul.interval_type == IntervalType.OPEN else ']'
+        ul_str = f"{ul._value!r}{ul_delim}"
 
     return f"{ll_str}, {ul_str}"
 
 
 def _get_rat_func_segment_info(segment: RatFuncSegment) -> str:
     ll = segment.lower_limit
-    ul = segment.upper_limit
     if ll is None or ll.interval_type == IntervalType.INFINITE:
         ll_str = "(-inf"
     else:
         ll_delim = '(' if ll.interval_type == IntervalType.OPEN else '['
         ll_str = f"{ll_delim}{ll._value!r}"
 
-        if ul is None or ul.interval_type == IntervalType.INFINITE:
-            ul_str = "inf)"
-        else:
-            ul_delim = ')' if ul.interval_type == IntervalType.OPEN else ']'
-            ul_str = f"{ul._value!r}{ul_delim}"
+    ul = segment.upper_limit
+    if ul is None or ul.interval_type == IntervalType.INFINITE:
+        ul_str = "inf)"
+    else:
+        ul_delim = ')' if ul.interval_type == IntervalType.OPEN else ']'
+        ul_str = f"{ul._value!r}{ul_delim}"
 
     return f"{ll_str}, {ul_str}"
 

odxtools/parameters/lengthkeyparameter.py

@@ -105,9 +105,8 @@ class LengthKeyParameter(ParameterWithDOP):
         # emplace a value of zero into the encode state, but pretend the bits not to be used
         n = odxrequire(self.dop.get_static_bit_length()) + encode_state.cursor_bit_position
         tmp_val = b'\x00' * ((n + 7) // 8)
-        encode_state.emplace_bytes(tmp_val, obj_used_mask=tmp_val)
-
         encode_state.cursor_bit_position = 0
+        encode_state.emplace_bytes(tmp_val, obj_used_mask=tmp_val)
 
     def encode_value_into_pdu(self, encode_state: EncodeState) -> None:
 

odxtools/parameters/parameter.py

@@ -33,11 +33,13 @@ ParameterType = Literal[
 @dataclass
 class Parameter(NamedElement):
     """This class corresponds to POSITIONABLE-PARAM in the ODX
-    specification.
+    specification
 
-    Be aware that, even though the ODX specification seems to make the
-    distinction of "positionable" and "normal" parameters, it does not
-    define any non-positionable parameter types.
+    All parameter classes must adhere to the `Codec` type protocol, so
+    `isinstance(param, Codec)` ought to be true.  Be aware that, even
+    though the ODX specification seems to make the distinction of
+    "positionable" and "normal" parameters, it does not define any
+    non-positionable parameter types.
 
     """
     oid: Optional[str]

odxtools/parameters/tablekeyparameter.py

@@ -80,18 +80,23 @@ class TableKeyParameter(Parameter):
         super()._resolve_odxlinks(odxlinks)
 
         # Either table_ref or table_row_ref will be defined
-        if self.table_ref:
+        if self.table_ref is not None:
             if TYPE_CHECKING:
                 self._table = odxlinks.resolve(self.table_ref, Table)
             else:
                 self._table = odxlinks.resolve(self.table_ref)
 
-        if self.table_row_ref:
+        if self.table_row_ref is not None:
             if TYPE_CHECKING:
                 self._table_row = odxlinks.resolve(self.table_row_ref, TableRow)
             else:
                 self._table_row = odxlinks.resolve(self.table_row_ref)
-            self._table = self._table_row.table
+
+            if self.table_ref is None and self.table_snref is None:
+                if TYPE_CHECKING:
+                    self._table = odxlinks.resolve(self._table_row.table_ref, Table)
+                else:
+                    self._table = odxlinks.resolve(self._table_row.table_ref)
 
     @override
     def _resolve_snrefs(self, context: SnRefContext) -> None:
@@ -116,11 +121,7 @@ class TableKeyParameter(Parameter):
 
     @property
     def table(self) -> "Table":
-        if self._table is not None:
-            return self._table
-        if self._table_row is not None:
-            return self._table_row.table
-        odxraise(f'Could not resolve the table of {self.short_name}')
+        return self._table
 
     @property
     def table_row(self) -> Optional["TableRow"]:

odxtools/paramlengthinfotype.py

@@ -20,9 +20,16 @@ if TYPE_CHECKING:
 
 @dataclass
 class ParamLengthInfoType(DiagCodedType):
-
     length_key_ref: OdxLinkRef
 
+    @property
+    def dct_type(self) -> DctType:
+        return "PARAM-LENGTH-INFO-TYPE"
+
+    @property
+    def length_key(self) -> "LengthKeyParameter":
+        return self._length_key
+
     @staticmethod
     @override
     def from_et(et_element: ElementTree.Element,
@@ -34,10 +41,6 @@ class ParamLengthInfoType(DiagCodedType):
 
         return ParamLengthInfoType(length_key_ref=length_key_ref, **kwargs)
 
-    @property
-    def dct_type(self) -> DctType:
-        return "PARAM-LENGTH-INFO-TYPE"
-
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         return super()._build_odxlinks()
 
@@ -54,10 +57,6 @@ class ParamLengthInfoType(DiagCodedType):
         """Recursively resolve any short-name references"""
         super()._resolve_snrefs(context)
 
-    @property
-    def length_key(self) -> "LengthKeyParameter":
-        return self._length_key
-
     @override
     def encode_into_pdu(self, internal_value: AtomicOdxType, encode_state: EncodeState) -> None:
         bit_length = encode_state.length_keys.get(self.length_key.short_name)

odxtools/request.py

@@ -1,39 +1,132 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List
+from typing import Any, Dict, List, Optional, cast
 from xml.etree import ElementTree
 
-from .basicstructure import BasicStructure
+from .admindata import AdminData
+from .codec import (composite_codec_decode_from_pdu, composite_codec_encode_into_pdu,
+                    composite_codec_get_coded_const_prefix, composite_codec_get_free_parameters,
+                    composite_codec_get_required_parameters, composite_codec_get_static_bit_length)
+from .decodestate import DecodeState
+from .element import IdentifiableElement
 from .encodestate import EncodeState
-from .odxlink import OdxDocFragment
-from .odxtypes import ParameterValue
+from .exceptions import odxraise
+from .nameditemlist import NamedItemList
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxtypes import ParameterValue, ParameterValueDict
+from .parameters.createanyparameter import create_any_parameter_from_et
+from .parameters.parameter import Parameter
 from .snrefcontext import SnRefContext
+from .specialdatagroup import SpecialDataGroup
 from .utils import dataclass_fields_asdict
 
 
-# TODO: The spec does not say that requests are basic structures. For
-# now, we derive from it anyway because it simplifies the en- and
-# decoding machinery...
 @dataclass
-class Request(BasicStructure):
+class Request(IdentifiableElement):
+    """Represents all information related to an UDS request
+
+    This class implements the `CompositeCodec` interface.
+    """
+    admin_data: Optional[AdminData]
+    parameters: NamedItemList[Parameter]
+    sdgs: List[SpecialDataGroup]
+
+    @property
+    def required_parameters(self) -> List[Parameter]:
+        return composite_codec_get_required_parameters(self)
+
+    @property
+    def free_parameters(self) -> List[Parameter]:
+        return composite_codec_get_free_parameters(self)
 
     @staticmethod
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Request":
-        """Reads a response."""
-        kwargs = dataclass_fields_asdict(BasicStructure.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
 
-        return Request(**kwargs)
+        admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), doc_frags)
+        parameters = NamedItemList([
+            create_any_parameter_from_et(et_parameter, doc_frags)
+            for et_parameter in et_element.iterfind("PARAMS/PARAM")
+        ])
+        sdgs = [
+            SpecialDataGroup.from_et(sdge, doc_frags) for sdge in et_element.iterfind("SDGS/SDG")
+        ]
 
-    def encode(self, **kwargs: ParameterValue) -> bytes:
-        encode_state = EncodeState(is_end_of_pdu=True)
+        return Request(admin_data=admin_data, parameters=parameters, sdgs=sdgs, **kwargs)
 
-        self.encode_into_pdu(physical_value=kwargs, encode_state=encode_state)
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        result = {self.odx_id: self}
 
-        return encode_state.coded_message
+        if self.admin_data is not None:
+            result.update(self.admin_data._build_odxlinks())
+
+        for param in self.parameters:
+            result.update(param._build_odxlinks())
+
+        for sdg in self.sdgs:
+            result.update(sdg._build_odxlinks())
+
+        return result
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        if self.admin_data is not None:
+            self.admin_data._resolve_odxlinks(odxlinks)
+
+        for param in self.parameters:
+            param._resolve_odxlinks(odxlinks)
+
+        for sdg in self.sdgs:
+            sdg._resolve_odxlinks(odxlinks)
 
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         context.request = self
+        context.parameters = self.parameters
 
-        super()._resolve_snrefs(context)
+        if self.admin_data is not None:
+            self.admin_data._resolve_snrefs(context)
+
+        for param in self.parameters:
+            param._resolve_snrefs(context)
+
+        for sdg in self.sdgs:
+            sdg._resolve_snrefs(context)
 
         context.request = None
+        context.parameters = None
+
+    def get_static_bit_length(self) -> Optional[int]:
+        return composite_codec_get_static_bit_length(self)
+
+    def print_free_parameters_info(self) -> None:
+        """Print a human readable description of the composite codec's
+        free parameters to `stdout`
+        """
+        from .parameterinfo import parameter_info
+
+        print(parameter_info(self.free_parameters), end="")
+
+    def encode(self, **kwargs: ParameterValue) -> bytearray:
+        encode_state = EncodeState(is_end_of_pdu=True)
+
+        self.encode_into_pdu(physical_value=kwargs, encode_state=encode_state)
+
+        return encode_state.coded_message
+
+    def decode(self, message: bytes) -> ParameterValueDict:
+        decode_state = DecodeState(coded_message=message)
+        param_values = self.decode_from_pdu(decode_state)
+
+        if not isinstance(param_values, dict):
+            odxraise("Decoding a request must result in a dictionary")
+
+        return cast(ParameterValueDict, param_values)
+
+    def encode_into_pdu(self, physical_value: Optional[ParameterValue],
+                        encode_state: EncodeState) -> None:
+        composite_codec_encode_into_pdu(self, physical_value, encode_state)
+
+    def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
+        return composite_codec_decode_from_pdu(self, decode_state)
+
+    def coded_const_prefix(self, request_prefix: bytes = b'') -> bytes:
+        return composite_codec_get_coded_const_prefix(self, request_prefix)

odxtools/response.py

@@ -1,15 +1,24 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
 from enum import Enum
-from typing import List, Optional, cast
+from typing import Any, Dict, List, Optional, cast
 from xml.etree import ElementTree
 
-from .basicstructure import BasicStructure
+from .admindata import AdminData
+from .codec import (composite_codec_decode_from_pdu, composite_codec_encode_into_pdu,
+                    composite_codec_get_coded_const_prefix, composite_codec_get_free_parameters,
+                    composite_codec_get_required_parameters, composite_codec_get_static_bit_length)
+from .decodestate import DecodeState
+from .element import IdentifiableElement
 from .encodestate import EncodeState
 from .exceptions import odxraise
-from .odxlink import OdxDocFragment
-from .odxtypes import ParameterValue
+from .nameditemlist import NamedItemList
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxtypes import ParameterValue, ParameterValueDict
+from .parameters.createanyparameter import create_any_parameter_from_et
+from .parameters.parameter import Parameter
 from .snrefcontext import SnRefContext
+from .specialdatagroup import SpecialDataGroup
 from .utils import dataclass_fields_asdict
 
 
@@ -19,17 +28,23 @@ class ResponseType(Enum):
     GLOBAL_NEGATIVE = "GLOBAL-NEG-RESPONSE"
 
 
-# TODO: The spec does not say that responses are basic structures. For
-# now, we derive from it anyway because it simplifies the en- and
-# decoding machinery...
 @dataclass
-class Response(BasicStructure):
+class Response(IdentifiableElement):
+    """Represents all information related to an UDS response
+
+    This class implements the `CompositeCodec` interface.
+    """
+
     response_type: ResponseType
 
+    admin_data: Optional[AdminData]
+    parameters: NamedItemList[Parameter]
+    sdgs: List[SpecialDataGroup]
+
     @staticmethod
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Response":
         """Reads a response."""
-        kwargs = dataclass_fields_asdict(BasicStructure.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
 
         try:
             response_type = ResponseType(et_element.tag)
@@ -37,18 +52,103 @@ class Response(BasicStructure):
             response_type = cast(ResponseType, None)
             odxraise(f"Encountered unknown response type '{et_element.tag}'")
 
-        return Response(response_type=response_type, **kwargs)
+        admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), doc_frags)
+        parameters = NamedItemList([
+            create_any_parameter_from_et(et_parameter, doc_frags)
+            for et_parameter in et_element.iterfind("PARAMS/PARAM")
+        ])
+        sdgs = [
+            SpecialDataGroup.from_et(sdge, doc_frags) for sdge in et_element.iterfind("SDGS/SDG")
+        ]
 
-    def encode(self, coded_request: Optional[bytes] = None, **kwargs: ParameterValue) -> bytes:
-        encode_state = EncodeState(triggering_request=coded_request, is_end_of_pdu=True)
+        return Response(
+            response_type=response_type,
+            admin_data=admin_data,
+            parameters=parameters,
+            sdgs=sdgs,
+            **kwargs)
 
-        self.encode_into_pdu(physical_value=kwargs, encode_state=encode_state)
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        result = {self.odx_id: self}
 
-        return encode_state.coded_message
+        if self.admin_data is not None:
+            result.update(self.admin_data._build_odxlinks())
+
+        for param in self.parameters:
+            result.update(param._build_odxlinks())
+
+        for sdg in self.sdgs:
+            result.update(sdg._build_odxlinks())
+
+        return result
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        if self.admin_data is not None:
+            self.admin_data._resolve_odxlinks(odxlinks)
+
+        for param in self.parameters:
+            param._resolve_odxlinks(odxlinks)
+
+        for sdg in self.sdgs:
+            sdg._resolve_odxlinks(odxlinks)
 
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         context.response = self
+        context.parameters = self.parameters
 
-        super()._resolve_snrefs(context)
+        if self.admin_data is not None:
+            self.admin_data._resolve_snrefs(context)
+
+        for param in self.parameters:
+            param._resolve_snrefs(context)
+
+        for sdg in self.sdgs:
+            sdg._resolve_snrefs(context)
 
         context.response = None
+        context.parameters = None
+
+    def encode(self, coded_request: Optional[bytes] = None, **kwargs: ParameterValue) -> bytearray:
+        encode_state = EncodeState(triggering_request=coded_request, is_end_of_pdu=True)
+
+        self.encode_into_pdu(physical_value=kwargs, encode_state=encode_state)
+
+        return encode_state.coded_message
+
+    def decode(self, message: bytes) -> ParameterValueDict:
+        decode_state = DecodeState(coded_message=message)
+        param_values = self.decode_from_pdu(decode_state)
+
+        if not isinstance(param_values, dict):
+            odxraise("Decoding a response must result in a dictionary")
+
+        return cast(ParameterValueDict, param_values)
+
+    def encode_into_pdu(self, physical_value: Optional[ParameterValue],
+                        encode_state: EncodeState) -> None:
+        composite_codec_encode_into_pdu(self, physical_value, encode_state)
+
+    def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
+        return composite_codec_decode_from_pdu(self, decode_state)
+
+    def get_static_bit_length(self) -> Optional[int]:
+        return composite_codec_get_static_bit_length(self)
+
+    @property
+    def required_parameters(self) -> List[Parameter]:
+        return composite_codec_get_required_parameters(self)
+
+    @property
+    def free_parameters(self) -> List[Parameter]:
+        return composite_codec_get_free_parameters(self)
+
+    def print_free_parameters_info(self) -> None:
+        """Return a human readable description of the structure's
+        free parameters.
+        """
+        from .parameterinfo import parameter_info
+
+        print(parameter_info(self.free_parameters), end="")
+
+    def coded_const_prefix(self, request_prefix: bytes = b'') -> bytes:
+        return composite_codec_get_coded_const_prefix(self, request_prefix)

odxtools/specialdatagroup.py

@@ -13,8 +13,8 @@ from .specialdatagroupcaption import SpecialDataGroupCaption
 class SpecialDataGroup:
     sdg_caption: Optional[SpecialDataGroupCaption]
     sdg_caption_ref: Optional[OdxLinkRef]
-    semantic_info: Optional[str]  # the "SI" attribute
     values: List[Union["SpecialDataGroup", SpecialData]]
+    semantic_info: Optional[str]  # the "SI" attribute
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,

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

@@ -5,32 +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 %}
-{%- 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-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 %}
-   {{pd.printDescription(comparam_spec.description)}}
-   {%- 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,36 +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 %}
-   {{pd.printDescription(comparam_subset.description)}}
-   {%- 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 %}