opentrons 8.7.0a7__py3-none-any.whl → 8.8.0a7__py3-none-any.whl

opentrons/protocol_engine/resources/file_provider.py

@@ -1,36 +1,91 @@
 """File interaction resource provider."""
 from datetime import datetime
+from io import StringIO
+import csv
 from typing import List, Optional, Callable, Awaitable, Dict
+from dataclasses import dataclass
 from pydantic import BaseModel
-from ..errors import StorageLimitReachedError
+from opentrons_shared_data.data_files import (
+    DataFileInfo,
+    MimeType,
+    RunFileNameMetadata,
+)
+
+SPECIAL_CHARACTERS = {
+    "#",
+    "%",
+    "&",
+    "{",
+    "}",
+    "\\",
+    "/",
+    "<",
+    ">",
+    "*",
+    "$",
+    "!",
+    "?",
+    ".",
+    "'",
+    '"',
+    ":",
+    ";",
+    "@",
+    "`",
+    "|",
+}
+
+
+@dataclass(frozen=True)
+class FileNameCmdMetadata:
+    """Command metadata associated with a specific data file."""
+
+    command_id: str
+    prev_command_id: str
+
+
+@dataclass(frozen=True)
+class ReadCmdFileNameMetadata(FileNameCmdMetadata):
+    """Data from a plate reader `read` command used to build the finalized file name."""
+
+    base_filename: str
+    wavelength: int
+
+
+@dataclass(frozen=True)
+class ImageCaptureCmdFileNameMetadata(FileNameCmdMetadata):
+    """Data from a camera capture command used to build the finalized file name."""
 
+    step_number: int
+    command_timestamp: datetime
+    base_filename: Optional[str]
 
-MAXIMUM_CSV_FILE_LIMIT = 400
 
+CommandFileNameMetadata = ReadCmdFileNameMetadata | ImageCaptureCmdFileNameMetadata
 
-class GenericCsvTransform:
-    """Generic CSV File Type data for rows of data to be seperated by a delimeter."""
 
-    filename: str
-    rows: List[List[str]]
-    delimiter: str = ","
+class FileData:
+    """File data container for writing to a file."""
+
+    data: bytes
+    mime_type: MimeType
+    run_metadata: RunFileNameMetadata
+    command_metadata: CommandFileNameMetadata
 
     @staticmethod
     def build(
-        filename: str, rows: List[List[str]], delimiter: str = ","
-    ) -> "GenericCsvTransform":
-        """Build a Generic CSV datatype class."""
-        if "." in filename and not filename.endswith(".csv"):
-            raise ValueError(
-                f"Provided filename {filename} invalid. Only CSV file format is accepted."
-            )
-        elif "." not in filename:
-            filename = f"{filename}.csv"
-        csv = GenericCsvTransform()
-        csv.filename = filename
-        csv.rows = rows
-        csv.delimiter = delimiter
-        return csv
+        data: bytes,
+        mime_type: MimeType,
+        run_metadata: RunFileNameMetadata,
+        command_metadata: CommandFileNameMetadata,
+    ) -> "FileData":
+        """Build a generic file data class."""
+        file_data = FileData()
+        file_data.data = data
+        file_data.mime_type = mime_type
+        file_data.run_metadata = run_metadata
+        file_data.command_metadata = command_metadata
+        return file_data
 
 
 class ReadData(BaseModel):
@@ -41,7 +96,7 @@ class ReadData(BaseModel):
 
 
 class PlateReaderData(BaseModel):
-    """Data from a Opentrons Plate Reader Read. Can be converted to CSV template format."""
+    """Data from an Opentrons Plate Reader Read. Can be converted to CSV format."""
 
     read_results: List[ReadData]
     reference_wavelength: Optional[int] = None
@@ -49,13 +104,8 @@ class PlateReaderData(BaseModel):
     finish_time: datetime
     serial_number: str
 
-    def build_generic_csv(  # noqa: C901
-        self, filename: str, measurement: ReadData
-    ) -> GenericCsvTransform:
-        """Builds a CSV compatible object containing Plate Reader Measurements.
-
-        This will also automatically reformat the provided filename to include the wavelength of those measurements.
-        """
+    def build_csv_bytes(self, measurement: ReadData) -> bytes:  # noqa: C901
+        """Builds CSV data as bytes containing Plate Reader Measurements."""
         plate_alpharows = ["A", "B", "C", "D", "E", "F", "G", "H"]
         rows = []
 
