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

odxtools/comparamsubset.py

@@ -1,50 +1,41 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
 from xml.etree import ElementTree
 
-from .admindata import AdminData
-from .companydata import CompanyData
 from .comparam import Comparam
 from .complexcomparam import ComplexComparam
 from .dataobjectproperty import DataObjectProperty
-from .element import IdentifiableElement
-from .exceptions import odxrequire
 from .nameditemlist import NamedItemList
+from .odxcategory import OdxCategory
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from .snrefcontext import SnRefContext
-from .specialdatagroup import SpecialDataGroup
 from .unitspec import UnitSpec
 from .utils import dataclass_fields_asdict
 
+if TYPE_CHECKING:
+    from .database import Database
+
 
 @dataclass
-class ComparamSubset(IdentifiableElement):
-    # mandatory in ODX 2.2, but non existent in ODX 2.0
+class ComparamSubset(OdxCategory):
+    # mandatory in ODX 2.2, but non-existent in ODX 2.0
     category: Optional[str]
-    data_object_props: NamedItemList[DataObjectProperty]
+
     comparams: NamedItemList[Comparam]
     complex_comparams: NamedItemList[ComplexComparam]
+    data_object_props: NamedItemList[DataObjectProperty]
     unit_spec: Optional[UnitSpec]
-    admin_data: Optional[AdminData]
-    company_datas: NamedItemList[CompanyData]
-    sdgs: List[SpecialDataGroup]
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "ComparamSubset":
 
-        category = et_element.get("CATEGORY")
-
-        short_name = odxrequire(et_element.findtext("SHORT-NAME"))
-        doc_frags = [OdxDocFragment(short_name, str(et_element.tag))]
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+        cat = OdxCategory.category_from_et(et_element, doc_frags, doc_type="COMPARAM-SUBSET")
+        doc_frags = cat.odx_id.doc_fragments
+        kwargs = dataclass_fields_asdict(cat)
 
