odxtools 5.2.6__py3-none-any.whl → 5.3.1__py3-none-any.whl

odxtools/basicstructure.py

@@ -77,7 +77,7 @@ class BasicStructure(DopBase):
     def required_parameters(self) -> List[Parameter]:
         """Return the list of parameters which are required for
         encoding the structure."""
-        return [p for p in self.parameters if p.is_required()]
+        return [p for p in self.parameters if p.is_required]
 
     @property
     def free_parameters(self) -> List[Union[Parameter, "EndOfPduField"]]:  # type: ignore
@@ -96,7 +96,7 @@ class BasicStructure(DopBase):
             if isinstance(param, EndOfPduField):
                 result.append(param)
                 continue
-            elif not param.is_required():
+            elif not param.is_required:
                 continue
             # The user cannot specify MatchingRequestParameters freely!
             elif isinstance(param, MatchingRequestParameter):

odxtools/cli/browse.py

@@ -4,7 +4,7 @@ import logging
 import sys
 from typing import Dict, List, Union
 
-import PyInquirer
+import PyInquirer.prompt as PI_prompt
 
 from ..database import Database
 from ..diaglayer import DiagLayer
@@ -38,7 +38,7 @@ def _convert_string_to_bytes(string_value):
 
 
 def _validate_string_value(input, parameter):
-    if parameter.is_optional() and input == "":
+    if parameter.is_optional and input == "":
         return True
     elif isinstance(parameter, ParameterWithDOP):
         try:
@@ -62,7 +62,7 @@ def prompt_single_parameter_value(parameter):
                 parameter.short_name,
             "message":
                 f"Value for parameter '{parameter.short_name}' (Type: {parameter.physical_type.base_data_type})"
-                + (f"[optional]" if parameter.is_optional() else ""),
+                + (f"[optional]" if parameter.is_optional else ""),
             # TODO: improve validation
             "validate":
                 lambda x: _validate_string_value(x, parameter),
@@ -79,8 +79,8 @@ def prompt_single_parameter_value(parameter):
             "message": f"Value for parameter '{parameter.short_name}'",
             "choices": parameter.get_valid_physical_values(),
         }]
-    answer = PyInquirer.prompt(param_prompt)
-    if answer.get(parameter.short_name) == "" and parameter.is_optional():
+    answer = PI_prompt.prompt(param_prompt)
+    if answer.get(parameter.short_name) == "" and parameter.is_optional:
         return None
     elif parameter.physical_type.base_data_type is not None:
         return _convert_string_to_odx_type(
@@ -97,15 +97,13 @@ def encode_message_interactively(sub_service, ask_user_confirmation=False):
         raise SystemError("This command can only be used in an interactive shell!")
     param_dict = sub_service.parameter_dict()
 
-    # list(filter(lambda p: p.is_required()
-    #                          or p.is_optional(), sub_service.parameters))
     exists_definable_param = False
     for k, param_or_dict in param_dict.items():
         if isinstance(param_or_dict, dict):
             for k, param in param_or_dict.items():
-                if param.is_required() or param.is_optional():
+                if param.is_settable:
                     exists_definable_param = True
-        elif param_or_dict.is_required() or param_or_dict.is_optional():
+        elif param_or_dict.is_settable:
             exists_definable_param = True
 
     param_values = {}
@@ -118,7 +116,7 @@ def encode_message_interactively(sub_service, ask_user_confirmation=False):
                 "message": f"Do you want to encode a message? [y/n]",
                 "choices": ["yes", "no"],
             }]
-            answer = PyInquirer.prompt(encode_message_prompt)
+            answer = PI_prompt.prompt(encode_message_prompt)
             if answer.get("yes_no_prompt") == "no":
                 return
 
@@ -133,7 +131,7 @@ def encode_message_interactively(sub_service, ask_user_confirmation=False):
                 "filter":
                     lambda input: _convert_string_to_bytes(input),
             }]
-            answer = PyInquirer.prompt(answered_request_prompt)
+            answer = PI_prompt.prompt(answered_request_prompt)
             answered_request = answer.get("request")
             print(f"Input interpretation as list: {list(answered_request)}")
 
