Added SinkDimension

The i member in SinkConfig now has its dimension, and thus its unit,
set by the new idim member.  It's a bit clunky, but the other
alternative I thought of is even clunkier.

pdbuddy/__init__.py

             cls.pid))
 
 
-class SinkConfig(namedtuple("SinkConfig", "status flags v vmin vmax i")):
+class SinkConfig(namedtuple("SinkConfig", "status flags v vmin vmax i idim")):
     """Python representation of a PD Buddy Sink configuration object
 
     ``status`` should be a `SinkStatus` object.  ``flags`` should be zero or
     more `SinkFlags` values.  ``v``, ``vmin``, and ``vmax`` are voltages in
-    millivolts, and ``i`` is the current in milliamperes.  `None` is also an
-    acceptible value for any of the fields.
+    millivolts, ``i`` is the value used to set current in the appropriate
+    milli- SI unit, and ``idim`` is the dimension of ``i``.  `None` is also
+    an acceptible value for any of the fields.
     """
     __slots__ = ()
 
             s += "vmax: {:.3f} V\n".format(self.vmax / 1000.0)
 
         if self.i is not None:
-            s += "i: {:.2f} A\n".format(self.i / 1000.0)
+            if self.idim is SinkDimension.CURRENT:
+                s += "i: {:.2f} A\n".format(self.i / 1000.0)
+            if self.idim is SinkDimension.POWER:
+                s += "p: {:.2f} W\n".format(self.i / 1000.0)
+            if self.idim is SinkDimension.RESISTANCE:
+                s += "r: {:.2f} \u03A9\n".format(self.i / 1000.0)
 
         # Return all but the last character of s to remove the trailing newline
         if s:
         vmin = None
         vmax = None
         i = None
+        idim = None
 
         # Iterate over all lines of text
         for line in text:
                 raise IndexError("configuration index out of range")
             # If there is no configuration, return an empty SinkConfig
             elif line.startswith(b"No configuration"):
-                return cls(None, None, None, None, None, None)
+                return cls(None, None, None, None, None, None, None)
             # If this line is the status field
             elif line.startswith(b"status: "):
                 line = line.split()[1:]
             elif line.startswith(b"i: "):
                 word = line.split()[1]
                 i = round(1000*float(word))
+                idim = SinkDimension.CURRENT
+            # If this line is the p field
+            elif line.startswith(b"p: "):
+                word = line.split()[1]
+                i = round(1000*float(word))
+                idim = SinkDimension.POWER
+            # If this line is the r field
+            elif line.startswith(b"r: "):
+                word = line.split()[1]
+                i = round(1000*float(word))
+                idim = SinkDimension.RESISTANCE
 
         # Create a new SinkConfig object with the values we just read
-        return cls(status=status, flags=flags, v=v, vmin=vmin, vmax=vmax, i=i)
+        return cls(status=status, flags=flags, v=v, vmin=vmin, vmax=vmax, i=i,
+                idim=idim)
 
 
 class SinkStatus(enum.Enum):
     INVALID = 3
 
 
+class SinkDimension(enum.Enum):
+    """Dimension of the value used to set the current requested"""
+    CURRENT = 1
+    POWER = 2
+    RESISTANCE = 3
+
+
 class SinkFlags(enum.Flag):
     """Flags field of a PD Buddy Sink configuration object"""
     NONE = 0

