odxtools 9.4.1__py3-none-any.whl → 9.5.0__py3-none-any.whl

odxtools/templates/macros/printEcuVariantPattern.xml.jinja2

@@ -1,18 +1,19 @@
+
 {#- -*- mode: sgml; tab-width: 1; indent-tabs-mode: nil -*-
  #
  # SPDX-License-Identifier: MIT
 -#}
 
-{%- import('macros/printElementId.xml.jinja2') as peid %}
-{%- import('macros/printState.xml.jinja2') as ps %}
-{%- import('macros/printStateTransition.xml.jinja2') as pst %}
-
 {%- macro printMatchingParameter(mp) -%}
 <MATCHING-PARAMETER>
   <EXPECTED-VALUE>{{mp.expected_value | e}}</EXPECTED-VALUE>
   <DIAG-COMM-SNREF SHORT-NAME="{{mp.diag_comm_snref}}" />
-  {#- TODO: OUT-PARAM-IF-SNPATHREF #}
-  <OUT-PARAM-IF-SNREF SHORT-NAME="{{mp.out_param_if}}" />
+  {%- if mp.out_param_if_snref is not none %}
+  <OUT-PARAM-IF-SNREF SHORT-NAME="{{mp.out_param_if_snref}}" />
+  {%- endif %}
+  {%- if mp.out_param_if_snpathref is not none %}
+  <OUT-PARAM-IF-SNPATHREF SHORT-NAME-PATH="{{mp.out_param_if_snpathref}}" />
+  {%- endif %}
 </MATCHING-PARAMETER>
 {%- endmacro -%}
 

odxtools/utils.py

@@ -3,11 +3,15 @@ import dataclasses
 import re
 from typing import TYPE_CHECKING, Any, Dict, Optional
 
+from typing_extensions import SupportsBytes
+
 if TYPE_CHECKING:
     from .database import Database
     from .diaglayers.diaglayer import DiagLayer
     from .snrefcontext import SnRefContext
 
+BytesTypes = (bytearray, bytes, SupportsBytes)
+
 
 def retarget_snrefs(database: "Database",
                     diag_layer: "DiagLayer",

odxtools/variantmatcher.py

@@ -0,0 +1,209 @@
+# SPDX-License-Identifier: MIT
+from copy import copy
+from enum import Enum
+from typing import Dict, Generator, List, Optional, Tuple, Union
+
+from .diaglayers.basevariant import BaseVariant
+from .diaglayers.ecuvariant import EcuVariant
+from .exceptions import DecodeError, odxraise
+from .matchingparameter import MatchingParameter
+from .response import Response
+
+
+class VariantMatcher:
+    """VariantMatcher implements the matching algorithm of ECU and
+    base variants according to their ECU-VARIANT-PATTERNs or
+    BASE-VARIANT-PATTERNs according to ISO 22901-1.
+
+        Usage (example):
+
+    ```python
+
+    # initialize the matcher with a list of base or ECU variants
+    matcher = VariantMatcher(candidates=[...], use_cache=use_cache)
+
+    # run the request loop to obtain responses for every request
+    for use_physical_addressing, encoded_request in matcher.request_loop():
+        if use_physical_addressing:
+            resp = send_to_ecu_using_physical_addressing(encoded_request)
+        else:
+            resp = send_to_ecu_using_functional_addressing(encoded_request)
+        matcher.evaluate(resp)
+
+    # result
+    if matcher.has_match():
+        if isinstance(matcher.matching_variant, BaseVariant):
+            print(f"Match found for base variant "
+                  f"{matcher.matching_variant.short_name}")
+        elif isinstance(matcher.matching_variant, EcuVariant):
+            print(f"Match found for ECU variant "
+                  f"{matcher.matching_variant.short_name}")
+        else:
+            print(f"Match found for unknown diag layer type "
+                  f"{type(matcher.matching_variant).__name__}")
+    else:
+        print("No matching base- or ECU variant found")
+    ```
+
+    TODO: Note that only patterns that exclusivly reference diagnostic
+    services (i.e., no single-ECU jobs) in their matching parameters
+    are currently supported.
+    """
+
+    class State(Enum):
+        PENDING = 0
+        NO_MATCH = 1
+        MATCH = 2
+
+    def __init__(self,
+                 variant_candidates: Union[List[EcuVariant], List[BaseVariant]],
+                 use_cache: bool = True):
+
+        self.variant_candidates = variant_candidates
+        self.use_cache = use_cache
+        self.req_resp_cache: Dict[bytes, bytes] = {}
+        self._recent_ident_response: Optional[bytes] = None
+
+        self._state = VariantMatcher.State.PENDING
+        self._matching_variant: Optional[Union[EcuVariant, BaseVariant]] = None
+
+    def request_loop(self) -> Generator[Tuple[bool, bytes], None, None]:
+        """The request loop yielding tuples of byte sequences of
+        requests and the whether physical addressing ought to be used
+        to send them
+
+        Each of these requests needs to be send to the ECU to be
+        identified using the specified addressing scheme. The response
+        of the ECU is then required to be passed to the matcher using
+        the `evaluate()` method.
+        """
+        from .basevariantpattern import BaseVariantPattern
+        from .ecuvariantpattern import EcuVariantPattern
+        from .matchingbasevariantparameter import MatchingBaseVariantParameter
+
+        if not self.is_pending():
+            return
+
+        self._matching_variant = None
+        for variant in self.variant_candidates:
+            variant_patterns: Union[List[EcuVariantPattern], List[BaseVariantPattern]]
+            if isinstance(variant, EcuVariant):
+                variant_patterns = variant.ecu_variant_patterns
+            elif isinstance(variant, BaseVariant):
+                if variant.base_variant_pattern is None:
+                    variant_patterns = []
+                else:
+                    variant_patterns = [variant.base_variant_pattern]
+            else:
+                odxraise(f"Only EcuVariant and BaseVariant are supported "
+                         f"for pattern matching, not {type(self).__name__}")
+                self._state = VariantMatcher.State.NO_MATCH
+                return
+
+            any_pattern_matches = False
+            for pattern in variant_patterns:
+                all_params_match = True
+                for matching_param in pattern.get_matching_parameters():
+                    req_bytes = matching_param.get_ident_service(variant).encode_request()
+
+                    if self.use_cache and req_bytes in self.req_resp_cache:
+                        resp_values = copy(self.req_resp_cache[req_bytes])
+                    else:
+                        if isinstance(matching_param, MatchingBaseVariantParameter):
+                            yield matching_param.use_physical_addressing, req_bytes
+                        else:
+                            yield True, req_bytes
+                        resp_values = self._get_ident_response()
+                        self._update_cache(req_bytes, copy(resp_values))
+
+                    cur_response_matches = self._ident_response_matches(
+                        variant, matching_param, resp_values)
+                    all_params_match = all_params_match and cur_response_matches
+                    if not all_params_match:
+                        break
+
+                if all_params_match:
+                    any_pattern_matches = True
+                    break
+
+            if any_pattern_matches:
+                self._state = VariantMatcher.State.MATCH
+                self._matching_variant = variant
+                break
+
+        if self.is_pending():
+            # no pattern has matched for any ecu variant
+            self._state = VariantMatcher.State.NO_MATCH
+
+    def evaluate(self, resp_bytes: bytes) -> None:
+        """Update the matcher with the response to a requst.
+
+        Warning: Use this method EXACTLY once within the loop body of the request loop.
+        """
+        self._recent_ident_response = bytes(resp_bytes)
+
+    def is_pending(self) -> bool:
+        """True iff request loop has not yet been run."""
+        return self._state == VariantMatcher.State.PENDING
+
+    def has_match(self) -> bool:
+        """Returns true iff the non-pending matcher found a matching ecu variant.
+
+        Raises a runtime error if the matcher is pending.
+        """
+        if self.is_pending():
+            raise RuntimeError(
+                "EcuVariantMatcher is pending. Run the request_loop to determine the active ecu variant."
+            )
+        return self._state == VariantMatcher.State.MATCH
+
+    @property
+    def matching_variant(self) -> Optional[Union[EcuVariant, BaseVariant]]:
+        """Returns the matched, i.e., active ecu variant if such a variant has been found."""
+        return self._matching_variant
+
+    def _ident_response_matches(
+        self,
+        variant: Union[EcuVariant, BaseVariant],
+        matching_param: MatchingParameter,
+        response_bytes: bytes,
+    ) -> bool:
+        """Decode a binary response and extract the identification string according
+        to the snref or snpathref of the matching_param.
+        """
+        service = matching_param.get_ident_service(variant)
+
+        # ISO 22901 requires that snref or snpathref is resolvable in
+        # at least one POS-RESPONSE or NEG-RESPONSE
+        all_responses: List[Response] = []
+        all_responses.extend(service.positive_responses)
+        all_responses.extend(service.negative_responses)
+        all_responses.extend(variant.global_negative_responses)
+
+        for cur_response in all_responses:
+            try:
+                decoded_vals = cur_response.decode(response_bytes)
+            except DecodeError:
+                # the current response object could not decode the received
+                # data. Ignore it.
+                continue
+
+            if not matching_param.matches(decoded_vals):
+                # This particular response object does not match the
+                # expected value of the specified matching
+                # parameter. Ignore it.
+                continue
+
+            return True
+
+        return False
+
+    def _update_cache(self, req_bytes: bytes, resp_bytes: bytes) -> None:
+        if self.use_cache:
+            self.req_resp_cache[req_bytes] = resp_bytes
+
+    def _get_ident_response(self) -> bytes:
+        if not self._recent_ident_response:
+            raise RuntimeError(
+                "No response available. Did you forget to call 'evaluate()' in a loop?")
+        return self._recent_ident_response

odxtools/variantpattern.py

@@ -0,0 +1,38 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, List, Union
+from xml.etree import ElementTree
+
+from .exceptions import odxraise
+from .matchingparameter import MatchingParameter
+from .odxlink import OdxDocFragment
+
+if TYPE_CHECKING:
+    from .matchingbasevariantparameter import MatchingBaseVariantParameter
+    from .matchingparameter import MatchingParameter
+
+
+@dataclass
+class VariantPattern:
+    """Variant patterns are used to identify the concrete variant of an ECU
+
+    This is done by observing the responses after sending it some
+    requests. There are two kinds of variant patterns:
+    `BaseVariantPattern`s which are used to identify the applicable
+    base variant and ECU variant patterns which can be used identify
+    concrete revisions of the ECU in question. (Both types of pattern
+    are optional, i.e., it might not be possible to identify the base-
+    or ECU variant present.)
+    """
+
+    def get_matching_parameters(
+            self) -> Union[List["MatchingParameter"], List["MatchingBaseVariantParameter"]]:
+        odxraise(
+            f"VariantPattern subclass `{type(self).__name__}` does not "
+            f"implement `.get_match_parameters()`", RuntimeError)
+        return []
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "VariantPattern":
+        return VariantPattern()

odxtools/version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '9.4.1'
-__version_tuple__ = version_tuple = (9, 4, 1)
+__version__ = version = '9.5.0'
+__version_tuple__ = version_tuple = (9, 5, 0)

{odxtools-9.4.1.dist-info → odxtools-9.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: odxtools
-Version: 9.4.1
+Version: 9.5.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>

{odxtools-9.4.1.dist-info → odxtools-9.5.0.dist-info}/RECORD

@@ -4,6 +4,7 @@ odxtools/additionalaudience.py,sha256=Xjy_PhTfTV23oAMvml5XeZw3ex8xssIhgRseSsxKcx
 odxtools/admindata.py,sha256=ue5MnYJK_jxNq6Okxy4aGtH15uBAnWXIjMBFSh36Q3g,1879
 odxtools/audience.py,sha256=_O6UPKnrDbwMMKRnCJ5b8M3_I2jU5jMR6Ss5zLzk9yM,3361
 odxtools/basecomparam.py,sha256=VxpIsTr6-S4e8Vw72hJXSLUFU5TvHy5CM0sweVL-ZWE,2384
+odxtools/basevariantpattern.py,sha256=c6XSjPGNYErOiyl9SrROwShkreoC9tIU3zmoXXAHimo,1462
 odxtools/basicstructure.py,sha256=GcyZuasaH62JcINgyeD300N297q7_LP6iMfDy8fwzMg,5071
 odxtools/codec.py,sha256=2aTfrQc0-cNuPAfXeDDyjxXAHjBJ1xy3ELCVeA9UQP0,8108
 odxtools/commrelation.py,sha256=Gh3CqMuF9rS0X107oxUkISNT2VWDZVPCpOSu54q7hcs,4793
@@ -19,9 +20,8 @@ odxtools/complexcomparam.py,sha256=4EJQXVmi_i3Eas5LAF-sEC5XnAUMZKr2sS6LoDNskk0,3
 odxtools/complexdop.py,sha256=AHkHMf_IEWfy-_zSiCuZXmdTNCXiCOpg5GRZ5uMVV5A,280
 odxtools/createanycomparam.py,sha256=RP0XA2Ut4GL2NWy05RvKBrTnpbvvCG2XuNL8OO-9rbI,617
 odxtools/createanydiagcodedtype.py,sha256=0DVmMj4UCDYIg0zu9pgTplyhHmRedz1KJcchq1uKMjg,1216
-odxtools/createecuvariantpatterns.py,sha256=FXHLGR4M791MRkpU2_keck88hoMYkuyPiCUxuGbUasQ,559
 odxtools/database.py,sha256=VJk-EOzHHtxjkhP7o0h470B0oyg73ZafK3w1UjnwRNM,9945
-odxtools/dataobjectproperty.py,sha256=N-8YJUXdvvlmM3IZYu5SokSnST1hbgPRr3sI-VP4Epk,6238
+odxtools/dataobjectproperty.py,sha256=OMbD5P2T1A5b7qoDmRik08jWGSZFvaBn4CQI2fGNMQA,6244
 odxtools/decodestate.py,sha256=VdYB4Q3yuFqCNV0IK2QfS_120n9dIgyLnPOwc3Hy33U,8292
 odxtools/description.py,sha256=xaSfOjRCWn7_9BhdTgI0ESPtaU-iUE815Z6WobYYL-A,1952
 odxtools/determinenumberofitems.py,sha256=DxM9udr1MQfEojiLdc35bbjniQl1fkeHcTMpoo9AfPI,1558
@@ -39,10 +39,9 @@ odxtools/dynamicendmarkerfield.py,sha256=Q7KKOBNSrAg5cehEP3i4YTPiqz5UetEIJDGah60
 odxtools/dynamiclengthfield.py,sha256=Us0qRvkRPId7xSNKrYdsr1AhVFdTBezRMCBhXl98E00,5273
 odxtools/dyndefinedspec.py,sha256=efvUG2kMUdwfmMG5qxGHzMSZ5CxdSJhmtzHecopnpHg,7610
 odxtools/dynenddopref.py,sha256=SYXrmRUQoLWD4UI3WV92oA5rNhxbDuRv6H1MeXeuWhM,1199
-odxtools/ecuvariantmatcher.py,sha256=muZfBcHVUQFXn3mBRwLtQ2asGV1oDYkDrBwZ9WYuLKU,6848
-odxtools/ecuvariantpattern.py,sha256=Xp2NpS13sVvyOjy2PgxLvXPptAfmYSH_KDIjqYByZHs,863
+odxtools/ecuvariantpattern.py,sha256=HxiDLdZWD2aOtBoCKJQjpTY8Fm1ptFtFK3-CcCj3hQo,1330
 odxtools/element.py,sha256=nCJkQMIPC26XfD4w1VrTH3l7Cd_BemMM_5lALh5gC7E,1259
-odxtools/encodestate.py,sha256=V3AEH3g6TYQIfP-TP2yinBgfCtEbdlbJ1xWgY_zhAVs,13566
+odxtools/encodestate.py,sha256=iufi35usTYoZ58iR6m1cN01VNFGeeGCmWV00dnAvr-o,13558
 odxtools/encoding.py,sha256=5gn6PDqwU9K2RzEfEO9kcBj1v55TSKI1nCXNcTiZE9s,1994
 odxtools/endofpdufield.py,sha256=mGkhTj-YGdJ4EHMsK3AlWV6G_KLWI4ymiFKbY8U2W50,3359
 odxtools/environmentdata.py,sha256=_wSKhV_NuMG6UPMnpOxz6mVjvrXsd2mtqqT7VKSSxHU,1414
@@ -57,9 +56,10 @@ odxtools/isotp_state_machine.py,sha256=O6v29IK7p_4gFqrr-fahnbp9Qmo78EEQfEwRsA_Vf
 odxtools/leadinglengthinfotype.py,sha256=oD0uwLECssJZDKicKYlOZRbrcCeTfz-CiWa-SROfrIU,4013
 odxtools/library.py,sha256=E_A6K6jcEoUdXh4h4sQILj7_JM-6X5OUUWSM47G69CU,2067
 odxtools/loadfile.py,sha256=hi8jVE7B1G9gklsb7MrGrp4aOAI65j0kNwvDeEEEN2k,1744
-odxtools/matchingparameter.py,sha256=2cqaxFCZ28GvvUKCIM-jas3ae4eYGbULbkBlb3aH5RY,2232
+odxtools/matchingbasevariantparameter.py,sha256=hpxAWJQfEGsChEkSos5K8pJDgblu4gbBsEG6f2VhMg8,1287
+odxtools/matchingparameter.py,sha256=nwdshZUUMc13XIKPyalMRYa-F64edg89UPIp-WjfTZU,5762
 odxtools/message.py,sha256=PDY-CDgTmJA6dyNacCV57M-p_ETtR8MdU7WZGEew4zM,855
-odxtools/minmaxlengthtype.py,sha256=tL_PSvDrZ1JZAnqup5RJWTyj9nuueQ_OjlowG-ZWciU,9710
+odxtools/minmaxlengthtype.py,sha256=TPDHQbHqOJTWNr7NGZSgtoEoYW1Cijilz8LL_smSLVA,9718
 odxtools/modification.py,sha256=9EJJUCNTzM05HGT6UZ7r2yLDm7voBFPO-hldBC9D4aw,875
 odxtools/multiplexer.py,sha256=flHlorv9grEMj8pNAWQJNrxhptnDxSsFERO7gpKYRME,10235
 odxtools/multiplexercase.py,sha256=qfxWJzfJLYAsnhFGheUWDsUaIte2dSRJ0nadiN9SXDw,3176
@@ -70,7 +70,7 @@ odxtools/negoutputparam.py,sha256=u2IhJvy6n19t3nyADGG0H0XTm7JNdQ0-95FawGAdtiE,13
 odxtools/obd.py,sha256=WsUbhdonqQJtxf972CUdYL78AMMTVjMQhoCJbaZhRIo,1860
 odxtools/odxcategory.py,sha256=5R5vUTcYnsgfzGD3c0TM6qFYXpbW-d-t1VpUmgZYHWU,3221
 odxtools/odxlink.py,sha256=WVPOXNIldLdz0YnwVpRVe42ugC6G1WX4Ic2Khhz-ito,10194
-odxtools/odxtypes.py,sha256=XJ6OR2_fsILR_cA3lDK47XAtYQ5U6KsH7r4Qn5nSNH8,8094
+odxtools/odxtypes.py,sha256=DUZSjmdeHSq0XCBgU4CvZTM7TvmcB2WtpE25QWm3NMs,8100
 odxtools/outputparam.py,sha256=VqD7jJ5yDvIq9KAatGWD17CWfuSqySQl142FXZYeQHE,1468
 odxtools/parameterinfo.py,sha256=PzhIZyYINNxykecPQWnRH1Ywrfgxx31DVax2VNN__CY,11183
 odxtools/paramlengthinfotype.py,sha256=zJ3gRweIEngl2C4wJoT2uuTf05NRNSJ4RlDmC2L3UBE,4859
@@ -90,13 +90,13 @@ odxtools/snrefcontext.py,sha256=5ZbrZiX1gw6LC6o62RPuxzSo4tDR2LqRQ9w9Vi57FA8,953
 odxtools/specialdata.py,sha256=5-1D_6dcEmi-TodCzCoBZK7gqeDY-cuRe1ybkTh4rBY,1033
 odxtools/specialdatagroup.py,sha256=9pNCA89kGwhBiVN9nC_03ASHZT6q3FL8l2CxRf9jwU0,3070
 odxtools/specialdatagroupcaption.py,sha256=pIa1l6EXVDXBisUtRkn6hTzAcUXFnXJoWstesayLfME,987
-odxtools/standardlengthtype.py,sha256=-Zi4yNXSiEPj0wk3mOQLaWhw15JkxCaZjBDcxqf9NzA,8190
+odxtools/standardlengthtype.py,sha256=nT0s-cvPKaOxxRnWPocY9rqHRgxnzFlW3iuCe_B8w2Y,8107
 odxtools/state.py,sha256=d--nCbV1qBmOmiTmUrQjDC_naispOM0a-H1AvCe5_xI,898
 odxtools/statechart.py,sha256=ZT8amPjec25pexwnOAPiifGEmKa68rliOILLnB6tNJc,2956
 odxtools/statetransition.py,sha256=Q7UaDksJmiKVGnO4GsxPH9pFIKt12ZOkDeJn4KICiGk,2599
 odxtools/staticfield.py,sha256=NBZa5UZD4BD4UekpqF5bq_IzFjxUafmvpCHIEptOl-s,4434
 odxtools/structure.py,sha256=kRBP00MDN1w9w3Vc2XnhZDC_SBBVCZwayGGJoKJ6U_c,866
-odxtools/subcomponent.py,sha256=OPnpbliL7OTfYy9dR0hpQclyqQiTUEa2e2n7GmIoZVE,10401
+odxtools/subcomponent.py,sha256=Sn4CH0FelZ8j_Ny9w7B7qeK6YJFs3FGcYSMPawmHUmc,10498
 odxtools/swvariable.py,sha256=7vmVTAqtKIn81UpAZrboIZpbbD4jqwW0MEiK0m5bZNo,697
 odxtools/table.py,sha256=UTNQMVuQOj3uOYos_V1eH3QgWXncv6MPRXUhTYUxiMA,6030
 odxtools/tablerow.py,sha256=QWOQxd83EN6jnOXDAc3ogaFxCz9R416vZSXpmZKjjnQ,9759
@@ -105,9 +105,11 @@ odxtools/uds.py,sha256=ttjCaqwfAU-DlM5peFpZCcwzq60QjBMxVpaOyUyY48k,5567
 odxtools/unit.py,sha256=n2aJdXWvtZbqvoGUXDRA6nXc5QwM25suZZg8dQG6y1A,3408
 odxtools/unitgroup.py,sha256=_WNpnYFmkiHQnOY8XhIviiQLXziY3kplH--7ufAWXyI,2067
 odxtools/unitspec.py,sha256=IAmDSLscVb4QUGgbQT-xXhtywW3qs0o9FfelnVYvimk,3074
-odxtools/utils.py,sha256=FaNlouR0FvO4W4nk3Wr7Ogx1wC4tYfuMOo07KF2QxbE,2764
+odxtools/utils.py,sha256=VBURockmg0E9NgaPZu177zA64QV6TxYRth1tpn7MfI0,2857
 odxtools/variablegroup.py,sha256=--5sMDOMUg4I3hFyoVOFcGCTOrctrrMADdmH3Mn4wHk,848
-odxtools/version.py,sha256=rCNnPeguHEaZ5sV4KzLUwq9jwQUlDxbmYLFI4XE-Jkk,511
+odxtools/variantmatcher.py,sha256=a1c1NtZgxRBA7OsRhEBM-3mgKUHqSywYXggT7Q5alJo,8355
+odxtools/variantpattern.py,sha256=f3t1KXXjrNkJLGmEc7iGG86Nj4h6Fdh9loFKTt-1Ffc,1431
+odxtools/version.py,sha256=EXUTEMMlT-sZN4IxnqEb0scBddeq3W9TNIgCRDO-ezE,511
 odxtools/writepdxfile.py,sha256=ZEoNkSxheqnXm836-HOpd04O6ipMXYKFzXZy6PM0YLc,7813
 odxtools/xdoc.py,sha256=gDq-8l8x-Tj1ZJOttPxZchcO5_jEPwcXxMgT29VgTS0,1433
 odxtools/cli/__init__.py,sha256=T7ano_FIyzBASxYpmcA5VJXU5bQLIy_Qk0HE_SDKelY,106
@@ -141,14 +143,14 @@ odxtools/compumethods/scalelinearcompumethod.py,sha256=o_Re17G4XlCn-XbStnvlTs9XV
 odxtools/compumethods/scaleratfunccompumethod.py,sha256=3imvLJgN3gkc7pILPIwAILHw0Ie5Ih_vysVGA8wYRgk,4457
 odxtools/compumethods/tabintpcompumethod.py,sha256=Gyf2qV5y53SHIcum5d5HQVGszoZCdu47jxMCQ6yKdQk,8065
 odxtools/compumethods/texttablecompumethod.py,sha256=vDYafbM0YaipjfN0NSlCFMiIPvp8waMNj3thNcwuYgk,5929
-odxtools/diaglayers/basevariant.py,sha256=mXS-SF-tcwtdV-rxZZCH6_yqdA-yhtMX1SGo1MS8w7k,4452
-odxtools/diaglayers/basevariantraw.py,sha256=A9h6p2Ri0sPPTW217rtEdNpAt5g6t0MwP9sgXqZ8pFo,4673
+odxtools/diaglayers/basevariant.py,sha256=x9WW-gpYl517la1nc2CJMj08-S_KGFb_8nwIOQN9Vg0,4645
+odxtools/diaglayers/basevariantraw.py,sha256=ujW58iFFWFSL9dzgUM4f5bPOA8oTZ7BjbH5lUHtLMJQ,4970
 odxtools/diaglayers/diaglayer.py,sha256=xs529IVG_18Fi8kbEZkD2vHjHRr57jeE4A_2lDLRKCQ,16254
 odxtools/diaglayers/diaglayerraw.py,sha256=ihOq51PWZUi4L7k0R5k06aLxZ8ppUkRYFym4hK_gXq8,12985
 odxtools/diaglayers/diaglayertype.py,sha256=FXL-EVBdrAURuHSHo9OthFuEYEybQO66aMB1o2GxVdI,1340
 odxtools/diaglayers/ecushareddata.py,sha256=QoV50wQIrJ2-faLtU1P7RrjdacbhPY2BfUtVtIyWqCM,3347
 odxtools/diaglayers/ecushareddataraw.py,sha256=cvkBhqTLOAey7Pt1bjQ3Jkkenp-D3Zh5djpB4ZWWUvw,3375
-odxtools/diaglayers/ecuvariant.py,sha256=OsLWg-dx6OJ_OPuYcgoTJuDXEReaJclDRbU5YKqrtBA,4368
+odxtools/diaglayers/ecuvariant.py,sha256=SE1JYUo3F67WO1wu8hYekW34s6OV7ORdoKkL62fZchU,4863
 odxtools/diaglayers/ecuvariantraw.py,sha256=bKlqFnBWkKdkM9EY5rFGOno3ClIVQNhgBoU5DseNnRc,4944
 odxtools/diaglayers/functionalgroup.py,sha256=o5bUGGDYisr7CjHZZh83fokA80f0s0zpHC_501cg-f0,4093
 odxtools/diaglayers/functionalgroupraw.py,sha256=H0-_XXlFTV8POGnh0S7CVBOKKQuyKHMB9lEyoAHuG_A,3963
@@ -177,7 +179,8 @@ odxtools/templates/diag_layer_container.odx-d.xml.jinja2,sha256=fDH9K2IdGfX-dVV0
 odxtools/templates/index.xml.jinja2,sha256=Z1bcntvvky7NoH0Q0CRJgUORwf3g96PFPGeOpi7VATw,647
 odxtools/templates/macros/printAdminData.xml.jinja2,sha256=YTB_CbhnALF6RIbE0XKQHRbC6c0PSZ_DxdrRHgqMD_s,2590
 odxtools/templates/macros/printAudience.xml.jinja2,sha256=vaYL_-GPVdlLc7WAQTbkVZZbFuQptnCbOhXJb3tsHv8,1286
-odxtools/templates/macros/printBaseVariant.xml.jinja2,sha256=l4Jp8v9ZfPXvIisqVLgTpzc5UdYGeIocY4vAcgCiiaE,1480
+odxtools/templates/macros/printBaseVariant.xml.jinja2,sha256=Ovf7NvO5jzy_9w1-iXi_q2dedoEfsQOYCK_WASkcITQ,1451
+odxtools/templates/macros/printBaseVariantPattern.xml.jinja2,sha256=foL_DmH4mWFzPObZ3VjPixdzbomAA5jK7GLpAhJsKVE,1192
 odxtools/templates/macros/printBasicStructure.xml.jinja2,sha256=V5oWGZesU_U5pvPO3Rtlodc7sxe5mFWY-uURLnQ8OfQ,614
 odxtools/templates/macros/printCompanyData.xml.jinja2,sha256=jcNmQBOGDw7wcKdam72NIJSOTxthfkPJvrmw24MBiYQ,2981
 odxtools/templates/macros/printComparam.xml.jinja2,sha256=e3hPCswAymJteQIUNoc7FOwsK_FrbJOvJooWdEx_vuQ,2408
@@ -193,7 +196,7 @@ odxtools/templates/macros/printDynamicEndmarkerField.xml.jinja2,sha256=6BmxPKesQ
 odxtools/templates/macros/printDynamicLengthField.xml.jinja2,sha256=bNvNh_4xyp4L6v7cxJ5cO1yOHYPnSFiaK9oY4l63fDU,784
 odxtools/templates/macros/printEcuSharedData.xml.jinja2,sha256=WK08eoDFEjj9o3eOuy__H0r9ioo688rTuQp6uXE6Tdo,820
 odxtools/templates/macros/printEcuVariant.xml.jinja2,sha256=Nsgj2VUWZvSDFPQsn6wv75M9TaryOB-tlQYCVq9hDEM,1594
-odxtools/templates/macros/printEcuVariantPattern.xml.jinja2,sha256=uSUrX1n2YVw6tt1-A0Lmlgy_W3dxW4r8bVErdrf_6vk,846
+odxtools/templates/macros/printEcuVariantPattern.xml.jinja2,sha256=YoYyzmxerJLJzUNoQ8H-JBnOqiwpVdODqk2KNRdWKWo,844
 odxtools/templates/macros/printElementId.xml.jinja2,sha256=Oe4sgtBB_VhTz6uJzaiTCpQki2ulKKfpBq56FVgBC-I,570
 odxtools/templates/macros/printEndOfPdu.xml.jinja2,sha256=ptjwOxyNTABATOajiitcvlJRKVGP_osh2wSJTCbaa38,679
 odxtools/templates/macros/printEnvData.xml.jinja2,sha256=2Goatqb66d-pCf9wqJDXn1EZWNhkQ8FJANKQMOnxuJs,609
@@ -221,9 +224,9 @@ odxtools/templates/macros/printStructure.xml.jinja2,sha256=M8p82SlgKaDk6nJA-0wr6
 odxtools/templates/macros/printSubComponent.xml.jinja2,sha256=ETo-k0K7px5nu9kgVjgDnjPoy8rYRfzq5ojvsZhM3Rw,3416
 odxtools/templates/macros/printTable.xml.jinja2,sha256=IMAaYNtpxs_6V7VxM_hfOeGkFfkyRjSmwvmr9_K8Ddc,3075
 odxtools/templates/macros/printUnitSpec.xml.jinja2,sha256=KOjRVwtdIg7uGl4B9cLpvW68-TYeE33Tz9sWZdnwkBE,2878
-odxtools-9.4.1.dist-info/LICENSE,sha256=NeGPFQdTa6EKeON3aShVlPAIquJnbbiOfj0suz6rzyQ,1074
-odxtools-9.4.1.dist-info/METADATA,sha256=jqTqPdpARQPDAnEyGaDMfjBGoOidZ1AyYZB_DZc5qyE,44055
-odxtools-9.4.1.dist-info/WHEEL,sha256=nn6H5-ilmfVryoAQl3ZQ2l8SH5imPWFpm1A5FgEuFV4,91
-odxtools-9.4.1.dist-info/entry_points.txt,sha256=_sBDzuNoT8LbbCjfc-OJiUt5WPrtOq_x-rr9txhrPjY,53
-odxtools-9.4.1.dist-info/top_level.txt,sha256=pdS02kE5ZdgsaBRZDpX3NBFlaSx3zotsqX4E4V6tXEI,9
-odxtools-9.4.1.dist-info/RECORD,,
+odxtools-9.5.0.dist-info/LICENSE,sha256=NeGPFQdTa6EKeON3aShVlPAIquJnbbiOfj0suz6rzyQ,1074
+odxtools-9.5.0.dist-info/METADATA,sha256=TG3F5Qqkpiu1FVtwEkeH1s3eKEyHWR6LR1eyBe6g3N0,44055
+odxtools-9.5.0.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
+odxtools-9.5.0.dist-info/entry_points.txt,sha256=_sBDzuNoT8LbbCjfc-OJiUt5WPrtOq_x-rr9txhrPjY,53
+odxtools-9.5.0.dist-info/top_level.txt,sha256=pdS02kE5ZdgsaBRZDpX3NBFlaSx3zotsqX4E4V6tXEI,9
+odxtools-9.5.0.dist-info/RECORD,,

{odxtools-9.4.1.dist-info → odxtools-9.5.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.1)
+Generator: setuptools (75.8.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

odxtools/createecuvariantpatterns.py

@@ -1,18 +0,0 @@
-# SPDX-License-Identifier: MIT
-from typing import List, Optional
-from xml.etree import ElementTree
-
-from .ecuvariantpattern import EcuVariantPattern
-from .odxlink import OdxDocFragment
-
-
-def create_ecu_variant_patterns_from_et(et_element: Optional[ElementTree.Element],
-                                        doc_frags: List[OdxDocFragment]) -> List[EcuVariantPattern]:
-
-    if et_element is None:
-        return []
-
-    return [
-        EcuVariantPattern.from_et(evp_elem, doc_frags)
-        for evp_elem in et_element.iterfind("ECU-VARIANT-PATTERN")
-    ]

odxtools/ecuvariantmatcher.py

@@ -1,171 +0,0 @@
-# SPDX-License-Identifier: MIT
-from enum import Enum
-from typing import Dict, Generator, List, Optional
-
-from .diaglayers.diaglayer import DiagLayer
-from .diaglayers.diaglayertype import DiagLayerType
-from .diaglayers.ecuvariant import EcuVariant
-from .diagservice import DiagService
-from .exceptions import OdxError, odxassert, odxrequire
-from .matchingparameter import MatchingParameter
-from .odxtypes import ParameterValue
-from .response import Response
-
-
-class EcuVariantMatcher:
-    """EcuVariantMatcher implements the matching algorithm of ecu variants according to their
-    ECU-VARIANT-PATTERN according to ISO 22901-1.
-
-    Usage (example):
-
-    ```python
-
-    # initialize the matcher with a list of ecu variants,
-    # i.e., DiagLayer instances of variant_type == DiagLayerType.ECU-VARIANT
-    matcher = EcuVariantMatcher(ecu_variant_candidates=[...], use_cache=use_cache)
-
-    # run the request loop to obtain responses for every request
-    for req in matcher.request_loop():
-        resp = ... # make a UDS request
-        matcher.evaluate(resp)
-
-    # result
-    if matcher.has_match()
-        match = matcher.get_active_ecu_variant()
-    ```
-    """
-
-    class State(Enum):
-        PENDING = 0
-        NO_MATCH = 1
-        MATCH = 2
-
-    @staticmethod
-    def get_ident_service(diag_layer: DiagLayer, matching_param: MatchingParameter) -> DiagService:
-        service_name = matching_param.diag_comm_snref
-        service = odxrequire(diag_layer.services.get(service_name))
-        return service
-
-    @staticmethod
-    def encode_ident_request(diag_layer: DiagLayer, matching_param: MatchingParameter) -> bytes:
-        service = EcuVariantMatcher.get_ident_service(diag_layer, matching_param)
-        return bytes(service.encode_request())
-
-    @staticmethod
-    def decode_ident_response(
-        diag_layer: DiagLayer,
-        matching_param: MatchingParameter,
-        response_bytes: bytes,
-    ) -> str:
-        """Decode a binary response and extract the identification string according
-        to the snref or snpathref of the matching_param.
-        """
-        service = EcuVariantMatcher.get_ident_service(diag_layer, matching_param)
-
-        # ISO 22901 requires that snref or snpathref is resolvable in at least one
-        # POS-RESPONSE or NEG-RESPONSE
-        pos_neg_responses: List[Response] = []
-        if service.positive_responses is not None:
-            pos_neg_responses.extend(service.positive_responses)
-        if service.negative_responses is not None:
-            pos_neg_responses.extend(service.negative_responses)
-
-        for any_response in pos_neg_responses:
-            decoded_val: Optional[ParameterValue] = any_response.decode(response_bytes)
-            # disassemble snref / snpathref
-            path_ref = matching_param.out_param_if.split(".")
-            for ref in path_ref:
-                if isinstance(decoded_val, dict) and ref in decoded_val:
-                    decoded_val = decoded_val[ref]
-                else:
-                    decoded_val = None
-                    break
-
-            if decoded_val is not None:
-                if isinstance(decoded_val, str) or isinstance(decoded_val, int):
-                    return str(decoded_val)
-
-        raise OdxError(f"The snref or snpathref '{matching_param.out_param_if}' is cannot be \
-                resolved for any positive or negative response.")
-
-    def __init__(self, ecu_variant_candidates: List[EcuVariant], use_cache: bool = True):
-
-        self.ecus = ecu_variant_candidates
-        for ecu in self.ecus:
-            odxassert(ecu.variant_type == DiagLayerType.ECU_VARIANT)
-
-        self.use_cache = use_cache
-        self.req_resp_cache: Dict[bytes, bytes] = {}
-        self._recent_ident_response: Optional[bytes] = None
-
-        self._state = EcuVariantMatcher.State.PENDING
-
-    def request_loop(self) -> Generator[bytes, None, None]:
-        """The request loop yields byte sequences of requests, which shall be executed within the
-        loop body. It is required to pass the response back to the matcher using the evaluate method.
-        """
-        if not self.is_pending():
-            return
-
-        for ecu in self.ecus:
-            any_match = False
-            for pattern in ecu.ecu_variant_patterns:
-                all_match = True
-                for matching_param in pattern.matching_parameters:
-                    req_bytes = bytes(EcuVariantMatcher.encode_ident_request(ecu, matching_param))
-                    if self.use_cache and req_bytes in self.req_resp_cache:
-                        resp_bytes = self.req_resp_cache[req_bytes]
-                    else:
-                        yield req_bytes
-                        resp_bytes = self._get_ident_response()
-                        self._update_cache(req_bytes, resp_bytes)
-                    ident_val = EcuVariantMatcher.decode_ident_response(
-                        ecu, matching_param, resp_bytes)
-                    all_match &= matching_param.is_match(ident_val)
-                if all_match:
-                    any_match = True
-                    break
-            if any_match:
-                self._state = EcuVariantMatcher.State.MATCH
-                self._match = ecu
-                break
-        if self.is_pending():
-            # no pattern has matched for any ecu variant
-            self._state = EcuVariantMatcher.State.NO_MATCH
-
-    def evaluate(self, resp_bytes: bytes) -> None:
-        """Update the matcher with the response to a requst.
-
-        Warning: Use this method EXACTLY once within the loop body of the request loop.
-        """
-        self._recent_ident_response = bytes(resp_bytes)
-
-    def is_pending(self) -> bool:
-        """True iff request loop has not yet been run."""
-        return self._state == EcuVariantMatcher.State.PENDING
-
-    def has_match(self) -> bool:
-        """Returns true iff the non-pending matcher found a matching ecu variant.
-
-        Raises a runtime error if the matcher is pending.
-        """
-        if self.is_pending():
-            raise RuntimeError(
-                "EcuVariantMatcher is pending. Run the request_loop to determine the active ecu variant."
-            )
-        return self._state == EcuVariantMatcher.State.MATCH
-
-    def get_active_ecu_variant(self) -> DiagLayer:
-        """Returns the matched, i.e., active ecu variant if such a variant has been found."""
-        odxassert(self.has_match())
-        return self._match
-
-    def _update_cache(self, req_bytes: bytes, resp_bytes: bytes) -> None:
-        if self.use_cache:
-            self.req_resp_cache[req_bytes] = resp_bytes
-
-    def _get_ident_response(self) -> bytes:
-        if not self._recent_ident_response:
-            raise RuntimeError(
-                "No response available. Did you forget to call 'evaluate()' in a loop?")
-        return self._recent_ident_response