-        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")
-        ])
+        category = et_element.get("CATEGORY")
 
         data_object_props = NamedItemList([
             DataObjectProperty.from_et(el, doc_frags)
@@ -61,25 +52,16 @@ class ComparamSubset(IdentifiableElement):
         else:
             unit_spec = None
 
-        sdgs = [
-            SpecialDataGroup.from_et(sdge, doc_frags) for sdge in et_element.iterfind("SDGS/SDG")
-        ]
-
         return ComparamSubset(
             category=category,
-            admin_data=admin_data,
-            company_datas=company_datas,
             data_object_props=data_object_props,
             comparams=comparams,
             complex_comparams=complex_comparams,
             unit_spec=unit_spec,
-            sdgs=sdgs,
             **kwargs)
 
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
-        odxlinks: Dict[OdxLinkId, Any] = {}
-        if self.odx_id is not None:
-            odxlinks[self.odx_id] = self
+        odxlinks = super()._build_odxlinks()
 
         for dop in self.data_object_props:
             odxlinks[dop.odx_id] = dop
@@ -93,19 +75,11 @@ class ComparamSubset(IdentifiableElement):
         if self.unit_spec:
             odxlinks.update(self.unit_spec._build_odxlinks())
 
-        if self.admin_data is not None:
-            odxlinks.update(self.admin_data._build_odxlinks())
-
-        if self.company_datas is not None:
-            for cd in self.company_datas:
-                odxlinks.update(cd._build_odxlinks())
-
-        for sdg in self.sdgs:
-            odxlinks.update(sdg._build_odxlinks())
-
         return odxlinks
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        super()._resolve_odxlinks(odxlinks)
+
         for dop in self.data_object_props:
             dop._resolve_odxlinks(odxlinks)
 
@@ -118,17 +92,12 @@ class ComparamSubset(IdentifiableElement):
         if self.unit_spec:
             self.unit_spec._resolve_odxlinks(odxlinks)
 
-        if self.admin_data is not None:
-            self.admin_data._resolve_odxlinks(odxlinks)
-
-        if self.company_datas is not None:
-            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:
+        super()._finalize_init(database, odxlinks)
 
     def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
+
         for dop in self.data_object_props:
             dop._resolve_snrefs(context)
 
@@ -140,13 +109,3 @@ class ComparamSubset(IdentifiableElement):
 
         if self.unit_spec:
             self.unit_spec._resolve_snrefs(context)
-
-        if self.admin_data is not None:
-            self.admin_data._resolve_snrefs(context)
-
-        if self.company_datas is not None:
-            for cd in self.company_datas:
-                cd._resolve_snrefs(context)
-
-        for sdg in self.sdgs:
-            sdg._resolve_snrefs(context)

odxtools/database.py

@@ -20,6 +20,7 @@ from .diaglayers.protocol import Protocol
 from .exceptions import odxraise, odxrequire
 from .nameditemlist import NamedItemList
 from .odxlink import OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
 
 
 class Database:
@@ -139,11 +140,26 @@ class Database:
         for dlc in self.diag_layer_containers:
             dlc._resolve_odxlinks(self._odxlinks)
 
-        # let the diaglayers sort out the inherited objects and the
-        # short name references
+        # resolve short name references for containers which do not do
+        # inheritance (we can call directly call _resolve_snrefs())
+        context = SnRefContext()
+        context.database = self
+
+        # let the diaglayers sort out the inherited objects
+        for subset in self.comparam_subsets:
+            subset._finalize_init(self, self._odxlinks)
+        for spec in self.comparam_specs:
+            spec._finalize_init(self, self._odxlinks)
         for dlc in self.diag_layer_containers:
             dlc._finalize_init(self, self._odxlinks)
 
+        for subset in self.comparam_subsets:
+            subset._resolve_snrefs(context)
+        for spec in self.comparam_specs:
+            spec._resolve_snrefs(context)
+        for dlc in self.diag_layer_containers:
+            dlc._resolve_snrefs(context)
+
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         result: Dict[OdxLinkId, Any] = {}
 

odxtools/diaglayercontainer.py

@@ -1,22 +1,19 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
 from itertools import chain
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
+from typing import TYPE_CHECKING, Any, Dict, List, Union
 from xml.etree import ElementTree
 
-from .admindata import AdminData
-from .companydata import CompanyData
 from .diaglayers.basevariant import BaseVariant
 from .diaglayers.diaglayer import DiagLayer
 from .diaglayers.ecushareddata import EcuSharedData
 from .diaglayers.ecuvariant import EcuVariant
 from .diaglayers.functionalgroup import FunctionalGroup
 from .diaglayers.protocol import Protocol
-from .element import IdentifiableElement
-from .exceptions import odxrequire
 from .nameditemlist import NamedItemList
+from .odxcategory import OdxCategory
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
-from .specialdatagroup import SpecialDataGroup
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
 if TYPE_CHECKING:
@@ -24,15 +21,12 @@ if TYPE_CHECKING:
 
 
 @dataclass
-class DiagLayerContainer(IdentifiableElement):
-    admin_data: Optional[AdminData]
-    company_datas: NamedItemList[CompanyData]
+class DiagLayerContainer(OdxCategory):
     ecu_shared_datas: NamedItemList[EcuSharedData]
     protocols: NamedItemList[Protocol]
     functional_groups: NamedItemList[FunctionalGroup]
     base_variants: NamedItemList[BaseVariant]
     ecu_variants: NamedItemList[EcuVariant]
-    sdgs: List[SpecialDataGroup]
 
     @property
     def ecus(self) -> NamedItemList[EcuVariant]:
@@ -54,17 +48,10 @@ class DiagLayerContainer(IdentifiableElement):
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "DiagLayerContainer":
 
-        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, "CONTAINER")]
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+        cat = OdxCategory.category_from_et(et_element, doc_frags, doc_type="CONTAINER")
+        doc_frags = cat.odx_id.doc_fragments
+        kwargs = dataclass_fields_asdict(cat)
 
-        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")
-        ])
         ecu_shared_datas = NamedItemList([
             EcuSharedData.from_et(dl_element, doc_frags)
             for dl_element in et_element.iterfind("ECU-SHARED-DATAS/ECU-SHARED-DATA")
@@ -85,30 +72,17 @@ class DiagLayerContainer(IdentifiableElement):
             EcuVariant.from_et(dl_element, doc_frags)
             for dl_element in et_element.iterfind("ECU-VARIANTS/ECU-VARIANT")
         ])
