Support the new typec_virtual PDO

This commit adds support for the new, yet-to-be-released typec_virtual
PDO reported from the firmware.  This was done by adding a
TypeCVirtualPDO class, code to load them from text, and support for them
in the calculation functions.  New tests have been written for all the
new code as well.

pdbuddy/__init__.py

         return s
 
 
+class TypeCVirtualPDO(namedtuple("TypeCVirtualPDO", "i")):
+    """A Type-C Current Virtual PDO
+
+    ``i`` is the advertised current in milliamperes.
+    """
+    __slots__ = ()
+
+    pdo_type = "typec_virtual"
+
+    def __str__(self):
+        """Print the TypeCVirtualPDO in the manner of the configuration shell"""
+        s = self.pdo_type + "\n"
+
+        s += "\ti: {:.2f} A".format(self.i / 1000.0)
+
+        return s
+
+
 def read_pdo(text):
     """Create a PDO object from partial text returned by Sink.send_command"""
     # First, determine the PDO type
                 peak_i=peak_i,
                 v=v,
                 i=i)
+    elif pdo_type == TypeCVirtualPDO.pdo_type:
+        # Load a TypeCVirtualPDO
+        for line in text[1:]:
+            fields = line.split(b":")
+            fields[0] = fields[0].strip()
+            fields[1] = fields[1].strip()
+            if fields[0] == b"i":
+                i = round(1000*float(fields[1].split()[0]))
+
+        # Make the TypeCVirtualPDO
+        return TypeCVirtualPDO(i=i)
     elif pdo_type == "No Source_Capabilities":
         return None
     else:
     for pdo in pdo_list:
         if pdo.pdo_type == "fixed":
             max_power = max(max_power, pdo.v / 1000.0 * pdo.i / 1000.0)
+        elif pdo.pdo_type == "typec_virtual":
+            max_power = max(max_power, 5.0 * pdo.i / 1000.0)
 
     return max_power
 
     # First, estimate the PDP assuming the rules are being followed
     pdp = calculate_pdp(pdo_list)
 
+    # If there's a typec_virtual PDO, there's no Power Delivery so the Power
+    # Rules cannot be violated.  In truth they're not really being followed
+    # either since they only apply to Power Delivery, but returning True here
+    # seems like the safer option.
+    if pdo_list and pdo_list[0].pdo_type == "typec_virtual":
+        return True
+
     # Make sure nothing exceeds the PDP
     for pdo in pdo_list:
         if pdo.pdo_type == "fixed":

test_pdbuddy/__init__.py

                 "fixed\n\tv: 5.00 V\n\ti: 1.50 A")
 
 
+class TypeCVirtualPDOTestCase(unittest.TestCase):
+
+    def setUp(self):
+        self.obj_1p5a = pdbuddy.TypeCVirtualPDO(1500)
+
+    def test_str_1p5a(self):
+        self.assertEqual(str(self.obj_1p5a), "typec_virtual\n\ti: 1.50 A")
+
+
 class ReadPDOTestCase(unittest.TestCase):
 
     def setUp(self):
                 False, False, 0, 5000, 1500)
         self.unknown_zero = pdbuddy.UnknownPDO(value=0x00000000)
         self.unknown_notzero = pdbuddy.UnknownPDO(value=0xFFFFFFFF)
+        self.typec_virtual = pdbuddy.TypeCVirtualPDO(1500)
 
     def test_read_src_fixed_everything(self):
         rp_src_fixed_everything = pdbuddy.read_pdo([b"PDO 1: fixed",
         rp_unknown_notzero = pdbuddy.read_pdo([b"PDO 1: FFFFFFFF"])
         self.assertEqual(self.unknown_notzero, rp_unknown_notzero)
 
+    def test_read_typec_virtual(self):
+        rp_typec_virtual = pdbuddy.read_pdo([b"PDO 5: typec_virtual",
+                b"\ti: 1.50 A"])
+        self.assertEqual(self.typec_virtual, rp_typec_virtual)
+
     def test_read_none(self):
         none_pdo = pdbuddy.read_pdo([b"No Source_Capabilities"])
         self.assertEqual(none_pdo, None)
                 False, False, 0, 5000, 1500)
         self.unknown_zero = pdbuddy.UnknownPDO(value=0x00000000)
         self.unknown_notzero = pdbuddy.UnknownPDO(value=0xFFFFFFFF)
+        self.typec_virtual = pdbuddy.TypeCVirtualPDO(1500)
 
     def test_read_pdo_list(self):
         # It's not a legal list for USB Power Delivery, but it works fine for
                 b"\tv: 5.00 V",
                 b"\ti: 1.50 A",
                 b"PDO 3: 00000000",
-                b"PDO 4: FFFFFFFF"]
+                b"PDO 4: FFFFFFFF",
+                b"PDO 5: typec_virtual",
+                b"\ti: 1.50 A"]
         pdo_list = pdbuddy.read_pdo_list(text)
 
         self.assertEqual(pdo_list[0], self.src_fixed_everything)
         self.assertEqual(pdo_list[1], self.src_fixed_minimal)
         self.assertEqual(pdo_list[2], self.unknown_zero)
         self.assertEqual(pdo_list[3], self.unknown_notzero)
+        self.assertEqual(pdo_list[4], self.typec_virtual)
 
 
 class PDOListCalculationsTestCase(unittest.TestCase):
                 False, False, 0, 20000, 2250)
         self.src_fixed_20v_5a = pdbuddy.SrcFixedPDO(False, False, False, False,
                 False, 0, 20000, 5000)
+        self.typec_virtual_1p5a = pdbuddy.TypeCVirtualPDO(1500)
+
+    def test_calculate_pdp_typec_virtual(self):
+        self.assertEqual(pdbuddy.calculate_pdp([self.typec_virtual_1p5a]), 7.5)
 
     def test_calculate_pdp_15w(self):
         self.assertEqual(pdbuddy.calculate_pdp([self.src_fixed_5v_3a]), 15)
     def test_follows_power_rules_true(self):
         # <= 15 W
         self.assertTrue(pdbuddy.follows_power_rules([]))
+        self.assertTrue(pdbuddy.follows_power_rules([self.typec_virtual_1p5a]))
         self.assertTrue(pdbuddy.follows_power_rules([self.src_fixed_5v_1p5a]))
         self.assertTrue(pdbuddy.follows_power_rules([self.src_fixed_5v_3a]))
         self.assertTrue(pdbuddy.follows_power_rules([self.src_fixed_5v_3a,