opentrons 8.6.0a9__py3-none-any.whl → 8.6.0a10__py3-none-any.whl

opentrons/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '8.6.0a9'
-__version_tuple__ = version_tuple = (8, 6, 0, 'a9')
+__version__ = version = '8.6.0a10'
+__version_tuple__ = version_tuple = (8, 6, 0, 'a10')
 
 __commit_id__ = commit_id = None

opentrons/protocol_api/module_contexts.py

@@ -248,7 +248,7 @@ class ModuleContext(CommandPublisher):
     ) -> 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(
@@ -1141,7 +1141,9 @@ class FlexStackerContext(ModuleContext):
 
     @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,10 @@ class FlexStackerContext(ModuleContext):
 
     @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]:
@@ -1184,24 +1189,25 @@ class FlexStackerContext(ModuleContext):
         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 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.
@@ -1219,14 +1225,17 @@ class FlexStackerContext(ModuleContext):
     ) -> 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.
 
-        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
-        for passing to :py:meth:`.fill`.
+        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.
+
+        .. 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 to 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(
@@ -1236,11 +1245,13 @@ class FlexStackerContext(ModuleContext):
 
     @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 +1259,9 @@ class FlexStackerContext(ModuleContext):
     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,43 +1272,44 @@ class FlexStackerContext(ModuleContext):
         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 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
-          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`.
-
-        :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
+        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.
+              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 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 +1328,9 @@ class FlexStackerContext(ModuleContext):
         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
@@ -1330,39 +1346,35 @@ class FlexStackerContext(ModuleContext):
             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
             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 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. 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)
-                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 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(
@@ -1381,11 +1393,13 @@ class FlexStackerContext(ModuleContext):
 
     @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()`. If no labware type has been set, the API will raise an error.
 
-        :param message: A message to display in the Opentrons App to note what kind of labware to add.
         :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)
 
@@ -1393,22 +1407,23 @@ class FlexStackerContext(ModuleContext):
     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
-        - 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.
-        :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)
 
     @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.
 
