407 tip tracking prediction (#153)

* Pipette raises RuntimeWarning when the tip iterator runs out of tips

* pylama

* fixes JSON protocol error that used too many tips

* WellSeries can take list of Wells for initializing

* adds Pipette.start_at_tip(tip)

* adds and tests for .start_at_tip(); adds method .current_tip() to set/get Pipette's tip

Author: andySigler

opentrons/containers/placeable.py

@@ -570,7 +570,9 @@ class WellSeries(Placeable):
     """
     def __init__(self, items):
         self.items = items
-        self.values = list(self.items.values())
+        if isinstance(items, dict):
+            items = list(self.items.values())
+        self.values = items
         self.offset = 0
 
     def set_offset(self, offset):

opentrons/instruments/pipette.py

@@ -88,6 +88,7 @@ def __init__(
 
         self.trash_container = trash_container
         self.tip_racks = tip_racks
+        self.starting_tip = None
 
         # default mm above tip to execute drop-tip
         # this gives room for the drop-tip mechanism to work
@@ -180,20 +181,44 @@ def reset_tip_tracking(self):
         """
         Resets the :any:`Pipette` tip tracking, "refilling" the tip racks
         """
-        self.current_tip_home_well = None
+        self.current_tip(None)
         self.tip_rack_iter = iter([])
 
         if self.has_tip_rack():
             iterables = self.tip_racks
 
             if self.channels > 1:
-                iterables = []
-                for rack in self.tip_racks:
-                    iterables.append(rack.rows)
+                iterables = [r for rack in self.tip_racks for r in rack.rows]
+            else:
+                iterables = [w for rack in self.tip_racks for w in rack]
+
+            if self.starting_tip:
+                iterables = iterables[iterables.index(self.starting_tip):]
+
+            self.tip_rack_iter = itertools.chain(iterables)
 
-            self.tip_rack_iter = itertools.cycle(
-                itertools.chain(*iterables)
-            )
+    def current_tip(self, *args):
+        if len(args) and (isinstance(args[0], Placeable) or args[0] is None):
+            self.current_tip_home_well = args[0]
+        return self.current_tip_home_well
+
+    def start_at_tip(self, _tip):
+        if isinstance(_tip, Placeable):
+            self.starting_tip = _tip
+            self.reset_tip_tracking()
+
+    def get_next_tip(self):
+        next_tip = None
+        if self.has_tip_rack():
+            try:
+                next_tip = next(self.tip_rack_iter)
+            except StopIteration as e:
+                raise RuntimeWarning(
+                    '{0} has run out of tips'.format(self.name))
+        else:
+            self.robot.add_warning(
+                'pick_up_tip called with no reference to a tip')
+        return next_tip
 
     def _associate_placeable(self, location):
         """
@@ -803,11 +828,11 @@ def _do():
             description=_description,
             enqueue=enqueue)
 
-        if not self.current_tip_home_well:
+        if not self.current_tip():
             self.robot.add_warning(
                 'Pipette has no tip to return, dropping in place')
 
-        self.drop_tip(self.current_tip_home_well, enqueue=enqueue)
+        self.drop_tip(self.current_tip(), enqueue=enqueue)
 
         return self
 
@@ -860,17 +885,12 @@ def pick_up_tip(self, location=None, enqueue=True):
         def _setup():
             nonlocal location
             if not location:
-                if self.has_tip_rack():
-                    # TODO: raise warning/exception if looped back to first tip
-                    location = next(self.tip_rack_iter)
-                else:
-                    self.robot.add_warning(
-                        'pick_up_tip called with no reference to a tip')
-
-            self.current_tip_home_well = None
+                location = self.get_next_tip()
+
+            self.current_tip(None)
             if location:
                 placeable, _ = containers.unpack_location(location)
-                self.current_tip_home_well = placeable
+                self.current_tip(placeable)
 
             if isinstance(location, Placeable):
                 location = location.bottom()
@@ -959,7 +979,7 @@ def _setup():
                 location = location.bottom(self._drop_tip_offset)
 
             self._associate_placeable(location)