-        sdgs = [
-            SpecialDataGroup.from_et(sdge, doc_frags) for sdge in et_element.iterfind("SDGS/SDG")
-        ]
 
         return DiagLayerContainer(
-            admin_data=admin_data,
-            company_datas=company_datas,
             ecu_shared_datas=ecu_shared_datas,
             protocols=protocols,
             functional_groups=functional_groups,
             base_variants=base_variants,
             ecu_variants=ecu_variants,
-            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())
+        result = super()._build_odxlinks()
 
         for ecu_shared_data in self.ecu_shared_datas:
             result.update(ecu_shared_data._build_odxlinks())
@@ -124,12 +98,7 @@ class DiagLayerContainer(IdentifiableElement):
         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)
+        super()._resolve_odxlinks(odxlinks)
 
         for ecu_shared_data in self.ecu_shared_datas:
             ecu_shared_data._resolve_odxlinks(odxlinks)
@@ -143,6 +112,8 @@ class DiagLayerContainer(IdentifiableElement):
             ecu_variant._resolve_odxlinks(odxlinks)
 
     def _finalize_init(self, database: "Database", odxlinks: OdxLinkDatabase) -> None:
+        super()._finalize_init(database, odxlinks)
+
         for ecu_shared_data in self.ecu_shared_datas:
             ecu_shared_data._finalize_init(database, odxlinks)
         for protocol in self.protocols:
@@ -154,6 +125,9 @@ class DiagLayerContainer(IdentifiableElement):
         for ecu_variant in self.ecu_variants:
             ecu_variant._finalize_init(database, odxlinks)
 
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
+
     @property
     def diag_layers(self) -> NamedItemList[DiagLayer]:
         return self._diag_layers

odxtools/diaglayers/hierarchyelement.py

@@ -8,8 +8,6 @@ from typing import (TYPE_CHECKING, Any, Callable, Dict, Iterable, List, Optional
                     Union, cast)
 from xml.etree import ElementTree
 
-from deprecation import deprecated
-
 from ..additionalaudience import AdditionalAudience
 from ..admindata import AdminData
 from ..comparaminstance import ComparamInstance
@@ -724,10 +722,6 @@ class HierarchyElement(DiagLayer):
 
         return int(result)
 
-    @deprecated(details="use get_can_receive_id()")  # type: ignore[misc]
-    def get_receive_id(self) -> Optional[int]:
-        return self.get_can_receive_id()
-
     def get_can_send_id(self, protocol: Optional[Union[str, "Protocol"]] = None) -> Optional[int]:
         """CAN ID to which the ECU sends replies to diagnostic messages"""
 
@@ -753,10 +747,6 @@ class HierarchyElement(DiagLayer):
 
         return int(result)
 
-    @deprecated(details="use get_can_send_id()")  # type: ignore[misc]
-    def get_send_id(self) -> Optional[int]:
-        return self.get_can_send_id()
-
     def get_can_func_req_id(self,
                             protocol: Optional[Union[str, "Protocol"]] = None) -> Optional[int]:
         """CAN Functional Request Id."""

odxtools/dopbase.py

@@ -16,10 +16,12 @@ from .utils import dataclass_fields_asdict
 
 @dataclass
 class DopBase(IdentifiableElement):
-    """Base class for all DOPs.
+    """Base class for all (simple and complex) data object properties.
+
+    Any class that a parameter can reference via a DOP-REF (Simple
+    DOPs, structures, ...) inherits from this class. All DOPs objects
+    implement the `Codec` type protocol.
 