@@ -63,7 +113,7 @@ class PlateReaderData(BaseModel):
         for i in range(8):
             row = [plate_alpharows[i]]
             for j in range(12):
-                row.append(str(measurement.data[f"{plate_alpharows[i]}{j+1}"]))
+                row.append(str(measurement.data[f"{plate_alpharows[i]}{j + 1}"]))
             rows.append(row)
         for i in range(3):
             rows.append([])
@@ -116,16 +166,12 @@ class PlateReaderData(BaseModel):
             ["Measurement finished at", self.finish_time.strftime("%m %d %H:%M:%S %Y")]
         )
 
-        # Ensure the filename adheres to ruleset contains the wavelength for a given measurement
-        if filename.endswith(".csv"):
-            filename = filename[:-4]
-        filename = filename + str(measurement.wavelength) + "nm.csv"
+        output = StringIO()
+        writer = csv.writer(output, delimiter=",")
+        writer.writerows(rows)
+        csv_bytes = output.getvalue().encode("utf-8")
 
-        return GenericCsvTransform.build(
-            filename=filename,
-            rows=rows,
-            delimiter=",",
-        )
+        return csv_bytes
 
 
 class FileProvider:
@@ -133,29 +179,58 @@ class FileProvider:
 
     def __init__(
         self,
-        data_files_write_csv_callback: Optional[
-            Callable[[GenericCsvTransform], Awaitable[str]]
+        data_files_write_file_cb: Optional[
+            Callable[[FileData], Awaitable[DataFileInfo]]
         ] = None,
-        data_files_filecount: Optional[Callable[[], Awaitable[int]]] = None,
     ) -> None:
         """Initialize the interface callbacks of the File Provider for data file handling within the Protocol Engine.
 
         Params:
-            data_files_write_csv_callback: Callback to write a CSV file to the data files directory and add it to the database.
+            data_files_write_file_callback: Callback to write a file to the data files directory and add it to the database.
             data_files_filecount: Callback to check the amount of data files already present in the data files directory.
         """
-        self._data_files_write_csv_callback = data_files_write_csv_callback
-        self._data_files_filecount = data_files_filecount
-
-    async def write_csv(self, write_data: GenericCsvTransform) -> str:
-        """Writes the provided CSV object to a file in the Data Files directory. Returns the File ID of the file created."""
-        if self._data_files_filecount is not None:
-            file_count = await self._data_files_filecount()
-            if file_count >= MAXIMUM_CSV_FILE_LIMIT:
-                raise StorageLimitReachedError(
-                    f"Not enough space to store file {write_data.filename}."
-                )
-            if self._data_files_write_csv_callback is not None:
-                return await self._data_files_write_csv_callback(write_data)
-        # If we are in an analysis or simulation state, return an empty file ID
-        return ""
+        self._data_files_write_file_cb = data_files_write_file_cb
+        self._run_metadata: RunFileNameMetadata | None = None
+
+    async def write_file(
+        self,
+        data: bytes,
+        mime_type: MimeType,
+        command_metadata: CommandFileNameMetadata,
+    ) -> DataFileInfo:
+        """Writes arbitrary data to a file in the Data Files directory.
+
+        Returns the `DataFileInfo` of the file created.
+
+        Raises:
+            Note that the callback may raise a StorageLimitReachedError.
+        """
+        if self._data_files_write_file_cb is not None:
+            assert self._run_metadata is not None
+            file_data = FileData.build(
+                data=data,
+                mime_type=mime_type,
+                command_metadata=command_metadata,
+                run_metadata=self._run_metadata,
+            )
+
+            return await self._data_files_write_file_cb(file_data)
+        # If we are in an analysis or simulation state, return an empty `DataFileInfo`
+        return DataFileInfo(
+            id="",
+            name="",
+            file_hash="",
+            created_at=datetime.now(),
+            generated=True,
+            stored=False,
+            path="",
+            mime_type=mime_type,
+        )
+
+    def set_run_metadata(self, metadata: RunFileNameMetadata) -> None:
+        """Sets metadata specific to the run."""
+        self._run_metadata = metadata
+
+    def clear_run_metadata(self) -> None:
+        """Clears metadata specific to the run."""
+        self._run_metadata = None

opentrons/protocol_engine/slot_standardization.py

@@ -27,6 +27,7 @@ from .types import (
     AddressableAreaLocation,
     ModuleLocation,
     OnLabwareLocation,
+    WASTE_CHUTE_LOCATION,
 )
 
 
@@ -116,6 +117,7 @@ def _standardize_labware_location(
         )
         or original == OFF_DECK_LOCATION
         or original == SYSTEM_LOCATION
+        or original == WASTE_CHUTE_LOCATION
     ):
         return original
 