-            self.current_tip_home_well = None
+            self.current_tip(None)
 
             self.current_volume = 0
 

tests/opentrons/json_importer/protocol_data/lewistanner_auto_pcr.json

@@ -11,13 +11,21 @@
             "labware": "tiprack-10ul",
             "slot": "B1"
         },
+        "p10-rack-ST-2": {
+            "labware": "tiprack-10ul",
+            "slot": "B2"
+        },
+        "p10-rack-ST-3": {
+            "labware": "tiprack-10ul",
+            "slot": "B3"
+        },
         "p200-rack": {
             "labware": "tiprack-200ul",
             "slot": "A2"
         },
         "trash": {
             "labware": "point",
-            "slot": "B2"
+            "slot": "C2"
         },
         "reagents": {
             "labware": "tube-rack-2ml",
@@ -72,6 +80,12 @@
             "tip-racks": [
                 {
                     "container": "p10-rack-ST"
+                },
+                {
+                    "container": "p10-rack-ST-2"
+                },
+                {
+                    "container": "p10-rack-ST-3"
                 }
             ],
             "trash-container": {

tests/opentrons/labware/test_pipette.py

@@ -623,7 +623,7 @@ def generate_plate(wells, cols, spacing, offset, radius):
 
         self.p200.move_to = mock.Mock()
 
-        for _ in range(0, total_tips_per_plate * 4):
+        for _ in range(0, total_tips_per_plate * 2):
             self.p200.pick_up_tip()
 
         self.robot.simulate()
@@ -633,16 +633,20 @@ def generate_plate(wells, cols, spacing, offset, radius):
             expected.append(self.build_move_to_bottom(self.tiprack1[i]))
         for i in range(0, total_tips_per_plate):
             expected.append(self.build_move_to_bottom(self.tiprack2[i]))
-        for i in range(0, total_tips_per_plate):
-            expected.append(self.build_move_to_bottom(self.tiprack1[i]))
-        for i in range(0, total_tips_per_plate):
-            expected.append(self.build_move_to_bottom(self.tiprack2[i]))
 
         self.assertEqual(
             self.p200.move_to.mock_calls,
             expected
         )
 
+        # test then when we go over the total number of tips,
+        # Pipette raises a RuntimeWarning
+        self.robot.clear_commands()
+        self.p200.reset()
+        for _ in range(0, total_tips_per_plate * 2):
+            self.p200.pick_up_tip()
+        self.assertRaises(RuntimeWarning, self.p200.pick_up_tip)
+
     def test_tip_tracking_chain_multi_channel(self):
         p200_multi = instruments.Pipette(
             trash_container=self.trash,
@@ -657,7 +661,7 @@ def test_tip_tracking_chain_multi_channel(self):
             top=0, bottom=10, blow_out=12, drop_tip=13)
         p200_multi.move_to = mock.Mock()
 
-        for _ in range(0, 12 * 4):
+        for _ in range(0, 12 * 2):
             p200_multi.pick_up_tip()
 
         self.robot.simulate()
@@ -667,16 +671,17 @@ def test_tip_tracking_chain_multi_channel(self):
             expected.append(self.build_move_to_bottom(self.tiprack1.rows[i]))
         for i in range(0, 12):
             expected.append(self.build_move_to_bottom(self.tiprack2.rows[i]))
-        for i in range(0, 12):
-            expected.append(self.build_move_to_bottom(self.tiprack1.rows[i]))
-        for i in range(0, 12):
-            expected.append(self.build_move_to_bottom(self.tiprack2.rows[i]))
 
         self.assertEqual(
             p200_multi.move_to.mock_calls,
             expected
         )
 
+    def test_tip_tracking_start_at_tip(self):
+        self.p200.start_at_tip(self.tiprack1['B2'])
+        self.p200.pick_up_tip()
+        self.assertEquals(self.tiprack1['B2'], self.p200.current_tip())
+
     def test_tip_tracking_return(self):
         self.p200.drop_tip = mock.Mock()