From 5e0fcce24158736c7e6e7cbc949b0aa2703654bf Mon Sep 17 00:00:00 2001 From: emilyburghardt Date: Fri, 8 Aug 2025 13:51:32 -0600 Subject: [PATCH 01/18] starting stacker docs --- api/docs/v2/modules/stacker.rst | 12 ++++++++++++ api/docs/v2/new_modules.rst | 1 + 2 files changed, 13 insertions(+) create mode 100644 api/docs/v2/modules/stacker.rst diff --git a/api/docs/v2/modules/stacker.rst b/api/docs/v2/modules/stacker.rst new file mode 100644 index 00000000000..2552adb73bc --- /dev/null +++ b/api/docs/v2/modules/stacker.rst @@ -0,0 +1,12 @@ +:og:description: How to use the Flex Stacker Module in a Python protocol. + +.. _stacker: + +******************* +Flex Stacker Module +******************* + +The Flex Stacker is an external module that provides automated labware storage. Each Flex supports up to four attached Stackers containing well plates, Flex tip racks, or reservoirs. The Stacker's shuttle moves labware from the stack to the deck for use during a protocol. + +The Stacker is represented in code by a ``StackerContext`` object that includes methods for storing and retrieving labware. You can also use helper commands in your protocol to calculate how many labware the Stacker can store. + diff --git a/api/docs/v2/new_modules.rst b/api/docs/v2/new_modules.rst index 594ceca3867..63a1ea51350 100644 --- a/api/docs/v2/new_modules.rst +++ b/api/docs/v2/new_modules.rst @@ -8,6 +8,7 @@ Hardware Modules .. toctree:: modules/setup + modules/stacker modules/absorbance_plate_reader modules/heater_shaker modules/magnetic_block From 61144eb9e69e59283f67994b2e3d5f55b488e2ab Mon Sep 17 00:00:00 2001 From: emilyburghardt Date: Mon, 11 Aug 2025 16:12:13 -0600 Subject: [PATCH 02/18] drafting... --- api/docs/v2/modules/stacker.rst | 56 +++++++++++++++++++++++++++++++++ 1 file changed, 56 insertions(+) diff --git a/api/docs/v2/modules/stacker.rst b/api/docs/v2/modules/stacker.rst index 2552adb73bc..24ac1258a2e 100644 --- a/api/docs/v2/modules/stacker.rst +++ b/api/docs/v2/modules/stacker.rst @@ -10,3 +10,59 @@ The Flex Stacker is an external module that provides automated labware storage. The Stacker is represented in code by a ``StackerContext`` object that includes methods for storing and retrieving labware. You can also use helper commands in your protocol to calculate how many labware the Stacker can store. +Loading and Deck Slots +======================== + +Up to four Stacker Modules can be attached to the right side of your Flex, creating deck slots A4--D4. Each Stacker occupies a deck slot in column 4, with the shuttle in column 3. + +Start by loading each Stacker as you would any other module: + +.. code-block:: python + stacker_1 = protocol.load_module( + module_name="flexStackerModuleV1", + location="A4" + ) + stacker_2 = protocol.load_module( + module_name="flexStackerModuleV1", + location="C4" + ) + +In this example, each Stacker has an attached shuttle that occupy deck slots A3 and C3. + +Adding Labware to the Stacker +============================== + +Next, you'll need to define the *type* and amount of labware a Stacker will store. Throughout yor protocol, the Flex can automatically move labware, like well plates or tip racks, from inside the Stacker to the deck. + +Each Stacker can hold a labware stack of up to: + +- 7 Flex tipracks (6 in the Stacker and 1 on the shuttle) +- 48 PCR plates +- 16 deep well plates + +##TODO: update the above list with tested labware types ("like ") + +Use :py:meth:`~.StackerContext.set_stored_labware()` to configure the Stacker. You must call this function before adding or removing labware from the Stacker during a protocol. Only one type of labware can be stored in each Stacker at one time. + +.. code-block:: python + + stacker_1.set_stored_labware( + load_name="opentrons_flex_96_tiprack_200ul", + count=6, + lid="opentrons_flex_tiprack_lid" + ) + stacker_2.set_stored_labware( + load_name="opentrons_96_wellplate_200ul_pcr_full_skirt", + count=12 + ) + +In this example, `stacker_1` is configured to hold 6 Flex tip racks, each with a compatible lid. Flex tip racks must have lids to be properly stored in the Stacker. `stacker_2` is configured to hold 12 PCR plates without lids. + + + + + + + + + From d0bc09d262fe91da040b7702408b379e13d5ecb8 Mon Sep 17 00:00:00 2001 From: emilyburghardt Date: Tue, 12 Aug 2025 11:24:01 -0600 Subject: [PATCH 03/18] writing rest of article --- api/docs/v2/modules/stacker.rst | 72 ++++++++++++++++++++++++++++----- 1 file changed, 63 insertions(+), 9 deletions(-) diff --git a/api/docs/v2/modules/stacker.rst b/api/docs/v2/modules/stacker.rst index 24ac1258a2e..7e49a2a5d36 100644 --- a/api/docs/v2/modules/stacker.rst +++ b/api/docs/v2/modules/stacker.rst @@ -6,9 +6,9 @@ Flex Stacker Module ******************* -The Flex Stacker is an external module that provides automated labware storage. Each Flex supports up to four attached Stackers containing well plates, Flex tip racks, or reservoirs. The Stacker's shuttle moves labware from the stack to the deck for use during a protocol. +The Flex Stacker is an external module that provides automated storage of well plates, Flex tip racks, or reservoirs. The Stacker's attached shuttle moves labware from the stack to the deck for use during a protocol. -The Stacker is represented in code by a ``StackerContext`` object that includes methods for storing and retrieving labware. You can also use helper commands in your protocol to calculate how many labware the Stacker can store. +The Stacker is represented in code by a ``StackerContext`` object that includes methods for storing and retrieving labware. You can also use helper commands in your protocol to calculate how many labware the Stacker can store at once. Loading and Deck Slots ======================== @@ -27,22 +27,20 @@ Start by loading each Stacker as you would any other module: location="C4" ) -In this example, each Stacker has an attached shuttle that occupy deck slots A3 and C3. +Each Stacker occupies a deck slot in column 4, with the attached shuttle in column 3. In this example, Stacker shuttles occupy deck slots A3 and C3. Adding Labware to the Stacker ============================== -Next, you'll need to define the *type* and amount of labware a Stacker will store. Throughout yor protocol, the Flex can automatically move labware, like well plates or tip racks, from inside the Stacker to the deck. +Next, you'll need to define the *type* and amount of labware the Stacker will store. Throughout yor protocol, the Flex automatically moves labware, like well plates or tip racks, from inside the Stacker to the deck. Each Stacker can hold a labware stack of up to: - 7 Flex tipracks (6 in the Stacker and 1 on the shuttle) -- 48 PCR plates -- 16 deep well plates +- 48 PCR plates, like +- 16 deep well plates, like -##TODO: update the above list with tested labware types ("like ") - -Use :py:meth:`~.StackerContext.set_stored_labware()` to configure the Stacker. You must call this function before adding or removing labware from the Stacker during a protocol. Only one type of labware can be stored in each Stacker at one time. +You'll need to use :py:meth:`~.StackerContext.set_stored_labware()` to configure the Stacker before adding or removing labware during a protocol. Only one type of labware can be stored in each Stacker at one time. .. code-block:: python @@ -58,6 +56,62 @@ Use :py:meth:`~.StackerContext.set_stored_labware()` to configure the Stacker. Y In this example, `stacker_1` is configured to hold 6 Flex tip racks, each with a compatible lid. Flex tip racks must have lids to be properly stored in the Stacker. `stacker_2` is configured to hold 12 PCR plates without lids. +Configuring the Stacker assigns a labware stack to this deck slot. You can use the Stacker and shuttle as a normal deck slot earlier in your protocol with :py:meth:`~.StackerContext.load_labware()`. You'll need to move this labware elsewhere on the deck before configuring and using the Stacker for storage. + +.. note:: + Different labware have varying `z` heights. One well plate might be 2 mm taller than another, affecting the number of plates the Stacker can store at once. The API includes helper commands to calculate how many labware the Stacker can hold: + + - `.ModuleContext.get_max_storable_labware()` + - `.ModuleContext.get_current_storable_labware()` + - `.ModuleContext.get_stored_labware()` + + Use ``get_max_storable_labware()`` or ``get_current_storable_labware()`` to calculate the maximum or current number of labware the Stacker can store, based on either the labware definition or the Stacker's current storage conditions. + + Like other hardware modules, the Stacker doesn't verify the labware you place inside it. If your Stacker is configured correctly, you can use ``get_stored_labware()`` throughout your protocol to check an updated list of labware stored inside. + +Using Stacker Labware +====================== +During a protocol, use `~.ModuleContext.stacker.retrieve()` to automatically access a single piece of labware to use on the Flex deck. + +.. code-block:: python + + stacker_1.retrieve() + protocol.move_labware( + labware="opentrons_flex_96_tiprack_200ul", + new_location="B2", + use_gripper="True" + ) +Here, the Flex tip rack at the bottom of the labware stack is moved to the shuttle in slot A3. Then, use the Flex Gripper or manually move the new tip rack elsewhere on the deck. + +To add more labware to a Stacker, use `~.ModuleContext.stacker.store()`:: + + protocol.move_labware( + labware="opentrons_96_wellplate_200ul_pcr_full_skirt", + new_location="C3", + use_gripper="True" + ) + stacker_2.store() + +After placing labware on the shuttle in slot C3, ``stacker_2`` stores another well plate on the bottom of the stack. + +To mark a Stacker as completely full or empty, use `~.ModuleContext.stacker.fill()` or `~.StackerContext.stacker.empty()`:: + + # mark the second Stacker as empty + stacker_2.empty() + + # configure the second Stacker and fill with new labware + stacker_2.set_stored_labware( + load_name="nest_12_reservoir_15ml", + count=8 + ) + stacker_2.fill(8, "Add 8 reservoirs to stacker_2.") + +Both ``fill()`` and ``empty()`` pause the protocol and allow you to manually add or remove labware from the Stacker. Each method assumes labware is loaded or moved ``off_deck``. + + + + + From ebcc090aa4698133be4b995b5dcc163e0b5386cc Mon Sep 17 00:00:00 2001 From: emilyburghardt Date: Tue, 12 Aug 2025 13:30:50 -0600 Subject: [PATCH 04/18] fixing most of the build errors --- api/docs/v2/modules/stacker.rst | 80 +++++++++++++++++---------------- 1 file changed, 41 insertions(+), 39 deletions(-) diff --git a/api/docs/v2/modules/stacker.rst b/api/docs/v2/modules/stacker.rst index 7e49a2a5d36..9d47ee66fa4 100644 --- a/api/docs/v2/modules/stacker.rst +++ b/api/docs/v2/modules/stacker.rst @@ -18,14 +18,15 @@ Up to four Stacker Modules can be attached to the right side of your Flex, creat Start by loading each Stacker as you would any other module: .. code-block:: python - stacker_1 = protocol.load_module( - module_name="flexStackerModuleV1", - location="A4" - ) - stacker_2 = protocol.load_module( - module_name="flexStackerModuleV1", - location="C4" - ) + + stacker_1 = protocol.load_module( + module_name="flexStackerModuleV1", + location="A4" + ) + stacker_2 = protocol.load_module( + module_name="flexStackerModuleV1", + location="C4" + ) Each Stacker occupies a deck slot in column 4, with the attached shuttle in column 3. In this example, Stacker shuttles occupy deck slots A3 and C3. @@ -40,23 +41,23 @@ Each Stacker can hold a labware stack of up to: - 48 PCR plates, like - 16 deep well plates, like -You'll need to use :py:meth:`~.StackerContext.set_stored_labware()` to configure the Stacker before adding or removing labware during a protocol. Only one type of labware can be stored in each Stacker at one time. +You'll need to use :py:meth:`~.FlexStackerContext.set_stored_labware()` to configure the Stacker before adding or removing labware during a protocol. Only one type of labware can be stored in each Stacker at one time. .. code-block:: python - stacker_1.set_stored_labware( - load_name="opentrons_flex_96_tiprack_200ul", - count=6, - lid="opentrons_flex_tiprack_lid" - ) - stacker_2.set_stored_labware( - load_name="opentrons_96_wellplate_200ul_pcr_full_skirt", - count=12 - ) + stacker_1.set_stored_labware( + load_name="opentrons_flex_96_tiprack_200ul", + count=6, + lid="opentrons_flex_tiprack_lid" + ) + stacker_2.set_stored_labware( + load_name="opentrons_96_wellplate_200ul_pcr_full_skirt", + count=12 + ) In this example, `stacker_1` is configured to hold 6 Flex tip racks, each with a compatible lid. Flex tip racks must have lids to be properly stored in the Stacker. `stacker_2` is configured to hold 12 PCR plates without lids. -Configuring the Stacker assigns a labware stack to this deck slot. You can use the Stacker and shuttle as a normal deck slot earlier in your protocol with :py:meth:`~.StackerContext.load_labware()`. You'll need to move this labware elsewhere on the deck before configuring and using the Stacker for storage. +Configuring the Stacker assigns a labware stack to this deck slot. You can use the Stacker and shuttle as a normal deck slot earlier in your protocol with :py:meth:`~.ProtocolContext.load_labware()`. You'll need to move this labware elsewhere on the deck before configuring and using the Stacker for storage. .. note:: Different labware have varying `z` heights. One well plate might be 2 mm taller than another, affecting the number of plates the Stacker can store at once. The API includes helper commands to calculate how many labware the Stacker can hold: @@ -75,36 +76,37 @@ During a protocol, use `~.ModuleContext.stacker.retrieve()` to automatically acc .. code-block:: python - stacker_1.retrieve() - protocol.move_labware( - labware="opentrons_flex_96_tiprack_200ul", - new_location="B2", - use_gripper="True" - ) + stacker_1.retrieve() + protocol.move_labware( + labware="opentrons_flex_96_tiprack_200ul", + new_location="B2", + use_gripper="True" + ) + Here, the Flex tip rack at the bottom of the labware stack is moved to the shuttle in slot A3. Then, use the Flex Gripper or manually move the new tip rack elsewhere on the deck. To add more labware to a Stacker, use `~.ModuleContext.stacker.store()`:: - protocol.move_labware( - labware="opentrons_96_wellplate_200ul_pcr_full_skirt", - new_location="C3", - use_gripper="True" - ) - stacker_2.store() + protocol.move_labware( + labware="opentrons_96_wellplate_200ul_pcr_full_skirt", + new_location="C3", + use_gripper="True" + ) + stacker_2.store() After placing labware on the shuttle in slot C3, ``stacker_2`` stores another well plate on the bottom of the stack. To mark a Stacker as completely full or empty, use `~.ModuleContext.stacker.fill()` or `~.StackerContext.stacker.empty()`:: - # mark the second Stacker as empty - stacker_2.empty() + # mark the second Stacker as empty + stacker_2.empty() - # configure the second Stacker and fill with new labware - stacker_2.set_stored_labware( - load_name="nest_12_reservoir_15ml", - count=8 - ) - stacker_2.fill(8, "Add 8 reservoirs to stacker_2.") + # configure the second Stacker and fill with new labware + stacker_2.set_stored_labware( + load_name="nest_12_reservoir_15ml", + count=8 + ) + stacker_2.fill(8, "Add 8 reservoirs to stacker_2.") Both ``fill()`` and ``empty()`` pause the protocol and allow you to manually add or remove labware from the Stacker. Each method assumes labware is loaded or moved ``off_deck``. From 986f504d838654ebbce3239bd2e4959ac1fc8f12 Mon Sep 17 00:00:00 2001 From: emilyburghardt Date: Wed, 13 Aug 2025 10:54:03 -0600 Subject: [PATCH 05/18] fix so code simulates --- api/docs/v2/modules/stacker.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/api/docs/v2/modules/stacker.rst b/api/docs/v2/modules/stacker.rst index 9d47ee66fa4..90f79bc5c45 100644 --- a/api/docs/v2/modules/stacker.rst +++ b/api/docs/v2/modules/stacker.rst @@ -89,7 +89,7 @@ To add more labware to a Stacker, use `~.ModuleContext.stacker.store()`:: protocol.move_labware( labware="opentrons_96_wellplate_200ul_pcr_full_skirt", - new_location="C3", + new_location=stacker_2, use_gripper="True" ) stacker_2.store() From 0b88b63c8fe7bb9bcf2ec3614e21a42b49ac8743 Mon Sep 17 00:00:00 2001 From: emilyburghardt Date: Thu, 14 Aug 2025 15:58:50 -0600 Subject: [PATCH 06/18] editing API reference for clarity --- .../opentrons/protocol_api/module_contexts.py | 130 ++++++++++-------- 1 file changed, 72 insertions(+), 58 deletions(-) diff --git a/api/src/opentrons/protocol_api/module_contexts.py b/api/src/opentrons/protocol_api/module_contexts.py index b3d9e805049..965e5386a17 100644 --- a/api/src/opentrons/protocol_api/module_contexts.py +++ b/api/src/opentrons/protocol_api/module_contexts.py @@ -1141,7 +1141,9 @@ def serial_number(self) -> str: @requires_version(2, 25) def retrieve(self) -> Labware: - """Retrieve a labware from the Flex Stacker and place it on the shuttle. + """Retrieve a labware from the Flex Stacker and move it onto the shuttle. + + The Stacker will retrieve the bottom-most labware in the stack. :returns: The retrieved :py:class:`Labware` object. This will always be the main labware, even if the Flex Stacker contains labware on an adapter. To get the adapter object, @@ -1159,7 +1161,9 @@ def retrieve(self) -> Labware: @requires_version(2, 25) def store(self) -> None: - """Move the labware currently on the Flex Stacker shuttle into the Flex Stacker.""" + """Move a labware currently on the Flex Stacker shuttle into the Flex Stacker. + + The labware must be the same type the Stacker is configured to store using :py:meth:`.set_stored_labware()`. If labware is currently stacked inside the module, this method moves the new labware to the bottom-most position of the stack. """ self._core.store() def _labware_to_cores(self, labware: Sequence[Labware]) -> list[LabwareCore]: @@ -1186,22 +1190,22 @@ def get_max_storable_labware_from_list( """Limit a list of labware instances to the number that can be stored in a Flex Stacker. A Flex Stacker has a limited amount of internal space and computes the number of labware - (or labware with lids or adapters) that it can store based on the heights of the labware - and the amount they overlap when placed on top of each other. To know how many of a given - labware the Flex Stacker can store, the Flex Stacker must know what labware it is. + (or labware with lids or adapters) that it can store based on the ``z`` heights of the labware + and the amount they overlap when stacked. To calculate how many of a given + labware the Stacker can store, the labware type must be specified. - You can use this function to take a list of labware and return the elements that the - stacker can currently store from it. The returned list is then guaranteed to be suitable + Provide a list of labware to this function to return the maximum number of labware of the given type that the + Stacker can store. The returned list is guaranteed to be suitable for passing to :py:meth:`.set_stored_labware_items`. - This function limits the list of labware based on the overall maximum number the stacker + This function limits the list of labware based on the overall maximum number the Stacker can hold and will not change as labware is added or removed. To limit a list of labware to the amount that will currently fit in the Flex Stacker, use :py:meth:`.get_current_storable_labware_from_list`. .. note:: - If a stacking offset is provided, make sure the same value is used when + If a ``z`` stacking offset is provided, be sure to specify the same value when configuring the Flex Stacker with :py:meth:`.set_stored_labware_items`. See :py:meth:`.set_stored_labware_items` for more details on stacking offset. @@ -1220,11 +1224,13 @@ def get_current_storable_labware_from_list( """Limit a list of labware instances to the number that the Flex Stacker currently has space for, based on the labware that is already stored in the Flex Stacker. - You can use this function to take a list of labware and return the elements that the - stacker can currently store from it. The returned list is then guaranteed to be suitable + A Flex Stacker has a limited amount of internal space and computes the number of labware that it can store based on the ``z`` height of the labware and the amount they overlap when stacked. + + Provide a list of labware to this function to return the elements that the + Stacker can currently store from it. The returned list is then guaranteed to be suitable for passing to :py:meth:`.fill`. - The number of elements in the returned list will change as labware is added to or removed from + The number of elements in the returned list will change as labware is added or removed from the Flex Stacker. To get a list limited to the overall maximum number of labware the Flex Stacker can store, use :py:meth:`.get_max_storable_labware_from_list`. """ @@ -1236,11 +1242,13 @@ def get_current_storable_labware_from_list( @requires_version(2, 25) def get_max_storable_labware(self) -> int: - """Get the number of labware that the Flex Stacker can store with its current stored labware configuration. + """Get the maximum number of labware that the Flex Stacker can store. - You can use this function to get the total number of labware that the Flex Stacker can store. This - number is the overall maximum and will not change as labware is added or removed. To get the space - currently available in the Flex Stacker, use :py:meth:`.get_current_storable_labware`. + Use this function to return the total number of labware that the Flex Stacker can store. A Stacker has a limited amount of internal space and calculates the total number of labware that can be stored based on the ``z`` height of the labware and the amount they overlap when stacked. + + The total number is calculated based on the labware definition for the type of labware the Stacker is currently configured to store using :py:meth:`.set_stored_labware()`. This + number is the overall maximum and will not change as labware is added or removed. To get the number of labware that can + be stored in the Flex Stacker based on its current conditions, use :py:meth:`.get_current_storable_labware`. """ return self._core.get_max_storable_labware() @@ -1248,7 +1256,9 @@ def get_max_storable_labware(self) -> int: def get_current_storable_labware(self) -> int: """Get the number of labware that the Flex Stacker currently has space for. - The number will change as labware is added or removed. To get the overall maximum number of labware the + Use this function to return the total number of labware that the Flex Stacker can store. A Stacker has a limited amount of internal space and calculates the number of labware that can be stored based on the ``z`` height of the labware and the amount they overlap when stacked. + + The number is calculated based on the labware definition for the type of labware the Stacker is currently configured to store using :py:meth:`.set_stored_labware()`. This function returns a number based on the current storage conditions of the Stacker, and will change as labware is added or removed. To get the overall maximum number of labware the Flex Stacker can store, use :py:meth:`.get_max_storable_labware`. """ return self._core.get_current_storable_labware() @@ -1259,7 +1269,7 @@ def set_stored_labware_items( labware: list[Labware], stacking_offset_z: float | None, ) -> None: - """Configure a Flex Stacker by providing an initial list of stored labware objects. + """Configure the labware the Flex Stacker will store during a protocol by providing an initial list of stored labware objects. The kind of labware stored by the Flex Stacker will be calculated from the list of labware specified here. You can use this to store labware objects that you have already created @@ -1276,26 +1286,23 @@ def set_stored_labware_items( will fit, use the return value of :py:method:`.get_max_storable_labware_from_list`. :param labware: A list of labware to load into the stacker. - :param stacking_offset_z: Stacking offset in mm between labware units to override the + :param stacking_offset_z: Stacking ``z`` offset in mm of stored labware. If specified, this overrides the calculated value from labware definitions. .. note:: - The stacking offset is the amount of vertical overlap (in mm) between the bottomside of a - labware unit and the topside of the unit below. This offset is used to determine how many - units can fit in the stacker and calculates the Z position of the shuttle when retrieving - or storing labware. The stacking offset is calculated automatically from the labware - definitions, but you can override it by providing a value here. + The stacking offset is the amount of vertical overlap (in mm) between the bottom side of a + labware unit and the top side of the unit below. This offset is used to determine how many + units can fit in the stacker and calculates the ``z`` position of the shuttle when retrieving + or storing labware. - There are four possible stacking configurations, each with a different way of calculating + There are four possible stacking configurations, each with a different method of calculating the stacking offset: - - Bare labware: labware (bottomside) overlaps with labware (topside) - - Labware on adapter: the adapter (bottomside) of the upper unit overlaps with labware (topside) - of the unit below. - - Labware with lid: the labware (bottomside) of the upper unit overlaps the lid (topside) - of the unit below. - - Labware with lid and adapter: the adapter (bottomside) of the upper unit overlaps the - lid (topside) of the unit below. + - Bare labware: labware (bottom side) overlaps with the top side of the labware below. + - Labware on adapter: the adapter (bottom side) of the upper labware unit overlaps with the top side of the labware below. + - Labware with lid: the labware (bottom side) of the upper unit overlaps with the lid (top side) of the unit below. + - Labware with lid and adapter: the adapter (bottom side) of the upper unit overlaps with the + lid (top side) of the unit below. """ self._core.set_stored_labware_items( @@ -1314,7 +1321,9 @@ def set_stored_labware( count: int | None = None, stacking_offset_z: float | None = None, ) -> None: - """Configure what kind of labware the Flex Stacker will store. + """Configure the type and starting quantity of labware the Flex Stacker will store during a protocol. This is the only type of labware you'll be able to store in the Stacker until it's reconfigured. + + You must use this method to load a labware stack stored inside the Stacker before you're able to ``retrieve()`` or ``store()`` additional labware. :param str load_name: A string to use for looking up a labware definition. You can find the ``load_name`` for any Opentrons-verified labware on the @@ -1340,29 +1349,26 @@ def set_stored_labware( values as the ``load_name`` parameter of :py:meth:`.load_lid_stack`. The lid will use the same namespace as the labware, and the API will choose the lid's version automatically. - :param count: The number of labware that the Flex Stacker should start the protocol - storing. If not specified, this will be the maximum amount of this kind of + :param count: The number of labware that the Flex Stacker should store at the beginning of the protocol. If not specified, this will be the maximum amount of this kind of labware that the Flex Stacker is capable of storing. - :param stacking_offset_z: Stacking offset in mm between labware units to override the - calculated value from labware definitions. + :param stacking_offset_z: Stacking ``z`` offset in mm of stored labware. If specified, this overrides the + calculated value in the labware definition. .. note:: - The stacking offset is the amount of vertical overlap (in mm) between the bottomside of a - labware unit and the topside of the unit below. This offset is used to determine how many - units can fit in the stacker and calculates the Z position of the shuttle when retrieving - or storing labware. The stacking offset is calculated automatically from the labware - definitions, but you can override it by providing a value here. + The stacking offset is the amount of vertical overlap (in mm) between the bottom side of a + labware unit and the top side of the unit below. This offset is used to determine how many + units can fit in the Stacker and calculates the ``z`` position of the shuttle when retrieving + or storing labware. - There are four possible stacking configurations, each with a different way of calculating + There are four possible stacking configurations, each with a different method of calculating the stacking offset: - - Bare labware: labware (bottomside) overlaps with labware (topside) - - Labware on adapter: the adapter (bottomside) of the upper unit overlaps with labware (topside) + - Bare labware: labware (bottom side) overlaps with the top side of the labware below. + - Labware on adapter: the adapter (bottom side) of the upper labware unit overlaps with the top side of the labware below. + - Labware with lid: the labware (bottom side) of the upper labware unit overlaps with the lid (top side) of the unit below. - - Labware with lid: the labware (bottomside) of the upper unit overlaps the lid (topside) - of the unit below. - - Labware with lid and adapter: the adapter (bottomside) of the upper unit overlaps the - lid (topside) of the unit below. + - Labware with lid and adapter: the adapter (bottom side) of the upper labware unit overlaps with the + lid (top side) of the unit below. """ self._core.set_stored_labware( @@ -1381,9 +1387,13 @@ def set_stored_labware( @requires_version(2, 25) def fill(self, count: int | None = None, message: str | None = None) -> None: - """Pause the protocol to add more labware to the Flex Stacker. + """Pause the protocol to add labware to the Flex Stacker. + + The labware must be the same type the Stacker is configured to store using :py:meth:`.set_stored_labware()`. - :param message: A message to display in the Opentrons App to note what kind of labware to add. + This method assumes that labware to fill the Stacker is loaded :py:obj:`OFF_DECK`. + + :param message: A message to display in the Opentrons App noting what kind of labware to fill the Stacker with. :param count: The amount of labware the Flex Stacker should hold after this command is executed. If not specified, the Flex Stacker should be full after this command is executed. """ @@ -1394,19 +1404,21 @@ def fill_items(self, labware: list[Labware], message: str | None = None) -> None """Pause the protocol to add a specific list of labware to the Flex Stacker. The ``labware`` argument must follow certain rules: - - It should have at least one item + - It should contain at least one item. - Its elements should be the same kind of labware previously passed to - :py:meth:`.set_stored_labware_items` or loaded by :py:meth:`.set_stored_labware` - - Its elements should all be loaded :py:obj:`OFF_DECK` + :py:meth:`.set_stored_labware_items` or loaded by :py:meth:`.set_stored_labware`. + - Its elements should all be loaded :py:obj:`OFF_DECK`. - :param message: A message to display in the Opentrons App. + :param message: A message to display in the Opentrons App noting the labware to fill the Stacker with. :param labware: The list of labware to add, following the rules above. """ self._core.fill_items(self._labware_to_cores(labware), message) @requires_version(2, 25) def empty(self, message: str | None = None) -> None: - """Pause the protocol to remove labware from the Flex Stacker. + """Pause the protocol to remove all labware stored in the Flex Stacker. + + This method assumes that labware removed from the Stacker is moved :py:obj:`OFF_DECK`. :param message: A message to display in the Opentrons App to note what should be removed from the Flex Stacker. @@ -1417,9 +1429,11 @@ def empty(self, message: str | None = None) -> None: @requires_version(2, 25) def get_stored_labware(self) -> list[Labware]: - """Get the list of labware currently stored inside the stacker. + """Get the list of labware currently stored inside the Stacker. - The first element of the list is on the bottom and will be the item retrieved by a call to + This function returns a list of all labware stored in the Stacker based on the labware intially stored using :py:meth:`.set_stored_labware() and any labware added or removed during the protocol. + + The first element of the list occupies the bottom-most position in the labware stack and would be the labware retrieved by a call to :py:meth:`.retrieve`. """ return self._cores_to_labware(self._core.get_stored_labware()) From 2de9d71c01e90fe655bcf365b6079e7f99b0fea3 Mon Sep 17 00:00:00 2001 From: emilyburghardt Date: Fri, 15 Aug 2025 10:12:54 -0600 Subject: [PATCH 07/18] trying to fix last error --- api/docs/v2/modules/stacker.rst | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/api/docs/v2/modules/stacker.rst b/api/docs/v2/modules/stacker.rst index 90f79bc5c45..73b8037a2ec 100644 --- a/api/docs/v2/modules/stacker.rst +++ b/api/docs/v2/modules/stacker.rst @@ -41,7 +41,7 @@ Each Stacker can hold a labware stack of up to: - 48 PCR plates, like - 16 deep well plates, like -You'll need to use :py:meth:`~.FlexStackerContext.set_stored_labware()` to configure the Stacker before adding or removing labware during a protocol. Only one type of labware can be stored in each Stacker at one time. +You'll need to use :py:meth:`~.FlexStackerContext.set_stored_labware` to configure the Stacker before adding or removing labware during a protocol. Only one type of labware can be stored in each Stacker at one time. .. code-block:: python @@ -72,7 +72,7 @@ Configuring the Stacker assigns a labware stack to this deck slot. You can use t Using Stacker Labware ====================== -During a protocol, use `~.ModuleContext.stacker.retrieve()` to automatically access a single piece of labware to use on the Flex deck. +During a protocol, use `~.FlexStackerContext.retrieve()` to automatically access a single piece of labware to use on the Flex deck. .. code-block:: python @@ -85,7 +85,7 @@ During a protocol, use `~.ModuleContext.stacker.retrieve()` to automatically acc Here, the Flex tip rack at the bottom of the labware stack is moved to the shuttle in slot A3. Then, use the Flex Gripper or manually move the new tip rack elsewhere on the deck. -To add more labware to a Stacker, use `~.ModuleContext.stacker.store()`:: +To add more labware to a Stacker, use `~.FlexStackerContext.store()`:: protocol.move_labware( labware="opentrons_96_wellplate_200ul_pcr_full_skirt", @@ -96,7 +96,7 @@ To add more labware to a Stacker, use `~.ModuleContext.stacker.store()`:: After placing labware on the shuttle in slot C3, ``stacker_2`` stores another well plate on the bottom of the stack. -To mark a Stacker as completely full or empty, use `~.ModuleContext.stacker.fill()` or `~.StackerContext.stacker.empty()`:: +To mark a Stacker as completely full or empty, use `~.FlexStackerContext.fill()` or `~.FlexStackerContext.empty()`:: # mark the second Stacker as empty stacker_2.empty() From c084251c9fcbc1cec9314b789b8f86eabce1b30e Mon Sep 17 00:00:00 2001 From: emilyburghardt Date: Tue, 19 Aug 2025 15:01:41 -0600 Subject: [PATCH 08/18] lil bit of feedback changes --- api/docs/v2/modules/stacker.rst | 51 +++++++++++++-------------------- 1 file changed, 20 insertions(+), 31 deletions(-) diff --git a/api/docs/v2/modules/stacker.rst b/api/docs/v2/modules/stacker.rst index 73b8037a2ec..66bba221b28 100644 --- a/api/docs/v2/modules/stacker.rst +++ b/api/docs/v2/modules/stacker.rst @@ -6,14 +6,14 @@ Flex Stacker Module ******************* -The Flex Stacker is an external module that provides automated storage of well plates, Flex tip racks, or reservoirs. The Stacker's attached shuttle moves labware from the stack to the deck for use during a protocol. +The Flex Stacker is an external module that provides automated storage and dispensing of Flex tip racks, well plates, or reservoirs. The Stacker's attached shuttle moves stored labware from the stack to add to the Flex deck during a protocol. -The Stacker is represented in code by a ``StackerContext`` object that includes methods for storing and retrieving labware. You can also use helper commands in your protocol to calculate how many labware the Stacker can store at once. +The Stacker is represented in code by a ``StackerContext`` object that includes methods for retrieving and storing labware. You can also use helper commands in your protocol to calculate how many labware the Stacker can store at once. Loading and Deck Slots ======================== -Up to four Stacker Modules can be attached to the right side of your Flex, creating deck slots A4--D4. Each Stacker occupies a deck slot in column 4, with the shuttle in column 3. +Up to four Stacker Modules can be attached to the right side of your Flex, creating deck slots A4–D4. Each Stacker occupies a deck slot in column 4, with the shuttle in column 3. Start by loading each Stacker as you would any other module: @@ -28,20 +28,20 @@ Start by loading each Stacker as you would any other module: location="C4" ) -Each Stacker occupies a deck slot in column 4, with the attached shuttle in column 3. In this example, Stacker shuttles occupy deck slots A3 and C3. +In this example, Stacker shuttles occupy deck slots A3 and C3. Adding Labware to the Stacker ============================== -Next, you'll need to define the *type* and amount of labware the Stacker will store. Throughout yor protocol, the Flex automatically moves labware, like well plates or tip racks, from inside the Stacker to the deck. +Next, you'll need to define the type and amount of labware the Stacker will store. Throughout your protocol, the Flex automatically moves labware, like well plates or tip racks, from inside the Stacker to the deck. Only one type of labware can be stored in each Stacker at one time. Each Stacker can hold a labware stack of up to: -- 7 Flex tipracks (6 in the Stacker and 1 on the shuttle) -- 48 PCR plates, like -- 16 deep well plates, like +- 7 Flex tipracks with lids (6 in the Stacker and 1 on the shuttle) +- 48 PCR plates, like ``opentrons_96_wellplate_200ul_pcr_full_skirt`` +- 16 deep well plates, like ``nest_96_wellplate_2ml_deep`` -You'll need to use :py:meth:`~.FlexStackerContext.set_stored_labware` to configure the Stacker before adding or removing labware during a protocol. Only one type of labware can be stored in each Stacker at one time. +You'll need to use :py:meth:`~.FlexStackerContext.set_stored_labware` to configure the Stacker before adding or removing labware during a protocol. .. code-block:: python @@ -55,24 +55,26 @@ You'll need to use :py:meth:`~.FlexStackerContext.set_stored_labware` to configu count=12 ) -In this example, `stacker_1` is configured to hold 6 Flex tip racks, each with a compatible lid. Flex tip racks must have lids to be properly stored in the Stacker. `stacker_2` is configured to hold 12 PCR plates without lids. +In this example, ``stacker_1`` is configured to hold 6 Flex tip racks, each with a compatible lid. Flex tip racks must have lids to be properly stored in the Stacker. ``stacker_2`` is configured to hold 12 PCR plates without lids. Configuring the Stacker assigns a labware stack to this deck slot. You can use the Stacker and shuttle as a normal deck slot earlier in your protocol with :py:meth:`~.ProtocolContext.load_labware()`. You'll need to move this labware elsewhere on the deck before configuring and using the Stacker for storage. -.. note:: - Different labware have varying `z` heights. One well plate might be 2 mm taller than another, affecting the number of plates the Stacker can store at once. The API includes helper commands to calculate how many labware the Stacker can hold: +Stacker Capacity +----------------- + +Different labware have varying `z` heights. One well plate might be 2 mm taller than another, affecting the number of plates the Stacker can store at once. The API includes helper commands to calculate how many labware the Stacker can hold: - `.ModuleContext.get_max_storable_labware()` - `.ModuleContext.get_current_storable_labware()` - `.ModuleContext.get_stored_labware()` - Use ``get_max_storable_labware()`` or ``get_current_storable_labware()`` to calculate the maximum or current number of labware the Stacker can store, based on either the labware definition or the Stacker's current storage conditions. +Use ``get_max_storable_labware()`` or ``get_current_storable_labware()`` to calculate the maximum or current number of labware the Stacker can store, based on either the labware definition or the Stacker's current storage conditions. - Like other hardware modules, the Stacker doesn't verify the labware you place inside it. If your Stacker is configured correctly, you can use ``get_stored_labware()`` throughout your protocol to check an updated list of labware stored inside. +Like other hardware modules, the Stacker doesn't verify the labware you place inside it. If your Stacker is configured correctly, you can use ``get_stored_labware()`` throughout your protocol to check an updated list of labware stored inside. Using Stacker Labware ====================== -During a protocol, use `~.FlexStackerContext.retrieve()` to automatically access a single piece of labware to use on the Flex deck. +During a protocol, use :py:meth:`~.FlexStackerContext.retrieve()` to automatically access a single piece of labware to use on the Flex deck. .. code-block:: python @@ -83,9 +85,9 @@ During a protocol, use `~.FlexStackerContext.retrieve()` to automatically access use_gripper="True" ) -Here, the Flex tip rack at the bottom of the labware stack is moved to the shuttle in slot A3. Then, use the Flex Gripper or manually move the new tip rack elsewhere on the deck. +Here, the Stacker's shuttle takes the Flex tip rack at the bottom of the labware stack and moves it into slot A3. Then, the Flex Gripper moves that tip rack to slot B2 on the deck. -To add more labware to a Stacker, use `~.FlexStackerContext.store()`:: +To move labware from the deck into a Stacker, use `~.FlexStackerContext.store()`:: protocol.move_labware( labware="opentrons_96_wellplate_200ul_pcr_full_skirt", @@ -108,17 +110,4 @@ To mark a Stacker as completely full or empty, use `~.FlexStackerContext.fill()` ) stacker_2.fill(8, "Add 8 reservoirs to stacker_2.") -Both ``fill()`` and ``empty()`` pause the protocol and allow you to manually add or remove labware from the Stacker. Each method assumes labware is loaded or moved ``off_deck``. - - - - - - - - - - - - - +Both ``fill()`` and ``empty()`` pause the protocol and allow you to manually add or remove labware from the Stacker. Each method assumes labware is loaded or moved ``off_deck``. \ No newline at end of file From bd6a61465e538873e6d5f8e5738744bf4f1b0df9 Mon Sep 17 00:00:00 2001 From: emilyburghardt Date: Mon, 25 Aug 2025 16:29:32 -0600 Subject: [PATCH 09/18] small changes for feedback --- api/docs/v2/modules/stacker.rst | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/api/docs/v2/modules/stacker.rst b/api/docs/v2/modules/stacker.rst index 66bba221b28..e99315a9d88 100644 --- a/api/docs/v2/modules/stacker.rst +++ b/api/docs/v2/modules/stacker.rst @@ -37,17 +37,17 @@ Next, you'll need to define the type and amount of labware the Stacker will stor Each Stacker can hold a labware stack of up to: -- 7 Flex tipracks with lids (6 in the Stacker and 1 on the shuttle) +- 7 Flex tip racks with lids (6 in the Stacker and 1 on the shuttle) - 48 PCR plates, like ``opentrons_96_wellplate_200ul_pcr_full_skirt`` - 16 deep well plates, like ``nest_96_wellplate_2ml_deep`` -You'll need to use :py:meth:`~.FlexStackerContext.set_stored_labware` to configure the Stacker before adding or removing labware during a protocol. +You'll need to use :py:meth:`~.FlexStackerContext.set_stored_labware` to configure and load the type of labware you want to store in the Stacker. .. code-block:: python stacker_1.set_stored_labware( load_name="opentrons_flex_96_tiprack_200ul", - count=6, + count=5, lid="opentrons_flex_tiprack_lid" ) stacker_2.set_stored_labware( @@ -55,9 +55,9 @@ You'll need to use :py:meth:`~.FlexStackerContext.set_stored_labware` to configu count=12 ) -In this example, ``stacker_1`` is configured to hold 6 Flex tip racks, each with a compatible lid. Flex tip racks must have lids to be properly stored in the Stacker. ``stacker_2`` is configured to hold 12 PCR plates without lids. +In this example, ``stacker_1`` is configured to hold 6 Flex tip racks, each with a compatible lid. Flex tip racks must have lids to be properly stored in the Stacker. ``stacker_2`` is configured to hold 12 PCR plates without lids. You must configure each Stacker in your protocol before using :py:meth:`.FlexStackerContext.store` or :py:meth:`.FlexStackerContext.retrieve`. -Configuring the Stacker assigns a labware stack to this deck slot. You can use the Stacker and shuttle as a normal deck slot earlier in your protocol with :py:meth:`~.ProtocolContext.load_labware()`. You'll need to move this labware elsewhere on the deck before configuring and using the Stacker for storage. +:py:meth:`~.FlexStackerContext.set_stored_labware` assigns a labware stack to the Stacker in this deck slot. You can use the Stacker and shuttle as a normal deck slot earlier in your protocol with :py:meth:`~.ProtocolContext.load_labware()`. You'll need to move this labware elsewhere on the deck before configuring and using the Stacker for storage. Stacker Capacity ----------------- @@ -66,7 +66,6 @@ Different labware have varying `z` heights. One well plate might be 2 mm taller - `.ModuleContext.get_max_storable_labware()` - `.ModuleContext.get_current_storable_labware()` - - `.ModuleContext.get_stored_labware()` Use ``get_max_storable_labware()`` or ``get_current_storable_labware()`` to calculate the maximum or current number of labware the Stacker can store, based on either the labware definition or the Stacker's current storage conditions. @@ -98,7 +97,7 @@ To move labware from the deck into a Stacker, use `~.FlexStackerContext.store()` After placing labware on the shuttle in slot C3, ``stacker_2`` stores another well plate on the bottom of the stack. -To mark a Stacker as completely full or empty, use `~.FlexStackerContext.fill()` or `~.FlexStackerContext.empty()`:: +You can use :py:meth:`~.FlexStackerContext.fill` to fill the Stacker with as many of its configured labware as it can store. Alternatively, use :py:meth:`~.FlexStackerContext.empty` to remove all labware from the Stacker:: # mark the second Stacker as empty stacker_2.empty() @@ -108,6 +107,8 @@ To mark a Stacker as completely full or empty, use `~.FlexStackerContext.fill()` load_name="nest_12_reservoir_15ml", count=8 ) - stacker_2.fill(8, "Add 8 reservoirs to stacker_2.") + stacker_1.fill(1, "Add another tip rack to stacker_1.") -Both ``fill()`` and ``empty()`` pause the protocol and allow you to manually add or remove labware from the Stacker. Each method assumes labware is loaded or moved ``off_deck``. \ No newline at end of file +Here, ``stacker_2`` is emptied and reconfigured to store NEST reservoirs with ``set_stored_labware()`` and the ``fill`` method adds another Flex tip rack to ``stacker_1``. + +Both ``fill()`` and ``empty()`` methods pause the protocol and allow you to manually add or remove labware from the Stacker. Each method assumes labware is loaded or moved off deck. \ No newline at end of file From 45ac465e0a1a5a284a0676953088ad5b22c03c21 Mon Sep 17 00:00:00 2001 From: emilyburghardt Date: Tue, 26 Aug 2025 11:01:02 -0600 Subject: [PATCH 10/18] final text changes? --- api/docs/v2/modules/stacker.rst | 10 +++++----- api/src/opentrons/protocol_api/module_contexts.py | 2 +- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/api/docs/v2/modules/stacker.rst b/api/docs/v2/modules/stacker.rst index e99315a9d88..c90f2a3a8ec 100644 --- a/api/docs/v2/modules/stacker.rst +++ b/api/docs/v2/modules/stacker.rst @@ -8,7 +8,7 @@ Flex Stacker Module The Flex Stacker is an external module that provides automated storage and dispensing of Flex tip racks, well plates, or reservoirs. The Stacker's attached shuttle moves stored labware from the stack to add to the Flex deck during a protocol. -The Stacker is represented in code by a ``StackerContext`` object that includes methods for retrieving and storing labware. You can also use helper commands in your protocol to calculate how many labware the Stacker can store at once. +The Stacker is represented in code by a :py:class:`.FlexStackerContext` object that includes methods for retrieving and storing labware. You can also use helper commands in your protocol to calculate how many labware the Stacker can store at once. Loading and Deck Slots ======================== @@ -57,15 +57,15 @@ You'll need to use :py:meth:`~.FlexStackerContext.set_stored_labware` to configu In this example, ``stacker_1`` is configured to hold 6 Flex tip racks, each with a compatible lid. Flex tip racks must have lids to be properly stored in the Stacker. ``stacker_2`` is configured to hold 12 PCR plates without lids. You must configure each Stacker in your protocol before using :py:meth:`.FlexStackerContext.store` or :py:meth:`.FlexStackerContext.retrieve`. -:py:meth:`~.FlexStackerContext.set_stored_labware` assigns a labware stack to the Stacker in this deck slot. You can use the Stacker and shuttle as a normal deck slot earlier in your protocol with :py:meth:`~.ProtocolContext.load_labware()`. You'll need to move this labware elsewhere on the deck before configuring and using the Stacker for storage. +:py:meth:`~.FlexStackerContext.set_stored_labware` assigns a labware stack to the Stacker in this deck slot. You can use the Stacker and shuttle as a normal deck slot earlier in your protocol with :py:meth:`~.FlexStackerContext.load_labware`. You'll need to move this labware elsewhere on the deck before configuring and using the Stacker for storage. Stacker Capacity ----------------- Different labware have varying `z` heights. One well plate might be 2 mm taller than another, affecting the number of plates the Stacker can store at once. The API includes helper commands to calculate how many labware the Stacker can hold: - - `.ModuleContext.get_max_storable_labware()` - - `.ModuleContext.get_current_storable_labware()` + - `.ModuleContext.get_max_storable_labware` + - `.ModuleContext.get_current_storable_labware` Use ``get_max_storable_labware()`` or ``get_current_storable_labware()`` to calculate the maximum or current number of labware the Stacker can store, based on either the labware definition or the Stacker's current storage conditions. @@ -73,7 +73,7 @@ Like other hardware modules, the Stacker doesn't verify the labware you place in Using Stacker Labware ====================== -During a protocol, use :py:meth:`~.FlexStackerContext.retrieve()` to automatically access a single piece of labware to use on the Flex deck. +During a protocol, use :py:meth:`~.FlexStackerContext.retrieve` to automatically access a single piece of labware to use on the Flex deck. .. code-block:: python diff --git a/api/src/opentrons/protocol_api/module_contexts.py b/api/src/opentrons/protocol_api/module_contexts.py index 965e5386a17..6a3d7e1716c 100644 --- a/api/src/opentrons/protocol_api/module_contexts.py +++ b/api/src/opentrons/protocol_api/module_contexts.py @@ -1339,7 +1339,7 @@ def set_stored_labware( definition whose ``load_name`` is the same as an Opentrons-verified definition, and you want to explicitly choose one or the other. :param version: The version of the labware definition. You should normally - leave this unspecified to let ``load_labware()`` choose a version + leave this unspecified to let the method choose a version automatically. :param adapter: An adapter to load the labware on top of. Accepts the same values as the ``load_name`` parameter of :py:meth:`.load_adapter`. The From 1ff837d32be5b005a07c6cf8d9e75278d5c7d6c6 Mon Sep 17 00:00:00 2001 From: emilyburghardt Date: Wed, 27 Aug 2025 13:04:35 -0600 Subject: [PATCH 11/18] feedback changes --- api/docs/v2/modules/stacker.rst | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-) diff --git a/api/docs/v2/modules/stacker.rst b/api/docs/v2/modules/stacker.rst index c90f2a3a8ec..ac31742044c 100644 --- a/api/docs/v2/modules/stacker.rst +++ b/api/docs/v2/modules/stacker.rst @@ -13,7 +13,7 @@ The Stacker is represented in code by a :py:class:`.FlexStackerContext` object t Loading and Deck Slots ======================== -Up to four Stacker Modules can be attached to the right side of your Flex, creating deck slots A4–D4. Each Stacker occupies a deck slot in column 4, with the shuttle in column 3. +Up to four Stacker Modules can be attached to the right side of your Flex. Each Stacker's shuttle occupies a deck slot in column 4. Start by loading each Stacker as you would any other module: @@ -64,8 +64,8 @@ Stacker Capacity Different labware have varying `z` heights. One well plate might be 2 mm taller than another, affecting the number of plates the Stacker can store at once. The API includes helper commands to calculate how many labware the Stacker can hold: - - `.ModuleContext.get_max_storable_labware` - - `.ModuleContext.get_current_storable_labware` + - :py:meth:`.FlexStackerContext.get_max_storable_labware` + - :py:meth:`.FlexStackerContext.get_current_storable_labware` Use ``get_max_storable_labware()`` or ``get_current_storable_labware()`` to calculate the maximum or current number of labware the Stacker can store, based on either the labware definition or the Stacker's current storage conditions. @@ -77,21 +77,20 @@ During a protocol, use :py:meth:`~.FlexStackerContext.retrieve` to automatically .. code-block:: python - stacker_1.retrieve() protocol.move_labware( - labware="opentrons_flex_96_tiprack_200ul", + labware=stacker_1.retrieve(), new_location="B2", - use_gripper="True" + use_gripper=True ) Here, the Stacker's shuttle takes the Flex tip rack at the bottom of the labware stack and moves it into slot A3. Then, the Flex Gripper moves that tip rack to slot B2 on the deck. -To move labware from the deck into a Stacker, use `~.FlexStackerContext.store()`:: +To move labware from the deck into a Stacker, use :py:meth:`~.FlexStackerContext.store()`:: protocol.move_labware( - labware="opentrons_96_wellplate_200ul_pcr_full_skirt", + labware=plate, new_location=stacker_2, - use_gripper="True" + use_gripper=True ) stacker_2.store() From 0b61285bc4b9536bc5e69b044a0d2d84a3b93a25 Mon Sep 17 00:00:00 2001 From: Edward Cormany Date: Fri, 15 Aug 2025 13:19:29 -0400 Subject: [PATCH 12/18] add stacker to ref and let forth the sphinx's riddles --- api/docs/v2/new_protocol_api.rst | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/api/docs/v2/new_protocol_api.rst b/api/docs/v2/new_protocol_api.rst index 3ca71ea99a9..750b2d93765 100644 --- a/api/docs/v2/new_protocol_api.rst +++ b/api/docs/v2/new_protocol_api.rst @@ -65,6 +65,14 @@ Absorbance Plate Reader :inherited-members: +Flex Stacker +------------ + +.. autoclass:: opentrons.protocol_api.FlexStackerContext + :members: + :exclude-members: calibrate, broker, geometry, load_labware_object, load_labware + :inherited-members: + Heater-Shaker ------------- From 89d12f1f02468a12eff3fce0757605db37d644ca Mon Sep 17 00:00:00 2001 From: Edward Cormany Date: Fri, 15 Aug 2025 13:27:50 -0400 Subject: [PATCH 13/18] solve the riddles --- .../opentrons/protocol_api/module_contexts.py | 96 ++++++++++--------- 1 file changed, 49 insertions(+), 47 deletions(-) diff --git a/api/src/opentrons/protocol_api/module_contexts.py b/api/src/opentrons/protocol_api/module_contexts.py index 6a3d7e1716c..41427a70ebb 100644 --- a/api/src/opentrons/protocol_api/module_contexts.py +++ b/api/src/opentrons/protocol_api/module_contexts.py @@ -248,7 +248,7 @@ def load_labware_by_name( ) -> Labware: """ .. deprecated:: 2.0 - Use :py:meth:`load_labware` instead. + Use ``load_labware`` instead. """ _log.warning("load_labware_by_name is deprecated. Use load_labware instead.") return self.load_labware( @@ -1143,7 +1143,7 @@ def serial_number(self) -> str: def retrieve(self) -> Labware: """Retrieve a labware from the Flex Stacker and move it onto the shuttle. - The Stacker will retrieve the bottom-most labware in the stack. + The Stacker will retrieve the bottom-most labware in the stack. :returns: The retrieved :py:class:`Labware` object. This will always be the main labware, even if the Flex Stacker contains labware on an adapter. To get the adapter object, @@ -1162,8 +1162,9 @@ def retrieve(self) -> Labware: @requires_version(2, 25) def store(self) -> None: """Move a labware currently on the Flex Stacker shuttle into the Flex Stacker. - - The labware must be the same type the Stacker is configured to store using :py:meth:`.set_stored_labware()`. If labware is currently stacked inside the module, this method moves the new labware to the bottom-most position of the stack. """ + + The labware must be the same type the Stacker is configured to store using :py:meth:`.set_stored_labware()`. If labware is currently stacked inside the module, this method moves the new labware to the bottom-most position of the stack. + """ self._core.store() def _labware_to_cores(self, labware: Sequence[Labware]) -> list[LabwareCore]: @@ -1224,8 +1225,8 @@ def get_current_storable_labware_from_list( """Limit a list of labware instances to the number that the Flex Stacker currently has space for, based on the labware that is already stored in the Flex Stacker. - A Flex Stacker has a limited amount of internal space and computes the number of labware that it can store based on the ``z`` height of the labware and the amount they overlap when stacked. - + A Flex Stacker has a limited amount of internal space and computes the number of labware that it can store based on the ``z`` height of the labware and the amount they overlap when stacked. + Provide a list of labware to this function to return the elements that the Stacker can currently store from it. The returned list is then guaranteed to be suitable for passing to :py:meth:`.fill`. @@ -1242,12 +1243,12 @@ def get_current_storable_labware_from_list( @requires_version(2, 25) def get_max_storable_labware(self) -> int: - """Get the maximum number of labware that the Flex Stacker can store. + """Get the maximum number of labware that the Flex Stacker can store. + + Use this function to return the total number of labware that the Flex Stacker can store. A Stacker has a limited amount of internal space and calculates the total number of labware that can be stored based on the ``z`` height of the labware and the amount they overlap when stacked. - Use this function to return the total number of labware that the Flex Stacker can store. A Stacker has a limited amount of internal space and calculates the total number of labware that can be stored based on the ``z`` height of the labware and the amount they overlap when stacked. - The total number is calculated based on the labware definition for the type of labware the Stacker is currently configured to store using :py:meth:`.set_stored_labware()`. This - number is the overall maximum and will not change as labware is added or removed. To get the number of labware that can + number is the overall maximum and will not change as labware is added or removed. To get the number of labware that can be stored in the Flex Stacker based on its current conditions, use :py:meth:`.get_current_storable_labware`. """ return self._core.get_max_storable_labware() @@ -1256,7 +1257,7 @@ def get_max_storable_labware(self) -> int: def get_current_storable_labware(self) -> int: """Get the number of labware that the Flex Stacker currently has space for. - Use this function to return the total number of labware that the Flex Stacker can store. A Stacker has a limited amount of internal space and calculates the number of labware that can be stored based on the ``z`` height of the labware and the amount they overlap when stacked. + Use this function to return the total number of labware that the Flex Stacker can store. A Stacker has a limited amount of internal space and calculates the number of labware that can be stored based on the ``z`` height of the labware and the amount they overlap when stacked. The number is calculated based on the labware definition for the type of labware the Stacker is currently configured to store using :py:meth:`.set_stored_labware()`. This function returns a number based on the current storage conditions of the Stacker, and will change as labware is added or removed. To get the overall maximum number of labware the Flex Stacker can store, use :py:meth:`.get_max_storable_labware`. @@ -1275,15 +1276,16 @@ def set_stored_labware_items( specified here. You can use this to store labware objects that you have already created so that, for instance, you can set their liquid state or nicknames. There are several restrictions on the values of the ``labware`` argument: - - ``labware`` must have at least one element - - Elements of ``labware`` will be stored along with their lid, if any, and an adapter they - rest on, if any. These must be compatible with the Flex Stacker. - - All elements of ``labware`` must be loaded :py:obj:`OFF_DECK`. - - All elements of ``labware`` must be the same kind of labware. If any of them have lids, they - must all have lids, and the lids must be the same. If any of them are on adapters, they all - must be on adapters, and the adapters must be the same. - - The number of labware objects must fit in the stacker physically. To make sure the labware - will fit, use the return value of :py:method:`.get_max_storable_labware_from_list`. + + - ``labware`` must have at least one element + - Elements of ``labware`` will be stored along with their lid, if any, and an adapter they + rest on, if any. These must be compatible with the Flex Stacker. + - All elements of ``labware`` must be loaded :py:obj:`OFF_DECK`. + - All elements of ``labware`` must be the same kind of labware. If any of them have lids, they + must all have lids, and the lids must be the same. If any of them are on adapters, they all + must be on adapters, and the adapters must be the same. + - The number of labware objects must fit in the stacker physically. To make sure the labware + will fit, use the return value of :py:meth:`.get_max_storable_labware_from_list`. :param labware: A list of labware to load into the stacker. :param stacking_offset_z: Stacking ``z`` offset in mm of stored labware. If specified, this overrides the @@ -1294,15 +1296,16 @@ def set_stored_labware_items( The stacking offset is the amount of vertical overlap (in mm) between the bottom side of a labware unit and the top side of the unit below. This offset is used to determine how many units can fit in the stacker and calculates the ``z`` position of the shuttle when retrieving - or storing labware. + or storing labware. There are four possible stacking configurations, each with a different method of calculating the stacking offset: - - Bare labware: labware (bottom side) overlaps with the top side of the labware below. - - Labware on adapter: the adapter (bottom side) of the upper labware unit overlaps with the top side of the labware below. - - Labware with lid: the labware (bottom side) of the upper unit overlaps with the lid (top side) of the unit below. - - Labware with lid and adapter: the adapter (bottom side) of the upper unit overlaps with the - lid (top side) of the unit below. + + - Bare labware: labware (bottom side) overlaps with the top side of the labware below. + - Labware on adapter: the adapter (bottom side) of the upper labware unit overlaps with the top side of the labware below. + - Labware with lid: the labware (bottom side) of the upper unit overlaps with the lid (top side) of the unit below. + - Labware with lid and adapter: the adapter (bottom side) of the upper unit overlaps with the + lid (top side) of the unit below. """ self._core.set_stored_labware_items( @@ -1321,9 +1324,9 @@ def set_stored_labware( count: int | None = None, stacking_offset_z: float | None = None, ) -> None: - """Configure the type and starting quantity of labware the Flex Stacker will store during a protocol. This is the only type of labware you'll be able to store in the Stacker until it's reconfigured. - - You must use this method to load a labware stack stored inside the Stacker before you're able to ``retrieve()`` or ``store()`` additional labware. + """Configure the type and starting quantity of labware the Flex Stacker will store during a protocol. This is the only type of labware you'll be able to store in the Stacker until it's reconfigured. + + You must use this method to load a labware stack stored inside the Stacker before you're able to ``retrieve()`` or ``store()`` additional labware. :param str load_name: A string to use for looking up a labware definition. You can find the ``load_name`` for any Opentrons-verified labware on the @@ -1346,7 +1349,7 @@ def set_stored_labware( adapter will use the same namespace as the labware, and the API will choose the adapter's version automatically. :param lid: A lid to load the on top of the main labware. Accepts the same - values as the ``load_name`` parameter of :py:meth:`.load_lid_stack`. The + values as the ``load_name`` parameter of :py:meth:`~.ProtocolContext.load_lid_stack`. The lid will use the same namespace as the labware, and the API will choose the lid's version automatically. :param count: The number of labware that the Flex Stacker should store at the beginning of the protocol. If not specified, this will be the maximum amount of this kind of @@ -1359,16 +1362,15 @@ def set_stored_labware( The stacking offset is the amount of vertical overlap (in mm) between the bottom side of a labware unit and the top side of the unit below. This offset is used to determine how many units can fit in the Stacker and calculates the ``z`` position of the shuttle when retrieving - or storing labware. + or storing labware. There are four possible stacking configurations, each with a different method of calculating the stacking offset: - - Bare labware: labware (bottom side) overlaps with the top side of the labware below. - - Labware on adapter: the adapter (bottom side) of the upper labware unit overlaps with the top side of the labware below. - - Labware with lid: the labware (bottom side) of the upper labware unit overlaps with the lid (top side) - of the unit below. - - Labware with lid and adapter: the adapter (bottom side) of the upper labware unit overlaps with the - lid (top side) of the unit below. + + - Bare labware: labware (bottom side) overlaps with the top side of the labware below. + - Labware on adapter: the adapter (bottom side) of the upper labware unit overlaps with the top side of the labware below. + - Labware with lid: the labware (bottom side) of the upper labware unit overlaps with the lid (top side) of the unit below. + - Labware with lid and adapter: the adapter (bottom side) of the upper labware unit overlaps with the lid (top side) of the unit below. """ self._core.set_stored_labware( @@ -1389,9 +1391,9 @@ def set_stored_labware( def fill(self, count: int | None = None, message: str | None = None) -> None: """Pause the protocol to add labware to the Flex Stacker. - The labware must be the same type the Stacker is configured to store using :py:meth:`.set_stored_labware()`. + The labware must be the same type the Stacker is configured to store using :py:meth:`.set_stored_labware()`. - This method assumes that labware to fill the Stacker is loaded :py:obj:`OFF_DECK`. + This method assumes that labware to fill the Stacker is loaded :py:obj:`OFF_DECK`. :param message: A message to display in the Opentrons App noting what kind of labware to fill the Stacker with. :param count: The amount of labware the Flex Stacker should hold after this command is executed. @@ -1404,10 +1406,10 @@ def fill_items(self, labware: list[Labware], message: str | None = None) -> None """Pause the protocol to add a specific list of labware to the Flex Stacker. The ``labware`` argument must follow certain rules: - - It should contain at least one item. - - Its elements should be the same kind of labware previously passed to - :py:meth:`.set_stored_labware_items` or loaded by :py:meth:`.set_stored_labware`. - - Its elements should all be loaded :py:obj:`OFF_DECK`. + - It should contain at least one item. + - Its elements should be the same kind of labware previously passed to + :py:meth:`.set_stored_labware_items` or loaded by :py:meth:`.set_stored_labware`. + - Its elements should all be loaded :py:obj:`OFF_DECK`. :param message: A message to display in the Opentrons App noting the labware to fill the Stacker with. :param labware: The list of labware to add, following the rules above. @@ -1418,7 +1420,7 @@ def fill_items(self, labware: list[Labware], message: str | None = None) -> None def empty(self, message: str | None = None) -> None: """Pause the protocol to remove all labware stored in the Flex Stacker. - This method assumes that labware removed from the Stacker is moved :py:obj:`OFF_DECK`. + This method assumes that labware removed from the Stacker is moved :py:obj:`OFF_DECK`. :param message: A message to display in the Opentrons App to note what should be removed from the Flex Stacker. @@ -1431,9 +1433,9 @@ def empty(self, message: str | None = None) -> None: def get_stored_labware(self) -> list[Labware]: """Get the list of labware currently stored inside the Stacker. - This function returns a list of all labware stored in the Stacker based on the labware intially stored using :py:meth:`.set_stored_labware() and any labware added or removed during the protocol. - - The first element of the list occupies the bottom-most position in the labware stack and would be the labware retrieved by a call to + This function returns a list of all labware stored in the Stacker based on the labware intially stored using :py:meth:`.set_stored_labware` and any labware added or removed during the protocol. + + The first element of the list occupies the bottom-most position in the labware stack and would be the labware retrieved by a call to :py:meth:`.retrieve`. """ return self._cores_to_labware(self._core.get_stored_labware()) From 4f3b67967d32cc697670d7ae70963dffc344b3c1 Mon Sep 17 00:00:00 2001 From: Edward Cormany Date: Tue, 26 Aug 2025 14:02:52 -0400 Subject: [PATCH 14/18] don't hide load_labware() for stacker --- api/docs/v2/new_protocol_api.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/api/docs/v2/new_protocol_api.rst b/api/docs/v2/new_protocol_api.rst index 750b2d93765..2cf8ef47fdf 100644 --- a/api/docs/v2/new_protocol_api.rst +++ b/api/docs/v2/new_protocol_api.rst @@ -70,7 +70,7 @@ Flex Stacker .. autoclass:: opentrons.protocol_api.FlexStackerContext :members: - :exclude-members: calibrate, broker, geometry, load_labware_object, load_labware + :exclude-members: calibrate, broker, geometry, load_labware_object :inherited-members: Heater-Shaker From 45841daf0fb9d795d1a4e281188095c4f16064be Mon Sep 17 00:00:00 2001 From: Edward Cormany Date: Wed, 20 Aug 2025 13:10:54 -0400 Subject: [PATCH 15/18] edits to Stacker method docstrings --- .../opentrons/protocol_api/module_contexts.py | 65 ++++++++++--------- 1 file changed, 33 insertions(+), 32 deletions(-) diff --git a/api/src/opentrons/protocol_api/module_contexts.py b/api/src/opentrons/protocol_api/module_contexts.py index 41427a70ebb..98252906e33 100644 --- a/api/src/opentrons/protocol_api/module_contexts.py +++ b/api/src/opentrons/protocol_api/module_contexts.py @@ -1189,6 +1189,7 @@ def get_max_storable_labware_from_list( stacking_offset_z: float | None = None, ) -> list[Labware]: """Limit a list of labware instances to the number that can be stored in a Flex Stacker. + Items will be taken from the head of the list. A Flex Stacker has a limited amount of internal space and computes the number of labware (or labware with lids or adapters) that it can store based on the ``z`` heights of the labware @@ -1224,16 +1225,17 @@ def get_current_storable_labware_from_list( ) -> list[Labware]: """Limit a list of labware instances to the number that the Flex Stacker currently has space for, based on the labware that is already stored in the Flex Stacker. + Items will be taken from the head of the list. A Flex Stacker has a limited amount of internal space and computes the number of labware that it can store based on the ``z`` height of the labware and the amount they overlap when stacked. - Provide a list of labware to this function to return the elements that the - Stacker can currently store from it. The returned list is then guaranteed to be suitable - for passing to :py:meth:`.fill`. + .. note:: + The number of elements in the returned list will change as labware is added or removed from + the Flex Stacker. To get a list limited to the overall maximum number of labware the Flex Stacker + can store, use :py:meth:`.get_max_storable_labware_from_list`. - The number of elements in the returned list will change as labware is added or removed from - the Flex Stacker. To get a list limited to the overall maximum number of labware the Flex Stacker - can store, use :py:meth:`.get_max_storable_labware_from_list`. + :param labware: A list of labware to limit. The returned list takes from the front of the provided list, and it is guaranteed to be suitable + for passing to :py:meth:`.fill_items`. """ return self._cores_to_labware( self._core.get_current_storable_labware_from_list( @@ -1270,24 +1272,26 @@ def set_stored_labware_items( labware: list[Labware], stacking_offset_z: float | None, ) -> None: - """Configure the labware the Flex Stacker will store during a protocol by providing an initial list of stored labware objects. + """Configure the labware the Flex Stacker will store during a protocol by providing an initial list of stored labware objects. The start of the list represents the bottom of the Stacker, + and the end of the list represents the top of the Stacker. The kind of labware stored by the Flex Stacker will be calculated from the list of labware specified here. You can use this to store labware objects that you have already created - so that, for instance, you can set their liquid state or nicknames. There are several - restrictions on the values of the ``labware`` argument: - - - ``labware`` must have at least one element - - Elements of ``labware`` will be stored along with their lid, if any, and an adapter they - rest on, if any. These must be compatible with the Flex Stacker. - - All elements of ``labware`` must be loaded :py:obj:`OFF_DECK`. - - All elements of ``labware`` must be the same kind of labware. If any of them have lids, they - must all have lids, and the lids must be the same. If any of them are on adapters, they all + so that, for instance, you can set their liquid state or nicknames. + + + :param labware: A list of labware to load into the Stacker. + + - The list must have at least one element. + - All labware must be loaded :py:obj:`OFF_DECK`. + - All labware must be of the same kind. If any of them have lids, they + must all have lids, and the lids must be the same. + If any of them are on adapters, they all must be on adapters, and the adapters must be the same. - - The number of labware objects must fit in the stacker physically. To make sure the labware + All lids and adapters must be compatible with the Stacker. + - The number of labware objects must fit in the Stacker physically. To make sure the labware will fit, use the return value of :py:meth:`.get_max_storable_labware_from_list`. - :param labware: A list of labware to load into the stacker. :param stacking_offset_z: Stacking ``z`` offset in mm of stored labware. If specified, this overrides the calculated value from labware definitions. @@ -1352,7 +1356,7 @@ def set_stored_labware( values as the ``load_name`` parameter of :py:meth:`~.ProtocolContext.load_lid_stack`. The lid will use the same namespace as the labware, and the API will choose the lid's version automatically. - :param count: The number of labware that the Flex Stacker should store at the beginning of the protocol. If not specified, this will be the maximum amount of this kind of + :param count: The number of labware that the Flex Stacker should store. If not specified, this will be the maximum amount of this kind of labware that the Flex Stacker is capable of storing. :param stacking_offset_z: Stacking ``z`` offset in mm of stored labware. If specified, this overrides the calculated value in the labware definition. @@ -1391,13 +1395,11 @@ def set_stored_labware( def fill(self, count: int | None = None, message: str | None = None) -> None: """Pause the protocol to add labware to the Flex Stacker. - The labware must be the same type the Stacker is configured to store using :py:meth:`.set_stored_labware()`. + The labware must be the same type the Stacker is configured to store using :py:meth:`.set_stored_labware()`. If no labware type has been set, the API will raise an error. - This method assumes that labware to fill the Stacker is loaded :py:obj:`OFF_DECK`. - - :param message: A message to display in the Opentrons App noting what kind of labware to fill the Stacker with. :param count: The amount of labware the Flex Stacker should hold after this command is executed. If not specified, the Flex Stacker should be full after this command is executed. + :param message: A message to display noting what kind of labware to fill the Stacker with. """ self._core.fill(count, message) @@ -1405,14 +1407,13 @@ def fill(self, count: int | None = None, message: str | None = None) -> None: def fill_items(self, labware: list[Labware], message: str | None = None) -> None: """Pause the protocol to add a specific list of labware to the Flex Stacker. - The ``labware`` argument must follow certain rules: - - It should contain at least one item. - - Its elements should be the same kind of labware previously passed to - :py:meth:`.set_stored_labware_items` or loaded by :py:meth:`.set_stored_labware`. - - Its elements should all be loaded :py:obj:`OFF_DECK`. + :param labware: The list of labware to add. The list must: - :param message: A message to display in the Opentrons App noting the labware to fill the Stacker with. - :param labware: The list of labware to add, following the rules above. + - Contain at least one labware. + - Have labware of the same kind previously passed to + :py:meth:`.set_stored_labware_items` or loaded by :py:meth:`.set_stored_labware`. + - All labware should be loaded :py:obj:`OFF_DECK`. + :param message: A message to display noting the labware to fill the Stacker with. """ self._core.fill_items(self._labware_to_cores(labware), message) @@ -1420,9 +1421,9 @@ def fill_items(self, labware: list[Labware], message: str | None = None) -> None def empty(self, message: str | None = None) -> None: """Pause the protocol to remove all labware stored in the Flex Stacker. - This method assumes that labware removed from the Stacker is moved :py:obj:`OFF_DECK`. + This method sets the location of all labware currently in the stacker to :py:obj:`OFF_DECK`. - :param message: A message to display in the Opentrons App to note what should be removed from + :param message: A message to display to note what should be removed from the Flex Stacker. """ self._core.empty( From 2e1e1abe83355539201338a4c585e0a86e8becd3 Mon Sep 17 00:00:00 2001 From: Edward Cormany Date: Wed, 27 Aug 2025 15:13:32 -0400 Subject: [PATCH 16/18] add stacker to modules landing page --- api/docs/v2/new_modules.rst | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/api/docs/v2/new_modules.rst b/api/docs/v2/new_modules.rst index 63a1ea51350..7b640a7536b 100644 --- a/api/docs/v2/new_modules.rst +++ b/api/docs/v2/new_modules.rst @@ -8,8 +8,8 @@ Hardware Modules .. toctree:: modules/setup - modules/stacker modules/absorbance_plate_reader + modules/stacker modules/heater_shaker modules/magnetic_block modules/magnetic_module @@ -27,6 +27,7 @@ Pages in this section of the documentation cover: - Working with the module contexts for each type of module. - :ref:`Absorbance Plate Reader Module ` + - :ref:`Flex Stacker Module ` - :ref:`Heater-Shaker Module ` - :ref:`Magnetic Block ` - :ref:`Magnetic Module ` From d1c5d2da1352f1d5152c515afe8eadb54b80bd38 Mon Sep 17 00:00:00 2001 From: Edward Cormany Date: Wed, 27 Aug 2025 15:17:56 -0400 Subject: [PATCH 17/18] final touchups --- api/docs/v2/modules/stacker.rst | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/api/docs/v2/modules/stacker.rst b/api/docs/v2/modules/stacker.rst index ac31742044c..77c16a41986 100644 --- a/api/docs/v2/modules/stacker.rst +++ b/api/docs/v2/modules/stacker.rst @@ -28,7 +28,7 @@ Start by loading each Stacker as you would any other module: location="C4" ) -In this example, Stacker shuttles occupy deck slots A3 and C3. +In this example, Stacker shuttles occupy deck slots A4 and C4. Adding Labware to the Stacker ============================== @@ -106,7 +106,8 @@ You can use :py:meth:`~.FlexStackerContext.fill` to fill the Stacker with as man load_name="nest_12_reservoir_15ml", count=8 ) - stacker_1.fill(1, "Add another tip rack to stacker_1.") + stacker_1.fill(count=1, message="Add another tip rack to Stacker 1.") + Here, ``stacker_2`` is emptied and reconfigured to store NEST reservoirs with ``set_stored_labware()`` and the ``fill`` method adds another Flex tip rack to ``stacker_1``. From d4020d3a43b68afe7cd9f26177593e09dcf3143a Mon Sep 17 00:00:00 2001 From: Edward Cormany Date: Wed, 27 Aug 2025 16:30:07 -0400 Subject: [PATCH 18/18] api version on stacker and setup pages --- api/docs/v2/modules/setup.rst | 3 +++ api/docs/v2/modules/stacker.rst | 2 ++ 2 files changed, 5 insertions(+) diff --git a/api/docs/v2/modules/setup.rst b/api/docs/v2/modules/setup.rst index a0cbe18bf0e..62661b5b04f 100644 --- a/api/docs/v2/modules/setup.rst +++ b/api/docs/v2/modules/setup.rst @@ -98,6 +98,9 @@ The first parameter of :py:meth:`.ProtocolContext.load_module` is the module's | Absorbance Plate | ``absorbanceReaderV1`` | 2.21 | | Reader Module | | | +--------------------+-------------------------------+---------------------------+ + | Flex Stacker | ``flexStackerModuleV1`` | 2.25 | + | Module | | | + +--------------------+-------------------------------+---------------------------+ Some modules were added to our Python API later than others, and others span multiple hardware generations. When writing a protocol that requires a module, make sure your ``requirements`` or ``metadata`` code block specifies an :ref:`API version ` high enough to support all the module generations you want to use. diff --git a/api/docs/v2/modules/stacker.rst b/api/docs/v2/modules/stacker.rst index 77c16a41986..6123a348e7e 100644 --- a/api/docs/v2/modules/stacker.rst +++ b/api/docs/v2/modules/stacker.rst @@ -30,6 +30,8 @@ Start by loading each Stacker as you would any other module: In this example, Stacker shuttles occupy deck slots A4 and C4. +.. versionadded:: 2.25 + Adding Labware to the Stacker ==============================