Made SinkConfig a collections.namedtuple

Since it's a class used for little more than storage, with no
interesting non-magic instance methods, it makes sense for SinkConfig to
be a namedtuple.  The rest of its code was mostly just boilerplate,
after all.  What remains makes it do everything we need with only slight
changes to its behavior (most notably, SinkConfig must be instantiated
with all its arguments now).

pdbuddy/__init__.py

 """Python bindings for PD Buddy Sink configuration"""
 
+from collections import namedtuple
+
 try:
     # Try importing enum from the standard library
     import enum
             cls.pid))
 
 
-class SinkConfig:
-    """Python representation of a PD Buddy Sink configuration object"""
-
-    def __init__(self, status=None, flags=None, v=None, i=None):
-        """Create a SinkConfig object
-        
-        :param status: A `SinkStatus` value
-        :param flags: Zero or more `SinkFlags` values
-        :param v: Voltage in millivolts
-        :param i: Current in milliamperes
-        """
-        self.status = status
-        self.flags = flags
-        self.v = v
-        self.i = i
-
-    def __repr__(self):
-        s = self.__class__.__name__ + "("
+class SinkConfig(namedtuple("SinkConfig", "status flags v i")):
+    """Python representation of a PD Buddy Sink configuration object
 
-        if self.status is not None:
-            s += "status={}".format(self.status)
-
-        if self.flags is not None:
-            if not s.endswith("("):
-                s += ", "
-            s += "flags={}".format(self.flags)
-
-        if self.v is not None:
-            if not s.endswith("("):
-                s += ", "
-            s += "v={}".format(self.v)
-
-        if self.i is not None:
-            if not s.endswith("("):
-                s += ", "
-            s += "i={}".format(self.i)
-
-        s += ")"
-
-        return s
+    ``status`` should be a `SinkStatus` object.  ``flags`` should be zero or
+    more `SinkFlags` values.  ``v`` is the voltage in millivolts, and ``i``
+    is the current in milliamperes.  `None` is also an acceptible value for
+    any of the fields."""
+    __slots__ = ()
 
     def __str__(self):
         """Print the SinkStatus in the manner of the configuration shell"""
         else:
             return "No configuration"
 
-    def __eq__(self, other):
-        if isinstance(other, self.__class__):
-            if other.status is not self.status:
-                return False
-            if other.flags is not self.flags:
-                return False
-            if other.v != self.v:
-                return False
-            if other.i != self.i:
-                return False
-            return True
-        return NotImplemented
-
-    def __ne__(self, other):
-        if isinstance(other, self.__class__):
-            return not self.__eq__(other)
-        return NotImplemented
-
-    def __hash__(self):
-        return hash(tuple(sorted(self.__dict__.items())))
-
     @classmethod
     def from_text(cls, text):
         """Creates a SinkConfig from text returned by Sink.send_command
                 raise IndexError("configuration index out of range")
             # If there is no configuration, return an empty SinkConfig
             elif line.startswith(b"No configuration"):
-                return cls()
+                return cls(None, None, None, None)
             # If this line is the status field
             elif line.startswith(b"status: "):
                 line = line.split()[1:]

test_pdbuddy/__init__.py

 class SinkConfigTestCase(unittest.TestCase):
 
     def setUp(self):
-        self.obj_none = pdbuddy.SinkConfig()
-        self.obj_empty = pdbuddy.SinkConfig(status=pdbuddy.SinkStatus.EMPTY)
+        self.obj_none = pdbuddy.SinkConfig(status=None, flags=None, v=None,
+                i=None)
+        self.obj_empty = pdbuddy.SinkConfig(status=pdbuddy.SinkStatus.EMPTY,
+                flags=None, v=None, i=None)
         self.obj_valid = pdbuddy.SinkConfig(status=pdbuddy.SinkStatus.VALID,
                 flags=pdbuddy.SinkFlags.NONE, v=15000, i=3000)
         self.obj_invalid = pdbuddy.SinkConfig(status=pdbuddy.SinkStatus.INVALID,
                 "status: valid\nflags: (none)\nv: 15.00 V\ni: 1.00 A")
 
     def test_eq_none(self):
-        self.assertTrue(self.obj_none == pdbuddy.SinkConfig())
+        self.assertTrue(self.obj_none == pdbuddy.SinkConfig(None, None, None,
+            None))
 
     def test_eq_valid(self):
         # Set invalid object as valid
-        self.obj_invalid.status = pdbuddy.SinkStatus.VALID
+        self.obj_invalid = self.obj_invalid._replace(status=pdbuddy.SinkStatus.VALID)
 
         self.assertTrue(self.obj_valid == self.obj_invalid)
 
         self.assertFalse(self.obj_valid == self.obj_valid_1a)
 
     def test_ne_none(self):
-        self.assertFalse(self.obj_none != pdbuddy.SinkConfig())
+        self.assertFalse(self.obj_none != pdbuddy.SinkConfig(None, None, None,
+            None))
 
     def test_ne_valid(self):
         # Set invalid object as valid
-        self.obj_invalid.status = pdbuddy.SinkStatus.VALID
+        self.obj_invalid = self.obj_invalid._replace(status=pdbuddy.SinkStatus.VALID)
 
         self.assertFalse(self.obj_valid != self.obj_invalid)
 
         self.assertTrue(self.obj_valid != self.obj_invalid)
 
     def test_hash_identical(self):
-        self.assertEqual(hash(self.obj_none), hash(pdbuddy.SinkConfig()))
+        self.assertEqual(hash(self.obj_none), hash(pdbuddy.SinkConfig(None,
+            None, None, None)))
 
     def test_hash_different(self):
         self.assertNotEqual(hash(self.obj_none), hash(self.obj_valid))