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

odxtools/snrefcontext.py

@@ -0,0 +1,29 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, List, Optional
+
+if TYPE_CHECKING:
+    from .database import Database
+    from .diaglayer import DiagLayer
+    from .diagservice import DiagService
+    from .parameters.parameter import Parameter
+    from .request import Request
+    from .response import Response
+    from .singleecujob import SingleEcuJob
+    from .statechart import StateChart
+
+
+@dataclass
+class SnRefContext:
+    """Represents the context for which a short name reference ought
+    to be resolved
+    """
+
+    database: Optional["Database"] = None
+    diag_layer: Optional["DiagLayer"] = None
+    diag_service: Optional["DiagService"] = None
+    single_ecu_job: Optional["SingleEcuJob"] = None
+    request: Optional["Request"] = None
+    response: Optional["Response"] = None
+    parameters: Optional[List["Parameter"]] = None
+    state_chart: Optional["StateChart"] = None

odxtools/specialdata.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
@@ -21,7 +19,7 @@ class SpecialData:
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         pass
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass
 
     @staticmethod

odxtools/specialdatagroup.py

@@ -1,15 +1,13 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Union
 from xml.etree import ElementTree
 
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .snrefcontext import SnRefContext
 from .specialdata import SpecialData
 from .specialdatagroupcaption import SpecialDataGroupCaption
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class SpecialDataGroup:
@@ -72,11 +70,11 @@ class SpecialDataGroup:
         for val in self.values:
             val._resolve_odxlinks(odxlinks)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         # resolve the SNREFs of the caption, but only if the caption
         # was specified by value, not by reference
         if self.sdg_caption is not None and self.sdg_caption_ref is None:
-            self.sdg_caption._resolve_snrefs(diag_layer)
+            self.sdg_caption._resolve_snrefs(context)
 
         for val in self.values:
-            val._resolve_snrefs(diag_layer)
+            val._resolve_snrefs(context)

odxtools/specialdatagroupcaption.py

@@ -1,16 +1,13 @@
 # SPDX-License-Identifier: MIT
-# import warnings
 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 SpecialDataGroupCaption(IdentifiableElement):