@@ -146,13 +144,12 @@ def encode_message_interactively(sub_service, ask_user_confirmation=False):
                 )
                 structure_param_values = {}
                 for param_sn, param in param_or_structure.items():
-                    if param.is_required() or param.is_optional():
+                    if param.is_settable:
                         val = prompt_single_parameter_value(param)
                         if val is not None:
                             structure_param_values[param_sn] = val
                 param_values[key] = structure_param_values
-            elif (param_or_structure.is_required() or param_or_structure.is_optional()
-                 ) and param_or_structure.parameter_type != "MATCHING-REQUEST-PARAM":
+            elif param_or_structure.is_settable:
                 # param_or_structure is a parameter
                 val = prompt_single_parameter_value(param_or_structure)
                 if val is not None:
@@ -183,12 +180,13 @@ def encode_message_from_string_values(
                 structured_value = parameter_values.get(parameter_sn)
                 if not isinstance(simple_param, Parameter):
                     continue
-                if simple_param.is_required() and (not isinstance(structured_value, dict) or
-                                                   structured_value.get(simple_param_sn) is None):
+                if simple_param.is_required and (not isinstance(structured_value, dict) or
+                                                 structured_value.get(simple_param_sn) is None):
                     missing_parameter_names.append(f"{parameter_sn} :: {simple_param_sn}")
         else:
-            if parameter.is_required() and parameter_values.get(parameter_sn) is None:
+            if parameter.is_required and parameter_values.get(parameter_sn) is None:
                 missing_parameter_names.append(parameter_sn)
+
     if len(missing_parameter_names) > 0:
         print("The following parameters are required but missing!")
         print(" - " + "\n - ".join(missing_parameter_names))
@@ -245,7 +243,7 @@ def browse(odxdb: Database):
             "message": "Select a Variant.",
             "choices": list(dl_names) + ["[exit]"],
         }]
-        answer = PyInquirer.prompt(selection)
+        answer = PI_prompt.prompt(selection)
         if answer.get("variant") == "[exit]":
             return
 
@@ -281,7 +279,7 @@ def browse(odxdb: Database):
                     f"The variant {variant.short_name} offers the following services. Select one!",
                 "choices": [s.short_name for s in services] + ["[back]"],
             }]
-            answer = PyInquirer.prompt(selection)
+            answer = PI_prompt.prompt(selection)
             if answer.get("service") == "[back]":
                 break
 
@@ -315,7 +313,7 @@ def browse(odxdb: Database):
                     "short": f"Negative response: {nr.short_name}",
                 } for nr in service.negative_responses] + ["[back]"],  # type: ignore
             }]
-            answer = PyInquirer.prompt(selection)
+            answer = PI_prompt.prompt(selection)
             if answer.get("message_type") == "[back]":
                 continue
 

odxtools/cli/dummy_sub_parser.py

