odxtools 7.1.1__py3-none-any.whl → 7.2.0__py3-none-any.whl

odxtools/functionalclass.py

@@ -1,15 +1,13 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List
+from typing import Any, Dict, List
 from xml.etree import ElementTree
 
 from .element import IdentifiableElement
 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 FunctionalClass(IdentifiableElement):
@@ -31,5 +29,5 @@ class FunctionalClass(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/inputparam.py

@@ -1,6 +1,6 @@
 # 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 deprecation import deprecated
@@ -9,11 +9,9 @@ from .dopbase import DopBase
 from .element import NamedElement
 from .exceptions import odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class InputParam(NamedElement):
@@ -44,7 +42,7 @@ class InputParam(NamedElement):
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         self._dop_base = odxlinks.resolve(self.dop_base_ref, DopBase)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass
 
     @property

odxtools/leadinglengthinfotype.py

@@ -1,14 +1,17 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Optional
+from typing import List, Optional
+from xml.etree import ElementTree
 
 from typing_extensions import override
 
 from .decodestate import DecodeState
 from .diagcodedtype import DctType, DiagCodedType
 from .encodestate import EncodeState
-from .exceptions import EncodeError, odxassert, odxraise
+from .exceptions import EncodeError, odxassert, odxraise, odxrequire
+from .odxlink import OdxDocFragment
 from .odxtypes import AtomicOdxType, DataType
+from .utils import dataclass_fields_asdict
 
 
 @dataclass
@@ -20,6 +23,16 @@ class LeadingLengthInfoType(DiagCodedType):
     #: object.
     bit_length: int
 
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "LeadingLengthInfoType":
+        kwargs = dataclass_fields_asdict(DiagCodedType.from_et(et_element, doc_frags))
+
+        bit_length = int(odxrequire(et_element.findtext("BIT-LENGTH")))
+
+        return LeadingLengthInfoType(bit_length=bit_length, **kwargs)
+
     def __post_init__(self) -> None:
         odxassert(self.bit_length > 0,
                   "A Leading length info type with bit length == 0 does not make sense.")

odxtools/loadfile.py

@@ -0,0 +1,64 @@
+# SPDX-License-Identifier: MIT
+import os
+from pathlib import Path
+from typing import Union
+
+from .database import Database
+
+
+def load_pdx_file(pdx_file: Union[str, Path]) -> Database:
+    db = Database()
+    db.add_pdx_file(str(pdx_file))
+    db.refresh()
+    return db
+
+
+def load_odx_d_file(odx_d_file_name: Union[str, Path]) -> Database:
+    db = Database()
+    db.add_odx_file(str(odx_d_file_name))
+    db.refresh()
+
+    return db
+
+
+def load_file(file_name: Union[str, Path]) -> Database:
+    if str(file_name).lower().endswith(".pdx"):
+        return load_pdx_file(str(file_name))
+    elif str(file_name).lower().endswith(".odx-d"):
+        return load_odx_d_file(str(file_name))
+    else:
+        raise RuntimeError(f"Could not guess the file format of file '{file_name}'!")
+
+
+def load_files(*file_names: Union[str, Path]) -> Database:
+    db = Database()
+    for file_name in file_names:
+        p = Path(file_name)
+        if p.suffix.lower() == ".pdx":
+            db.add_pdx_file(str(file_name))
+        elif p.suffix.lower().startswith(".odx"):
+            db.add_odx_file(str(file_name))
+        elif p.name.lower() != "index.xml":
+            db.add_auxiliary_file(str(file_name))
+
+    db.refresh()
+    return db
+
+
+def load_directory(dir_name: Union[str, Path]) -> Database:
+    db = Database()
+    for file_name in os.listdir(str(dir_name)):
+        p = Path(dir_name) / file_name
+
+        if not p.is_file():
+            continue
+
+        if p.suffix.lower() == ".pdx":
+            db.add_pdx_file(str(p))
+        elif p.suffix.lower().startswith(".odx"):
+            db.add_odx_file(str(p))
+        elif p.name.lower() != "index.xml":
+            db.add_auxiliary_file(p.name, open(str(p), "rb"))
+
+    db.refresh()
+    return db

odxtools/minmaxlengthtype.py

@@ -1,14 +1,17 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Optional
+from typing import List, Optional
+from xml.etree import ElementTree
 
 from typing_extensions import override
 
 from .decodestate import DecodeState
 from .diagcodedtype import DctType, DiagCodedType
 from .encodestate import EncodeState
-from .exceptions import DecodeError, EncodeError, odxassert, odxraise
+from .exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequire
+from .odxlink import OdxDocFragment
 from .odxtypes import AtomicOdxType, DataType
+from .utils import dataclass_fields_asdict
 
 
 @dataclass
@@ -17,6 +20,21 @@ class MinMaxLengthType(DiagCodedType):
     max_length: Optional[int]
     termination: str
 
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "MinMaxLengthType":
+        kwargs = dataclass_fields_asdict(DiagCodedType.from_et(et_element, doc_frags))
+
+        min_length = int(odxrequire(et_element.findtext("MIN-LENGTH")))
+        max_length = None
+        if et_element.find("MAX-LENGTH") is not None:
+            max_length = int(odxrequire(et_element.findtext("MAX-LENGTH")))
+        termination = odxrequire(et_element.get("TERMINATION"))
+
+        return MinMaxLengthType(
+            min_length=min_length, max_length=max_length, termination=termination, **kwargs)
+
     def __post_init__(self) -> None:
         odxassert(self.max_length is None or self.min_length <= self.max_length)
         odxassert(

odxtools/modification.py

@@ -1,12 +1,10 @@
 # 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 .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
-
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
+from .snrefcontext import SnRefContext
 
 
 @dataclass
@@ -27,5 +25,5 @@ class Modification:
     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/multiplexer.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Optional, Tuple
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -14,11 +14,9 @@ from .multiplexerdefaultcase import MultiplexerDefaultCase
 from .multiplexerswitchkey import MultiplexerSwitchKey
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from .odxtypes import AtomicOdxType, ParameterValue, odxstr_to_bool
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class Multiplexer(ComplexDop):
@@ -90,7 +88,6 @@ class Multiplexer(ComplexDop):
             with only one key equal to the desired case""")
 
         orig_origin = encode_state.origin_byte_position
-        orig_cursor = encode_state.cursor_byte_position
 
         encode_state.origin_byte_position = encode_state.cursor_byte_position
 
@@ -120,8 +117,6 @@ class Multiplexer(ComplexDop):
                     physical_value=key_value, encode_state=encode_state)
 
                 encode_state.origin_byte_position = orig_origin
-                encode_state.cursor_byte_position = max(orig_cursor,
-                                                        encode_state.cursor_byte_position)
                 return
 
         raise EncodeError(f"The case {case_name} is not found in Multiplexer {self.short_name}")
@@ -132,7 +127,6 @@ class Multiplexer(ComplexDop):
         # multiplexers are structures and thus the origin position
         # must be moved to the start of the multiplexer
         orig_origin = decode_state.origin_byte_position
-        orig_cursor = decode_state.cursor_byte_position
         if self.byte_position is not None:
             decode_state.cursor_byte_position = decode_state.origin_byte_position + self.byte_position
         decode_state.origin_byte_position = decode_state.cursor_byte_position
@@ -164,7 +158,6 @@ class Multiplexer(ComplexDop):
 
         # go back to the original origin
         decode_state.origin_byte_position = orig_origin
-        decode_state.cursor_byte_position = max(orig_cursor, decode_state.cursor_byte_position)
 
         return mux_value
 
@@ -191,12 +184,12 @@ class Multiplexer(ComplexDop):
                 odxlinks, key_physical_type=self.switch_key.dop.physical_type.base_data_type)
 
     @override
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        super()._resolve_snrefs(diag_layer)
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
 
-        self.switch_key._resolve_snrefs(diag_layer)
+        self.switch_key._resolve_snrefs(context)
         if self.default_case is not None:
-            self.default_case._resolve_snrefs(diag_layer)
+            self.default_case._resolve_snrefs(context)
 
         for mux_case in self.cases:
-            mux_case._resolve_snrefs(diag_layer)
+            mux_case._resolve_snrefs(context)

odxtools/multiplexercase.py

@@ -1,6 +1,6 @@
 # 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 .basicstructure import BasicStructure
@@ -9,11 +9,9 @@ from .element import NamedElement
 from .exceptions import odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from .odxtypes import AtomicOdxType, DataType
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class MultiplexerCase(NamedElement):
@@ -70,9 +68,9 @@ class MultiplexerCase(NamedElement):
         self.lower_limit.set_value_type(key_physical_type)
         self.upper_limit.set_value_type(key_physical_type)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         if self.structure_snref:
-            ddds = diag_layer.diag_data_dictionary_spec
+            ddds = odxrequire(context.diag_layer).diag_data_dictionary_spec
             self._structure = resolve_snref(self.structure_snref, ddds.structures, BasicStructure)
 
     def applies(self, value: AtomicOdxType) -> bool:

odxtools/multiplexerdefaultcase.py

@@ -1,17 +1,15 @@
 # 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 .basicstructure import BasicStructure
 from .element import NamedElement
 from .exceptions import odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class MultiplexerDefaultCase(NamedElement):
@@ -43,9 +41,9 @@ class MultiplexerDefaultCase(NamedElement):
         if self.structure_ref is not None:
             self._structure = odxlinks.resolve(self.structure_ref)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         if self.structure_snref:
-            ddds = diag_layer.diag_data_dictionary_spec
+            ddds = odxrequire(context.diag_layer).diag_data_dictionary_spec
             self._structure = resolve_snref(self.structure_snref, ddds.structures, BasicStructure)
 
     @property

odxtools/multiplexerswitchkey.py

@@ -1,13 +1,12 @@
+# 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 .dataobjectproperty import DataObjectProperty
 from .exceptions import odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
-
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
+from .snrefcontext import SnRefContext
 
 
 @dataclass
@@ -39,7 +38,7 @@ class MultiplexerSwitchKey:
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         self._dop = odxlinks.resolve(self.dop_ref, DataObjectProperty)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass
 
     @property

odxtools/negoutputparam.py

@@ -1,17 +1,15 @@
 # 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 .dopbase import DopBase
 from .element import NamedElement
 from .exceptions import odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class NegOutputParam(NamedElement):
@@ -35,7 +33,7 @@ class NegOutputParam(NamedElement):
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         self._dop = odxlinks.resolve(self.dop_base_ref)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass
 
     @property

odxtools/outputparam.py

@@ -1,6 +1,6 @@
 # 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 deprecation import deprecated
@@ -9,11 +9,9 @@ from .dopbase import DopBase
 from .element import IdentifiableElement
 from .exceptions import odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class OutputParam(IdentifiableElement):
@@ -37,7 +35,7 @@ class OutputParam(IdentifiableElement):
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         self._dop_base = odxlinks.resolve(self.dop_base_ref, DopBase)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass
 
     @property

odxtools/parameterinfo.py

@@ -128,7 +128,7 @@ def parameter_info(param_list: Iterable[Parameter], quoted_names: bool = False)
 
         if isinstance(cm, TexttableCompuMethod):
             of.write(f": enum; choices:\n")
-            for scale in cm.internal_to_phys:
+            for scale in odxrequire(cm.compu_internal_to_phys).compu_scales:
                 val_str = ""
                 if scale.lower_limit is not None:
                     val_str = f"({repr(scale.lower_limit.value)})"
@@ -166,8 +166,8 @@ def parameter_info(param_list: Iterable[Parameter], quoted_names: bool = False)
             else:
                 of.write(f": <unknown type>")
 
-            ll = cm.physical_lower_limit
-            ul = cm.physical_upper_limit
+            ll = cm.segment.physical_lower_limit
+            ul = cm.segment.physical_upper_limit
             if ll is None or ll.interval_type == IntervalType.INFINITE:
                 ll_str = "(-inf"
             else:

odxtools/parameters/codedconstparameter.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: MIT
 import warnings
 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 typing_extensions import override
@@ -11,14 +11,11 @@ from ..decodestate import DecodeState
 from ..diagcodedtype import DiagCodedType
 from ..encodestate import EncodeState
 from ..exceptions import DecodeError, EncodeError, odxraise, odxrequire
-from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from ..odxlink import OdxDocFragment, OdxLinkId
 from ..odxtypes import AtomicOdxType, DataType, ParameterValue
 from ..utils import dataclass_fields_asdict
 from .parameter import Parameter, ParameterType
 
-if TYPE_CHECKING:
-    from ..diaglayer import DiagLayer
-
 
 @dataclass
 class CodedConstParameter(Parameter):
@@ -54,15 +51,6 @@ class CodedConstParameter(Parameter):
 
         return result
 
-    @override
-    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        super()._resolve_odxlinks(odxlinks)
-
-    @override
-    def _parameter_resolve_snrefs(self, diag_layer: "DiagLayer", *,
-                                  param_list: List[Parameter]) -> None:
-        super()._parameter_resolve_snrefs(diag_layer, param_list=param_list)
-
     @override
     def get_static_bit_length(self) -> Optional[int]:
         return self.diag_coded_type.get_static_bit_length()

odxtools/parameters/lengthkeyparameter.py

@@ -1,6 +1,6 @@
 # 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 typing_extensions import final, override
@@ -8,15 +8,12 @@ from typing_extensions import final, override
 from ..decodestate import DecodeState
 from ..encodestate import EncodeState
 from ..exceptions import EncodeError, odxraise, odxrequire
-from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from ..odxlink import OdxDocFragment, OdxLinkId
 from ..odxtypes import ParameterValue
 from ..utils import dataclass_fields_asdict
-from .parameter import Parameter, ParameterType
+from .parameter import ParameterType
 from .parameterwithdop import ParameterWithDOP
 
-if TYPE_CHECKING:
-    from ..diaglayer import DiagLayer
-
 
 @dataclass
 class LengthKeyParameter(ParameterWithDOP):
@@ -55,15 +52,6 @@ class LengthKeyParameter(ParameterWithDOP):
 
         return result
 
-    @override
-    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        super()._resolve_odxlinks(odxlinks)
-
-    @override
-    def _parameter_resolve_snrefs(self, diag_layer: "DiagLayer", *,
-                                  param_list: List[Parameter]) -> None:
-        super()._parameter_resolve_snrefs(diag_layer, param_list=param_list)
-
     @property
     @override
     def is_required(self) -> bool:
@@ -107,7 +95,6 @@ class LengthKeyParameter(ParameterWithDOP):
 
             encode_state.length_keys[self.short_name] = physical_value
 
-        orig_cursor = encode_state.cursor_byte_position
         pos = encode_state.cursor_byte_position
         if self.byte_position is not None:
             pos = encode_state.origin_byte_position + self.byte_position
@@ -120,7 +107,6 @@ class LengthKeyParameter(ParameterWithDOP):
         tmp_val = b'\x00' * ((n + 7) // 8)
         encode_state.emplace_bytes(tmp_val, obj_used_mask=tmp_val)
 
-        encode_state.cursor_byte_position = max(encode_state.cursor_byte_position, orig_cursor)
         encode_state.cursor_bit_position = 0
 
     def encode_value_into_pdu(self, encode_state: EncodeState) -> None:

odxtools/parameters/nrcconstparameter.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: MIT
 import warnings
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, cast
+from typing import Any, Dict, List, Optional, cast
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -11,14 +11,11 @@ from ..decodestate import DecodeState
 from ..diagcodedtype import DiagCodedType
 from ..encodestate import EncodeState
 from ..exceptions import DecodeError, EncodeError, odxraise, odxrequire
-from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from ..odxlink import OdxDocFragment, OdxLinkId
 from ..odxtypes import AtomicOdxType, DataType, ParameterValue
 from ..utils import dataclass_fields_asdict
 from .parameter import Parameter, ParameterType
 
-if TYPE_CHECKING:
-    from ..diaglayer import DiagLayer
-
 
 @dataclass
 class NrcConstParameter(Parameter):
@@ -70,15 +67,6 @@ class NrcConstParameter(Parameter):
 
         return result
 
-    @override
-    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        super()._resolve_odxlinks(odxlinks)
-
-    @override
-    def _parameter_resolve_snrefs(self, diag_layer: "DiagLayer", *,
-                                  param_list: List[Parameter]) -> None:
-        super()._parameter_resolve_snrefs(diag_layer, param_list=param_list)
-
     @override
     def get_static_bit_length(self) -> Optional[int]:
         return self.diag_coded_type.get_static_bit_length()