@@ -32,5 +29,5 @@ class SpecialDataGroupCaption(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/standardlengthtype.py

@@ -1,6 +1,7 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Literal, Optional
+from typing import List, Literal, Optional
+from xml.etree import ElementTree
 
 from typing_extensions import override
 
@@ -8,7 +9,9 @@ from .decodestate import DecodeState
 from .diagcodedtype import DctType, DiagCodedType
 from .encodestate import EncodeState
 from .exceptions import odxassert, odxraise, odxrequire
-from .odxtypes import AtomicOdxType, DataType
+from .odxlink import OdxDocFragment
+from .odxtypes import AtomicOdxType, DataType, odxstr_to_bool
+from .utils import dataclass_fields_asdict
 
 
 @dataclass
@@ -18,6 +21,28 @@ class StandardLengthType(DiagCodedType):
     bit_mask: Optional[int]
     is_condensed_raw: Optional[bool]
 
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "StandardLengthType":
+        kwargs = dataclass_fields_asdict(DiagCodedType.from_et(et_element, doc_frags))
+
+        bit_length = int(odxrequire(et_element.findtext("BIT-LENGTH")))
+        bit_mask = None
+        if (bit_mask_str := et_element.findtext("BIT-MASK")) is not None:
+            # The XSD uses the type xsd:hexBinary
+            # xsd:hexBinary allows for leading/trailing whitespace, empty strings, and it only allows an even
+            # number of hex digits, while some of the examples shown in the  ODX specification exhibit an
+            # odd number of hex digits.
+            # This causes a validation paradox, so we try to be flexible
+            bit_mask_str = bit_mask_str.strip()
+            if len(bit_mask_str):
+                bit_mask = int(bit_mask_str, 16)
+        is_condensed_raw = odxstr_to_bool(et_element.get("IS-CONDENSED"))
+
+        return StandardLengthType(
+            bit_length=bit_length, bit_mask=bit_mask, is_condensed_raw=is_condensed_raw, **kwargs)
+
     @property
     def dct_type(self) -> DctType:
         return "STANDARD-LENGTH-TYPE"

odxtools/state.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 State(IdentifiableElement):
@@ -29,5 +27,5 @@ class State(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/statechart.py

@@ -1,19 +1,17 @@
 # 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 .exceptions import odxrequire
 from .nameditemlist import NamedItemList
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, resolve_snref
+from .snrefcontext import SnRefContext
 from .state import State
 from .statetransition import StateTransition
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class StateChart(IdentifiableElement):
@@ -68,7 +66,9 @@ class StateChart(IdentifiableElement):
         for st in self.states:
             st._resolve_odxlinks(odxlinks)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        context.state_chart = self
+
         # For now, we assume that the start state short name reference
         # points to a local state of the state chart. TODO: The XSD
         # allows to define state charts without any states, yet the
@@ -78,11 +78,9 @@ class StateChart(IdentifiableElement):
         self._start_state = resolve_snref(self.start_state_snref, self.states, State)
 
         for st in self.states:
-            st._resolve_snrefs(diag_layer)
+            st._resolve_snrefs(context)
 
         for strans in self.state_transitions:
-            # note that the signature of the state transition's
-            # _resolve_snrefs() method is non-standard as the
-            # namespace of these SNREFs is the state chart, not the
-            # whole diag layer...
-            strans._resolve_snrefs(diag_layer, states=self.states)
+            strans._resolve_snrefs(context)
+
+        context.state_chart = None

odxtools/statetransition.py

@@ -1,17 +1,15 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, Iterable, List
+from typing import Any, Dict, List
 from xml.etree import ElementTree
 
 from .element import IdentifiableElement
 from .exceptions import odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, resolve_snref
+from .snrefcontext import SnRefContext
 from .state import State
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class StateTransition(IdentifiableElement):
@@ -50,10 +48,7 @@ class StateTransition(IdentifiableElement):
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         pass
 
-    # note that the signature of this method is non-standard because
-    # the namespace of these SNREFs is the corresponding state
-    # chart. To mitigate this a bit, the non-standard parameters are
-    # keyword-only...
-    def _resolve_snrefs(self, diag_layer: "DiagLayer", *, states: Iterable[State]) -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        states = odxrequire(context.state_chart).states
         self._source_state = resolve_snref(self.source_snref, states, State)
         self._target_state = resolve_snref(self.target_snref, states, State)

odxtools/staticfield.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Sequence
+from typing import Any, Dict, List, Sequence
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -11,11 +11,9 @@ from .exceptions import odxassert, odxraise, odxrequire
 from .field import Field
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from .odxtypes import ParameterValue
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class StaticField(Field):
@@ -44,8 +42,8 @@ class StaticField(Field):
         super()._resolve_odxlinks(odxlinks)
 
     @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)
 
     @override
     def encode_into_pdu(self, physical_value: ParameterValue, encode_state: EncodeState) -> None:
@@ -89,7 +87,6 @@ class StaticField(Field):
                   "No bit position can be specified for static length fields!")
 
         orig_origin = decode_state.origin_byte_position
-        orig_cursor = decode_state.cursor_byte_position
         decode_state.origin_byte_position = decode_state.cursor_byte_position
 
         result: List[ParameterValue] = []
@@ -106,6 +103,5 @@ class StaticField(Field):
             decode_state.cursor_byte_position = orig_cursor + self.item_byte_size
 
         decode_state.origin_byte_position = orig_origin
-        decode_state.cursor_byte_position = max(orig_cursor, decode_state.cursor_byte_position)
 
         return result

odxtools/table.py

@@ -1,22 +1,19 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Union
 from xml.etree import ElementTree
 
 from .admindata import AdminData
-from .createsdgs import create_sdgs_from_et
 from .dataobjectproperty import DataObjectProperty
 from .element import IdentifiableElement
 from .exceptions import odxassert
 from .nameditemlist import NamedItemList
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .snrefcontext import SnRefContext
 from .specialdatagroup import SpecialDataGroup
 from .tablerow import TableRow
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class Table(IdentifiableElement):
@@ -50,7 +47,9 @@ class Table(IdentifiableElement):
             elif sub_elem.tag == "TABLE-ROW-REF":
                 table_rows_raw.append(OdxLinkRef.from_et(sub_elem, doc_frags))
 