test_pdbuddy/__init__.py

 
         self.obj_valid = pdbuddy.SinkConfig(status=pdbuddy.SinkStatus.VALID,
                 flags=pdbuddy.SinkFlags.NONE, v=15000, vmin=None, vmax=None,
-                i=3000)
+                i=3000, idim=pdbuddy.SinkDimension.CURRENT)
         self.obj_valid_gb = pdbuddy.SinkConfig(status=pdbuddy.SinkStatus.VALID,
                 flags=pdbuddy.SinkFlags.GIVEBACK, v=15000, vmin=None,
-                vmax=None, i=3000)
+                vmax=None, i=3000, idim=pdbuddy.SinkDimension.CURRENT)
         self.obj_range = pdbuddy.SinkConfig(status=pdbuddy.SinkStatus.VALID,
                 flags=pdbuddy.SinkFlags.HV_PREFERRED, v=13800, vmin=12000,
-                vmax=16000, i=2000)
+                vmax=16000, i=2000, idim=pdbuddy.SinkDimension.CURRENT)
 
         self.obj_huge_v = pdbuddy.SinkConfig(status=pdbuddy.SinkStatus.VALID,
                 flags=pdbuddy.SinkFlags.NONE, v=65536, vmin=None, vmax=None,
-                i=1000)
+                i=1000, idim=pdbuddy.SinkDimension.CURRENT)
         self.obj_big_v = pdbuddy.SinkConfig(status=pdbuddy.SinkStatus.VALID,
                 flags=pdbuddy.SinkFlags.NONE, v=21001, vmin=None, vmax=None,
-                i=1000)
+                i=1000, idim=pdbuddy.SinkDimension.CURRENT)
         self.obj_neg_v = pdbuddy.SinkConfig(status=pdbuddy.SinkStatus.VALID,
                 flags=pdbuddy.SinkFlags.NONE, v=-1, vmin=None, vmax=None,
-                i=1000)
+                i=1000, idim=pdbuddy.SinkDimension.CURRENT)
 
         self.obj_inv_range = pdbuddy.SinkConfig(status=pdbuddy.SinkStatus.VALID,
                 flags=pdbuddy.SinkFlags.HV_PREFERRED, v=13800, vmin=16000,
-                vmax=12000, i=2000)
+                vmax=12000, i=2000, idim=pdbuddy.SinkDimension.CURRENT)
 
         self.obj_huge_i = pdbuddy.SinkConfig(status=pdbuddy.SinkStatus.VALID,
                 flags=pdbuddy.SinkFlags.NONE, v=5000, vmin=None, vmax=None,
-                i=65536)
+                i=65536, idim=pdbuddy.SinkDimension.CURRENT)
         self.obj_big_i = pdbuddy.SinkConfig(status=pdbuddy.SinkStatus.VALID,
                 flags=pdbuddy.SinkFlags.NONE, v=5000, vmin=None, vmax=None,
-                i=5001)
+                i=5001, idim=pdbuddy.SinkDimension.CURRENT)
         self.obj_neg_i = pdbuddy.SinkConfig(status=pdbuddy.SinkStatus.VALID,
                 flags=pdbuddy.SinkFlags.NONE, v=5000, vmin=None, vmax=None,
-                i=-1)
+                i=-1, idim=pdbuddy.SinkDimension.CURRENT)
 
     def tearDown(self):
         # Close the connection to the PD Buddy Sink
 
     def setUp(self):
         self.obj_none = pdbuddy.SinkConfig(status=None, flags=None, v=None,
-                vmin=None, vmax=None, i=None)
+                vmin=None, vmax=None, i=None, idim=None)
         self.obj_empty = pdbuddy.SinkConfig(status=pdbuddy.SinkStatus.EMPTY,
-                flags=None, v=None, vmin=None, vmax=None, i=None)
+                flags=None, v=None, vmin=None, vmax=None, i=None, idim=None)
         self.obj_valid = pdbuddy.SinkConfig(status=pdbuddy.SinkStatus.VALID,
                 flags=pdbuddy.SinkFlags.NONE, v=15000, vmin=None, vmax=None,
-                i=3000)
+                i=3000, idim=pdbuddy.SinkDimension.CURRENT)
         self.obj_invalid = pdbuddy.SinkConfig(status=pdbuddy.SinkStatus.INVALID,
                 flags=pdbuddy.SinkFlags.NONE, v=15000, vmin=None, vmax=None,
-                i=3000)
+                i=3000, idim=pdbuddy.SinkDimension.CURRENT)
         self.obj_valid_gb = pdbuddy.SinkConfig(status=pdbuddy.SinkStatus.VALID,
                 flags=pdbuddy.SinkFlags.GIVEBACK, v=15000, vmin=None,
-                vmax=None, i=3000)
+                vmax=None, i=3000, idim=pdbuddy.SinkDimension.CURRENT)
         self.obj_valid_5v = pdbuddy.SinkConfig(status=pdbuddy.SinkStatus.VALID,
                 flags=pdbuddy.SinkFlags.NONE, v=5000, vmin=None, vmax=None,
-                i=3000)
+                i=3000, idim=pdbuddy.SinkDimension.CURRENT)
         self.obj_valid_1a = pdbuddy.SinkConfig(status=pdbuddy.SinkStatus.VALID,
                 flags=pdbuddy.SinkFlags.NONE, v=15000, vmin=None, vmax=None,
-                i=1000)
+                i=1000, idim=pdbuddy.SinkDimension.CURRENT)
         self.obj_valid_range = pdbuddy.SinkConfig(status=pdbuddy.SinkStatus.VALID,
                 flags=pdbuddy.SinkFlags.NONE, v=15000, vmin=12000, vmax=16000,
-                i=1000)
+                i=1000, idim=pdbuddy.SinkDimension.CURRENT)
         self.obj_valid_hv = pdbuddy.SinkConfig(status=pdbuddy.SinkStatus.VALID,
                 flags=pdbuddy.SinkFlags.HV_PREFERRED, v=15000, vmin=12000,
-                vmax=16000, i=1000)
+                vmax=16000, i=1000, idim=pdbuddy.SinkDimension.CURRENT)
+        self.obj_valid_10w = pdbuddy.SinkConfig(status=pdbuddy.SinkStatus.VALID,
+                flags=pdbuddy.SinkFlags.NONE, v=15000, vmin=None, vmax=None,
+                i=10000, idim=pdbuddy.SinkDimension.POWER)
+        self.obj_valid_10r = pdbuddy.SinkConfig(status=pdbuddy.SinkStatus.VALID,
+                flags=pdbuddy.SinkFlags.NONE, v=15000, vmin=None, vmax=None,
+                i=10000, idim=pdbuddy.SinkDimension.RESISTANCE)
 
     def test_str_none(self):
         self.assertEqual(str(self.obj_none), "No configuration")
                 "status: valid\nflags: HV_Preferred\nv: 15.000 V\n"
                 "vmin: 12.000 V\nvmax: 16.000 V\ni: 1.00 A")
 
