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

odxtools/tablerow.py

@@ -5,7 +5,6 @@ from xml.etree import ElementTree
 
 from .admindata import AdminData
 from .audience import Audience
-from .basicstructure import BasicStructure
 from .dataobjectproperty import DataObjectProperty
 from .dtcdop import DtcDop
 from .element import IdentifiableElement
@@ -14,10 +13,11 @@ from .functionalclass import FunctionalClass
 from .nameditemlist import NamedItemList
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from .odxtypes import AtomicOdxType, odxstr_to_bool
+from .preconditionstateref import PreConditionStateRef
 from .snrefcontext import SnRefContext
 from .specialdatagroup import SpecialDataGroup
-from .state import State
-from .statetransition import StateTransition
+from .statetransitionref import StateTransitionRef
+from .structure import Structure
 from .utils import dataclass_fields_asdict
 
 if TYPE_CHECKING:
@@ -27,8 +27,8 @@ if TYPE_CHECKING:
 @dataclass
 class TableRow(IdentifiableElement):
     """This class represents a TABLE-ROW."""
-    key_raw: str
     table_ref: OdxLinkRef
+    key_raw: str
 
     # The spec mandates that either a structure or a non-complex DOP
     # must be referenced here, i.e., exactly one of the four
@@ -41,8 +41,8 @@ class TableRow(IdentifiableElement):
     sdgs: List[SpecialDataGroup]
     audience: Optional[Audience]
     functional_class_refs: List[OdxLinkRef]
-    state_transition_refs: List[OdxLinkRef]
-    pre_condition_state_refs: List[OdxLinkRef]
+    state_transition_refs: List[StateTransitionRef]
+    pre_condition_state_refs: List[PreConditionStateRef]
     admin_data: Optional[AdminData]
 
     is_executable_raw: Optional[bool]
@@ -51,16 +51,28 @@ class TableRow(IdentifiableElement):
     is_final_raw: Optional[bool]
 
     @property
-    def functional_classes(self) -> NamedItemList[FunctionalClass]:
-        return self._functional_classes
+    def table(self) -> "Table":
+        return self._table
+
+    # the value of the key expressed in the type represented by the
+    # referenced DOP
+    @property
+    def key(self) -> Optional[AtomicOdxType]:
+        return self._key
+
+    @property
+    def dop(self) -> Optional[DataObjectProperty]:
+        """The data object property object resolved by dop_ref."""
+        return self._dop
 
     @property
-    def state_transitions(self) -> NamedItemList[StateTransition]:
-        return self._state_transitions
+    def structure(self) -> Optional[Structure]:
+        """The structure associated with this table row."""
+        return self._structure
 
     @property
-    def pre_condition_states(self) -> NamedItemList[State]:
-        return self._pre_condition_states
+    def functional_classes(self) -> NamedItemList[FunctionalClass]:
+        return self._functional_classes
 
     @property
     def is_executable(self) -> bool:
@@ -74,21 +86,6 @@ class TableRow(IdentifiableElement):
     def is_final(self) -> bool:
         return self.is_final_raw is True
 
-    def __post_init__(self) -> None:
-        self._structure: Optional[BasicStructure] = None
-        self._dop: Optional[DataObjectProperty] = None
-
-        n = sum([0 if x is None else 1 for x in (self.structure_ref, self.structure_snref)])
-        odxassert(
-            n <= 1,
-            f"Table row {self.short_name}: The structure can either be defined using ODXLINK or SNREF but not both."
-        )
-        n = sum([0 if x is None else 1 for x in (self.dop_ref, self.dop_snref)])
-        odxassert(
-            n <= 1,
-            f"Table row {self.short_name}: The dop can either be defined using ODXLINK or SNREF but not both."
-        )
-
     @staticmethod
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> Any:
         raise RuntimeError(
@@ -99,16 +96,19 @@ class TableRow(IdentifiableElement):
                          table_ref: OdxLinkRef) -> "TableRow":
         """Reads a TABLE-ROW."""
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
-        semantic = et_element.get("SEMANTIC")
+
         key_raw = odxrequire(et_element.findtext("KEY"))