-        sdgs = create_sdgs_from_et(et_element.find("SDGS"), doc_frags)
+        sdgs = [
+            SpecialDataGroup.from_et(sdge, doc_frags) for sdge in et_element.iterfind("SDGS/SDG")
+        ]
 
         return Table(
             semantic=semantic,
@@ -99,7 +98,7 @@ class Table(IdentifiableElement):
 
         self._table_rows = NamedItemList(table_rows)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         for table_row_wrapper in self.table_rows_raw:
             if isinstance(table_row_wrapper, TableRow):
-                table_row_wrapper._resolve_snrefs(diag_layer)
+                table_row_wrapper._resolve_snrefs(context)

odxtools/tablerow.py

@@ -4,18 +4,17 @@ from typing import TYPE_CHECKING, Any, Dict, List, Optional
 from xml.etree import ElementTree
 
 from .basicstructure import BasicStructure
-from .createsdgs import create_sdgs_from_et
 from .dataobjectproperty import DataObjectProperty
 from .dtcdop import DtcDop
 from .element import IdentifiableElement
 from .exceptions import odxassert, odxraise, odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from .odxtypes import AtomicOdxType
+from .snrefcontext import SnRefContext
 from .specialdatagroup import SpecialDataGroup
 from .utils import dataclass_fields_asdict
 
 if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
     from .table import Table
 
 
@@ -70,7 +69,9 @@ class TableRow(IdentifiableElement):
         dop_snref: Optional[str] = None
         if (dop_snref_elem := et_element.find("DATA-OBJECT-PROP-SNREF")) is not None:
             dop_snref = dop_snref_elem.attrib["SHORT-NAME"]
-        sdgs = create_sdgs_from_et(et_element.find("SDGS"), doc_frags)
+        sdgs = [
+            SpecialDataGroup.from_et(sdge, doc_frags) for sdge in et_element.iterfind("SDGS/SDG")
+        ]
 
         return TableRow(
             table_ref=table_ref,
@@ -107,7 +108,7 @@ class TableRow(IdentifiableElement):
         for sdg in self.sdgs:
             sdg._resolve_odxlinks(odxlinks)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         # convert the raw key into the proper internal
         # representation. note that we cannot do this earlier because
         # the table's ODXLINKs must be resolved and the order of
@@ -125,7 +126,7 @@ class TableRow(IdentifiableElement):
         else:
             self._key = key_dop.physical_type.base_data_type.from_string(self.key_raw)
 
-        ddd_spec = diag_layer.diag_data_dictionary_spec
+        ddd_spec = odxrequire(context.diag_layer).diag_data_dictionary_spec
 
         if self.structure_snref is not None:
             self._structure = resolve_snref(self.structure_snref, ddd_spec.structures,
@@ -135,7 +136,7 @@ class TableRow(IdentifiableElement):
                                       DataObjectProperty)
 
         for sdg in self.sdgs:
-            sdg._resolve_snrefs(diag_layer)
+            sdg._resolve_snrefs(context)
 
     @property
     def table(self) -> "Table":

odxtools/teammember.py

@@ -1,16 +1,14 @@
 # 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 .element import IdentifiableElement
 from .exceptions import odxrequire
 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 TeamMember(IdentifiableElement):
@@ -55,5 +53,5 @@ class TeamMember(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/templates/comparam-spec.odx-c.xml.jinja2

@@ -8,6 +8,7 @@
 {%- import('macros/printAdminData.xml.jinja2') as pad -%}
 {%- import('macros/printCompanyData.xml.jinja2') as pcd -%}
 {%- import('macros/printProtStack.xml.jinja2') as pps %}
+{%- import('macros/printDescription.xml.jinja2') as pd %}
 {#- -#}
 
 <?xml version="1.0" encoding="UTF-8" standalone="no" ?>
@@ -18,11 +19,7 @@
    {%- if comparam_spec.long_name is not none %}
    <LONG-NAME>{{comparam_spec.long_name|e}}</LONG-NAME>
    {%- endif %}
-   {%- if comparam_spec.description and comparam_spec.description.strip() %}
-   <DESC>
-     {{comparam_spec.description}}
-   </DESC>
-   {%- endif %}
+   {{pd.printDescription(comparam_spec.description)}}
    {%- if comparam_spec.admin_data is not none %}
    {{- pad.printAdminData(comparam_spec.admin_data) | indent(3) }}
    {%- endif %}

odxtools/templates/comparam-subset.odx-cs.xml.jinja2

@@ -11,6 +11,7 @@
 {%- import('macros/printDOP.xml.jinja2') as pdop %}
 {%- import('macros/printUnitSpec.xml.jinja2') as pus %}
 {%- import('macros/printSpecialData.xml.jinja2') as psd %}
+{%- import('macros/printDescription.xml.jinja2') as pd %}
 {#- -#}
 
 <?xml version="1.0" encoding="UTF-8" standalone="no" ?>
@@ -22,11 +23,7 @@
    {%- if comparam_subset.long_name is not none %}
    <LONG-NAME>{{comparam_subset.long_name|e}}</LONG-NAME>
    {%- endif %}
-   {%- if comparam_subset.description and comparam_subset.description.strip() %}
-   <DESC>
-     {{comparam_subset.description}}
-   </DESC>
-   {%- endif %}
+   {{pd.printDescription(comparam_subset.description)}}
    {%- if comparam_subset.admin_data is not none %}
    {{- pad.printAdminData(comparam_subset.admin_data) | indent(3) }}
    {%- endif %}

odxtools/templates/macros/printCompanyData.xml.jinja2

@@ -5,6 +5,7 @@
 
 {%- import('macros/printElementId.xml.jinja2') as peid %}
 {%- import('macros/printSpecialData.xml.jinja2') as psd %}
+{%- import('macros/printDescription.xml.jinja2') as pd %}
 
 {%- macro printCompanyData(company_data) %}
 <COMPANY-DATA ID="{{company_data.odx_id.local_id}}">
@@ -81,11 +82,7 @@
      {%- endif %}
     </XDOC>
     {%- endif %}
-    {%- if rd.description is not none %}
-    <DESC>
-{{rd.description}}
-    </DESC>
-    {%- endif %}
+    {{pd.printDescription(rd.description)}}
    </RELATED-DOC>
   {%- endfor %}
   </RELATED-DOCS>

odxtools/templates/macros/printComparamRef.xml.jinja2

@@ -3,6 +3,7 @@
  # SPDX-License-Identifier: MIT
 -#}
 {%- import('macros/printComparam.xml.jinja2') as pcp %}
+{%- import('macros/printDescription.xml.jinja2') as pd %}
 {#- -#}
 
 {%- macro printComparamRef(cp) %}
@@ -11,27 +12,19 @@
               DOCTYPE="COMPARAM-SUBSET">
   {%- if cp.value is string %}
   <SIMPLE-VALUE>{{cp.value}}</SIMPLE-VALUE>
-  {%- if cp.description %}
-  <DESC>{{cp.description}}</DESC>
-  {%- endif %}
+  {{ pd.printDescription(cp.description) }}
   {%- elif cp.value is iterable %}
   {%- if hasattr(cp.value, "hex") %}
   {#- the value has a hex() method. assume that is a bytes or bytestring #}
   <SIMPLE-VALUE>{{cp.value.hex().upper()}}</SIMPLE-VALUE>
-  {%- if cp.description %}
-  <DESC>{{cp.description}}</DESC>
-  {%- endif %}
+  {{ pd.printDescription(cp.description) }}
   {%- else %}
   {{ pcp.printComplexValue(cp.value)|indent(1) }}
-  {%- if cp.description %}
-  <DESC>{{cp.description}}</DESC>
-  {%- endif %}
+  {{ pd.printDescription(cp.description) }}
   {%- endif %}
   {%- else %}
   <SIMPLE-VALUE>{{cp.value}}</SIMPLE-VALUE>
-  {%- if cp.description %}
-  <DESC>{{cp.description}}</DESC>
-  {%- endif %}
+  {{ pd.printDescription(cp.description) }}
   {%- endif %}
   {%- if cp.prot_stack_snref is not none %}
   <PROT-STACK-SNREF SHORT-NAME="{{cp.prot_stack_snref}}"/>