opentrons/protocol_engine/state/camera.py

@@ -0,0 +1,54 @@
+"""Camera related state and store resource.
+
+Camera settings, particularly for enablement, can be quieried from via the Camera Provider callback.
+However, here Camera settings may also be provided to override or supercede those provided by the callbacks.
+"""
+from dataclasses import dataclass
+from typing import Optional
+from opentrons.protocol_engine.actions import AddCameraSettingsAction
+from opentrons.protocol_engine.resources.camera_provider import CameraSettings
+
+from ._abstract_store import HasState, HandlesActions
+from ..actions import Action
+
+
+@dataclass
+class CameraState:
+    """State of Engine Camera override settings."""
+
+    enablement_settings: Optional[CameraSettings]
+    # todo(chb, 2025-10-28): Eventually we will want to extend this to include the camera configurations overrides (contrast, zoom, etc)
+
+
+class CameraStore(HasState[CameraState], HandlesActions):
+    """Camera container."""
+
+    _state: CameraState
+
+    def __init__(self) -> None:
+        """Initialize a Camera store and its state."""
+        self._state = CameraState(enablement_settings=None)
+
+    def handle_action(self, action: Action) -> None:
+        """Modify state in reaction to an action."""
+        if isinstance(action, AddCameraSettingsAction):
+            # Update the Camera Enablement settings to the newest override settings
+            self._state.enablement_settings = action.enablement_settings
+
+
+class CameraView:
+    """Read-only engine created Camera state view."""
+
+    _state: CameraState
+
+    def __init__(self, state: CameraState) -> None:
+        """Initialize the view of Camera state.
+
+        Arguments:
+            state: Camera dataclass used for tracking override settings for the camera.
+        """
+        self._state = state
+
+    def get_enablement_settings(self) -> CameraSettings | None:
+        """Get the enablement settings override currently in use. This will take priority over Camera Provider callback provided settings."""
+        return self._state.enablement_settings

opentrons/protocol_engine/state/commands.py

@@ -239,7 +239,10 @@ class CommandState:
     """Whether the run has entered error recovery."""
 
     stopped_by_async_error: bool
-    """If this is set to True, the engine was stopped by an estop event."""
+    """If this is set to True, the engine was stopped by an async event."""
+
+    is_stopping_because_of_async_error: bool
+    """If this is set to True, the engine was stopped by an asynch event and hasn't finished stopping."""
 
     error_recovery_policy: ErrorRecoveryPolicy
     """See `CommandView.get_error_recovery_policy()`."""
@@ -273,6 +276,7 @@ class CommandStore(HasState[CommandState], HandlesActions):
             run_started_at=None,
             latest_protocol_command_hash=None,
             stopped_by_async_error=False,
+            is_stopping_because_of_async_error=False,
             error_recovery_policy=error_recovery_policy,
             has_entered_error_recovery=False,
         )
@@ -474,6 +478,7 @@ class CommandStore(HasState[CommandState], HandlesActions):
 
             if action.from_asynchronous_error:
                 self._state.stopped_by_async_error = True
+                self._state.is_stopping_because_of_async_error = True
                 self._state.run_result = RunResult.FAILED
             else:
                 self._state.run_result = RunResult.STOPPED
@@ -499,14 +504,29 @@ class CommandStore(HasState[CommandState], HandlesActions):
                     action.error_details.error,
                 )
         else:
-            # HACK(sf): There needs to be a better way to set
-            # an estop error than this else clause
-            if self._state.stopped_by_async_error and action.error_details:
+            # HACK(sf): There needs to be a better way to handle async errors than this logic
+            # which is way too nonlocal. The idea here is that
+            # (1) there's an async error that calls one of the engine async error handlers,
+            # which emits a stop action and then tells the orchestrator to call finish
+            # (2) calling stop normally would lock out the run error field (since the idea is that
+            # stop happens in the handler of the error that stops the run, and thus the failed
+            # command has already set the run error), but here either the command didn't fail or
+            # the command failed with an error that isn't relevant or is duplicative, so we want
+            # to override that
+            # (3) but we don't want to override it twice, because some other error handler might
+            # tell us to finish with the cancelled error that happens because a command was cancelled
+            # in reaction to (2)
+            # So we set and clear this stopped_by_async_error and it's awful. Let's figure out a better
+            # way.
+
+            if self._state.is_stopping_because_of_async_error and action.error_details:
                 self._state.run_error = self._map_run_exception_to_error_occurrence(
                     action.error_details.error_id,
                     action.error_details.created_at,
                     action.error_details.error,
                 )
