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

odxtools/templates/macros/printCompuMethod.xml.jinja2

@@ -0,0 +1,153 @@
+{#- -*- mode: sgml; tab-width: 1; indent-tabs-mode: nil -*-
+ #
+ # SPDX-License-Identifier: MIT
+-#}
+
+{%- import('macros/printElementId.xml.jinja2') as peid %}
+{%- import('macros/printAdminData.xml.jinja2') as pad %}
+{%- import('macros/printSpecialData.xml.jinja2') as psd %}
+{%- import('macros/printDescription.xml.jinja2') as pd %}
+
+
+{%- macro printLimit(tag_name, limit_obj) -%}
+{%- if limit_obj is not none %}
+<{{tag_name}}
+{%- if limit_obj.interval_type is not none %}
+  {{- make_xml_attrib("INTERVAL-TYPE", limit_obj.interval_type.value) }}
+  {%- endif %}
+{%- if limit_obj.value_raw is none %}
+  {#- #}/>
+{%- else %}
+  {#- #}>
+  {%- if hasattr(limit_obj._value, 'hex') -%}
+  {#- bytes or bytarray limit #}
+  {{- limit_obj._value.hex().upper() }}
+  {%- else -%}
+  {{- limit_obj._value }}
+  {%- endif -%}
+</{{tag_name}}>
+{%- endif -%}
+{%- endif -%}
+{%- endmacro -%}
+
+{%- macro printCompuInverseValue(civ) -%}
+<COMPU-INVERSE-VALUE>
+  {%- if civ.v is not none %}
+  <V>{{civ.v}}</V>
+  {%- endif %}
+  {%- if civ.vt is not none %}
+  <VT>{{civ.vt | e}}</VT>
+  {%- endif %}
+</COMPU-INVERSE-VALUE>
+{%- endmacro -%}
+
+{%- macro printCompuDefaultValue(cdv) -%}
+<COMPU-DEFAULT-VALUE>
+  {%- if cdv.v is not none %}
+  <V>{{cdv.v}}</V>
+  {%- endif %}
+  {%- if cdv.vt is not none %}
+  <VT>{{cdv.vt | e}}</VT>
+  {%- endif %}
+  {%- if cdv.compu_inverse_value is not none %}
+  {{printCompuInverseValue(cdv.compu_inverse_value)}}
+  {%- endif %}
+</COMPU-DEFAULT-VALUE>
+{%- endmacro -%}
+
+{%- macro printCompuScale(cs) -%}
+<COMPU-SCALE>
+  {%- if cs.short_label is not none %}
+  <SHORT-LABEL>{{cs.short_label|e}}</SHORT-LABEL>
+  {%- endif %}
+  {{- pd.printDescription(cs.description)|indent(2, first=True) }}
+  {{- printLimit("LOWER-LIMIT", cs.lower_limit)|indent(2, first=True) }}
+  {{- printLimit("UPPER-LIMIT", cs.upper_limit)|indent(2, first=True) }}
+  {%- if cs.compu_inverse_value is not none %}
+  {{printCompuInverseValue(cs.compu_inverse_value)}}
+  {%- endif %}
+  {%- if cs.compu_const is not none %}
+  <COMPU-CONST>
+    {%- if cs.compu_const.v is not none %}
+    <V>{{cs.compu_const.v}}</V>
+    {%- endif %}
+    {%- if cs.compu_const.vt is not none %}
+    <VT>{{cs.compu_const.vt | e}}</VT>
+    {%- endif %}
+  </COMPU-CONST>
+  {%- endif %}
+  {%- set crc = cs.compu_rational_coeffs %}
+  {%- if crc is not none %}
+  <COMPU-RATIONAL-COEFFS>
+    <COMPU-NUMERATOR>
+      {%- for v in crc.numerators %}
+      <V>{{v}}</V>
+      {%- endfor %}
+    </COMPU-NUMERATOR>
+    {%- if crc.denominators %}
+    <COMPU-DENOMINATOR>
+      {%- for v in crc.denominators %}
+      <V>{{v}}</V>
+      {%- endfor %}
+    </COMPU-DENOMINATOR>
+    {%- endif %}
+  </COMPU-RATIONAL-COEFFS>
+  {%- endif %}
+</COMPU-SCALE>
+{%- endmacro -%}
+
+{%- macro printProgCode(pc) -%}
+<PROG-CODE>
+  <CODE-FILE>{{pc.code_file}}</CODE-FILE>
+  <SYNTAX>{{pc.syntax}}</SYNTAX>
+  {%- if pc.encryption is not none %}
+  <ENCRYPTION>{{pc.encryption}}</ENCRYPTION>
+  {%- endif %}
+  {%- if pc.entry_point is not none %}
+  <ENTRY-POINT>{{pc.entry_point}}</ENTRY-POINT>
+  {%- endif %}
+  {%- if pc.library_refs %}
+  <LIBRARY-REFS>
+    {%- for libref in pc.library_refs %}
+    <LIBRARY-REF ID-REF="{{libref.ref_id}}" />
+    {%- endfor %}
+  </LIBRARY-REFS>
+  {%- endif %}
+</PROG-CODE>
+{%- endmacro -%}
+
+{%- macro printCompuMethod(cm) -%}
+<COMPU-METHOD>
+ <CATEGORY>{{cm.category.value}}</CATEGORY>
+ {%- if cm.compu_internal_to_phys is not none %}
+ <COMPU-INTERNAL-TO-PHYS>
+  <COMPU-SCALES>
+    {%- for cs in cm.compu_internal_to_phys.compu_scales %}
+    {{ printCompuScale(cs) | indent(3) }}
+    {%- endfor %}
+  </COMPU-SCALES>
+  {%- if cm.compu_internal_to_phys.prog_code is not none %}
+  {{ printProgCode(cm.compu_internal_to_phys.prog_code) | indent(3) }}
+  {%- endif %}
+  {%- if cm.compu_internal_to_phys.compu_default_value is not none %}
+  {{ printCompuDefaultValue(cm.compu_internal_to_phys.compu_default_value) | indent(3) }}
+  {%- endif %}
+ </COMPU-INTERNAL-TO-PHYS>
+ {%- endif %}
+ {%- if cm.compu_phys_to_internal is not none %}
+ <COMPU-PHYS-TO-INTERNAL>
+  <COMPU-SCALES>
+    {%- for cs in cm.compu_phys_to_internal.compu_scales %}
+    {{ printCompuScale(cs) | indent(3) }}
+    {%- endfor %}
+  </COMPU-SCALES>
+  {%- if cm.compu_phys_to_internal.prog_code is not none %}
+  {{ printProgCode(cm.compu_phys_to_internal.prog_code) | indent(3) }}
+  {%- endif %}
+  {%- if cm.compu_phys_to_internal.compu_default_value is not none %}
+  {{ printCompuDefaultValue(cm.compu_phys_to_internal.compu_default_value) | indent(3) }}
+  {%- endif %}
+ </COMPU-PHYS-TO-INTERNAL>
+ {%- endif %}
+</COMPU-METHOD>
+{%- endmacro -%}

odxtools/templates/macros/printDOP.xml.jinja2

@@ -6,6 +6,9 @@
 {%- import('macros/printElementId.xml.jinja2') as peid %}
 {%- import('macros/printAdminData.xml.jinja2') as pad %}
 {%- import('macros/printSpecialData.xml.jinja2') as psd %}
+{%- import('macros/printCompuMethod.xml.jinja2') as pcm %}
+{%- import('macros/printDescription.xml.jinja2') as pd %}
+
 
 {%- macro printDiagCodedType(dct) -%}
 <DIAG-CODED-TYPE {{-make_xml_attrib("BASE-DATA-TYPE", dct.base_data_type.value)}}
@@ -30,7 +33,6 @@
 </DIAG-CODED-TYPE>
 {%- endmacro -%}
 
-
 {%- macro printPhysicalType(physical_type) %}
 {%- if physical_type.display_radix is not none %}
 <PHYSICAL-TYPE BASE-DATA-TYPE="{{physical_type.base_data_type.value}}" DISPLAY-RADIX="{{physical_type.display_radix.name}}" />
@@ -43,39 +45,14 @@
 {%- endif %}
 {%- endmacro -%}
 
-{%- macro printLimit(tag_name, limit_obj) -%}
-{%- if limit_obj is not none %}
-<{{tag_name}}
-{%- if limit_obj.interval_type is not none %}
-  {{- make_xml_attrib("INTERVAL-TYPE", limit_obj.interval_type.value) }}
-  {%- endif %}
-{%- if limit_obj.value_raw is none %}
-  {#- #}/>
-{%- else %}
-  {#- #}>
-  {%- if hasattr(limit_obj._value, 'hex') -%}
-  {#- bytes or bytarray limit #}
-  {{- limit_obj._value.hex().upper() }}
-  {%- else -%}
-  {{- limit_obj._value }}
-  {%- endif -%}
-</{{tag_name}}>
-{%- endif -%}
-{%- endif -%}
-{%- endmacro -%}
-
 {%- macro printScaleConstr(sc) %}
 <SCALE-CONSTR VALIDITY="{{sc.validity.value}}">
   {%- if sc.short_label is not none %}
   <SHORT-LABEL>{{sc.short_label|e}}</SHORT-LABEL>
   {%- endif %}
-  {%- if sc.description and sc.description.strip() %}
-  <DESC>
-    {{sc.description}}
-  </DESC>
-  {%- endif %}
-  {{printLimit("LOWER-LIMIT", sc.lower_limit) }}
-  {{printLimit("UPPER-LIMIT", sc.upper_limit) }}
+  {{pd.printDescription(sc.description)}}
+  {{pcm.printLimit("LOWER-LIMIT", sc.lower_limit) }}
+  {{pcm.printLimit("UPPER-LIMIT", sc.upper_limit) }}
 </SCALE-CONSTR>
 {%- endmacro -%}
 
@@ -85,8 +62,8 @@
 {%- else %}
 <INTERNAL-CONSTR>
 {%- endif %}
-  {{printLimit("LOWER-LIMIT", ic.lower_limit) }}
-  {{printLimit("UPPER-LIMIT", ic.upper_limit) }}
+  {{pcm.printLimit("LOWER-LIMIT", ic.lower_limit) }}
+  {{pcm.printLimit("UPPER-LIMIT", ic.upper_limit) }}
   {%- if ic.scale_constrs %}
   <SCALE-CONSTRS>
   {%- for sc in ic.scale_constrs %}
@@ -101,105 +78,6 @@
 {%- endif %}
 {%- endmacro -%}
 
-{%- macro printCompuMethod(cm) -%}
-<COMPU-METHOD>
- <CATEGORY>{{cm.category}}</CATEGORY>
- {%- if cm.category == "TEXTTABLE" %}
- <COMPU-INTERNAL-TO-PHYS>
-  <COMPU-SCALES>
-  {%- for cs in cm.internal_to_phys %}
-   <COMPU-SCALE>
-   {%- if cs.short_label and cs.short_label.strip() %}
-    <SHORT-LABEL>{{cs.short_label|e}}</SHORT-LABEL>
-   {%- endif %}
-   {%- if cs.description and cs.description.strip() %}
-    <DESC>
-    {{cs.description}}
-    </DESC>
-   {%- endif %}
-   {{printLimit("LOWER-LIMIT", cs.lower_limit) }}
-   {{printLimit("UPPER-LIMIT", cs.upper_limit) }}
-   {%- if cs.compu_inverse_value is not none %}
-    <COMPU-INVERSE-VALUE>
-     <V>{{cs.compu_inverse_value}}</V>
-    </COMPU-INVERSE-VALUE>
-   {%- endif %}
-    <COMPU-CONST>
-     <VT>{{cs.compu_const | e}}</VT>
-    </COMPU-CONST>
-   </COMPU-SCALE>
-  {%- endfor %}
-  </COMPU-SCALES>
-  {%- if cm.compu_default_value is not none %}
-  <COMPU-DEFAULT-VALUE>
-    <VT>{{cm.compu_default_value.compu_const}}</VT>
-    {%- if cm.compu_default_value.compu_inverse_value is not none %}
-    <COMPU-INVERSE-VALUE>
-     <V>{{cm.compu_default_value.compu_inverse_value}}</V>
-    </COMPU-INVERSE-VALUE>
-    {%- endif %}
-  </COMPU-DEFAULT-VALUE>
-  {%- endif %}
- </COMPU-INTERNAL-TO-PHYS>
- {%- elif cm.category == "LINEAR" %}
- <COMPU-INTERNAL-TO-PHYS>
-		<COMPU-SCALES>
-			<COMPU-SCALE>
-     {{printLimit("LOWER-LIMIT", cm.internal_lower_limit) }}
-     {{printLimit("UPPER-LIMIT", cm.internal_upper_limit) }}
-				<COMPU-RATIONAL-COEFFS>
-					<COMPU-NUMERATOR>
-						<V>{{cm.offset}}</V>
-						<V>{{cm.factor}}</V>
-					</COMPU-NUMERATOR>
-   {%- if cm.denominator != 1 %}
-					<COMPU-DENOMINATOR>
-							<V>{{cm.denominator}}</V>
-					</COMPU-DENOMINATOR>
-   {%- endif %}
-				</COMPU-RATIONAL-COEFFS>
-			</COMPU-SCALE>
-		</COMPU-SCALES>
-	</COMPU-INTERNAL-TO-PHYS>
- {%- elif cm.category == "SCALE-LINEAR" %}
- <COMPU-INTERNAL-TO-PHYS>
-		<COMPU-SCALES>
-  {%- for lm in cm.linear_methods %}
- 		<COMPU-SCALE>
-    {{printLimit("LOWER-LIMIT", lm.internal_lower_limit) }}
-    {{printLimit("UPPER-LIMIT", lm.internal_upper_limit) }}
-				<COMPU-RATIONAL-COEFFS>
-					<COMPU-NUMERATOR>
-							<V>{{lm.offset}}</V>
-							<V>{{lm.factor}}</V>
-					</COMPU-NUMERATOR>
-   {%- if lm.denominator != 1 %}
-					<COMPU-DENOMINATOR>
-							<V>{{lm.denominator}}</V>
-					</COMPU-DENOMINATOR>
-   {%- endif %}
-				</COMPU-RATIONAL-COEFFS>
-			</COMPU-SCALE>
-  {%- endfor %}
-		</COMPU-SCALES>
- </COMPU-INTERNAL-TO-PHYS>
- {%- elif cm.category == "TAB-INTP" %}
- <COMPU-INTERNAL-TO-PHYS>
-  <COMPU-SCALES>
-  {%- for idx in range( cm.internal_points | length ) %}
-  <COMPU-SCALE>
-    <LOWER-LIMIT>{{ cm.internal_points[idx] }}</LOWER-LIMIT>
-    <COMPU-CONST>
-     <V>{{ cm.physical_points[idx] }}</V>
-    </COMPU-CONST>
-   </COMPU-SCALE>
-  {%- endfor %}
-  </COMPU-SCALES>
- </COMPU-INTERNAL-TO-PHYS>
- {%- endif %}
-</COMPU-METHOD>
-{%- endmacro -%}
-
 {%- macro printDopBaseAttribs(dop) %}
 {{- make_xml_attrib("ID", dop.odx_id.local_id) }}
 {{- make_xml_attrib("OID", dop.oid) }}
@@ -225,7 +103,7 @@
 {%- macro printDataObjectProp(dop) %}
 <DATA-OBJECT-PROP {{- printDopBaseAttribs(dop) }}>
  {{- printDopBaseSubtags(dop) }}
- {{- printCompuMethod(dop.compu_method)|indent(1) }}
+ {{- pcm.printCompuMethod(dop.compu_method)|indent(1) }}
  {{- printDiagCodedType(dop.diag_coded_type)|indent(1) }}
  {{- printPhysicalType(dop.physical_type)|indent(1) }}
  {%- if dop.internal_constr %}
@@ -246,7 +124,7 @@
  {{- printDopBaseSubtags(dop)|indent(1) }}
  {{- printDiagCodedType(dop.diag_coded_type)|indent(1) }}
  {{- printPhysicalType(dop.physical_type)|indent(1) }}
- {{- printCompuMethod(dop.compu_method)|indent(1) }}
+ {{- pcm.printCompuMethod(dop.compu_method)|indent(1) }}
  <DTCS>
  {%- for dtc in dop.dtcs_raw %}
  {%- if hasattr(dtc, "ref_id") %}

odxtools/templates/macros/printDescription.xml.jinja2

@@ -0,0 +1,18 @@
+{#- -*- mode: sgml; tab-width: 1; sgml-basic-offset: 1; indent-tabs-mode: nil -*-
+ #
+ # SPDX-License-Identifier: MIT
+-#}
+
+{%- macro printDescription(desc) %}
+{%- if desc is not none %}
+<DESC {{make_xml_attrib("TI", desc.text_identifier)}}>{{desc.text}}
+{%- if desc.external_docs %}
+<EXTERNAL-DOCS>
+ {%- for ed in desc.external_docs %}
+ <EXTERNAL-DOC HREF="{{ed}}" />
+ {%- endfor %}
+</EXTERNAL-DOCS>
+{%- endif -%}
+</DESC>
+{%- endif %}
+{%- endmacro %}

odxtools/templates/macros/printElementId.xml.jinja2

@@ -3,12 +3,12 @@
  # SPDX-License-Identifier: MIT
 -#}
 
+{%- import('macros/printDescription.xml.jinja2') as pd %}
+
 {%- macro printElementIdSubtags(obj) -%}
 <SHORT-NAME>{{ obj.short_name }}</SHORT-NAME>
 {%- if obj.long_name %}
 <LONG-NAME>{{ obj.long_name|e }}</LONG-NAME>
 {%- endif %}
-{%- if obj.description %}
-<DESC>{{ obj.description }}</DESC>
-{%- endif %}
+{{- pd.printDescription(obj.description) }}
 {%- endmacro -%}

odxtools/templates/macros/printMux.xml.jinja2

@@ -4,6 +4,7 @@
 -#}
 
 {%- import('macros/printElementId.xml.jinja2') as peid %}
+{%- import('macros/printCompuMethod.xml.jinja2') as pcm %}
 {%- import('macros/printDOP.xml.jinja2') as pdop %}
 
 {%- macro printMux(mux) %}
@@ -41,8 +42,8 @@
       {%- if case.structure_snref is not none %}
       <STRUCTURE-SNREF SHORT_NAME="{{case.structure_snref}}"/>
       {%- endif %}
-      {{ pdop.printLimit("LOWER-LIMIT", case.lower_limit) }}
-      {{ pdop.printLimit("UPPER-LIMIT", case.upper_limit) }}
+      {{ pcm.printLimit("LOWER-LIMIT", case.lower_limit) }}
+      {{ pcm.printLimit("UPPER-LIMIT", case.upper_limit) }}
     </CASE>
     {%- endfor %}
   </CASES>

odxtools/templates/macros/printTable.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 printTable(table) %}
 <TABLE ID="{{table.odx_id.local_id}}"
@@ -21,9 +22,7 @@
   {%- if table_row.long_name %}
   <LONG-NAME>{{table_row.long_name|e}}</LONG-NAME>
   {%- endif %}
-  {%- if table_row.description %}
-  <DESC>{{table_row.description}}</DESC>
-  {%- endif %}
+  {{ pd.printDescription(table_row.description) }}
   <KEY>{{table_row.key|e}}</KEY>
   {%- if table_row.dop_ref %}
   <DATA-OBJECT-PROP-REF ID-REF="{{ table_row.dop_ref.ref_id }}" />

odxtools/unit.py

@@ -1,17 +1,15 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
 from .element import IdentifiableElement
 from .exceptions import odxassert, odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .physicaldimension import PhysicalDimension
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class Unit(IdentifiableElement):
@@ -104,5 +102,5 @@ class Unit(IdentifiableElement):
                 f"The physical_dimension_ref must be resolved to a PhysicalDimension."
                 f" {self.physical_dimension_ref} referenced {self._physical_dimension}")
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass

odxtools/unitgroup.py

@@ -1,19 +1,17 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
 from enum import Enum
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, cast
+from typing import Any, Dict, List, Optional, cast
 from xml.etree import ElementTree
 
 from .element import NamedElement
 from .exceptions import odxraise, odxrequire
 from .nameditemlist import NamedItemList
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .snrefcontext import SnRefContext
 from .unit import Unit
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 class UnitGroupCategory(Enum):
     COUNTRY = "COUNTRY"
@@ -57,7 +55,7 @@ class UnitGroup(NamedElement):
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         self._units = NamedItemList[Unit]([odxlinks.resolve(ref) for ref in self.unit_refs])
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass
 
     @property

odxtools/unitspec.py

@@ -1,19 +1,16 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Union
+from typing import Any, Dict, List, Union
 from xml.etree import ElementTree
 
-from .createsdgs import create_sdgs_from_et
 from .nameditemlist import NamedItemList
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from .physicaldimension import PhysicalDimension
+from .snrefcontext import SnRefContext
 from .specialdatagroup import SpecialDataGroup
 from .unit import Unit
 from .unitgroup import UnitGroup
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class UnitSpec:
@@ -49,7 +46,9 @@ class UnitSpec:
             PhysicalDimension.from_et(el, doc_frags)
             for el in et_element.iterfind("PHYSICAL-DIMENSIONS/PHYSICAL-DIMENSION")
         ]
-        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 UnitSpec(
             unit_groups=unit_groups,
@@ -76,10 +75,10 @@ class UnitSpec:
         for sdg in self.sdgs:
             sdg._resolve_odxlinks(odxlinks)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         for unit in self.units:
-            unit._resolve_snrefs(diag_layer)
+            unit._resolve_snrefs(context)
         for group in self.unit_groups:
-            group._resolve_snrefs(diag_layer)
+            group._resolve_snrefs(context)
         for sdg in self.sdgs:
-            sdg._resolve_snrefs(diag_layer)
+            sdg._resolve_snrefs(context)

odxtools/utils.py

@@ -1,32 +1,7 @@
 # SPDX-License-Identifier: MIT
 import dataclasses
 import re
-from typing import Any, Dict, Optional
-from xml.etree import ElementTree
-
-
-def create_description_from_et(et_element: Optional[ElementTree.Element],) -> Optional[str]:
-    """Read a description tag.
-
-    The description is located underneath the DESC tag of an an ODX
-    element."""
-
-    if et_element is None:
-        return None
-
-    if et_element.tag != "DESC":
-        raise TypeError(f"Attempted to extract an ODX description from a "
-                        f"'{et_element.tag}' XML node. (Must be a 'DESC' node!)")
-
-    # Extract the contents of the tag as a XHTML 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 lines
-    stripped_lines = [x.strip() for x in raw_string.split("\n")]
-
-    return "\n".join(stripped_lines).strip()
+from typing import Any, Dict
 
 
 def dataclass_fields_asdict(obj: Any) -> Dict[str, Any]:

odxtools/version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '7.1.0'
-__version_tuple__ = version_tuple = (7, 1, 0)
+__version__ = version = '7.2.0'
+__version_tuple__ = version_tuple = (7, 2, 0)

odxtools/{write_pdx_file.py → writepdxfile.py}

@@ -1,10 +1,11 @@
 # SPDX-License-Identifier: MIT
 import datetime
 import inspect
+import mimetypes
 import os
 import time
 import zipfile
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, Optional
 
 import jinja2
 
@@ -60,7 +61,6 @@ __templates_dir = os.path.sep.join([os.path.dirname(__module_filename), "templat
 def write_pdx_file(
     output_file_name: str,
     database: Database,
-    auxiliary_content_specifiers: Optional[List[Tuple[str, bytes]]] = None,
     templates_dir: str = __templates_dir,
 ) -> bool:
     """
@@ -68,9 +68,6 @@ def write_pdx_file(
     """
     global odxdatabase
 
-    if auxiliary_content_specifiers is None:
-        auxiliary_content_specifiers = []
-
     odxdatabase = database
 
     file_index = []
@@ -96,12 +93,18 @@ def write_pdx_file(
                     # are written based on the database)
                     continue
 
-                template_file_mime_type = "text/plain"
+                template_file_mime_type = None
                 if template_file_name.endswith(".odx-cs"):
                     template_file_mime_type = "application/x-asam.odx.odx-cs"
                 elif template_file_name.endswith(".odx-d"):
                     template_file_mime_type = "application/x-asam.odx.odx-d"
 
+                guessed_mime_type, guessed_encoding = mimetypes.guess_type(template_file_name)
+                if template_file_mime_type is None and guessed_mime_type is not None:
+                    template_file_mime_type = guessed_mime_type
+                else:
+                    template_file_mime_type = "application/octet-stream"
+
                 in_path = [root]
                 in_path.append(template_file_name)
                 in_file_name = os.path.sep.join(in_path)
@@ -115,20 +118,26 @@ def write_pdx_file(
                     out_file.write(open(in_file_name, "rb").read())
 
         # write the auxiliary files
-        for output_file_name, data in auxiliary_content_specifiers:
+        for output_file_name, data_file in database.auxiliary_files.items():
             file_cdate = datetime.datetime.fromtimestamp(time.time())
             creation_date = file_cdate.strftime("%Y-%m-%dT%H:%M:%S")
 
-            mime_type = "text/plain"
+            mime_type = None
             if output_file_name.endswith(".odx-cs"):
                 mime_type = "application/x-asam.odx.odx-cs"
             elif output_file_name.endswith(".odx-d"):
                 mime_type = "application/x-asam.odx.odx-d"
 
+            guessed_mime_type, guessed_encoding = mimetypes.guess_type(output_file_name)
+            if mime_type is None and guessed_mime_type is not None:
+                mime_type = guessed_mime_type
+            else:
+                mime_type = "application/octet-stream"
+
             zf_name = os.path.basename(output_file_name)
             with zf.open(zf_name, "w") as out_file:
                 file_index.append((zf_name, creation_date, mime_type))
-                out_file.write(data)
+                out_file.write(data_file.read())
 
         jinja_env = jinja2.Environment(loader=jinja2.FileSystemLoader(templates_dir))
         jinja_env.globals["hasattr"] = hasattr
@@ -187,7 +196,7 @@ def write_pdx_file(
 
         # write the index.xml file
         vars["file_index"] = file_index
-        index_tpl = jinja_env.get_template("index.xml.xml.jinja2")
+        index_tpl = jinja_env.get_template("index.xml.jinja2")
         text = index_tpl.render(**vars)
         zf.writestr("index.xml", text)
 

odxtools/xdoc.py

@@ -1,15 +1,13 @@
 # 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 NamedElement
 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 XDoc(NamedElement):
@@ -45,5 +43,5 @@ class XDoc(NamedElement):
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         pass
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass