opentrons 8.1.0a0__py2.py3-none-any.whl → 8.2.0a0__py2.py3-none-any.whl

opentrons/protocol_engine/commands/heater_shaker/deactivate_heater.py

@@ -9,7 +9,7 @@ from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, Succe
 from ...errors.error_occurrence import ErrorOccurrence
 
 if TYPE_CHECKING:
-    from opentrons.protocol_engine.state import StateView
+    from opentrons.protocol_engine.state.state import StateView
     from opentrons.protocol_engine.execution import EquipmentHandler
 
 
@@ -27,9 +27,7 @@ class DeactivateHeaterResult(BaseModel):
 
 
 class DeactivateHeaterImpl(
-    AbstractCommandImpl[
-        DeactivateHeaterParams, SuccessData[DeactivateHeaterResult, None]
-    ]
+    AbstractCommandImpl[DeactivateHeaterParams, SuccessData[DeactivateHeaterResult]]
 ):
     """Execution implementation of a Heater-Shaker's deactivate heater command."""
 
@@ -44,7 +42,7 @@ class DeactivateHeaterImpl(
 
     async def execute(
         self, params: DeactivateHeaterParams
-    ) -> SuccessData[DeactivateHeaterResult, None]:
+    ) -> SuccessData[DeactivateHeaterResult]:
         """Unset a Heater-Shaker's target temperature."""
         hs_module_substate = self._state_view.modules.get_heater_shaker_module_substate(
             module_id=params.moduleId
@@ -58,7 +56,9 @@ class DeactivateHeaterImpl(
         if hs_hardware_module is not None:
             await hs_hardware_module.deactivate_heater()
 
-        return SuccessData(public=DeactivateHeaterResult(), private=None)
+        return SuccessData(
+            public=DeactivateHeaterResult(),
+        )
 
 
 class DeactivateHeater(

opentrons/protocol_engine/commands/heater_shaker/deactivate_shaker.py

@@ -9,7 +9,7 @@ from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, Succe
 from ...errors.error_occurrence import ErrorOccurrence
 
 if TYPE_CHECKING:
-    from opentrons.protocol_engine.state import StateView
+    from opentrons.protocol_engine.state.state import StateView
     from opentrons.protocol_engine.execution import EquipmentHandler
 
 DeactivateShakerCommandType = Literal["heaterShaker/deactivateShaker"]
@@ -26,9 +26,7 @@ class DeactivateShakerResult(BaseModel):
 
 
 class DeactivateShakerImpl(
-    AbstractCommandImpl[
-        DeactivateShakerParams, SuccessData[DeactivateShakerResult, None]
-    ]
+    AbstractCommandImpl[DeactivateShakerParams, SuccessData[DeactivateShakerResult]]
 ):
     """Execution implementation of a Heater-Shaker's deactivate shaker command."""
 
@@ -43,7 +41,7 @@ class DeactivateShakerImpl(
 
     async def execute(
         self, params: DeactivateShakerParams
-    ) -> SuccessData[DeactivateShakerResult, None]:
+    ) -> SuccessData[DeactivateShakerResult]:
         """Deactivate shaker for a Heater-Shaker."""
         # Allow propagation of ModuleNotLoadedError and WrongModuleTypeError.
         hs_module_substate = self._state_view.modules.get_heater_shaker_module_substate(
@@ -60,7 +58,9 @@ class DeactivateShakerImpl(
         if hs_hardware_module is not None:
             await hs_hardware_module.deactivate_shaker()
 
-        return SuccessData(public=DeactivateShakerResult(), private=None)
+        return SuccessData(
+            public=DeactivateShakerResult(),
+        )
 
 
 class DeactivateShaker(

opentrons/protocol_engine/commands/heater_shaker/open_labware_latch.py

@@ -6,9 +6,10 @@ from pydantic import BaseModel, Field
 
 from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
 from ...errors.error_occurrence import ErrorOccurrence
+from ...state import update_types
 
 if TYPE_CHECKING:
-    from opentrons.protocol_engine.state import StateView
+    from opentrons.protocol_engine.state.state import StateView
     from opentrons.protocol_engine.execution import EquipmentHandler, MovementHandler
 
 OpenLabwareLatchCommandType = Literal["heaterShaker/openLabwareLatch"]
@@ -33,9 +34,7 @@ class OpenLabwareLatchResult(BaseModel):
 
 
 class OpenLabwareLatchImpl(
-    AbstractCommandImpl[
-        OpenLabwareLatchParams, SuccessData[OpenLabwareLatchResult, None]
-    ]
+    AbstractCommandImpl[OpenLabwareLatchParams, SuccessData[OpenLabwareLatchResult]]
 ):
     """Execution implementation of a Heater-Shaker's open latch labware command."""
 
@@ -52,8 +51,10 @@ class OpenLabwareLatchImpl(
 
     async def execute(
         self, params: OpenLabwareLatchParams
-    ) -> SuccessData[OpenLabwareLatchResult, None]:
+    ) -> SuccessData[OpenLabwareLatchResult]:
         """Open a Heater-Shaker's labware latch."""
+        state_update = update_types.StateUpdate()
+
         # Allow propagation of ModuleNotLoadedError and WrongModuleTypeError.
         hs_module_substate = self._state_view.modules.get_heater_shaker_module_substate(
             module_id=params.moduleId
@@ -72,6 +73,7 @@ class OpenLabwareLatchImpl(
             await self._movement.home(
                 axes=self._state_view.motion.get_robot_mount_axes()
             )
+            state_update.clear_all_pipette_locations()
 
         # Allow propagation of ModuleNotAttachedError.
         hs_hardware_module = self._equipment.get_module_hardware_api(
@@ -83,7 +85,7 @@ class OpenLabwareLatchImpl(
 
         return SuccessData(
             public=OpenLabwareLatchResult(pipetteRetracted=pipette_should_retract),
-            private=None,
+            state_update=state_update,
         )
 
 

opentrons/protocol_engine/commands/heater_shaker/set_and_wait_for_shake_speed.py

@@ -6,9 +6,10 @@ from pydantic import BaseModel, Field
 
 from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
 from ...errors.error_occurrence import ErrorOccurrence
+from ...state import update_types
 
 if TYPE_CHECKING:
-    from opentrons.protocol_engine.state import StateView
+    from opentrons.protocol_engine.state.state import StateView
     from opentrons.protocol_engine.execution import EquipmentHandler, MovementHandler
 
 SetAndWaitForShakeSpeedCommandType = Literal["heaterShaker/setAndWaitForShakeSpeed"]
@@ -35,7 +36,7 @@ class SetAndWaitForShakeSpeedResult(BaseModel):
 
 class SetAndWaitForShakeSpeedImpl(
     AbstractCommandImpl[
-        SetAndWaitForShakeSpeedParams, SuccessData[SetAndWaitForShakeSpeedResult, None]
+        SetAndWaitForShakeSpeedParams, SuccessData[SetAndWaitForShakeSpeedResult]
     ]
 ):
     """Execution implementation of Heater-Shaker's set and wait shake speed command."""
@@ -54,8 +55,10 @@ class SetAndWaitForShakeSpeedImpl(
     async def execute(
         self,
         params: SetAndWaitForShakeSpeedParams,
-    ) -> SuccessData[SetAndWaitForShakeSpeedResult, None]:
+    ) -> SuccessData[SetAndWaitForShakeSpeedResult]:
         """Set and wait for a Heater-Shaker's target shake speed."""
+        state_update = update_types.StateUpdate()
+
         # Allow propagation of ModuleNotLoadedError and WrongModuleTypeError.
         hs_module_substate = self._state_view.modules.get_heater_shaker_module_substate(
             module_id=params.moduleId
@@ -77,6 +80,7 @@ class SetAndWaitForShakeSpeedImpl(
             await self._movement.home(
                 axes=self._state_view.motion.get_robot_mount_axes()
             )
+            state_update.clear_all_pipette_locations()
 
         # Allow propagation of ModuleNotAttachedError.
         hs_hardware_module = self._equipment.get_module_hardware_api(
@@ -90,7 +94,7 @@ class SetAndWaitForShakeSpeedImpl(
             public=SetAndWaitForShakeSpeedResult(
                 pipetteRetracted=pipette_should_retract
             ),
-            private=None,
+            state_update=state_update,
         )
 
 

opentrons/protocol_engine/commands/heater_shaker/set_target_temperature.py

@@ -9,7 +9,7 @@ from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, Succe
 from ...errors.error_occurrence import ErrorOccurrence
 
 if TYPE_CHECKING:
-    from opentrons.protocol_engine.state import StateView
+    from opentrons.protocol_engine.state.state import StateView
     from opentrons.protocol_engine.execution import EquipmentHandler
 
 
@@ -29,7 +29,7 @@ class SetTargetTemperatureResult(BaseModel):
 
 class SetTargetTemperatureImpl(
     AbstractCommandImpl[
-        SetTargetTemperatureParams, SuccessData[SetTargetTemperatureResult, None]
+        SetTargetTemperatureParams, SuccessData[SetTargetTemperatureResult]
     ]
 ):
     """Execution implementation of a Heater-Shaker's set temperature command."""
@@ -46,7 +46,7 @@ class SetTargetTemperatureImpl(
     async def execute(
         self,
         params: SetTargetTemperatureParams,
-    ) -> SuccessData[SetTargetTemperatureResult, None]:
+    ) -> SuccessData[SetTargetTemperatureResult]:
         """Set a Heater-Shaker's target temperature."""
         # Allow propagation of ModuleNotLoadedError and WrongModuleTypeError.
         hs_module_substate = self._state_view.modules.get_heater_shaker_module_substate(
@@ -64,7 +64,9 @@ class SetTargetTemperatureImpl(
         if hs_hardware_module is not None:
             await hs_hardware_module.start_set_temperature(validated_temp)
 
-        return SuccessData(public=SetTargetTemperatureResult(), private=None)
+        return SuccessData(
+            public=SetTargetTemperatureResult(),
+        )
 
 
 class SetTargetTemperature(

opentrons/protocol_engine/commands/heater_shaker/wait_for_temperature.py

@@ -9,7 +9,7 @@ from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, Succe
 from ...errors.error_occurrence import ErrorOccurrence
 
 if TYPE_CHECKING:
-    from opentrons.protocol_engine.state import StateView
+    from opentrons.protocol_engine.state.state import StateView
     from opentrons.protocol_engine.execution import EquipmentHandler
 
 
@@ -36,9 +36,7 @@ class WaitForTemperatureResult(BaseModel):
 
 
 class WaitForTemperatureImpl(
-    AbstractCommandImpl[
-        WaitForTemperatureParams, SuccessData[WaitForTemperatureResult, None]
-    ]
+    AbstractCommandImpl[WaitForTemperatureParams, SuccessData[WaitForTemperatureResult]]
 ):
     """Execution implementation of a Heater-Shaker's wait for temperature command."""
 
@@ -53,7 +51,7 @@ class WaitForTemperatureImpl(
 
     async def execute(
         self, params: WaitForTemperatureParams
-    ) -> SuccessData[WaitForTemperatureResult, None]:
+    ) -> SuccessData[WaitForTemperatureResult]:
         """Wait for a Heater-Shaker's target temperature to be reached."""
         hs_module_substate = self._state_view.modules.get_heater_shaker_module_substate(
             module_id=params.moduleId
@@ -72,7 +70,9 @@ class WaitForTemperatureImpl(
         if hs_hardware_module is not None:
             await hs_hardware_module.await_temperature(awaiting_temperature=target_temp)
 
-        return SuccessData(public=WaitForTemperatureResult(), private=None)
+        return SuccessData(
+            public=WaitForTemperatureResult(),
+        )
 
 
 class WaitForTemperature(

opentrons/protocol_engine/commands/home.py

@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING, Optional, List, Type
 from typing_extensions import Literal
 
 from opentrons.types import MountType
+from ..state import update_types
 from ..types import MotorAxis
 from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
 from ..errors.error_occurrence import ErrorOccurrence
@@ -41,16 +42,16 @@ class HomeResult(BaseModel):
     """Result data from the execution of a Home command."""
 
 
-class HomeImplementation(
-    AbstractCommandImpl[HomeParams, SuccessData[HomeResult, None]]
-):
+class HomeImplementation(AbstractCommandImpl[HomeParams, SuccessData[HomeResult]]):
     """Home command implementation."""
 
     def __init__(self, movement: MovementHandler, **kwargs: object) -> None:
         self._movement = movement
 
-    async def execute(self, params: HomeParams) -> SuccessData[HomeResult, None]:
+    async def execute(self, params: HomeParams) -> SuccessData[HomeResult]:
         """Home some or all motors to establish positional accuracy."""
+        state_update = update_types.StateUpdate()
+
         if (
             params.skipIfMountPositionOk is None
             or not await self._movement.check_for_valid_position(
@@ -58,7 +59,12 @@ class HomeImplementation(
             )
         ):
             await self._movement.home(axes=params.axes)
-        return SuccessData(public=HomeResult(), private=None)
+
+        # todo(mm, 2024-09-17): Clearing all pipette locations *unconditionally* is to
+        # preserve prior behavior, but we might only want to do this if we actually home.
+        state_update.clear_all_pipette_locations()
+
+        return SuccessData(public=HomeResult(), state_update=state_update)
 
 
 class Home(BaseCommand[HomeParams, HomeResult, ErrorOccurrence]):

opentrons/protocol_engine/commands/liquid_probe.py

@@ -1,24 +1,26 @@
 """The liquidProbe and tryLiquidProbe commands."""
 
 from __future__ import annotations
-from typing import TYPE_CHECKING, Optional, Type, Union
+from typing import TYPE_CHECKING, NamedTuple, Optional, Type, Union
+from typing_extensions import Literal
+
+from pydantic import Field
+
+from opentrons.protocol_engine.state import update_types
 from opentrons.protocol_engine.errors.exceptions import (
     MustHomeError,
     PipetteNotReadyToAspirateError,
     TipNotEmptyError,
+    IncompleteLabwareDefinitionError,
 )
 from opentrons.types import MountType
 from opentrons_shared_data.errors.exceptions import (
     PipetteLiquidNotFoundError,
 )
-from typing_extensions import Literal
-
-from pydantic import Field
 
 from ..types import DeckPoint
 from .pipetting_common import (
     LiquidNotFoundError,
-    LiquidNotFoundErrorInternalData,
     PipetteIdMixin,
     WellLocationMixin,
     DestinationPositionResult,
@@ -36,7 +38,7 @@ from ..errors.error_occurrence import ErrorOccurrence
 if TYPE_CHECKING:
     from ..execution import MovementHandler, PipettingHandler
     from ..resources import ModelUtils
-    from ..state import StateView
+    from ..state.state import StateView
 
 
 LiquidProbeCommandType = Literal["liquidProbe"]
@@ -84,10 +86,86 @@ class TryLiquidProbeResult(DestinationPositionResult):
 
 
 _LiquidProbeExecuteReturn = Union[
-    SuccessData[LiquidProbeResult, None],
-    DefinedErrorData[LiquidNotFoundError, LiquidNotFoundErrorInternalData],
+    SuccessData[LiquidProbeResult],
+    DefinedErrorData[LiquidNotFoundError],
 ]
-_TryLiquidProbeExecuteReturn = SuccessData[TryLiquidProbeResult, None]
+_TryLiquidProbeExecuteReturn = SuccessData[TryLiquidProbeResult]
+
+
+class _ExecuteCommonResult(NamedTuple):
+    # If the probe succeeded, the z_pos that it returned.
+    # Or, if the probe found no liquid, the error representing that,
+    # so calling code can propagate those details up.
+    z_pos_or_error: float | PipetteLiquidNotFoundError
+
+    state_update: update_types.StateUpdate
+    deck_point: DeckPoint
+
+
+async def _execute_common(
+    state_view: StateView,
+    movement: MovementHandler,
+    pipetting: PipettingHandler,
+    params: _CommonParams,
+) -> _ExecuteCommonResult:
+    pipette_id = params.pipetteId
+    labware_id = params.labwareId
+    well_name = params.wellName
+
+    state_update = update_types.StateUpdate()
+
+    # May raise TipNotAttachedError.
+    aspirated_volume = state_view.pipettes.get_aspirated_volume(pipette_id)
+
+    if aspirated_volume is None:
+        # Theoretically, we could avoid raising an error by automatically preparing
+        # to aspirate above the well like AspirateImplementation does. However, the
+        # only way for this to happen is if someone tries to do a liquid probe with
+        # a tip that's previously held liquid, which they should avoid anyway.
+        raise PipetteNotReadyToAspirateError(
+            "The pipette cannot probe liquid because of a previous blow out."
+            " The plunger must be reset while the tip is somewhere away from liquid."
+        )
+    elif aspirated_volume != 0:
+        raise TipNotEmptyError(
+            message="The pipette cannot probe for liquid when the tip has liquid in it."
+        )
+
+    if await movement.check_for_valid_position(mount=MountType.LEFT) is False:
+        raise MustHomeError(
+            message="Current position of pipette is invalid. Please home."
+        )
+
+    # liquid_probe process start position
+    position = await movement.move_to_well(
+        pipette_id=pipette_id,
+        labware_id=labware_id,
+        well_name=well_name,
+        well_location=params.wellLocation,
+    )
+    deck_point = DeckPoint.construct(x=position.x, y=position.y, z=position.z)
+    state_update.set_pipette_location(
+        pipette_id=pipette_id,
+        new_labware_id=labware_id,
+        new_well_name=well_name,
+        new_deck_point=deck_point,
+    )
+
+    try:
+        z_pos = await pipetting.liquid_probe_in_place(
+            pipette_id=pipette_id,
+            labware_id=labware_id,
+            well_name=well_name,
+            well_location=params.wellLocation,
+        )
+    except PipetteLiquidNotFoundError as exception:
+        return _ExecuteCommonResult(
+            z_pos_or_error=exception, state_update=state_update, deck_point=deck_point
+        )
+    else:
+        return _ExecuteCommonResult(
+            z_pos_or_error=z_pos, state_update=state_update, deck_point=deck_point
+        )
 
 
 class LiquidProbeImplementation(
@@ -124,48 +202,17 @@ class LiquidProbeImplementation(
             MustHomeError: as an undefined error, if the plunger is not in a valid
                 position.
         """
-        pipette_id = params.pipetteId
-        labware_id = params.labwareId
-        well_name = params.wellName
-
-        # May raise TipNotAttachedError.
-        aspirated_volume = self._state_view.pipettes.get_aspirated_volume(pipette_id)
-
-        if aspirated_volume is None:
-            # Theoretically, we could avoid raising an error by automatically preparing
-            # to aspirate above the well like AspirateImplementation does. However, the
-            # only way for this to happen is if someone tries to do a liquid probe with
-            # a tip that's previously held liquid, which they should avoid anyway.
-            raise PipetteNotReadyToAspirateError(
-                "The pipette cannot probe liquid because of a previous blow out."
-                " The plunger must be reset while the tip is somewhere away from liquid."
-            )
-        elif aspirated_volume != 0:
-            raise TipNotEmptyError(
-                message="The pipette cannot probe for liquid when the tip has liquid in it."
-            )
-
-        if await self._movement.check_for_valid_position(mount=MountType.LEFT) is False:
-            raise MustHomeError(
-                message="Current position of pipette is invalid. Please home."
-            )
-
-        # liquid_probe process start position
-        position = await self._movement.move_to_well(
-            pipette_id=pipette_id,
-            labware_id=labware_id,
-            well_name=well_name,
-            well_location=params.wellLocation,
+        z_pos_or_error, state_update, deck_point = await _execute_common(
+            self._state_view, self._movement, self._pipetting, params
         )
-
-        try:
-            z_pos = await self._pipetting.liquid_probe_in_place(
-                pipette_id=pipette_id,
-                labware_id=labware_id,
-                well_name=well_name,
-                well_location=params.wellLocation,
+        if isinstance(z_pos_or_error, PipetteLiquidNotFoundError):
+            state_update.set_liquid_probed(
+                labware_id=params.labwareId,
+                well_name=params.wellName,
+                height=update_types.CLEAR,
+                volume=update_types.CLEAR,
+                last_probed=self._model_utils.get_timestamp(),
             )
-        except PipetteLiquidNotFoundError as e:
             return DefinedErrorData(
                 public=LiquidNotFoundError(
                     id=self._model_utils.generate_id(),
@@ -174,21 +221,35 @@ class LiquidProbeImplementation(
                         ErrorOccurrence.from_failed(
                             id=self._model_utils.generate_id(),
                             createdAt=self._model_utils.get_timestamp(),
-                            error=e,
+                            error=z_pos_or_error,
                         )
                     ],
                 ),
-                private=LiquidNotFoundErrorInternalData(
-                    position=DeckPoint(x=position.x, y=position.y, z=position.z)
-                ),
+                state_update=state_update,
             )
         else:
+            try:
+                well_volume: float | update_types.ClearType = (
+                    self._state_view.geometry.get_well_volume_at_height(
+                        labware_id=params.labwareId,
+                        well_name=params.wellName,
+                        height=z_pos_or_error,
+                    )
+                )
+            except IncompleteLabwareDefinitionError:
+                well_volume = update_types.CLEAR
+            state_update.set_liquid_probed(
+                labware_id=params.labwareId,
+                well_name=params.wellName,
+                height=z_pos_or_error,
+                volume=well_volume,
+                last_probed=self._model_utils.get_timestamp(),
+            )
             return SuccessData(
                 public=LiquidProbeResult(
-                    z_position=z_pos,
-                    position=DeckPoint(x=position.x, y=position.y, z=position.z),
+                    z_position=z_pos_or_error, position=deck_point
                 ),
-                private=None,
+                state_update=state_update,
             )
 
 
@@ -217,40 +278,37 @@ class TryLiquidProbeImplementation(
         found, `tryLiquidProbe` returns a success result with `z_position=null` instead
         of a defined error.
         """
-        # We defer to the `liquidProbe` implementation. If it returns a defined
-        # `liquidNotFound` error, we remap that to a success result.
-        # Otherwise, we return the result or propagate the exception unchanged.
-
-        original_impl = LiquidProbeImplementation(
-            state_view=self._state_view,
-            movement=self._movement,
-            pipetting=self._pipetting,
-            model_utils=self._model_utils,
+        z_pos_or_error, state_update, deck_point = await _execute_common(
+            self._state_view, self._movement, self._pipetting, params
         )
-        original_result = await original_impl.execute(params)
-
-        match original_result:
-            case DefinedErrorData(
-                public=LiquidNotFoundError(),
-                private=LiquidNotFoundErrorInternalData() as original_private,
-            ):
-                return SuccessData(
-                    public=TryLiquidProbeResult(
-                        z_position=None,
-                        position=original_private.position,
-                    ),
-                    private=None,
-                )
-            case SuccessData(
-                public=LiquidProbeResult() as original_public, private=None
-            ):
-                return SuccessData(
-                    public=TryLiquidProbeResult(
-                        position=original_public.position,
-                        z_position=original_public.z_position,
-                    ),
-                    private=None,
+
+        if isinstance(z_pos_or_error, PipetteLiquidNotFoundError):
+            z_pos = None
+            well_volume: float | update_types.ClearType = update_types.CLEAR
+        else:
+            z_pos = z_pos_or_error
+            try:
+                well_volume = self._state_view.geometry.get_well_volume_at_height(
+                    labware_id=params.labwareId, well_name=params.wellName, height=z_pos
                 )
+            except IncompleteLabwareDefinitionError:
+                well_volume = update_types.CLEAR
+
+        state_update.set_liquid_probed(
+            labware_id=params.labwareId,
+            well_name=params.wellName,
+            height=z_pos if z_pos is not None else update_types.CLEAR,
+            volume=well_volume,
+            last_probed=self._model_utils.get_timestamp(),
+        )
+
+        return SuccessData(
+            public=TryLiquidProbeResult(
+                z_position=z_pos,
+                position=deck_point,
+            ),
+            state_update=state_update,
+        )
 
 
 class LiquidProbe(

opentrons/protocol_engine/commands/load_labware.py

@@ -17,9 +17,10 @@ from ..types import (
 
 from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
 from ..errors.error_occurrence import ErrorOccurrence
+from ..state.update_types import StateUpdate
 
 if TYPE_CHECKING:
-    from ..state import StateView
+    from ..state.state import StateView
     from ..execution import EquipmentHandler
 
 
@@ -87,7 +88,7 @@ class LoadLabwareResult(BaseModel):
 
 
 class LoadLabwareImplementation(
-    AbstractCommandImpl[LoadLabwareParams, SuccessData[LoadLabwareResult, None]]
+    AbstractCommandImpl[LoadLabwareParams, SuccessData[LoadLabwareResult]]
 ):
     """Load labware command implementation."""
 
@@ -99,7 +100,7 @@ class LoadLabwareImplementation(
 
     async def execute(
         self, params: LoadLabwareParams
-    ) -> SuccessData[LoadLabwareResult, None]:
+    ) -> SuccessData[LoadLabwareResult]:
         """Load definition and calibration data necessary for a labware."""
         # TODO (tz, 8-15-2023): extend column validation to column 1 when working
         # on https://opentrons.atlassian.net/browse/RSS-258 and completing
@@ -115,7 +116,10 @@ class LoadLabwareImplementation(
 
         if isinstance(params.location, AddressableAreaLocation):
             area_name = params.location.addressableAreaName
-            if not fixture_validation.is_deck_slot(params.location.addressableAreaName):
+            if not (
+                fixture_validation.is_deck_slot(params.location.addressableAreaName)
+                or fixture_validation.is_abs_reader(params.location.addressableAreaName)
+            ):
                 raise LabwareIsNotAllowedInLocationError(
                     f"Cannot load {params.loadName} onto addressable area {area_name}"
                 )
@@ -138,6 +142,16 @@ class LoadLabwareImplementation(
             labware_id=params.labwareId,
         )
 
+        state_update = StateUpdate()
+
+        state_update.set_loaded_labware(
+            labware_id=loaded_labware.labware_id,
+            offset_id=loaded_labware.offsetId,
+            definition=loaded_labware.definition,
+            location=verified_location,
+            display_name=params.displayName,
+        )
+
         # TODO(jbl 2023-06-23) these validation checks happen after the labware is loaded, because they rely on
         #   on the definition. In practice this will not cause any issues since they will raise protocol ending
         #   exception, but for correctness should be refactored to do this check beforehand.
@@ -153,7 +167,7 @@ class LoadLabwareImplementation(
                 definition=loaded_labware.definition,
                 offsetId=loaded_labware.offsetId,
             ),
-            private=None,
+            state_update=state_update,
         )