-        structure_ref = OdxLinkRef.from_et(et_element.find("STRUCTURE-REF"), doc_frags)
-        structure_snref: Optional[str] = None
-        if (structure_snref_elem := et_element.find("STRUCTURE-SNREF")) is not None:
-            structure_snref = structure_snref_elem.attrib["SHORT-NAME"]
+
         dop_ref = OdxLinkRef.from_et(et_element.find("DATA-OBJECT-PROP-REF"), doc_frags)
         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"]
+
+        structure_ref = OdxLinkRef.from_et(et_element.find("STRUCTURE-REF"), doc_frags)
+        structure_snref: Optional[str] = None
+        if (structure_snref_elem := et_element.find("STRUCTURE-SNREF")) is not None:
+            structure_snref = structure_snref_elem.attrib["SHORT-NAME"]
+
         sdgs = [
             SpecialDataGroup.from_et(sdge, doc_frags) for sdge in et_element.iterfind("SDGS/SDG")
         ]
@@ -123,12 +123,12 @@ class TableRow(IdentifiableElement):
         ]
 
         state_transition_refs = [
-            odxrequire(OdxLinkRef.from_et(el, doc_frags))
+            StateTransitionRef.from_et(el, doc_frags)
             for el in et_element.iterfind("STATE-TRANSITION-REFS/STATE-TRANSITION-REF")
         ]
 
         pre_condition_state_refs = [
-            odxrequire(OdxLinkRef.from_et(el, doc_frags))
+            PreConditionStateRef.from_et(el, doc_frags)
             for el in et_element.iterfind("PRE-CONDITION-STATE-REFS/PRE-CONDITION-STATE-REF")
         ]
 
@@ -142,10 +142,10 @@ class TableRow(IdentifiableElement):
         return TableRow(
             table_ref=table_ref,
             key_raw=key_raw,
-            structure_ref=structure_ref,
-            structure_snref=structure_snref,
             dop_ref=dop_ref,
             dop_snref=dop_snref,
+            structure_ref=structure_ref,
+            structure_snref=structure_snref,
             sdgs=sdgs,
             audience=audience,
             functional_class_refs=functional_class_refs,
@@ -158,38 +158,66 @@ class TableRow(IdentifiableElement):
             is_final_raw=is_final_raw,
             **kwargs)
 
+    def __post_init__(self) -> None:
+        self._dop: Optional[DataObjectProperty] = None
+        self._structure: Optional[Structure] = None
+
+        n = sum([0 if x is None else 1 for x in (self.dop_ref, self.dop_snref)])
+        odxassert(
+            n <= 1,
+            f"Table row {self.short_name}: The dop can either be defined using ODXLINK or SNREF but not both."
+        )
+
+        n = sum([0 if x is None else 1 for x in (self.structure_ref, self.structure_snref)])
+        odxassert(
+            n <= 1,
+            f"Table row {self.short_name}: The structure can either be defined using ODXLINK or SNREF but not both."
+        )
+
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         result = {self.odx_id: self}
 
         for sdg in self.sdgs:
             result.update(sdg._build_odxlinks())
 
+        if self.audience is not None:
+            result.update(self.audience._build_odxlinks())
+
+        for st_ref in self.state_transition_refs:
+            result.update(st_ref._build_odxlinks())
+
+        for pc_ref in self.pre_condition_state_refs:
+            result.update(pc_ref._build_odxlinks())
+
         return result
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        if self.structure_ref is not None:
-            self._structure = odxlinks.resolve(self.structure_ref, BasicStructure)
-        if self.dop_ref is not None:
-            self._dop = odxlinks.resolve(self.dop_ref)
-            if not isinstance(self._dop, (DataObjectProperty, DtcDop)):
-                odxraise("The DOP-REF of TABLE-ROWs must reference a simple DOP!")
-
         if TYPE_CHECKING:
             self._table = odxlinks.resolve(self.table_ref, Table)
         else:
             self._table = odxlinks.resolve(self.table_ref)
 
