Make read_bg_targets only ever return data in mg/dL, not mmol/L

The OpenAPS system universally uses mg/dL for data. This helps ensure user
safety by ensuring we never mix up mg/dL and mmol/L.

However, the read_bg_targets code would return the values in the user-selected
measurement unit.

This patch makes the openaps system only ever write mg/dL to the read_bg_targets
file, and then stores the user-preferred value into the file.

Additionally, this change includes features to:
* Convert from mg/dL to mmol/L and vs versa
* Functions to support uniform display of mg/dL and mmol/L (by handling rounding
  appropriately, since the significant digit 6 in '5.6mmol/l' is significant,
  while the 6 in 100.6mg/dL is not signficant)

TEST FRAMEWORK:

This change also introduces a testing framework into the repository, so that we
can test these functions.

To get this to work, I've fixed a longstanding bug building on circleci: if you
run 'sudo' to install python modules, the packages are not installed in your
active virtualenv - so tests fail.

I've also switched to the TravisCI infrastructure, and removed the need to sudo
at all.

Author: oskarpearson

.travis.yml

@@ -1,10 +1,9 @@
-
+sudo: false
 language: python
 python:
   - "2.7"
 foo:
   - pip install -e .
 install:
-  - sudo python setup.py install
+  - python setup.py install
 script: make ci-test
-

Makefile

@@ -2,7 +2,7 @@
 TESTS = $(wildcard openaps/*.py openaps/*/*.py)
 
 test:
-	python -m unittest openaps
+	python -m nose
 	openaps -h
 	# python -m doctest discover
 	# do the test dance
@@ -12,4 +12,3 @@ ci-test: test
 
 
 .PHONY: test
-

circle.yml

@@ -1,9 +1,3 @@
-
-dependencies:
-  override:
-    - sudo python setup.py install
-
 test:
   override:
     - make ci-test
-

openaps/glucose/__init__.py

@@ -0,0 +1,23 @@
+class Convert(object):
+    """
+        How to convert from mg/dL (World Wide format) to mmol/L (mostly UK
+        and ex-UK colonies)
+
+        Please note that rounding of these values is a *view* related
+        function, and should happen at the very last point before data is
+        being viewed, not here. See http://physics.stackexchange.com/a/63330
+
+        This code *could* be used for mathematical processing of results by
+        someone down the line, so we take pain to avoid throwing away
+        potentially significant data by rounding.
+    """
+
+    MMOLL_CONVERT_FACTOR = 18.0
+
+    @classmethod
+    def mmol_l_to_mg_dl(klass, mmol_l):
+        return mmol_l * klass.MMOLL_CONVERT_FACTOR
+
+    @classmethod
+    def mg_dl_to_mmol_l(klass, mg_dl):
+        return mg_dl / klass.MMOLL_CONVERT_FACTOR

openaps/glucose/convert.py

@@ -0,0 +1,19 @@
+class Display(object):
+    """
+        Round Glucose values for display, so that they are consistent in
+        all OpenAPS apps
+
+        Example:
+
+            from openaps.glucose.display import Display
+            print(Display.display('mmol/L', 5.5))
+            print(Display.display('mg/dL', 100))
+    """
+    @classmethod
+    def display(klass, unit, val):
+        assert unit in ['mmol/L', 'mg/dL']
+
+        if unit == 'mg/dL':
+            return int(round(val))
+        elif unit == 'mmol/L':
+            return round(val, 1)

openaps/glucose/display.py

@@ -5,6 +5,7 @@
 from openaps.uses.use import Use
 from openaps.uses.registry import Registry
 from openaps.configurable import Configurable
+from openaps.glucose.convert import Convert as GlucoseConvert
 import decocare
 import argparse
 import json
@@ -187,6 +188,31 @@ class read_clock (MedtronicTask):
   def main (self, args, app):
     return self.pump.model.read_clock( )
 
+@use( )
+class read_bg_targets (MedtronicTask):
+  """
+    Universally, OpenAPS uses blood glucose measurements in mg/dL units.
+
+    This code converts whatever decoding-carelink gave us to mg/dL,
+    irrespective of the user-preferred units.
+
+    We then add a new field to the result, called 'user-preferred-units'.
+    This reflects what the pump-owner prefers their unit of measurement to be.
+  """
+  def main (self, args, app):
+      bg_targets = self.pump.model.read_bg_targets( )
+      assert bg_targets['units'] in ['mg/dL', 'mmol/L']
+
+      if bg_targets['units'] and bg_targets['units'] == 'mmol/L':
+          for target in bg_targets['targets']:
+              target['high'] = GlucoseConvert.mmol_l_to_mg_dl(target['high'])
+              target['low'] = GlucoseConvert.mmol_l_to_mg_dl(target['low'])
+
+      bg_targets['user_preferred_units'] = bg_targets['units']
+      bg_targets['units'] = 'mg/dL'
+
+      return bg_targets
+
 class SameNameCommand (MedtronicTask):
   def main (self, args, app):
     name = self.__class__.__name__.split('.').pop( )
@@ -244,10 +270,6 @@ class resume_pump (suspend_pump):
 class read_battery_status (SameNameCommand):
   """ Check battery status. """
 
-@use( )
-class read_bg_targets (SameNameCommand):
-  """ Read bg targets. """
-
 @use( )
 class read_insulin_sensitivies (SameNameCommand):
   """ Read insulin sensitivies. """