-        :param message: A message to display in the Opentrons App to note what should be removed from
+        This method sets the location of all labware currently in the stacker to :py:obj:`OFF_DECK`.
+
+        :param message: A message to display to note what should be removed from
                         the Flex Stacker.
         """
         self._core.empty(
@@ -1417,9 +1432,11 @@ class FlexStackerContext(ModuleContext):
 
     @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.
+
+        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 is on the bottom and will be the item retrieved by a call to
+        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())

{opentrons-8.6.0a9.dist-info → opentrons-8.6.0a10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opentrons
-Version: 8.6.0a9
+Version: 8.6.0a10
 Summary: The Opentrons API is a simple framework designed to make writing automated biology lab protocols easy.
 Project-URL: opentrons.com, https://www.opentrons.com
 Project-URL: Source Code On Github, https://github.com/Opentrons/opentrons/tree/edge/api
@@ -24,7 +24,7 @@ Requires-Dist: click<9,>=8.0.0
 Requires-Dist: importlib-metadata>=1.0; python_version < '3.8'
 Requires-Dist: jsonschema<4.18.0,>=3.0.1
 Requires-Dist: numpy<2,>=1.20.0
-Requires-Dist: opentrons-shared-data==8.6.0a9
+Requires-Dist: opentrons-shared-data==8.6.0a10
 Requires-Dist: packaging>=21.0
 Requires-Dist: pydantic-settings<3,>=2
 Requires-Dist: pydantic<3,>=2.0.0
@@ -32,6 +32,6 @@ Requires-Dist: pyserial>=3.5
 Requires-Dist: pyusb==1.2.1
 Requires-Dist: typing-extensions<5,>=4.0.0
 Provides-Extra: flex-hardware
-Requires-Dist: opentrons-hardware[flex]==8.6.0a9; extra == 'flex-hardware'
+Requires-Dist: opentrons-hardware[flex]==8.6.0a10; extra == 'flex-hardware'
 Provides-Extra: ot2-hardware
-Requires-Dist: opentrons-hardware==8.6.0a9; extra == 'ot2-hardware'
+Requires-Dist: opentrons-hardware==8.6.0a10; extra == 'ot2-hardware'

{opentrons-8.6.0a9.dist-info → opentrons-8.6.0a10.dist-info}/RECORD

@@ -1,5 +1,5 @@
 opentrons/__init__.py,sha256=TQ_Ca_zzAM3iLzAysWKkFkQHG8-imihxDPQbLCYrf-E,4533
-opentrons/_version.py,sha256=mcOZzafaKAqrw2Ny0k7_2YqUf1Hbmefuy0RnsrBhvmA,712
+opentrons/_version.py,sha256=WOzpqMGqbeQfu1DNnQl-_lxA9A_N9iJAD333-1EKRCI,714
 opentrons/execute.py,sha256=Y88qICDiHWQjU0L4Ou7DI5OXXu7zZcdkUvNUYmZqIfc,29282
 opentrons/legacy_broker.py,sha256=XnuEBBlrHCThc31RFW2UR0tGqctqWZ-CZ9vSC4L9whU,1553
 opentrons/ordered_set.py,sha256=g-SB3qA14yxHu9zjGyc2wC7d2TUCBE6fKZlHAtbPzI8,4082
@@ -235,7 +235,7 @@ opentrons/protocol_api/deck.py,sha256=94vFceg1SC1bAGd7TvC1ZpYwnJR-VlzurEZ6jkacYe
 opentrons/protocol_api/disposal_locations.py,sha256=NRiSGmDR0LnbyEkWSOM-o64uR2fUoB1NWJG7Y7SsJSs,7920
 opentrons/protocol_api/instrument_context.py,sha256=dOg04iqYnNMJ7XnlHBX3tTGiEahc-7feIuErcevRdwY,141216
 opentrons/protocol_api/labware.py,sha256=ZP4QuGadoDp6xtyToupXVSJFnsx4NfWcskRQAH3iU4Y,61443
-opentrons/protocol_api/module_contexts.py,sha256=zhm2FfciAs2K73cVZ_8OwKcFKAU7VAiTOnCRnQaki_E,57712
+opentrons/protocol_api/module_contexts.py,sha256=RF6T__0Y7cYoFDWLmRU2BxPEVtMshEflelCHdW7IDbM,59743
 opentrons/protocol_api/module_validation_and_errors.py,sha256=ljst-M_KK78GnyG3pyZ_6yoYkMY3HORS1QyQyWrme-U,2250
 opentrons/protocol_api/protocol_context.py,sha256=Hzgw3FbCRyd4kWmw4RZwZHJhoGZkmn7ug-Q7JZGCcqs,70298
 opentrons/protocol_api/robot_context.py,sha256=D6ZdpFX30VTtVUDHitsVjabJQXD5TxOV9_Z6sik1LvE,11891
@@ -594,8 +594,8 @@ opentrons/util/linal.py,sha256=IlKAP9HkNBBgULeSf4YVwSKHdx9jnCjSr7nvDvlRALg,5753
 opentrons/util/logging_config.py,sha256=7et4YYuQdWdq_e50U-8vFS_QyNBRgdnqPGAQJm8qrIo,9954
 opentrons/util/logging_queue_handler.py,sha256=ZsSJwy-oV8DXwpYiZisQ1PbYwmK2cOslD46AcyJ1E4I,2484
 opentrons/util/performance_helpers.py,sha256=ew7H8XD20iS6-2TJAzbQeyzStZkkE6PzHt_Adx3wbZQ,5172
-opentrons-8.6.0a9.dist-info/METADATA,sha256=HvG4RCoHOhItRW5W9BXLVWdA2s_99JqAaMem8veXaHo,1607
-opentrons-8.6.0a9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-opentrons-8.6.0a9.dist-info/entry_points.txt,sha256=fTa6eGCYkvOtv0ov-KVE8LLGetgb35LQLF9x85OWPVw,106
-opentrons-8.6.0a9.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-opentrons-8.6.0a9.dist-info/RECORD,,
+opentrons-8.6.0a10.dist-info/METADATA,sha256=hjGup8Y1ej9BXaAbYLKI-_0wSxiI2BR2JNPy01YO7Sk,1611
+opentrons-8.6.0a10.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+opentrons-8.6.0a10.dist-info/entry_points.txt,sha256=fTa6eGCYkvOtv0ov-KVE8LLGetgb35LQLF9x85OWPVw,106
+opentrons-8.6.0a10.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+opentrons-8.6.0a10.dist-info/RECORD,,