+                self._state.is_stopping_because_of_async_error = False
+                self._state.stopped_by_async_error = True
 
     def _handle_hardware_stopped_action(self, action: HardwareStoppedAction) -> None:
         self._state.queue_status = QueueStatus.PAUSED

opentrons/protocol_engine/state/geometry.py

@@ -68,6 +68,8 @@ from ..types import (
     CurrentPipetteLocation,
     TipGeometry,
     InStackerHopperLocation,
+    WASTE_CHUTE_LOCATION,
+    AccessibleByGripperLocation,
     OnDeckLabwareLocation,
     AddressableAreaLocation,
     AddressableOffsetVector,
@@ -198,6 +200,7 @@ class GeometryView:
             if isinstance(loc, InStackerHopperLocation) or isinstance(
                 loc, NotOnDeckLocationSequenceComponent
             ):
+
                 return False
         return True
 
@@ -396,6 +399,11 @@ class GeometryView:
                 "Labware does not have a slot or module associated with it"
                 " since it is no longer on the deck."
             )
+        elif location == WASTE_CHUTE_LOCATION:
+            raise errors.LabwareNotOnDeckError(
+                "Labware does not have a slot or module associated with it"
+                " since it is in the waste chute."
+            )
 
     def get_labware_origin_position(self, labware_id: str) -> Point:
         """Get the deck coordinates of a labware's origin.
@@ -459,7 +467,6 @@ class GeometryView:
                 current_definition = self._labware.get_definition(current_labware_id)
             else:
                 break
-
         return definitions_locations_top_to_bottom
 
     def _get_stackup_module_parent_to_child_offset(
@@ -491,7 +498,6 @@ class GeometryView:
     ) -> LabwareStackupAncestorDefinition:
         """Traverse the stackup to find the first non-labware definition."""
         current_location = top_most_lw_location
-
         while True:
             if isinstance(current_location, OnLabwareLocation):
                 current_labware_id = current_location.labwareId
@@ -500,6 +506,7 @@ class GeometryView:
             else:
                 if isinstance(current_location, ModuleLocation):
                     return self._modules.get_definition(current_location.moduleId)
+
                 elif isinstance(current_location, AddressableAreaLocation):
                     return self._addressable_areas.get_addressable_area(
                         current_location.addressableAreaName
@@ -508,6 +515,10 @@ class GeometryView:
                     return self._addressable_areas.get_slot_definition(
                         current_location.slotName.id
                     )
+                elif current_location == WASTE_CHUTE_LOCATION:
+                    return self._addressable_areas.get_addressable_area(
+                        "gripperWasteChute"
+                    )
                 else:
                     raise errors.InvalidLabwarePositionError(
                         f"Cannot get ancestor slot of location {current_location}"
@@ -522,6 +533,8 @@ class GeometryView:
             return self._modules.get_provided_addressable_area(location.moduleId)
         elif isinstance(location, OnLabwareLocation):
             return self.get_ancestor_addressable_area_name(location.labwareId)
+        elif location == WASTE_CHUTE_LOCATION:
+            return "gripperWasteChute"
         else:
             raise errors.InvalidLabwarePositionError(
                 f"Cannot get ancestor slot of location {location}"
@@ -624,7 +637,9 @@ class GeometryView:
         if meniscus_tracking:
             location = LiquidHandlingWellLocation(
                 origin=WellOrigin.MENISCUS,
-                offset=WellOffset(x=0, y=0, z=absolute_point.z),
+                offset=WellOffset(
+                    x=absolute_point.x, y=absolute_point.y, z=absolute_point.z
+                ),
             )
             # TODO(cm): handle operationVolume being a float other than 0
             if meniscus_tracking == MeniscusTrackingTarget.END:
@@ -680,6 +695,9 @@ class GeometryView:
         return well_def.depth
 
     def _get_highest_z_from_labware_data(self, lw_data: LoadedLabware) -> float:
+        if lw_data.location == WASTE_CHUTE_LOCATION:
+            # Returns 0 so that the waste chute height is not added to the height of the lbw
+            return 0
         labware_pos = self.get_labware_position(lw_data.id)
         z_dim = self._labware.get_dimensions(labware_id=lw_data.id).z
         height_over_labware: float = 0
@@ -833,6 +851,11 @@ class GeometryView:
                 f"Labware {self._labware.get_display_name(labware_id)} does not have a slot associated with it"
                 f" since it is no longer on the deck."
             )
+        elif labware.location == WASTE_CHUTE_LOCATION:
+            raise errors.LabwareNotOnDeckError(
+                f"Labware {self._labware.get_display_name(labware_id)} does not have a slot associated with it"
+                f" since it is in the waste chute."
+            )
         else:
             _LOG.error(
                 f"Unhandled location type in get_ancestor_slot_name: {labware.location}"
@@ -1018,9 +1041,7 @@ class GeometryView:
     def get_labware_grip_point(
         self,
         labware_definition: LabwareDefinition,
-        location: Union[
-            DeckSlotLocation, ModuleLocation, OnLabwareLocation, AddressableAreaLocation
-        ],
+        location: AccessibleByGripperLocation,
         move_type: GripperMoveType,
         user_additional_offset: Point | None,
     ) -> Point:
@@ -1047,9 +1068,7 @@ class GeometryView:
     def _get_aa_origin_to_nominal_grip_point(
         self,
         labware_definition: LabwareDefinition,
-        location: Union[
-            DeckSlotLocation, ModuleLocation, OnLabwareLocation, AddressableAreaLocation
-        ],
+        location: AccessibleByGripperLocation,
         move_type: GripperMoveType,
     ) -> Point:
         """Get the nominal grip point of a labware.
