odxtools 9.6.0__py3-none-any.whl → 9.7.0__py3-none-any.whl

odxtools/subcomponentparamconnector.py

@@ -0,0 +1,103 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any, Dict, List
+from xml.etree import ElementTree
+
+from .diagservice import DiagService
+from .element import IdentifiableElement
+from .exceptions import odxassert, odxraise, odxrequire
+from .nameditemlist import NamedItemList
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, resolve_snref
+from .parameters.parameter import Parameter
+from .snrefcontext import SnRefContext
+from .utils import dataclass_fields_asdict
+
+
+@dataclass
+class SubComponentParamConnector(IdentifiableElement):
+    diag_comm_snref: str
+
+    # TODO: we currently only support SNREFs, not SNPATHREFs
+    out_param_if_refs: List[str]
+    in_param_if_refs: List[str]
+
+    @property
+    def service(self) -> DiagService:
+        return self._service
+
+    @property
+    def out_param_ifs(self) -> NamedItemList[Parameter]:
+        return self._out_param_ifs
+
+    @property
+    def in_param_ifs(self) -> NamedItemList[Parameter]:
+        return self._in_param_ifs
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "SubComponentParamConnector":
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+
+        diag_comm_snref = odxrequire(
+            odxrequire(et_element.find("DIAG-COMM-SNREF")).get("SHORT-NAME"))
+
+        out_param_if_refs = []
+        for elem in et_element.find("OUT-PARAM-IF-REFS") or []:
+            if elem.tag != "OUT-PARAM-IF-SNREF":
+                odxraise("Currently, only SNREFS are supported for OUT-PARAM-IF-REFS")
+                continue
+            else:
+                odxassert(elem.tag == "OUT-PARAM-IF-SNREF")
+                out_param_if_refs.append(odxrequire(elem.attrib.get("SHORT-NAME")))
+
+        in_param_if_refs = []
+        for elem in et_element.find("IN-PARAM-IF-REFS") or []:
+            if elem.tag != "IN-PARAM-IF-SNREF":
+                odxraise("Currently, only SNREFS are supported for IN-PARAM-IF-REFS")
+                continue
+            else:
+                odxassert(elem.tag == "IN-PARAM-IF-SNREF")
+                in_param_if_refs.append(odxrequire(elem.attrib.get("SHORT-NAME")))
+
+        return SubComponentParamConnector(
+            diag_comm_snref=diag_comm_snref,
+            out_param_if_refs=out_param_if_refs,
+            in_param_if_refs=in_param_if_refs,
+            **kwargs)
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        return {}
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        pass
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        service = resolve_snref(self.diag_comm_snref,
+                                odxrequire(context.diag_layer).diag_comms, DiagService)
+        self._service = service
+
+        if self._service.request is not None:
+            odxraise()
+            return
+        if not self._service.positive_responses:
+            odxraise()
+            return
+
+        request = odxrequire(service.request)
+        in_param_ifs = []
+        for x in self.in_param_if_refs:
+            in_param_ifs.append(resolve_snref(x, request.parameters, Parameter))
+
+        # TODO: The output parameters are probably part of a response
+        # (?). If so, they cannot be resolved ahead of time because
+        # the service in question can have multiple responses
+        # associated with it and each of these has its own set of
+        # parameters. In the meantime, we simply use the first
+        # positive response specified.
+        response = service.positive_responses[0]
+        out_param_ifs = []
+        for x in self.out_param_if_refs:
+            out_param_ifs.append(resolve_snref(x, response.parameters, Parameter))
+
+        self._in_param_ifs = NamedItemList(in_param_ifs)
+        self._out_param_ifs = NamedItemList(out_param_ifs)

odxtools/subcomponentpattern.py

@@ -0,0 +1,42 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Dict, List
+from xml.etree import ElementTree
+
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
+
+if TYPE_CHECKING:
+    from .matchingparameter import MatchingParameter
+
+
+@dataclass
+class SubComponentPattern:
+    matching_parameters: List["MatchingParameter"]
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "SubComponentPattern":
+        from .matchingparameter import MatchingParameter
+
+        matching_parameters = [
+            MatchingParameter.from_et(el, doc_frags)
+            for el in et_element.iterfind("MATCHING-PARAMETERS/MATCHING-PARAMETER")
+        ]
+
+        return SubComponentPattern(matching_parameters=matching_parameters)
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        result = {}
+        for mp in self.matching_parameters:
+            result.update(mp._build_odxlinks())
+
+        return result
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        for mp in self.matching_parameters:
+            mp._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        for mp in self.matching_parameters:
+            mp._resolve_snrefs(context)

odxtools/table.py

@@ -5,55 +5,17 @@ from xml.etree import ElementTree
 
 from .admindata import AdminData
 from .dataobjectproperty import DataObjectProperty
-from .diagcomm import DiagComm
 from .element import IdentifiableElement
-from .exceptions import odxassert, odxrequire
+from .exceptions import odxassert
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .snrefcontext import SnRefContext
 from .specialdatagroup import SpecialDataGroup