+    def test_str_valid_10w(self):
+        self.assertEqual(str(self.obj_valid_10w),
+                "status: valid\nflags: (none)\nv: 15.000 V\np: 10.00 W")
+
+    def test_str_valid_10r(self):
+        self.assertEqual(str(self.obj_valid_10r),
+                "status: valid\nflags: (none)\nv: 15.000 V\nr: 10.00 \u03A9")
+
     def test_from_text_none(self):
         ft_none = pdbuddy.SinkConfig.from_text([])
         self.assertEqual(ft_none, self.obj_none)
                 b"i: 1.00 A"])
         self.assertEqual(ft_valid_hv, self.obj_valid_hv)
 
+    def test_from_text_valid_10w(self):
+        ft_valid_10w = pdbuddy.SinkConfig.from_text([b"status: valid",
+                b"flags: (none)",
+                b"v: 15.000 V",
+                b"p: 10.00 W"])
+        self.assertEqual(ft_valid_10w, self.obj_valid_10w)
+
+    def test_from_text_valid_10r(self):
+        ft_valid_10r = pdbuddy.SinkConfig.from_text([b"status: valid",
+                b"flags: (none)",
+                b"v: 15.000 V",
+                b"r: 10.00 \u03A9"])
+        self.assertEqual(ft_valid_10r, self.obj_valid_10r)
+
     def test_from_text_invalid_index(self):
         with self.assertRaises(IndexError):
             pdbuddy.SinkConfig.from_text([b"Invalid index"])