+        if self.dop_ref is not None:
+            self._dop = odxlinks.resolve(self.dop_ref)
+            if not isinstance(self._dop, (DataObjectProperty, DtcDop)):
+                odxraise("The DOP-REF of TABLE-ROWs must reference a simple DOP!")
+        if self.structure_ref is not None:
+            self._structure = odxlinks.resolve(self.structure_ref, Structure)
+
         for sdg in self.sdgs:
             sdg._resolve_odxlinks(odxlinks)
 
+        if self.audience is not None:
+            self.audience._resolve_odxlinks(odxlinks)
+
         self._functional_classes = NamedItemList(
             [odxlinks.resolve(fc_ref, FunctionalClass) for fc_ref in self.functional_class_refs])
 
-        self._state_transitions = NamedItemList(
-            [odxlinks.resolve(st_ref, StateTransition) for st_ref in self.state_transition_refs])
+        for st_ref in self.state_transition_refs:
+            st_ref._resolve_odxlinks(odxlinks)
 
-        self._pre_condition_states = NamedItemList(
-            [odxlinks.resolve(pcs_ref, State) for pcs_ref in self.pre_condition_state_refs])
+        for pc_ref in self.pre_condition_state_refs:
+            pc_ref._resolve_odxlinks(odxlinks)
 
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         # convert the raw key into the proper internal
@@ -212,34 +240,23 @@ class TableRow(IdentifiableElement):
         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,
-                                            BasicStructure)
+            self._structure = resolve_snref(self.structure_snref, ddd_spec.structures, Structure)
         if self.dop_snref is not None:
-            self._dop = resolve_snref(self.dop_snref, ddd_spec.data_object_props,
-                                      DataObjectProperty)
+            self._dop = resolve_snref(self.dop_snref, ddd_spec.data_object_props)
+            if not isinstance(self._dop, (DataObjectProperty, DtcDop)):
+                odxraise("The DOP-SNREF of TABLE-ROWs must reference a simple DOP!")
+
+        if self.audience is not None:
+            self.audience._resolve_snrefs(context)
 
         for sdg in self.sdgs:
             sdg._resolve_snrefs(context)
 
-    @property
-    def table(self) -> "Table":
-        return self._table
+        for st_ref in self.state_transition_refs:
+            st_ref._resolve_snrefs(context)
 
-    # the value of the key expressed in the type represented by the
-    # referenced DOP
-    @property
-    def key(self) -> Optional[AtomicOdxType]:
-        return self._key
-
-    @property
-    def structure(self) -> Optional[BasicStructure]:
-        """The structure associated with this table row."""
-        return self._structure
-
-    @property
-    def dop(self) -> Optional[DataObjectProperty]:
-        """The data object property object resolved by dop_ref."""
-        return self._dop
+        for pc_ref in self.pre_condition_state_refs:
+            pc_ref._resolve_snrefs(context)
 
     def __reduce__(self) -> Tuple[Any, ...]:
         """This ensures that the object can be correctly reconstructed during unpickling."""

odxtools/teammember.py

@@ -15,7 +15,7 @@ class TeamMember(IdentifiableElement):
     roles: List[str]
     department: Optional[str]
     address: Optional[str]
-    zip: Optional[str]
+    zipcode: Optional[str]  # the tag for this is "ZIP", but `zip` is a keyword in python
     city: Optional[str]
     phone: Optional[str]
     fax: Optional[str]
@@ -24,11 +24,11 @@ class TeamMember(IdentifiableElement):
     @staticmethod
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "TeamMember":
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
-        roles = [odxrequire(role_elem.text) for role_elem in et_element.iterfind("ROLES/ROLE")]
 
+        roles = [odxrequire(role_elem.text) for role_elem in et_element.iterfind("ROLES/ROLE")]
         department = et_element.findtext("DEPARTMENT")
         address = et_element.findtext("ADDRESS")
-        zip = et_element.findtext("ZIP")
+        zipcode = et_element.findtext("ZIP")
         city = et_element.findtext("CITY")
         phone = et_element.findtext("PHONE")
         fax = et_element.findtext("FAX")