@@ -418,6 +440,3 @@ def get_uses (device, config):
   all_uses = known_uses[:] + use.get_uses(device, config)
   all_uses.sort(key=lambda usage: getattr(usage, 'sortOrder', usage.__name__))
   return all_uses
-
-
-

openaps/vendors/medtronic.py

@@ -19,7 +19,7 @@ def readme():
     include_package_data = True,
     install_requires = [
       'pyserial', 'python-dateutil', 'argcomplete',
-      'gitpython',
+      'gitpython', 'mock', 'nose',
       'decocare > 0.0.16', 'dexcom_reader > 0.0.5'
     ],
     dependency_links = [

setup.py

@@ -0,0 +1,50 @@
+from unittest import TestCase
+
+from openaps.glucose.convert import Convert
+
+
+class ConvertTestCase (TestCase):
+    """
+        Test a variety of blood glucose values.
+        Note that the Glucose converter does *not* (and should not)
+        round values. See the glucose.round module for that.
+    """
+
+    # The List of mmol/L sugars was generated by a run of
+    # random.uniform(0.0,35.0)
+    MMOL_LIST = [
+        0.10200000000000001, 1.3519999999999999, 1.6260000000000001, 3.811,
+        4.333000000000001, 6.683, 8.024, 8.171,
+        10.671, 11.062000000000001, 13.943999999999999, 14.902,
+        17.683000000000003, 20.474, 24.657, 25.338, 28.008, 33.665,
+        34.626000000000005, 34.817]
+
+    # This list needs to match the above MMOL_LIST - it's built mathematically
+    # and manually, but has been checked against
+    # http://www.diabetes.co.uk/blood-sugar-converter.html
+    #
+    # Note that the URL above only rounds to one digit
+    MGDL_LIST = [
+        1.836, 24.336, 29.268, 68.598,
+        77.99400000000001, 120.294, 144.432, 147.07799999999997,
+        192.07799999999997, 199.116, 250.992, 268.236,
+        318.29400000000004, 368.532, 443.826, 456.084, 504.144, 605.97,
+        623.268, 626.706]
+
+    def test_mmol_l_to_mg_dl(self):
+        results = [Convert.mmol_l_to_mg_dl(mmol) for mmol in
+                   self.MMOL_LIST]
+
+        self.assertListEqual(
+            results,
+            self.MGDL_LIST
+        )
+
+    def test_mg_dl_to_mmol_l(self):
+        results = [Convert.mg_dl_to_mmol_l(mg_dl) for mg_dl in
+                   self.MGDL_LIST]
+
+        self.assertListEqual(
+            results,
+            self.MMOL_LIST
+        )

tests/__init__.py

@@ -0,0 +1,21 @@
+from unittest import TestCase
+from openaps.glucose.display import Display
+
+
+class DisplayTestCase (TestCase):
+    """
+        Checks that the display function rounds to the correct number
+        of significant digits
+    """
+
+    def test_display_mmol_l(self):
+        self.assertEqual(Display.display('mmol/L', 5.490000), 5.5)
+        self.assertEqual(Display.display('mmol/L', 5.500001), 5.5)
+        self.assertEqual(Display.display('mmol/L', 5.510000), 5.5)
+        self.assertEqual(Display.display('mmol/L', 5.590000), 5.6)
+
+    def test_display_mg_dl(self):
+        self.assertEqual(Display.display('mg/dL', 147.078), 147)
+        self.assertEqual(Display.display('mg/dL', 268.236), 268)
+        self.assertEqual(Display.display('mg/dL', 605.970), 606)
+        self.assertEqual(Display.display('mg/dL', 623.268), 623)

tests/glucose/__init__.py

@@ -0,0 +1,54 @@
+from unittest import TestCase
+from mock import Mock
+
+from openaps.vendors.medtronic import read_bg_targets
+
+
+class BgTargetsTestCase(TestCase):
+    """Test openaps.vendor.medtronic read_bg_targets"""
+
+    def mg_dl_pump_response(self):
+        return {'units': 'mg/dL', 'targets': [
+                    {'high': 200, 'low': 100},
+                    {'high': 300, 'low': 200}
+                ]}.copy()
+
+    def mmol_l_pump_response(self):
+        return {'units': 'mmol/L', 'targets': [{'high': 6, 'low': 5}]}.copy()
+
+    class MockMethod():
+        pass
+
+    class MockParent():
+        device = 'irrelevant'
+
+    def test_read_bg_targets_from_mg_dl_pump(self):
+        instance = read_bg_targets(None, BgTargetsTestCase.MockParent())
+
+        mock = Mock()
+        mock.model.read_bg_targets.return_value = self.mg_dl_pump_response()
+        instance.pump = mock
+
+        response = instance.main(None, None)
+        expected_response = dict({
+            'targets': [{'high': 200, 'low': 100}, {'high': 300, 'low': 200}],
+            'units': 'mg/dL',
+            'user_preferred_units': 'mg/dL',
+        })
+        self.assertEqual(response, expected_response)
+
+    def test_read_bg_targets_from_mmol_l_pump(self):
+        instance = read_bg_targets(None, BgTargetsTestCase.MockParent())
+
+        mock = Mock()
+        mock.model.read_bg_targets.return_value = self.mmol_l_pump_response()
+        instance.pump = mock
+
+        expected_response = {
+            'targets': [{'high': 108, 'low': 90}],
+            'units': 'mg/dL',
+            'user_preferred_units': 'mmol/L',
+        }
+
+        response = instance.main(None, None)
+        self.assertEqual(response, expected_response)