@@ -14,11 +14,11 @@ class DummyTool:
     should bail out.
     """
 
-    def __init__(self, tool_name, error):
+    def __init__(self, tool_name: str, error: Exception):
         self._odxtools_tool_name_ = tool_name
         self._error = error
 
-    def add_subparser(self, subparser_list):
+    def add_subparser(self, subparser_list: "argparse._SubParsersAction") -> None:
         subparser_list.add_parser(
             self._odxtools_tool_name_,
             description=f"Tool '{self._odxtools_tool_name_}' is unavailable: {self._error}",
@@ -26,7 +26,7 @@ class DummyTool:
             formatter_class=argparse.RawTextHelpFormatter,
         )
 
-    def run(self, args: argparse.Namespace):
+    def run(self, args: argparse.Namespace) -> None:
         print(
             f"Error: Tool '{self._odxtools_tool_name_}' is unavailable: {self._error}",
             file=sys.stderr,

odxtools/cli/main.py

@@ -16,7 +16,7 @@ for tool_name in ["list", "browse", "snoop", "find"]:
         tool_modules.append(DummyTool(tool_name, e))
 
 
-def start_cli():
+def start_cli() -> None:
     argparser = argparse.ArgumentParser(
         description="\n".join([
             "Utilities to interact with automotive diagnostic descriptions based on the ODX standard.",

odxtools/compumethods/compuscale.py

@@ -1,9 +1,8 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, NamedTuple, Optional, Union
+from typing import List, Optional
 from xml.etree import ElementTree
 
-from ..exceptions import odxrequire
 from ..odxlink import OdxDocFragment
 from ..odxtypes import AtomicOdxType, DataType
 from ..utils import create_description_from_et

odxtools/compumethods/createanycompumethod.py

@@ -7,7 +7,6 @@ from ..exceptions import OdxWarning, odxassert, odxraise, odxrequire
 from ..globals import logger
 from ..odxlink import OdxDocFragment
 from ..odxtypes import DataType
-from ..utils import create_description_from_et
 from .compumethod import CompuMethod
 from .compuscale import CompuScale
 from .identicalcompumethod import IdenticalCompuMethod

odxtools/compumethods/identicalcompumethod.py

@@ -1,8 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Union
 
-from ..odxtypes import DataType
 from .compumethod import CompuMethod, CompuMethodCategory
 
 

odxtools/compumethods/limit.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
 from enum import Enum
-from typing import NamedTuple, Optional, Union
+from typing import Optional, Union
 from xml.etree import ElementTree
 
 from ..exceptions import odxassert, odxraise, odxrequire

odxtools/compumethods/linearcompumethod.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Optional, Union
+from typing import Union
 
 from ..exceptions import odxassert
 from ..odxtypes import DataType

odxtools/compumethods/scalelinearcompumethod.py

@@ -3,7 +3,6 @@ from dataclasses import dataclass
 from typing import List
 
 from ..exceptions import odxassert
-from ..globals import logger
 from .compumethod import CompuMethod, CompuMethodCategory
 from .linearcompumethod import LinearCompuMethod
 

odxtools/compumethods/tabintpcompumethod.py

@@ -3,7 +3,6 @@ from dataclasses import dataclass
 from typing import List, Tuple, Union
 
 from ..exceptions import DecodeError, EncodeError, odxassert, odxraise
-from ..globals import logger
 from ..odxtypes import DataType
 from .compumethod import CompuMethod, CompuMethodCategory
 from .limit import IntervalType, Limit

odxtools/determinenumberofitems.py

@@ -0,0 +1,18 @@
+from dataclasses import dataclass
+from typing import List
+from xml.etree import ElementTree
+
+from .odxlink import OdxDocFragment
+from .positioneddataobjectproperty import PositionedDataObjectProperty
+from .utils import dataclass_fields_asdict
+
+
+@dataclass
+class DetermineNumberOfItems(PositionedDataObjectProperty):
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "DetermineNumberOfItems":
+        kwargs = dataclass_fields_asdict(
+            PositionedDataObjectProperty.from_et(et_element, doc_frags))
+        return DetermineNumberOfItems(**kwargs)

odxtools/diagdatadictionaryspec.py

@@ -9,6 +9,7 @@ from .createanystructure import create_any_structure_from_et
 from .createsdgs import create_sdgs_from_et
 from .dataobjectproperty import DataObjectProperty
 from .dtcdop import DtcDop
+from .dynamiclengthfield import DynamicLengthField
 from .endofpdufield import EndOfPduField
 from .environmentdata import EnvironmentData
 from .environmentdatadescription import EnvironmentDataDescription
@@ -31,6 +32,7 @@ class DiagDataDictionarySpec:
     data_object_props: NamedItemList[DataObjectProperty]
     structures: NamedItemList[BasicStructure]
     end_of_pdu_fields: NamedItemList[EndOfPduField]
+    dynamic_length_fields: NamedItemList[DynamicLengthField]
     tables: NamedItemList[Table]
     env_data_descs: NamedItemList[EnvironmentDataDescription]
     env_datas: NamedItemList[EnvironmentData]
@@ -44,6 +46,7 @@ class DiagDataDictionarySpec:
                 self.data_object_props,
                 self.structures,
                 self.end_of_pdu_fields,
+                self.dynamic_length_fields,
                 self.dtc_dops,
                 self.tables,
             ),)
@@ -67,6 +70,11 @@ class DiagDataDictionarySpec:
             for eofp_element in et_element.iterfind("END-OF-PDU-FIELDS/END-OF-PDU-FIELD")
         ]
 
+        dynamic_length_fields = [
+            DynamicLengthField.from_et(dl_element, doc_frags)
+            for dl_element in et_element.iterfind("DYNAMIC-LENGTH-FIELDS/DYNAMIC-LENGTH-FIELD")
+        ]
+
         dtc_dops = []
         for dtc_dop_elem in et_element.iterfind("DTC-DOPS/DTC-DOP"):
             dtc_dop = DtcDop.from_et(dtc_dop_elem, doc_frags)
@@ -123,6 +131,7 @@ class DiagDataDictionarySpec:
             data_object_props=NamedItemList(data_object_props),
             structures=NamedItemList(structures),
             end_of_pdu_fields=NamedItemList(end_of_pdu_fields),
+            dynamic_length_fields=NamedItemList(dynamic_length_fields),
             dtc_dops=NamedItemList(dtc_dops),
             unit_spec=unit_spec,
             tables=NamedItemList(tables),
@@ -145,6 +154,7 @@ class DiagDataDictionarySpec:
                 self.sdgs,
                 self.structures,
                 self.end_of_pdu_fields,
+                self.dynamic_length_fields,
                 self.tables,
         ):
             odxlinks.update(obj._build_odxlinks())
@@ -157,8 +167,8 @@ class DiagDataDictionarySpec:
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
 
         for obj in chain(self.data_object_props, self.dtc_dops, self.end_of_pdu_fields,
-                         self.env_data_descs, self.env_datas, self.muxs, self.sdgs, self.structures,
-                         self.tables):
+                         self.dynamic_length_fields, self.env_data_descs, self.env_datas, self.muxs,
+                         self.sdgs, self.structures, self.tables):
             obj._resolve_odxlinks(odxlinks)
 
         if self.unit_spec is not None:
@@ -166,8 +176,8 @@ class DiagDataDictionarySpec:
 
     def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
         for obj in chain(self.data_object_props, self.dtc_dops, self.end_of_pdu_fields,
-                         self.env_data_descs, self.env_datas, self.muxs, self.sdgs, self.structures,
-                         self.tables):
+                         self.dynamic_length_fields, self.env_data_descs, self.env_datas, self.muxs,
+                         self.sdgs, self.structures, self.tables):
             obj._resolve_snrefs(diag_layer)
 
         if self.unit_spec is not None:

odxtools/diaglayer.py

@@ -10,24 +10,17 @@ from deprecation import deprecated
 
 from .additionalaudience import AdditionalAudience
 from .admindata import AdminData
-from .basicstructure import BasicStructure
 from .communicationparameterref import CommunicationParameterRef
 from .companydata import CompanyData
-from .dataobjectproperty import DataObjectProperty
 from .diagdatadictionaryspec import DiagDataDictionarySpec
 from .diaglayerraw import DiagLayerRaw
 from .diaglayertype import DiagLayerType
 from .diagservice import DiagService
-from .dtcdop import DtcDop
 from .ecuvariantpattern import EcuVariantPattern
-from .endofpdufield import EndOfPduField
-from .environmentdata import EnvironmentData
-from .environmentdatadescription import EnvironmentDataDescription
 from .exceptions import DecodeError, OdxWarning, odxassert
 from .functionalclass import FunctionalClass
 from .message import Message
-from .multiplexer import Multiplexer
-from .nameditemlist import NamedItemList
+from .nameditemlist import NamedItemList, OdxNamed
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .parentref import ParentRef
 from .request import Request
@@ -40,6 +33,7 @@ from .unitgroup import UnitGroup
 from .unitspec import UnitSpec
 
 T = TypeVar("T")
+TNamed = TypeVar("TNamed", bound=OdxNamed)
 
 PrefixTree = Dict[int, Union[List[DiagService], "PrefixTree"]]
 
@@ -154,47 +148,58 @@ class DiagLayer:
                 sdgs=[])
         ############
 
-        dops = NamedItemList(self._compute_available_data_object_props())
-        tables = NamedItemList(self._compute_available_tables())
-        dtc_dops: NamedItemList[DtcDop]
-        structures: NamedItemList[BasicStructure]
-        end_of_pdu_fields: NamedItemList[EndOfPduField]
-        env_data_descs: NamedItemList[EnvironmentDataDescription]
-        env_datas: NamedItemList[EnvironmentData]
-        muxs: NamedItemList[Multiplexer]
+        dops = self._compute_available_ddd_spec_items(
+            lambda ddd_spec: ddd_spec.data_object_props,
+            lambda parent_ref: parent_ref.not_inherited_dops,
+        )
+        structures = self._compute_available_ddd_spec_items(
+            lambda ddd_spec: ddd_spec.structures,
+            lambda parent_ref: parent_ref.not_inherited_dops,
+        )
+        dtc_dops = self._compute_available_ddd_spec_items(
+            lambda ddd_spec: ddd_spec.dtc_dops,
+            lambda parent_ref: parent_ref.not_inherited_dops,
+        )
+        end_of_pdu_fields = self._compute_available_ddd_spec_items(
+            lambda ddd_spec: ddd_spec.end_of_pdu_fields,
+            lambda parent_ref: parent_ref.not_inherited_dops,
+        )
+        dynamic_length_fields = self._compute_available_ddd_spec_items(
+            lambda ddd_spec: ddd_spec.dynamic_length_fields,
+            lambda parent_ref: parent_ref.not_inherited_dops,
+        )
+        env_data_descs = self._compute_available_ddd_spec_items(
+            lambda ddd_spec: ddd_spec.env_data_descs,
+            lambda parent_ref: parent_ref.not_inherited_dops,
+        )
+        env_datas = self._compute_available_ddd_spec_items(
+            lambda ddd_spec: ddd_spec.env_datas, lambda parent_ref: parent_ref.not_inherited_dops)
+        muxs = self._compute_available_ddd_spec_items(
+            lambda ddd_spec: ddd_spec.muxs, lambda parent_ref: parent_ref.not_inherited_dops)
+        tables = self._compute_available_ddd_spec_items(
+            lambda ddd_spec: ddd_spec.tables, lambda parent_ref: parent_ref.not_inherited_tables)
         ddds_sdgs: List[SpecialDataGroup]
         if self.diag_layer_raw.diag_data_dictionary_spec:
-            dtc_dops = self.diag_layer_raw.diag_data_dictionary_spec.dtc_dops
-            structures = self.diag_layer_raw.diag_data_dictionary_spec.structures
-            end_of_pdu_fields = self.diag_layer_raw.diag_data_dictionary_spec.end_of_pdu_fields
-            env_data_descs = self.diag_layer_raw.diag_data_dictionary_spec.env_data_descs
-            env_datas = self.diag_layer_raw.diag_data_dictionary_spec.env_datas
-            muxs = self.diag_layer_raw.diag_data_dictionary_spec.muxs
             ddds_sdgs = self.diag_layer_raw.diag_data_dictionary_spec.sdgs
         else:
-            dtc_dops = NamedItemList()
-            structures = NamedItemList()
-            end_of_pdu_fields = NamedItemList()
-            env_data_descs = NamedItemList()
-            env_datas = NamedItemList()
-            muxs = NamedItemList()
             ddds_sdgs = []
 
         # create a DiagDataDictionarySpec which includes all the
         # inherited objects. To me, this seems rather inelegant, but
         # hey, it's described like this in the standard.
-        self._diag_data_dictionary_spec = \
-            DiagDataDictionarySpec(
-                data_object_props=dops,
-                dtc_dops=dtc_dops,
-                structures=structures,
-                end_of_pdu_fields=end_of_pdu_fields,
-                tables=tables,
-                env_data_descs=env_data_descs,
-                env_datas=env_datas,
-                muxs=muxs,
-                unit_spec=unit_spec,
-                sdgs=ddds_sdgs)
+        self._diag_data_dictionary_spec = DiagDataDictionarySpec(
+            data_object_props=dops,
+            dtc_dops=dtc_dops,
+            structures=structures,
+            end_of_pdu_fields=end_of_pdu_fields,
+            dynamic_length_fields=dynamic_length_fields,
+            tables=tables,
+            env_data_descs=env_data_descs,
+            env_datas=env_datas,
+            muxs=muxs,
+            unit_spec=unit_spec,
+            sdgs=ddds_sdgs,
+        )
 
         #####
         # compute the communication parameters applicable to the
@@ -457,29 +462,19 @@ class DiagLayer:
 
         return self._compute_available_objects(get_local_objects_fn, not_inherited_fn)
 
-    def _compute_available_data_object_props(self) -> Iterable[DataObjectProperty]:
-
-        def get_local_objects_fn(dl):
-            if dl.diag_layer_raw.diag_data_dictionary_spec is None:
-                return []
-            return dl.diag_layer_raw.diag_data_dictionary_spec.data_object_props
-
-        def not_inherited_fn(parent_ref):
-            return parent_ref.not_inherited_dops
-
-        return self._compute_available_objects(get_local_objects_fn, not_inherited_fn)
-
-    def _compute_available_tables(self) -> Iterable[Table]:
+    def _compute_available_ddd_spec_items(
+        self,
+        include: Callable[[DiagDataDictionarySpec], Iterable[TNamed]],
+        exclude: Callable[["ParentRef"], List[str]],
+    ) -> NamedItemList[TNamed]:
 
-        def get_local_objects_fn(dl):
+        def get_local_objects_fn(dl: "DiagLayer"):
             if dl.diag_layer_raw.diag_data_dictionary_spec is None:
                 return []
-            return dl.diag_layer_raw.diag_data_dictionary_spec.tables
+            return include(dl.diag_layer_raw.diag_data_dictionary_spec)
 
-        def not_inherited_fn(parent_ref):
-            return parent_ref.not_inherited_tables
-
-        return self._compute_available_objects(get_local_objects_fn, not_inherited_fn)
+        found = self._compute_available_objects(get_local_objects_fn, exclude)
+        return NamedItemList(found)
 
     def _compute_available_functional_classes(self) -> Iterable[FunctionalClass]:
 

odxtools/dynamiclengthfield.py

@@ -0,0 +1,59 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Dict, List
+from xml.etree import ElementTree
+
+from .decodestate import DecodeState
+from .determinenumberofitems import DetermineNumberOfItems
+from .encodestate import EncodeState
+from .exceptions import odxrequire
+from .field import Field
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxtypes import ParameterValueDict
+from .utils import dataclass_fields_asdict
+
+if TYPE_CHECKING:
+    from .diaglayer import DiagLayer
+
+
+@dataclass
+class DynamicLengthField(Field):
+    """Array of structure with length field"""
+    offset: int
+    determine_number_of_items: DetermineNumberOfItems
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "DynamicLengthField":
+        kwargs = dataclass_fields_asdict(Field.from_et(et_element, doc_frags))
+        offset = int(odxrequire(et_element.findtext('OFFSET')))
+        determine_number_of_items = DetermineNumberOfItems.from_et(
+            odxrequire(et_element.find('DETERMINE-NUMBER-OF-ITEMS')),
+            doc_frags,
+        )
+        return DynamicLengthField(
+            offset=offset, determine_number_of_items=determine_number_of_items, **kwargs)
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        odxlinks = super()._build_odxlinks()
+        odxlinks.update(self.determine_number_of_items._build_odxlinks())
+        return odxlinks
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        super()._resolve_odxlinks(odxlinks)
+        self.determine_number_of_items._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+        super()._resolve_snrefs(diag_layer)
+        self.determine_number_of_items._resolve_snrefs(diag_layer)
+
+    def convert_physical_to_bytes(
+        self,
+        physical_value: List[ParameterValueDict],
+        encode_state: EncodeState,
+        bit_position: int = 0,
+    ) -> bytes:
+        raise NotImplementedError()
+
+    def convert_bytes_to_physical(self, decode_state: DecodeState, bit_position: int = 0):
+        raise NotImplementedError()

odxtools/element.py

@@ -2,11 +2,9 @@ from dataclasses import dataclass
 from typing import List, Optional
 from xml.etree import ElementTree
 
-from odxtools.exceptions import odxrequire
-from odxtools.utils import create_description_from_et
-
+from .exceptions import odxrequire
 from .odxlink import OdxDocFragment, OdxLinkId
-from .utils import dataclass_fields_asdict
+from .utils import create_description_from_et, dataclass_fields_asdict
 
 
 @dataclass