odxtools 6.4.2__py3-none-any.whl → 6.5.0__py3-none-any.whl

odxtools/scaleconstr.py

@@ -0,0 +1,50 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from enum import Enum
+from typing import Optional
+from xml.etree import ElementTree
+
+from .compumethods.limit import Limit
+from .exceptions import odxraise, odxrequire
+from .odxtypes import DataType
+from .utils import create_description_from_et
+
+
+class ValidType(Enum):
+    VALID = "VALID"
+    NOT_VALID = "NOT-VALID"
+    NOT_DEFINED = "NOT-DEFINED"
+    NOT_AVAILABLE = "NOT-AVAILABLE"
+
+
+@dataclass
+class ScaleConstr:
+    """This class represents a SCALE-CONSTR.
+    """
+
+    short_label: Optional[str]
+    description: Optional[str]
+    lower_limit: Optional[Limit]
+    upper_limit: Optional[Limit]
+    validity: ValidType
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, internal_type: DataType) -> "ScaleConstr":
+        short_label = et_element.findtext("SHORT-LABEL")
+        description = create_description_from_et(et_element.find("DESC"))
+
+        lower_limit = Limit.from_et(et_element.find("LOWER-LIMIT"), internal_type=internal_type)
+        upper_limit = Limit.from_et(et_element.find("UPPER-LIMIT"), internal_type=internal_type)
+
+        validity_str = odxrequire(et_element.get("VALIDITY"))
+        try:
+            validity = ValidType(validity_str)
+        except ValueError:
+            odxraise(f"Encountered unknown Validity '{validity_str}'")
+
+        return ScaleConstr(
+            short_label=short_label,
+            description=description,
+            lower_limit=lower_limit,
+            upper_limit=upper_limit,
+            validity=validity)

odxtools/standardlengthtype.py

@@ -48,7 +48,7 @@ class StandardLengthType(DiagCodedType):
 
     def convert_internal_to_bytes(self, internal_value: AtomicOdxType, encode_state: EncodeState,
                                   bit_position: int) -> bytes:
-        return self._to_bytes(
+        return self._encode_internal_value(
             self.__apply_mask(internal_value),
             bit_position,
             self.bit_length,
@@ -59,7 +59,7 @@ class StandardLengthType(DiagCodedType):
     def convert_bytes_to_internal(self,
                                   decode_state: DecodeState,
                                   bit_position: int = 0) -> Tuple[AtomicOdxType, int]:
-        internal_value, cursor_position = self._extract_internal(
+        internal_value, cursor_position = self._extract_internal_value(
             decode_state.coded_message,
             decode_state.cursor_position,
             bit_position,

odxtools/templates/macros/printDOP.xml.jinja2

@@ -34,7 +34,7 @@
 {%- 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}}" />
-{%- elif physical_type.precision is not none   %}
+{%- elif physical_type.precision is not none %}
 <PHYSICAL-TYPE BASE-DATA-TYPE="{{physical_type.base_data_type.value}}">
  <PRECISION>{{physical_type.precision}}</PRECISION>
 </PHYSICAL-TYPE>
@@ -44,11 +44,52 @@
 {%- endmacro -%}
 
 {%- macro printLimitValue(lv) -%}
-{%- if hasattr(lv, 'hex') %}
+{%- if hasattr(lv, 'hex') -%}
 {#- bytes or bytarray limit #}
 {{lv.hex()}}
-{%- else %}
+{%- else -%}
 {{lv}}
+{%- endif -%}
+{%- endmacro -%}
+
+{%- macro printScaleConstr(sc) %}
+<SCALE-CONSTR VALIDITY="{{sc.validity.value}}">
+  {%- if sc.short_label and sc.short_label.strip() %}
+  <SHORT-LABEL>{{sc.short_label|e}}</SHORT-LABEL>
+  {%- endif %}
+  {%- if sc.description and sc.description.strip() %}
+  <DESC>
+    {{sc.description}}
+  </DESC>
+  {%- endif %}
+  <LOWER-LIMIT>{{printLimitValue(sc.lower_limit.value)}}</LOWER-LIMIT>
+  <UPPER-LIMIT>{{printLimitValue(sc.upper_limit.value)}}</UPPER-LIMIT>
+</SCALE-CONSTR>
+{%- endmacro -%}
+
+{%- macro printInternalConstr(ic, is_physical) %}
+{%- if is_physical %}
+<PHYS-CONSTR>
+{%- else %}
+<INTERNAL-CONSTR>
+{%- endif %}
+  {%- if ic.lower_limit %}
+  <LOWER-LIMIT>{{printLimitValue(ic.lower_limit.value)}}</LOWER-LIMIT>
+  {%- endif %}
+  {%- if ic.upper_limit %}
+  <UPPER-LIMIT>{{printLimitValue(ic.upper_limit.value)}}</UPPER-LIMIT>
+  {%- endif %}
+  {%- if ic.scale_constrs %}
+  <SCALE-CONSTRS>
+  {%- for sc in ic.scale_constrs %}
+    {{- printScaleConstr(sc)|indent(4)}}
+  {%- endfor %}
+  </SCALE-CONSTRS>
+  {%- endif %}
+{%- if is_physical %}
+</PHYS-CONSTR>
+{%- else %}
+</INTERNAL-CONSTR>
 {%- endif %}
 {%- endmacro -%}
 
@@ -69,10 +110,10 @@
     </DESC>
    {%- endif %}
    {%- if cs.lower_limit is not none %}
-    <LOWER-LIMIT>{{printLimitValue(cs.lower_limit.value)}}</LOWER-LIMIT>
+     <LOWER-LIMIT>{{printLimitValue(cs.lower_limit.value)}}</LOWER-LIMIT>
    {%- endif %}
    {%- if cs.upper_limit is not none %}
-    <UPPER-LIMIT>{{printLimitValue(cs.upper_limit.value)}}</UPPER-LIMIT>
+     <UPPER-LIMIT>{{printLimitValue(cs.upper_limit.value)}}</UPPER-LIMIT>
    {%- endif %}
    {%- if cs.compu_inverse_value is not none %}
     <COMPU-INVERSE-VALUE>
@@ -191,9 +232,15 @@
  {{- printCompuMethod(dop.compu_method)|indent(1) }}
  {{- printDiagCodedType(dop.diag_coded_type)|indent(1) }}
  {{- printPhysicalType(dop.physical_type)|indent(1) }}
+ {%- if dop.internal_constr %}
+ {{- printInternalConstr(dop.internal_constr, False)|indent(1) }}
+ {%- endif %}
  {%- if dop.unit_ref %}
  <UNIT-REF ID-REF="{{ dop.unit_ref.ref_id }}" />
  {%- endif %}
+ {%- if dop.physical_constr %}
+ {{- printInternalConstr(dop.internal_constr, True)|indent(1) }}
+ {%- endif %}
 </DATA-OBJECT-PROP>
 {%- endmacro %}
 

odxtools/version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '6.4.2'
-__version_tuple__ = version_tuple = (6, 4, 2)
+__version__ = version = '6.5.0'
+__version_tuple__ = version_tuple = (6, 5, 0)