@@ -1440,9 +1459,16 @@ class GeometryView:
     def ensure_valid_gripper_location(
         location: LabwareLocation,
     ) -> Union[
-        DeckSlotLocation, ModuleLocation, OnLabwareLocation, AddressableAreaLocation
+        DeckSlotLocation,
+        ModuleLocation,
+        OnLabwareLocation,
+        AddressableAreaLocation,
     ]:
         """Ensure valid on-deck location for gripper, otherwise raise error."""
+        if location == WASTE_CHUTE_LOCATION:
+            raise errors.LabwareMovementNotAllowedError(
+                "Labware movements out of the waste chute are not supported using the gripper."
+            )
         if not isinstance(
             location,
             (
@@ -1457,6 +1483,28 @@ class GeometryView:
             )
         return location
 
+    @staticmethod
+    def ensure_valid_new_gripper_location(
+        location: LabwareLocation,
+    ) -> AccessibleByGripperLocation:
+        """Ensure valid on-deck location for gripper, otherwise raise error."""
+        if (
+            not isinstance(
+                location,
+                (
+                    DeckSlotLocation,
+                    ModuleLocation,
+                    OnLabwareLocation,
+                    AddressableAreaLocation,
+                ),
+            )
+            and location != WASTE_CHUTE_LOCATION
+        ):
+            raise errors.LabwareMovementNotAllowedError(
+                "Off-deck labware movements are not supported using the gripper."
+            )
+        return location
+
     # todo(mm, 2024-11-05): This may be incorrect because it does not take the following
     # offsets into account, which *are* taken into account for the actual gripper movement:
     #
@@ -1677,6 +1725,12 @@ class GeometryView:
             return self._recurse_labware_location_from_stacker_hopper(
                 labware_location, building
             )
+        elif labware_location == WASTE_CHUTE_LOCATION:
+            return [
+                NotOnDeckLocationSequenceComponent(
+                    logicalLocationName=WASTE_CHUTE_LOCATION
+                )
+            ]
         else:
             _LOG.warn(f"Unhandled labware location kind: {labware_location}")
             return building
@@ -2262,6 +2316,10 @@ class GeometryView:
             raise errors.LocationNotAccessibleByPipetteError(
                 f"Cannot move pipette to {labware.loadName}, labware is off-deck."
             )
+        elif labware_location == WASTE_CHUTE_LOCATION:
+            raise errors.LocationNotAccessibleByPipetteError(
+                f"Cannot move pipette to {labware.loadName}, labware is in waste chute."
+            )
         elif isinstance(labware_location, ModuleLocation):
             module = self._modules.get(labware_location.moduleId)
             if ModuleModel.is_flex_stacker(module.model):

opentrons/protocol_engine/state/labware.py

@@ -52,6 +52,7 @@ from ..types import (
     LabwareOffsetLocationSequence,
     LegacyLabwareOffsetLocation,
     InStackerHopperLocation,
+    WASTE_CHUTE_LOCATION,
     LabwareLocation,
     LoadedLabware,
     ModuleLocation,
@@ -343,14 +344,18 @@ class LabwareStore(HasState[LabwareState], HandlesActions):
         self, labware_id: str, new_location: LabwareLocation, new_offset_id: str | None
     ) -> None:
         self._state.labware_by_id[labware_id].offsetId = new_offset_id
-
         if isinstance(new_location, AddressableAreaLocation) and (
-            fixture_validation.is_gripper_waste_chute(new_location.addressableAreaName)
-            or fixture_validation.is_trash(new_location.addressableAreaName)
+            fixture_validation.is_trash(new_location.addressableAreaName)
         ):
-            # If a labware has been moved into a waste chute it's been chuted away and is now technically off deck
+            # TODO (RC, 2025-10-07: create a specific trash off deck location)
+            # If a labware has been moved into trash and is now technically off deck
             new_location = OFF_DECK_LOCATION
-
+        elif isinstance(
+            new_location, AddressableAreaLocation
+        ) and fixture_validation.is_gripper_waste_chute(
+            new_location.addressableAreaName
+        ):
+            new_location = WASTE_CHUTE_LOCATION
         self._state.labware_by_id[labware_id].location = new_location
 
     def _set_labware_location(self, state_update: update_types.StateUpdate) -> None:
@@ -483,7 +488,6 @@ class LabwareView:
     ) -> Optional[LoadedLabware]:
         """Get the labware located in a given slot, if any."""
         loaded_labware = list(self._state.labware_by_id.values())