+from .tablediagcommconnector import TableDiagCommConnector
 from .tablerow import TableRow
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
-class TableDiagCommConnector:
-    semantic: str
-
-    diag_comm_ref: Optional[OdxLinkRef]
-    diag_comm_snref: Optional[str]
-
-    @property
-    def diag_comm(self) -> DiagComm:
-        return self._diag_comm
-
-    @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "TableDiagCommConnector":
-
-        semantic = odxrequire(et_element.findtext("SEMANTIC"))
-
-        diag_comm_ref = OdxLinkRef.from_et(et_element.find("DIAG-COMM-REF"), doc_frags)
-        diag_comm_snref = None
-        if (dc_snref_elem := et_element.find("DIAG-COMM-SNREF")) is not None:
-            diag_comm_snref = odxrequire(dc_snref_elem.get("SHORT-NAME"))
-
-        return TableDiagCommConnector(
-            semantic=semantic, diag_comm_ref=diag_comm_ref, diag_comm_snref=diag_comm_snref)
-
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
-        return {}
-
-    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        if self.diag_comm_ref is not None:
-            self._diag_comm = odxlinks.resolve(self.diag_comm_ref, DiagComm)
-
-    def _resolve_snrefs(self, context: SnRefContext) -> None:
-        if self.diag_comm_snref is not None:
-            dl = odxrequire(context.diag_layer)
-            self._diag_comm = resolve_snref(self.diag_comm_snref, dl.diag_comms, DiagComm)
-
-
 @dataclass
 class Table(IdentifiableElement):
     """This class represents a TABLE."""

odxtools/tablediagcommconnector.py

@@ -0,0 +1,47 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
+from xml.etree import ElementTree
+
+from .diagcomm import DiagComm
+from .exceptions import odxrequire
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from .snrefcontext import SnRefContext
+
+
+@dataclass
+class TableDiagCommConnector:
+    semantic: str
+
+    diag_comm_ref: Optional[OdxLinkRef]
+    diag_comm_snref: Optional[str]
+
+    @property
+    def diag_comm(self) -> DiagComm:
+        return self._diag_comm
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "TableDiagCommConnector":
+
+        semantic = odxrequire(et_element.findtext("SEMANTIC"))
+
+        diag_comm_ref = OdxLinkRef.from_et(et_element.find("DIAG-COMM-REF"), doc_frags)
+        diag_comm_snref = None
+        if (dc_snref_elem := et_element.find("DIAG-COMM-SNREF")) is not None:
+            diag_comm_snref = odxrequire(dc_snref_elem.get("SHORT-NAME"))
+
+        return TableDiagCommConnector(
+            semantic=semantic, diag_comm_ref=diag_comm_ref, diag_comm_snref=diag_comm_snref)
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        return {}
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        if self.diag_comm_ref is not None:
+            self._diag_comm = odxlinks.resolve(self.diag_comm_ref, DiagComm)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        if self.diag_comm_snref is not None:
+            dl = odxrequire(context.diag_layer)
+            self._diag_comm = resolve_snref(self.diag_comm_snref, dl.diag_comms, DiagComm)

odxtools/tablerowconnector.py

@@ -0,0 +1,46 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any, Dict, List
+from xml.etree import ElementTree
+
+from .element import NamedElement
+from .exceptions import odxrequire
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from .snrefcontext import SnRefContext
+from .table import Table
+from .tablerow import TableRow
+from .utils import dataclass_fields_asdict
+
+
+@dataclass
+class TableRowConnector(NamedElement):
+    table_ref: OdxLinkRef
+    table_row_snref: str
+
+    @property
+    def table(self) -> Table:
+        return self._table
+
+    @property
+    def table_row(self) -> TableRow:
+        return self._table_row
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "TableRowConnector":
+        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
+
+        table_ref = odxrequire(OdxLinkRef.from_et(et_element.find("TABLE-REF"), doc_frags))
+        table_row_snref_el = odxrequire(et_element.find("TABLE-ROW-SNREF"))
+        table_row_snref = odxrequire(table_row_snref_el.get("SHORT-NAME"))
+
+        return TableRowConnector(table_ref=table_ref, table_row_snref=table_row_snref, **kwargs)
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        return {}
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        self._table = odxlinks.resolve(self.table_ref, Table)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        self._table_row = resolve_snref(self.table_row_snref, self._table.table_rows, TableRow)

odxtools/templates/macros/printService.xml.jinja2

@@ -8,7 +8,8 @@
 
 {%- macro printPosResponseSuppressible(prs) -%}
 <POS-RESPONSE-SUPPRESSABLE>
