Convert uncertainty field to string (#2096)

* Implemented float to string API function

* Converted Uncertainty field to StringField

* Converted methods to handle strings

* Added migration step

* Ensure we have a string result for interpolations

* Handle different exponential notation

* Set unfloatable uncertainty values to None

* Don't float default value

* added default return values

* Fix test

* Return empty string when field is not set

* Convert to float in formatting function

* Handle integer values

* Fixed wrong interpolator

* Always format manual uncertainty with full precision

* convert to float for comparison

* fixed test

* set uncertainty to None if on a detection limit

* Remove unsed import

* Added doctest

* Added another test

* Doctest description

* Added test for uncertainty value as percentage of the result

* Added test for floating point arithmetic

* Removed newlines

Author: ramonski

src/bika/lims/api/__init__.py

@@ -18,9 +18,15 @@
 # Copyright 2018-2021 by it's authors.
 # Some rights reserved, see README and LICENSE.
 
-import Missing
 import re
+from collections import OrderedDict
+from datetime import datetime
+from datetime import timedelta
+from itertools import groupby
+
 import six
+
+import Missing
 from AccessControl.PermissionRole import rolesForPermissionOn
 from Acquisition import aq_base
 from Acquisition import aq_inner
@@ -29,12 +35,8 @@
 from bika.lims.interfaces import IClient
 from bika.lims.interfaces import IContact
 from bika.lims.interfaces import ILabContact
-from collections import OrderedDict
-from datetime import datetime
 from DateTime import DateTime
-from datetime import timedelta
 from DateTime.interfaces import DateTimeError
-from itertools import groupby
 from plone import api as ploneapi
 from plone.api.exc import InvalidParameterError
 from plone.app.layout.viewlets.content import ContentHistoryView
@@ -1379,6 +1381,44 @@ def to_float(value, default=_marker):
     return float(value)
 
 
+def float_to_string(value, default=_marker):
+    """Convert a float value to string without exponential notation
+
+    This function preserves the whole fraction
+
+    :param value: The float value to be converted to a string
+    :type value: str, float, int
+    :returns: String representation of the float w/o exponential notation
+    :rtype: str
+    """
+    if not is_floatable(value):
+        if default is not _marker:
+            return default
+        fail("Value %s is not floatable" % repr(value))
+
+    # Leave floatable string values unchanged
+    if isinstance(value, six.string_types):
+        return value
+
+    value = float(value)
+    str_value = str(value)
+
+    if "." in str_value:
+        # might be something like 1.23e-26
+        front, back = str_value.split(".")
+    else:
+        # or 1e-07 for 0.0000001
+        back = str_value
+
+    if "e-" in back:
+        fraction, zeros = back.split("e-")
+        # we want to cover the faction and the zeros
+        precision = len(fraction) + int(zeros)
+        template = "{:.%df}" % precision
+        str_value = template.format(value)
+    return str_value
+
+
 def to_searchable_text_metadata(value):
     """Parse the given metadata value to searchable text
 

src/bika/lims/content/abstractanalysis.py

@@ -51,7 +51,6 @@
 from bika.lims.workflow import getTransitionDate
 from DateTime import DateTime
 from Products.Archetypes.Field import DateTimeField
-from Products.Archetypes.Field import FixedPointField
 from Products.Archetypes.Field import IntegerField
 from Products.Archetypes.Field import StringField
 from Products.Archetypes.references import HoldingReference
@@ -109,7 +108,7 @@
 
 # The actual uncertainty for this analysis' result, populated from the ranges
 # specified in the analysis service when the result is submitted.
-Uncertainty = FixedPointField(
+Uncertainty = StringField(
     'Uncertainty',
     read_permission=View,
     write_permission="Field: Edit Result",
@@ -240,56 +239,66 @@ def getDefaultUncertainty(self, result=None):
                 return None
 
             for d in uncertainties:
-                _min = float(d['intercept_min'])
-                _max = float(d['intercept_max'])
-                if _min <= res and res <= _max:
-                    if str(d['errorvalue']).strip().endswith('%'):
+
+                # convert to min/max
+                unc_min = api.to_float(d["intercept_min"], default=0)
+                unc_max = api.to_float(d["intercept_max"], default=0)
+
+                if unc_min <= res and res <= unc_max:
+                    _err = str(d["errorvalue"]).strip()
+                    if _err.endswith("%"):
                         try:
-                            percvalue = float(d['errorvalue'].replace('%', ''))
+                            percvalue = float(_err.replace("%", ""))
                         except ValueError:
                             return None
+                        # calculate uncertainty from result
                         uncertainty = res / 100 * percvalue
                     else:
-                        uncertainty = float(d['errorvalue'])
+                        uncertainty = api.to_float(_err, default=0)
 
-                    return uncertainty
+                    # convert back to string value
+                    return api.float_to_string(uncertainty, default=None)
         return None
 
     @security.public
     def getUncertainty(self, result=None):
         """Returns the uncertainty for this analysis and result.
+
         Returns the value from Schema's Uncertainty field if the Service has
-        the option 'Allow manual uncertainty'. Otherwise, do a callback to
-        getDefaultUncertainty(). Returns None if no result specified and the
-        current result for this analysis is below or above detections limits.
+        the option 'Allow manual uncertainty'.
+        Otherwise, do a callback to getDefaultUncertainty().
+
+        Returns empty string if no result specified and the current result for this
+        analysis is below or above detections limits.
         """
-        uncertainty = self.getField('Uncertainty').get(self)
-        if result is None and (self.isAboveUpperDetectionLimit() or
-                               self.isBelowLowerDetectionLimit()):
-            return None
+        uncertainty = self.getField("Uncertainty").get(self)
+        if result is None:
+            if self.isAboveUpperDetectionLimit():
+                return None
+            if self.isBelowLowerDetectionLimit():
+                return None
+
+        if uncertainty and self.getAllowManualUncertainty():
+            return api.float_to_string(uncertainty, default=None)
 
-        if uncertainty and self.getAllowManualUncertainty() is True:
-            try:
-                uncertainty = float(uncertainty)
-                return uncertainty
-            except (TypeError, ValueError):
-                # if uncertainty is not a number, return default value
-                pass
         return self.getDefaultUncertainty(result)
 
     @security.public
     def setUncertainty(self, unc):
-        """Sets the uncertainty for this analysis. If the result is a
-        Detection Limit or the value is below LDL or upper UDL, sets the
-        uncertainty value to 0
+        """Sets the uncertainty for this analysis
+
+        If the result is a Detection Limit or the value is below LDL or upper
+        UDL, set the uncertainty to None``
         """
         # Uncertainty calculation on DL
         # https://jira.bikalabs.com/browse/LIMS-1808
-        if self.isAboveUpperDetectionLimit() or \
-                self.isBelowLowerDetectionLimit():
-            self.getField('Uncertainty').set(self, None)
-        else:
-            self.getField('Uncertainty').set(self, unc)
+        if self.isAboveUpperDetectionLimit():
+            unc = None
+        if self.isBelowLowerDetectionLimit():
+            unc = None
+
+        field = self.getField("Uncertainty")
+        field.set(self, api.float_to_string(unc, default=None))
 
     @security.public
     def setDetectionLimitOperand(self, value):
@@ -972,10 +981,10 @@ def getPrecision(self, result=None):
         if allow_manual or precision_unc:
             uncertainty = self.getUncertainty(result)
             if uncertainty is None:
-                return self.getField('Precision').get(self)
-            if uncertainty == 0 and result is None:
-                return self.getField('Precision').get(self)
-            if uncertainty == 0:
+                return self.getField("Precision").get(self)
+            if api.to_float(uncertainty) == 0 and result is None:
+                return self.getField("Precision").get(self)
+            if api.to_float(uncertainty) == 0:
                 strres = str(result)
                 numdecimals = strres[::-1].find('.')
                 return numdecimals

src/bika/lims/content/abstractroutineanalysis.py

@@ -35,7 +35,7 @@
 from bika.lims.interfaces.analysis import IRequestAnalysis
 from bika.lims.workflow import getTransitionDate
 from Products.Archetypes.Field import BooleanField
-from Products.Archetypes.Field import FixedPointField
+from Products.Archetypes.Field import StringField
 from Products.Archetypes.Schema import Schema
 from Products.ATContentTypes.utils import DT2dt
 from Products.ATContentTypes.utils import dt2DT
@@ -47,7 +47,7 @@
 
 # The actual uncertainty for this analysis' result, populated when the result
 # is submitted.
-Uncertainty = FixedPointField(
+Uncertainty = StringField(
     'Uncertainty',
     read_permission=View,
     write_permission="Field: Edit Result",

src/bika/lims/utils/analysis.py

@@ -175,7 +175,7 @@ def _format_decimal_or_sci(result, precision, threshold, sciformat):
     if sci:
         # First, cut the extra decimals according to the precision
         prec = precision if precision and precision > 0 else 0
-        nresult = str("%%.%sf" % prec) % result
+        nresult = str("%%.%sf" % prec) % api.to_float(result, 0)
 
         if sign:
             # 0.0012345 -> 1.2345
@@ -208,7 +208,7 @@ def _format_decimal_or_sci(result, precision, threshold, sciformat):
     else:
         # Decimal notation
         prec = precision if precision and precision > 0 else 0
-        formatted = str("%%.%sf" % prec) % result
+        formatted = str("%%.%sf" % prec) % api.to_float(result, 0)
         if float(formatted) == 0 and '-' in formatted:
             # We don't want things like '-0.00'
             formatted = formatted.replace('-', '')
@@ -223,7 +223,7 @@ def format_uncertainty(analysis, result, decimalmark='.', sciformat=1):
     If the "Calculate precision from uncertainties" is enabled in
     the Analysis service, and
 
-    a) If the the non-decimal number of digits of the result is above
+    a) If the non-decimal number of digits of the result is above
        the service's ExponentialFormatPrecision, the uncertainty will
        be formatted in scientific notation. The uncertainty exponential
        value used will be the same as the one used for the result. The
@@ -286,21 +286,37 @@ def format_uncertainty(analysis, result, decimalmark='.', sciformat=1):
     except ValueError:
         pass
 
+    uncertainty = None
     if result == objres:
         # To avoid problems with DLs
         uncertainty = analysis.getUncertainty()
     else:
         uncertainty = analysis.getUncertainty(result)
 
-    if uncertainty is None or uncertainty == 0:
+    if not uncertainty:
         return ""
 
+    precision = -1
+    # always get full precision of the uncertainty if user entered manually
+    # => avoids rounding and cut-off
+    allow_manual = analysis.getAllowManualUncertainty()
+    manual_value = analysis.getField("Uncertainty").get(analysis)
+    if allow_manual and manual_value:
+        precision = uncertainty[::-1].find(".")
+
+    if precision == -1:
+        precision = analysis.getPrecision(result)
+
     # Scientific notation?
     # Get the default precision for scientific notation
     threshold = analysis.getExponentialFormatPrecision()
-    precision = analysis.getPrecision(result)
-    formatted = _format_decimal_or_sci(uncertainty, precision, threshold,
-                                       sciformat)
+    formatted = _format_decimal_or_sci(
+        uncertainty, precision, threshold, sciformat)
+
+    # strip off trailing zeros and the orphane dot
+    if "." in formatted:
+        formatted = formatted.rstrip("0").rstrip(".")
+
     return formatDecimalMark(formatted, decimalmark)
 
 

src/senaite/core/tests/doctests/API.rst

@@ -1547,6 +1547,63 @@ With default fallback:
     2
 
 
+Convert float to string
+.......................
+
+Values below zero get converted by the `float` class to the exponential notation, e.g.
+
+    >>> value = "0.000000000123"
+    >>> float_value = float(value)
+
+    >>> float_value
+    1.23e-10
+
+    >>> other_value = "0.0000001"
+    >>> other_float_value = float(other_value)
+
+    >>> other_float_value
+    1e-07
+
+Converting it back to a string would keep this notation:
+
+    >>> str(float_value)
+    '1.23e-10'
+
+    >>> str(other_float_value)
+    '1e-07'
+
+The function `float_to_string` converts the float value without exponential notation:
+
+    >>> api.float_to_string(float_value)
+    '0.000000000123'
+
+    >>> api.float_to_string(float_value) == value
+    True
+
+Passing in the string value should convert it to the same value:
+
+    >>> api.float_to_string(value) == value
+    True
+
+When the fraction contains more digits, it will retain them all and takes care of the trailing zero:
+
+    >>> new_value = 0.000000000123777
+    >>> api.float_to_string(new_value)
+    '0.000000000123777'
+
+Converting integers work as well:
+
+    >>> int_value = 123
+    >>> api.float_to_string(int_value)
+    '123.0'
+
+The function also ensures that floatable string values remain unchanged:
+
+    >>> str_value = "1.99887766554433221100"
+    >>> api.float_to_string(str_value) == str_value
+    True
+
+
 Convert to minutes
 ..................