@@ -38,7 +38,7 @@ class TeamMember(IdentifiableElement):
             roles=roles,
             department=department,
             address=address,
-            zip=zip,
+            zipcode=zipcode,
             city=city,
             phone=phone,
             fax=fax,

odxtools/templates/macros/printCompanyData.xml.jinja2

@@ -35,8 +35,8 @@
    {%- if team_member.address is not none %}
    <ADDRESS>{{team_member.address|e}}</ADDRESS>
    {%- endif %}
-   {%- if team_member.zip is not none %}
-   <ZIP>{{team_member.zip|e}}</ZIP>
+   {%- if team_member.zipcode is not none %}
+   <ZIP>{{team_member.zipcode|e}}</ZIP>
    {%- endif %}
    {%- if team_member.city is not none %}
    <CITY>{{team_member.city|e}}</CITY>

odxtools/templates/macros/printComparam.xml.jinja2

@@ -44,9 +44,7 @@
          {{make_xml_attrib("DISPLAY-LEVEL", cp.display_level)}}{#- #}
           CPUSAGE="{{cp.cpusage.value}}">
   {{ peid.printElementIdSubtags(cp)|indent(1) }}
-  {%- if cp.physical_default_value is not none %}
-  <PHYSICAL-DEFAULT-VALUE>{{cp.physical_default_value | e}}</PHYSICAL-DEFAULT-VALUE>
-  {%- endif %}
+  <PHYSICAL-DEFAULT-VALUE>{{cp.physical_default_value_raw}}</PHYSICAL-DEFAULT-VALUE>
  <DATA-OBJECT-PROP-REF ID-REF="{{cp.dop_ref.ref_id}}" />
 </COMPARAM>
 {%- endmacro %}
@@ -55,9 +53,9 @@
 <COMPLEX-COMPARAM {{-peid.printElementIdAttribs(cp)}}
                   PARAM-CLASS="{{cp.param_class}}"
                   CPTYPE="{{cp.cptype.value}}"
-                 {{make_xml_attrib("DISPLAY-LEVEL", cp.display_level)}}{#- #}
+                  {{make_xml_attrib("DISPLAY-LEVEL", cp.display_level)}}{#- #}
                   CPUSAGE="{{cp.cpusage.value}}"
-                 {{make_bool_xml_attrib("ALLOW-MULTIPLE-VALUES", cp.allow_multiple_values_raw)}}
+                  {{make_bool_xml_attrib("ALLOW-MULTIPLE-VALUES", cp.allow_multiple_values_raw)}}
                   {#- #}>
  {{ peid.printElementIdSubtags(cp)|indent(1) }}
  {%- for sub_cp in cp.subparams %}

odxtools/templates/macros/printDOP.xml.jinja2

@@ -17,6 +17,9 @@
                  {%- if dct.termination is defined %}
                  {{-make_xml_attrib("TERMINATION", dct.termination.value)}}
                  {%- endif %}
+                 {%- if dct.is_condensed_raw is defined %}
+                 {{-make_bool_xml_attrib("CONDENSED", dct.is_condensed_raw)}}
+                 {%- endif %}
                  {#- #} xsi:type="{{dct.dct_type}}">
  {%- if dct.dct_type in ("STANDARD-LENGTH-TYPE", "LEADING-LENGTH-INFO-TYPE") %}
  <BIT-LENGTH>{{dct.bit_length}}</BIT-LENGTH>
@@ -136,7 +139,7 @@
   {%- if dtc.display_trouble_code is not none   %}
    <DISPLAY-TROUBLE-CODE>{{dtc.display_trouble_code}}</DISPLAY-TROUBLE-CODE>
   {%- endif %}
-   <TEXT>{{dtc.text|e}}</TEXT>
+   <TEXT {{- make_xml_attrib("TI", dtc.text.text_identifier) }}>{{dtc.text|e}}</TEXT>
   {%- if not dtc.level is none   %}
    <LEVEL>{{dtc.level}}</LEVEL>
   {%- endif %}

odxtools/templates/macros/printDiagComm.xml.jinja2

@@ -7,6 +7,8 @@
 {%- import('macros/printAdminData.xml.jinja2') as pad %}
 {%- import('macros/printAudience.xml.jinja2') as paud %}
 {%- import('macros/printSpecialData.xml.jinja2') as psd %}
+{%- import('macros/printPreConditionStateRef.xml.jinja2') as ppcsr %}
+{%- import('macros/printStateTransitionRef.xml.jinja2') as pstr %}
 
 {%- macro printDiagCommAttribs(dc) -%}
 {{-peid.printElementIdAttribs(dc)}}
@@ -17,7 +19,6 @@
 {{-make_bool_xml_attrib("IS-FINAL", dc.is_final_raw)}}
 {%- endmacro -%}
 
-
 {%- macro printDiagCommSubtags(dc) -%}
  {{ peid.printElementIdSubtags(dc)|indent(1) }}
  {%- if dc.admin_data %}
@@ -53,15 +54,15 @@
  {%- if dc.pre_condition_state_refs %}
  <PRE-CONDITION-STATE-REFS>
   {%- for ps_ref in dc.pre_condition_state_refs %}
-  <PRE-CONDITION-STATE-REF ID-REF="{{ps_ref.ref_id}}" />
+  {{ ppcsr.printPreConditionStateRef(ps_ref)|indent(2) }}
   {%- endfor %}
  </PRE-CONDITION-STATE-REFS>
  {%- endif%}
  {%- if dc.state_transition_refs %}
  <STATE-TRANSITION-REFS>
-   {%- for st_ref in dc.state_transition_refs %}
-   <STATE-TRANSITION-REF ID-REF="{{st_ref.ref_id}}" />
-   {%- endfor %}
+  {%- for st_ref in dc.state_transition_refs %}
+  {{ pstr.printStateTransitionRef(st_ref)|indent(2) }}
+  {%- endfor %}
  </STATE-TRANSITION-REFS>
  {%- endif%}
 {%- endmacro -%}

odxtools/templates/macros/printParam.xml.jinja2

@@ -33,12 +33,12 @@
 {%- if param.byte_length is defined and param.byte_length is not none %}
  <BYTE-LENGTH>{{param.byte_length}}</BYTE-LENGTH>
 {%- endif %}
-{%- if param.coded_value is defined %}
- <CODED-VALUE>{{param.coded_value}}</CODED-VALUE>
-{%- elif param.coded_values is defined %}
+{%- if param.coded_value_raw is defined %}
+ <CODED-VALUE>{{param.coded_value_raw}}</CODED-VALUE>
+{%- elif param.coded_values_raw is defined %}
  <CODED-VALUES>
- {%- for coded_value in param.coded_values %}
-  <CODED-VALUE>{{coded_value}}</CODED-VALUE>
+ {%- for coded_value_raw in param.coded_values_raw %}
+  <CODED-VALUE>{{coded_value_raw}}</CODED-VALUE>
  {%- endfor %}
  </CODED-VALUES>
 {%- endif %}

odxtools/templates/macros/printPreConditionStateRef.xml.jinja2

@@ -0,0 +1,18 @@
+{#- -*- mode: sgml; tab-width: 1; indent-tabs-mode: nil -*-
+ #
+ # SPDX-License-Identifier: MIT
+-#}
+
+{%- macro printPreConditionStateRef(ps_ref) -%}
+<PRE-CONDITION-STATE-REF ID-REF="{{ps_ref.ref_id}}">
+  {%- if ps_ref.value is not none %}
+  <VALUE>{{ ps_ref.value }}</VALUE>
+  {%- endif %}
+  {%- if ps_ref.in_param_if_snref is not none %}
+  <IN-PARAM-IF-SNREF SHORT-NAME="{{ ps_ref.in_param_if_snref }}" />
+  {%- endif %}
+  {%- if ps_ref.in_param_if_snpathref is not none %}
+  <IN-PARAM-IF-SNPATHREF SHORT-NAME-PATH="{{ ps_ref.in_param_if_snpathref }}" />
+  {%- endif %}
+</PRE-CONDITION-STATE-REF>
+{%- endmacro -%}

odxtools/templates/macros/printStateTransitionRef.xml.jinja2

@@ -0,0 +1,18 @@
+{#- -*- mode: sgml; tab-width: 1; indent-tabs-mode: nil -*-
+ #
+ # SPDX-License-Identifier: MIT
+-#}
+
+{%- macro printStateTransitionRef(st_ref) -%}
+<STATE-TRANSITION-REF ID-REF="{{st_ref.ref_id}}">
+  {%- if st_ref.value is not none %}
+  <VALUE>{{ st_ref.value }}</VALUE>
+  {%- endif %}
+  {%- if st_ref.in_param_if_snref is not none %}
+  <IN-PARAM-IF-SNREF SHORT-NAME="{{ st_ref.in_param_if_snref }}" />
+  {%- endif %}
+  {%- if st_ref.in_param_if_snpathref is not none %}
+  <IN-PARAM-IF-SNPATHREF SHORT-NAME-PATH="{{ st_ref.in_param_if_snpathref }}" />
+  {%- endif %}
+</STATE-TRANSITION-REF>
+{%- endmacro -%}

odxtools/templates/macros/printTable.xml.jinja2

@@ -8,6 +8,8 @@
 {%- import('macros/printDescription.xml.jinja2') as pd %}
 {%- import('macros/printAdminData.xml.jinja2') as pad %}
 {%- import('macros/printAudience.xml.jinja2') as paud %}
+{%- import('macros/printPreConditionStateRef.xml.jinja2') as ppcsr %}
+{%- import('macros/printStateTransitionRef.xml.jinja2') as pstr %}
 
 {%- macro printTable(table) %}
 <TABLE {{-peid.printElementIdAttribs(table)}}
@@ -20,18 +22,20 @@
  {%- if hasattr(table_row, "key") %}
  <TABLE-ROW {{-peid.printElementIdAttribs(table_row)}}
             {{-make_xml_attrib("SEMANTIC", table_row.semantic)}}>
-  <SHORT-NAME>{{table_row.short_name}}</SHORT-NAME>
-  {%- if table_row.long_name %}
-  <LONG-NAME>{{table_row.long_name|e}}</LONG-NAME>
-  {%- endif %}
-  {{ pd.printDescription(table_row.description) }}
+  {{-peid.printElementIdSubtags(table_row)}}
   <KEY>{{table_row.key|e}}</KEY>
-  {%- if table_row.dop_ref %}
+  {%- if table_row.dop_ref is not none %}
   <DATA-OBJECT-PROP-REF ID-REF="{{ table_row.dop_ref.ref_id }}" />
   {%- endif %}
-  {%- if table_row.structure_ref %}
+  {%- if table_row.dop_snref is not none %}
+  <DATA-OBJECT-PROP-SNREF SHORT-NAME="{{ table_row.dop_snref }}" />
+  {%- endif %}
+  {%- if table_row.structure_ref is not none %}
   <STRUCTURE-REF ID-REF="{{ table_row.structure_ref.ref_id }}" />
   {%- endif %}
+  {%- if table_row.structure_snref is not none %}
+  <STRUCTURE-SNREF SHORT-NAME="{{ table_row.structure_snref }}" />
+  {%- endif %}
   {{- psd.printSpecialDataGroups(table_row.sdgs)|indent(2, first=True) }}
   {%- if table_row.audience is not none %}
   {{ paud.printAudience(table_row.audience) | indent(2) }}
@@ -46,14 +50,14 @@
   {%- if table_row.state_transition_refs %}
   <STATE-TRANSITION-REFS>
     {%- for st_ref in table_row.state_transition_refs %}
-    <STATE-TRANSITION-REF ID-REF="{{ st_ref.ref_id }}" />
+    {{ pstr.printStateTransitionRef(st_ref)|indent(4) }}
     {%- endfor %}
   </STATE-TRANSITION-REFS>
   {%- endif %}
   {%- if table_row.pre_condition_state_refs %}
   <PRE-CONDITION-STATE-REFS>
     {%- for pcs_ref in table_row.pre_condition_state_refs %}
-    <PRE-CONDITION-STATE-REF ID-REF="{{ pcs_ref.ref_id }}" />
+    {{ ppcsr.printPreConditionStateRef(ps_ref)|indent(4) }}
     {%- endfor %}
   </PRE-CONDITION-STATE-REFS>
   {%- endif %}

odxtools/text.py

@@ -0,0 +1,35 @@
+from dataclasses import dataclass
+from typing import List, Optional
+from xml.etree import ElementTree
+
+from .odxlink import OdxDocFragment
+
+
+@dataclass
+class Text:
+    text: str
+    text_identifier: Optional[str]
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Text":
+        # Extract the contents of the tag as a string.
+        raw_string = et_element.text or ""
+        for e in et_element:
+            raw_string += ElementTree.tostring(e, encoding="unicode")
+
+        # remove white spaces at the beginning and at the end of all
+        # extracted lines
+        stripped_lines = [x.strip() for x in raw_string.split("\n")]
+
+        text = "\n".join(stripped_lines).strip()
+
+        text_identifier = et_element.get("TI")
+
+        return Text(text=text, text_identifier=text_identifier)
+
+    @staticmethod
+    def from_string(text: str) -> "Text":
+        return Text(text=text, text_identifier=None)
+
+    def __str__(self) -> str:
+        return self.text

odxtools/unit.py

@@ -61,9 +61,6 @@ class Unit(IdentifiableElement):
     def physical_dimension(self) -> Optional[PhysicalDimension]:
         return self._physical_dimension
 
-    def __post_init__(self) -> None:
-        self._physical_dimension: Optional[PhysicalDimension] = None
-
     @staticmethod
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Unit":
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
@@ -92,6 +89,7 @@ class Unit(IdentifiableElement):
         return {self.odx_id: self}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        self._physical_dimension: Optional[PhysicalDimension] = None
         if self.physical_dimension_ref:
             self._physical_dimension = odxlinks.resolve(self.physical_dimension_ref,
                                                         PhysicalDimension)

odxtools/unitgroup.py

@@ -28,13 +28,14 @@ class UnitGroup(NamedElement):
     unit_refs: List[OdxLinkRef]
     oid: Optional[str]
 
-    def __post_init__(self) -> None:
-        self._units = NamedItemList[Unit]()
+    @property
+    def units(self) -> NamedItemList[Unit]:
+        return self._units
 
     @staticmethod
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "UnitGroup":
-        oid = et_element.get("OID")
         kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
+
         category_str = odxrequire(et_element.findtext("CATEGORY"))
         try:
             category = UnitGroupCategory(category_str)
@@ -42,10 +43,11 @@ class UnitGroup(NamedElement):
             category = cast(UnitGroupCategory, None)
             odxraise(f"Encountered unknown unit group category '{category_str}'")
 
-        unit_refs: List[OdxLinkRef] = [
+        unit_refs = [
             odxrequire(OdxLinkRef.from_et(el, doc_frags))
             for el in et_element.iterfind("UNIT-REFS/UNIT-REF")
         ]
+        oid = et_element.get("OID")
 
         return UnitGroup(category=category, unit_refs=unit_refs, oid=oid, **kwargs)
 
@@ -57,7 +59,3 @@ class UnitGroup(NamedElement):
 
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass
-
-    @property
-    def units(self) -> NamedItemList[Unit]:
-        return self._units

odxtools/utils.py

@@ -3,15 +3,11 @@ 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/version.py

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

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: odxtools
-Version: 9.5.0
+Version: 9.6.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>
@@ -43,6 +43,7 @@ Provides-Extra: examples
 Requires-Dist: can-isotp>=1.9; extra == "examples"
 Provides-Extra: all
 Requires-Dist: odxtools[browse-tool,examples,test]; extra == "all"
+Dynamic: license-file
 
 <!-- SPDX-License-Identifier: MIT -->
 [![PyPi - Version](https://img.shields.io/pypi/v/odxtools)](https://pypi.org/project/odxtools)