-  <BIT-MASK>{{ hex(prs.bit_mask).lower() }}</BIT-MASK>
+  {%- set num_nibbles = (prs.bit_mask.bit_length() + 7) // 8 * 2 %}
+  <BIT-MASK>{{ ("%%0%dX" | format(num_nibbles | int)) | format(prs.bit_mask | int) }}</BIT-MASK>
   {%- if prs.coded_const_snref is not none %}
   <CODED-CONST-SNREF SHORT-NAME="{{ prs.coded_const_snref }}" />
   {%- endif %}

odxtools/termination.py

@@ -0,0 +1,8 @@
+# SPDX-License-Identifier: MIT
+from enum import Enum
+
+
+class Termination(Enum):
+    END_OF_PDU = "END-OF-PDU"
+    ZERO = "ZERO"
+    HEX_FF = "HEX-FF"

odxtools/transmode.py

@@ -0,0 +1,9 @@
+# SPDX-License-Identifier: MIT
+from enum import Enum
+
+
+class TransMode(Enum):
+    SEND_ONLY = "SEND-ONLY"
+    RECEIVE_ONLY = "RECEIVE-ONLY"
+    SEND_AND_RECEIVE = "SEND-AND-RECEIVE"
+    SEND_OR_RECEIVE = "SEND-OR-RECEIVE"

odxtools/unitgroup.py

@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from enum import Enum
 from typing import Any, Dict, List, Optional, cast
 from xml.etree import ElementTree
 
@@ -10,14 +9,10 @@ from .nameditemlist import NamedItemList
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .snrefcontext import SnRefContext
 from .unit import Unit
+from .unitgroupcategory import UnitGroupCategory
 from .utils import dataclass_fields_asdict
 
 
-class UnitGroupCategory(Enum):
-    COUNTRY = "COUNTRY"
-    EQUIV_UNITS = "EQUIV-UNITS"
-
-
 @dataclass
 class UnitGroup(NamedElement):
     """A group of units.

odxtools/unitgroupcategory.py

@@ -0,0 +1,7 @@
+# SPDX-License-Identifier: MIT
+from enum import Enum
+
+
+class UnitGroupCategory(Enum):
+    COUNTRY = "COUNTRY"
+    EQUIV_UNITS = "EQUIV-UNITS"

odxtools/usage.py

@@ -0,0 +1,9 @@
+# SPDX-License-Identifier: MIT
+from enum import Enum
+
+
+class Usage(Enum):
+    ECU_SOFTWARE = "ECU-SOFTWARE"
+    ECU_COMM = "ECU-COMM"
+    APPLICATION = "APPLICATION"
+    TESTER = "TESTER"

odxtools/utils.py

@@ -2,6 +2,9 @@
 import dataclasses
 import re
 from typing import TYPE_CHECKING, Any, Dict, Optional
+from xml.etree import ElementTree
+
+from .exceptions import odxraise
 
 if TYPE_CHECKING:
     from .database import Database
@@ -9,6 +12,32 @@ if TYPE_CHECKING:
     from .snrefcontext import SnRefContext
 
 
+def read_hex_binary(et_element: Optional[ElementTree.Element]) -> Optional[int]:
+    """Convert the contents of an xsd:hexBinary to an integer
+    """
+    if et_element is None:
+        return None
+
+    if (bytes_str := et_element.text) is None:
+        # tag exists but is immediately terminated ("<FOO />"). we
+        # treat this like an empty string.
+        return 0
+
+    # The XSD uses the type xsd:hexBinary and xsd:hexBinary allows for
+    # leading/trailing whitespace and empty strings whilst `int(x,
+    # 16)` raises an exception if one of these things happen.
+    bytes_str = bytes_str.strip()
+    if len(bytes_str) == 0:
+        return 0
+
+    try:
+        return int(bytes_str, 16)
+    except Exception as e:
+        odxraise(f"Caught exception while parsing hex string `{bytes_str}`"
+                 f" of {et_element.tag}: {e}")
+        return None
+
+
 def retarget_snrefs(database: "Database",
                     diag_layer: "DiagLayer",
                     context: Optional["SnRefContext"] = None) -> None:

odxtools/validtype.py

@@ -0,0 +1,9 @@
+# SPDX-License-Identifier: MIT
+from enum import Enum
+
+
+class ValidType(Enum):
+    VALID = "VALID"
+    NOT_VALID = "NOT-VALID"
+    NOT_DEFINED = "NOT-DEFINED"
+    NOT_AVAILABLE = "NOT-AVAILABLE"

odxtools/version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '9.6.0'
-__version_tuple__ = version_tuple = (9, 6, 0)
+__version__ = version = '9.7.0'
+__version_tuple__ = version_tuple = (9, 7, 0)

{odxtools-9.6.0.dist-info → odxtools-9.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: odxtools
-Version: 9.6.0
+Version: 9.7.0
 Summary: Utilities to work with the ODX standard for automotive diagnostics
 Author-email: Katrin Bauer <katrin.bauer@mbition.io>, Andreas Lauser <andreas.lauser@mbition.io>, Ayoub Kaanich <kayoub5@live.com>
 Maintainer-email: Andreas Lauser <andreas.lauser@mbition.io>, Ayoub Kaanich <kayoub5@live.com>