-
         for labware in loaded_labware:
             if (
                 isinstance(labware.location, DeckSlotLocation)

opentrons/protocol_engine/state/labware_origin_math/stackup_origin_to_labware_origin.py

@@ -49,6 +49,7 @@ from opentrons.protocol_engine.types import (
     OnLabwareLocation,
     LabwareMovementOffsetData,
     LabwareOffsetVector,
+    WASTE_CHUTE_LOCATION,
 )
 
 _OFFSET_ON_TC_OT2 = Point(x=0, y=0, z=10.7)
@@ -174,9 +175,13 @@ def _get_stackup_origin_to_lw_origin(
             slot_name=slot_name,
             is_topmost_labware=False,
         )
+    elif location == WASTE_CHUTE_LOCATION:
+        raise LabwareNotOnDeckError(
+            f"Cannot access {definition.metadata.displayName} because it is in the waste chute."
+        )
     else:
         raise LabwareNotOnDeckError(
-            "Cannot access labware since it is not on the deck. "
+            f"Cannot access {definition.metadata.displayName} since it is not on the deck. "
             "Either it has been loaded off-deck or its been moved off-deck."
         )
 

opentrons/protocol_engine/state/modules.py

@@ -267,6 +267,7 @@ class ModuleStore(HasState[ModuleState], HandlesActions):
                 heater_shaker.SetTargetTemperatureResult,
                 heater_shaker.DeactivateHeaterResult,
                 heater_shaker.SetAndWaitForShakeSpeedResult,
+                heater_shaker.SetShakeSpeedResult,
                 heater_shaker.DeactivateShakerResult,
                 heater_shaker.OpenLabwareLatchResult,
                 heater_shaker.CloseLabwareLatchResult,
@@ -430,6 +431,7 @@ class ModuleStore(HasState[ModuleState], HandlesActions):
             heater_shaker.SetTargetTemperature,
             heater_shaker.DeactivateHeater,
             heater_shaker.SetAndWaitForShakeSpeed,
+            heater_shaker.SetShakeSpeed,
             heater_shaker.DeactivateShaker,
             heater_shaker.OpenLabwareLatch,
             heater_shaker.CloseLabwareLatch,
@@ -465,6 +467,13 @@ class ModuleStore(HasState[ModuleState], HandlesActions):
                 is_plate_shaking=True,
                 plate_target_temperature=prev_state.plate_target_temperature,
             )
+        elif isinstance(command.result, heater_shaker.SetShakeSpeedResult):
+            self._state.substate_by_module_id[module_id] = HeaterShakerModuleSubState(
+                module_id=HeaterShakerModuleId(module_id),
+                labware_latch_status=prev_state.labware_latch_status,
+                is_plate_shaking=True,
+                plate_target_temperature=prev_state.plate_target_temperature,
+            )
         elif isinstance(command.result, heater_shaker.DeactivateShakerResult):
             self._state.substate_by_module_id[module_id] = HeaterShakerModuleSubState(
                 module_id=HeaterShakerModuleId(module_id),