-    Any class that a parameter can reference via a DOP-REF should
-    inherit from this class.
     """
 
     admin_data: Optional[AdminData]

odxtools/dtcdop.py

@@ -15,13 +15,59 @@ from .dopbase import DopBase
 from .encodestate import EncodeState
 from .exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequire
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from .odxtypes import ParameterValue, odxstr_to_bool
 from .physicaltype import PhysicalType
 from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
 
+@dataclass
+class LinkedDtcDop:
+    not_inherited_dtc_snrefs: List[str]
+    dtc_dop_ref: OdxLinkRef
+
+    @property
+    def dtc_dop(self) -> "DtcDop":
+        return self._dtc_dop
+
+    @property
+    def short_name(self) -> str:
+        return self._dtc_dop.short_name
+
+    @property
+    def not_inherited_dtcs(self) -> NamedItemList[DiagnosticTroubleCode]:
+        return self._not_inherited_dtcs
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "LinkedDtcDop":
+        not_inherited_dtc_snrefs = [
+            odxrequire(el.get("SHORT-NAME"))
+            for el in et_element.iterfind("NOT-INHERITED-DTC-SNREFS/"
+                                          "NOT-INHERITED-DTC-SNREF")
+        ]
+
+        dtc_dop_ref = odxrequire(OdxLinkRef.from_et(et_element.find("DTC-DOP-REF"), doc_frags))
+
+        return LinkedDtcDop(
+            not_inherited_dtc_snrefs=not_inherited_dtc_snrefs, dtc_dop_ref=dtc_dop_ref)
+
+    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:
+        dtc_dop = self._dtc_dop
+        not_inherited_dtcs = [
+            resolve_snref(ni_snref, dtc_dop.dtcs, DiagnosticTroubleCode)
+            for ni_snref in self.not_inherited_dtc_snrefs
+        ]
+
+        self._not_inherited_dtcs = NamedItemList(not_inherited_dtcs)
+
+
 @dataclass
 class DtcDop(DopBase):
     """A DOP describing a diagnostic trouble code"""
@@ -30,9 +76,12 @@ class DtcDop(DopBase):
     physical_type: PhysicalType
     compu_method: CompuMethod
     dtcs_raw: List[Union[DiagnosticTroubleCode, OdxLinkRef]]
-    linked_dtc_dop_refs: List[OdxLinkRef]
+    linked_dtc_dops_raw: List[LinkedDtcDop]
     is_visible_raw: Optional[bool]
 
+    def __post_init__(self) -> None:
+        self._init_finished = False
+
     @staticmethod
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "DtcDop":
         """Reads a DTC-DOP."""
@@ -56,12 +105,10 @@ class DtcDop(DopBase):
                 elif dtc_proxy_elem.tag == "DTC-REF":
                     dtcs_raw.append(OdxLinkRef.from_et(dtc_proxy_elem, doc_frags))
 
-        # TODO: NOT-INHERITED-DTC-SNREFS
-        linked_dtc_dop_refs = [
-            OdxLinkRef.from_et(dtc_ref_elem, doc_frags)
+        linked_dtc_dops_raw = [
+            LinkedDtcDop.from_et(dtc_ref_elem, doc_frags)
             for dtc_ref_elem in et_element.iterfind("LINKED-DTC-DOPS/"
-                                                    "LINKED-DTC-DOP/"
-                                                    "DTC-DOP-REF")
+                                                    "LINKED-DTC-DOP")
         ]
         is_visible_raw = odxstr_to_bool(et_element.get("IS-VISIBLE"))
 
@@ -70,7 +117,7 @@ class DtcDop(DopBase):
             physical_type=physical_type,
             compu_method=compu_method,
             dtcs_raw=dtcs_raw,
-            linked_dtc_dop_refs=linked_dtc_dop_refs,
+            linked_dtc_dops_raw=linked_dtc_dops_raw,
             is_visible_raw=is_visible_raw,
             **kwargs)
 
@@ -79,12 +126,12 @@ class DtcDop(DopBase):
         return self._dtcs
 
     @property
-    def is_visible(self) -> bool:
-        return self.is_visible_raw is True
+    def linked_dtc_dops(self) -> NamedItemList[LinkedDtcDop]:
+        return self._linked_dtc_dops
 
     @property
-    def linked_dtc_dops(self) -> NamedItemList["DtcDop"]:
-        return self._linked_dtc_dops
+    def is_visible(self) -> bool:
+        return self.is_visible_raw is True
 
     @override
     def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
@@ -185,6 +232,9 @@ class DtcDop(DopBase):
             if isinstance(dtc_proxy, DiagnosticTroubleCode):
                 odxlinks.update(dtc_proxy._build_odxlinks())
 
+        for linked_dtc_dop in self.linked_dtc_dops_raw:
+            odxlinks.update(linked_dtc_dop._build_odxlinks())
+
         return odxlinks
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
@@ -201,10 +251,19 @@ class DtcDop(DopBase):
                 dtc = odxlinks.resolve(dtc_proxy, DiagnosticTroubleCode)
                 self._dtcs.append(dtc)
 
-        linked_dtc_dops = [odxlinks.resolve(x, DtcDop) for x in self.linked_dtc_dop_refs]
-        self._linked_dtc_dops = NamedItemList(linked_dtc_dops)
+        for linked_dtc_dop in self.linked_dtc_dops_raw:
+            linked_dtc_dop._resolve_odxlinks(odxlinks)
 
     def _resolve_snrefs(self, context: SnRefContext) -> None:
+        # hack to avoid initializing the DtcDop object multiple
+        # times. This is required, because the linked DTC DOP feature
+        # requires the "parent" DTC DOPs to be fully initialized but
+        # the standard does not define a formal ordering of DTC DOPs.
+        if self._init_finished:
+            return
+
+        self._init_finished = True
+
         super()._resolve_snrefs(context)
 
         self.compu_method._resolve_snrefs(context)
@@ -212,3 +271,31 @@ class DtcDop(DopBase):
         for dtc_proxy in self.dtcs_raw:
             if isinstance(dtc_proxy, DiagnosticTroubleCode):
                 dtc_proxy._resolve_snrefs(context)
+
+        for linked_dtc_dop in self.linked_dtc_dops_raw:
+            linked_dtc_dop._resolve_snrefs(context)
+
+        # add the inherited DTCs from linked DTC DOPs. Note that this
+        # requires that there are no cycles in the "link-hierarchy"
+        dtc_short_names = {dtc.short_name for dtc in self._dtcs}
+        for linked_dtc_dop in self.linked_dtc_dops_raw:
+            linked_dtc_dop.dtc_dop._resolve_snrefs(context)
+
+            for dtc in linked_dtc_dop.dtc_dop.dtcs:
+                if dtc.short_name in dtc_short_names:
+                    # we already have a DTC with that name. Since we
+                    # are not supposed to overwrite the local DTCs, we
+                    # skip processing this one. TODO: Are inheritance
+                    # conflicts for DTCs allowed?
+                    continue
+
+                if dtc.short_name in linked_dtc_dop.not_inherited_dtc_snrefs:
+                    # DTC is explicitly not inherited
+                    continue
+
+                self._dtcs.append(dtc)
+                dtc_short_names.add(dtc.short_name)
+
+        # at this place, the linked DTC DOPs exhibit .short_name, so
+        # we can create a NamedItemList...
+        self._linked_dtc_dops = NamedItemList(self.linked_dtc_dops_raw)

odxtools/inputparam.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 NamedElement
 from .exceptions import odxrequire
@@ -49,8 +47,3 @@ class InputParam(NamedElement):
     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/leadinglengthinfotype.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Optional
+from typing import List
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -50,13 +50,6 @@ class LeadingLengthInfoType(DiagCodedType):
     def dct_type(self) -> DctType:
         return "LEADING-LENGTH-INFO-TYPE"
 
-    def get_static_bit_length(self) -> Optional[int]:
-        # note that self.bit_length is just the length of the length
-        # specifier field. This is then followed by the same number of
-        # bytes as the value of this field, i.e., the length of this
-        # DCT is dynamic!
-        return None
-
     @override
     def encode_into_pdu(self, internal_value: AtomicOdxType, encode_state: EncodeState) -> None:
 

odxtools/message.py

@@ -2,8 +2,6 @@
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Union
 
-from deprecation import deprecated
-
 from .odxtypes import ParameterValue, ParameterValueDict
 
 if TYPE_CHECKING:
@@ -29,8 +27,3 @@ class Message:
 
     def __getitem__(self, key: str) -> ParameterValue:
         return self.param_dict[key]
-
-    @property
-    @deprecated("use .coding_object")  # type: ignore[misc]
-    def structure(self) -> Union["Request", "Response"]:
-        return self.coding_object

odxtools/minmaxlengthtype.py

@@ -20,6 +20,10 @@ class MinMaxLengthType(DiagCodedType):
     max_length: Optional[int]
     termination: str
 
+    @property
+    def dct_type(self) -> DctType:
+        return "MIN-MAX-LENGTH-TYPE"
+
     @staticmethod
     @override
     def from_et(et_element: ElementTree.Element,
@@ -50,10 +54,6 @@ class MinMaxLengthType(DiagCodedType):
             "END-OF-PDU",
         ], f"A min-max length type cannot have the termination {self.termination}")
 
-    @property
-    def dct_type(self) -> DctType:
-        return "MIN-MAX-LENGTH-TYPE"
-
     def __termination_sequence(self) -> bytes:
         """Returns the termination byte sequence if it isn't defined."""
         # The termination sequence is actually not specified by ASAM