opentrons 8.6.0__py3-none-any.whl

opentrons/protocol_engine/commands/unsafe/unsafe_engage_axes.py

@@ -0,0 +1,82 @@
+"""Update position estimators payload, result, and implementaiton."""
+
+from __future__ import annotations
+from pydantic import BaseModel, Field
+from typing import TYPE_CHECKING, Optional, List, Type
+from typing_extensions import Literal
+
+from ...types import MotorAxis
+from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
+from ...errors.error_occurrence import ErrorOccurrence
+from ...resources import ensure_ot3_hardware
+
+from opentrons.hardware_control import HardwareControlAPI
+
+if TYPE_CHECKING:
+    from ...execution import GantryMover
+
+
+UnsafeEngageAxesCommandType = Literal["unsafe/engageAxes"]
+
+
+class UnsafeEngageAxesParams(BaseModel):
+    """Payload required for an UnsafeEngageAxes command."""
+
+    axes: List[MotorAxis] = Field(..., description="The axes for which to enable.")
+
+
+class UnsafeEngageAxesResult(BaseModel):
+    """Result data from the execution of an UnsafeEngageAxes command."""
+
+
+class UnsafeEngageAxesImplementation(
+    AbstractCommandImpl[
+        UnsafeEngageAxesParams,
+        SuccessData[UnsafeEngageAxesResult],
+    ]
+):
+    """Enable axes command implementation."""
+
+    def __init__(
+        self,
+        hardware_api: HardwareControlAPI,
+        gantry_mover: GantryMover,
+        **kwargs: object,
+    ) -> None:
+        self._hardware_api = hardware_api
+        self._gantry_mover = gantry_mover
+
+    async def execute(
+        self, params: UnsafeEngageAxesParams
+    ) -> SuccessData[UnsafeEngageAxesResult]:
+        """Enable exes."""
+        ot3_hardware_api = ensure_ot3_hardware(self._hardware_api)
+        await ot3_hardware_api.engage_axes(
+            self._gantry_mover.motor_axes_to_present_hardware_axes(params.axes)
+        )
+        return SuccessData(
+            public=UnsafeEngageAxesResult(),
+        )
+
+
+class UnsafeEngageAxes(
+    BaseCommand[UnsafeEngageAxesParams, UnsafeEngageAxesResult, ErrorOccurrence]
+):
+    """UnsafeEngageAxes command model."""
+
+    commandType: UnsafeEngageAxesCommandType = "unsafe/engageAxes"
+    params: UnsafeEngageAxesParams
+    result: Optional[UnsafeEngageAxesResult] = None
+
+    _ImplementationCls: Type[
+        UnsafeEngageAxesImplementation
+    ] = UnsafeEngageAxesImplementation
+
+
+class UnsafeEngageAxesCreate(BaseCommandCreate[UnsafeEngageAxesParams]):
+    """UnsafeEngageAxes command request model."""
+
+    commandType: UnsafeEngageAxesCommandType = "unsafe/engageAxes"
+    params: UnsafeEngageAxesParams
+
+    _CommandCls: Type[UnsafeEngageAxes] = UnsafeEngageAxes

opentrons/protocol_engine/commands/unsafe/unsafe_place_labware.py

@@ -0,0 +1,208 @@
+"""Place labware payload, result, and implementaiton."""
+
+from __future__ import annotations
+from typing import TYPE_CHECKING, Optional, Type
+from typing_extensions import Literal
+
+from opentrons_shared_data.labware.types import LabwareUri
+from opentrons_shared_data.labware.labware_definition import LabwareDefinition
+from pydantic import BaseModel, Field
+
+from opentrons.hardware_control.types import Axis, OT3Mount
+from opentrons.motion_planning.waypoints import get_gripper_labware_placement_waypoints
+from opentrons.protocol_engine.errors.exceptions import (
+    CannotPerformGripperAction,
+    GripperNotAttachedError,
+)
+from opentrons.types import Point
+
+from ...types import (
+    DeckSlotLocation,
+    ModuleModel,
+    OnDeckLabwareLocation,
+)
+from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
+from ...errors.error_occurrence import ErrorOccurrence
+from ...resources import ensure_ot3_hardware
+
+from opentrons.hardware_control import HardwareControlAPI, OT3HardwareControlAPI
+
+if TYPE_CHECKING:
+    from ...state.state import StateView
+    from ...execution.equipment import EquipmentHandler
+
+
+UnsafePlaceLabwareCommandType = Literal["unsafe/placeLabware"]
+
+
+class UnsafePlaceLabwareParams(BaseModel):
+    """Payload required for an UnsafePlaceLabware command."""
+
+    labwareURI: str = Field(..., description="Labware URI for labware.")
+    location: OnDeckLabwareLocation = Field(
+        ..., description="Where to place the labware."
+    )
+
+
+class UnsafePlaceLabwareResult(BaseModel):
+    """Result data from the execution of an UnsafePlaceLabware command."""
+
+
+class UnsafePlaceLabwareImplementation(
+    AbstractCommandImpl[
+        UnsafePlaceLabwareParams,
+        SuccessData[UnsafePlaceLabwareResult],
+    ]
+):
+    """The UnsafePlaceLabware command implementation."""
+
+    def __init__(
+        self,
+        hardware_api: HardwareControlAPI,
+        state_view: StateView,
+        equipment: EquipmentHandler,
+        **kwargs: object,
+    ) -> None:
+        self._hardware_api = hardware_api
+        self._state_view = state_view
+        self._equipment = equipment
+
+    async def execute(
+        self, params: UnsafePlaceLabwareParams
+    ) -> SuccessData[UnsafePlaceLabwareResult]:
+        """Place Labware.
+
+        This command is used only when the gripper is in the middle of moving
+        labware but is interrupted before completing the move. (i.e., the e-stop
+        is pressed, get into error recovery, etc).
+
+        Unlike the `moveLabware` command, where you pick a source and destination
+        location, this command takes the labwareURI of the labware to be moved
+        and location to move it to.
+
+        """
+        ot3api = ensure_ot3_hardware(self._hardware_api)
+        if not ot3api.has_gripper():
+            raise GripperNotAttachedError("No gripper found to perform labware place.")
+
+        if ot3api.gripper_jaw_can_home():
+            raise CannotPerformGripperAction(
+                "Cannot place labware when gripper is not gripping."
+            )
+
+        location = self._state_view.geometry.ensure_valid_gripper_location(
+            params.location,
+        )
+
+        definition = self._state_view.labware.get_definition_by_uri(
+            # todo(mm, 2024-11-07): This is an unsafe cast from untrusted input.
+            # We need a str -> LabwareUri parse/validate function.
+            LabwareUri(params.labwareURI)
+        )
+
+        # todo(mm, 2024-11-06): This is only correct in the special case of an
+        # absorbance reader lid. Its definition currently puts the offsets for *itself*
+        # in the property that's normally meant for offsets for its *children.*
+        final_offsets = self._state_view.labware.get_child_gripper_offsets(
+            labware_definition=definition, slot_name=None
+        )
+        drop_offset = (
+            Point(
+                final_offsets.dropOffset.x,
+                final_offsets.dropOffset.y,
+                final_offsets.dropOffset.z,
+            )
+            if final_offsets
+            else None
+        )
+
+        if isinstance(params.location, DeckSlotLocation):
+            self._state_view.addressable_areas.raise_if_area_not_in_deck_configuration(
+                params.location.slotName.id
+            )
+
+        # This is an absorbance reader, move the lid to its dock (staging area).
+        if isinstance(location, DeckSlotLocation):
+            module = self._state_view.modules.get_by_slot(location.slotName)
+            if module and module.model == ModuleModel.ABSORBANCE_READER_V1:
+                location = self._state_view.modules.absorbance_reader_dock_location(
+                    module.id
+                )
+
+        # NOTE: When the estop is pressed, the gantry loses position, lets use
+        # the encoders to sync position.
+        # Ideally, we'd do a full home, but this command is used when
+        # the gripper is holding the plate reader, and a full home would
+        # bang it into the right window.
+        await ot3api.home(axes=[Axis.Z_L, Axis.Z_R, Axis.Z_G])
+        await ot3api.engage_axes([Axis.X, Axis.Y])
+        await ot3api.update_axis_position_estimations([Axis.X, Axis.Y])
+
+        # Place the labware down
+        await self._start_movement(ot3api, definition, location, drop_offset)
+
+        return SuccessData(public=UnsafePlaceLabwareResult())
+
+    async def _start_movement(
+        self,
+        ot3api: OT3HardwareControlAPI,
+        labware_definition: LabwareDefinition,
+        location: OnDeckLabwareLocation,
+        drop_offset: Optional[Point],
+    ) -> None:
+        gripper_homed_position = await ot3api.gantry_position(
+            mount=OT3Mount.GRIPPER,
+            refresh=True,
+        )
+
+        to_labware_center = self._state_view.geometry.get_labware_grip_point(
+            labware_definition=labware_definition, location=location
+        )
+
+        movement_waypoints = get_gripper_labware_placement_waypoints(
+            to_labware_center=to_labware_center,
+            gripper_home_z=gripper_homed_position.z,
+            drop_offset=drop_offset,
+        )
+
+        # start movement
+        for waypoint_data in movement_waypoints:
+            if waypoint_data.jaw_open:
+                if waypoint_data.dropping:
+                    # This `disengage_axes` step is important in order to engage
+                    # the electronic brake on the Z axis of the gripper. The brake
+                    # has a stronger holding force on the axis than the hold current,
+                    # and prevents the axis from spuriously dropping when  e.g. the notch
+                    # on the side of a falling tiprack catches the jaw.
+                    await ot3api.disengage_axes([Axis.Z_G])
+                await ot3api.ungrip()
+                if waypoint_data.dropping:
+                    # We lost the position estimation after disengaging the axis, so
+                    # it is necessary to home it next
+                    await ot3api.home_z(OT3Mount.GRIPPER)
+            await ot3api.move_to(
+                mount=OT3Mount.GRIPPER, abs_position=waypoint_data.position
+            )
+
+
+class UnsafePlaceLabware(
+    BaseCommand[UnsafePlaceLabwareParams, UnsafePlaceLabwareResult, ErrorOccurrence]
+):
+    """UnsafePlaceLabware command model."""
+
+    commandType: UnsafePlaceLabwareCommandType = "unsafe/placeLabware"
+    params: UnsafePlaceLabwareParams
+    result: Optional[UnsafePlaceLabwareResult] = None
+
+    _ImplementationCls: Type[
+        UnsafePlaceLabwareImplementation
+    ] = UnsafePlaceLabwareImplementation
+
+
+class UnsafePlaceLabwareCreate(BaseCommandCreate[UnsafePlaceLabwareParams]):
+    """UnsafePlaceLabware command request model."""
+
+    commandType: UnsafePlaceLabwareCommandType = "unsafe/placeLabware"
+    params: UnsafePlaceLabwareParams
+
+    _CommandCls: Type[UnsafePlaceLabware] = UnsafePlaceLabware

opentrons/protocol_engine/commands/unsafe/unsafe_stacker_close_latch.py

@@ -0,0 +1,94 @@
+"""Command models to close the latch of a Flex Stacker."""
+
+from __future__ import annotations
+
+from __future__ import annotations
+from typing import Optional, Literal, TYPE_CHECKING
+from typing_extensions import Type
+
+from pydantic import BaseModel, Field
+
+from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
+from ...errors import ErrorOccurrence
+
+if TYPE_CHECKING:
+    from ...state.state import StateView
+    from opentrons.protocol_engine.execution import EquipmentHandler
+
+UnsafeFlexStackerCloseLatchCommandType = Literal["unsafe/flexStacker/closeLatch"]
+
+
+class UnsafeFlexStackerCloseLatchParams(BaseModel):
+    """The parameters defining how a stacker should close its latch."""
+
+    moduleId: str = Field(..., description="Unique ID of the Flex Stacker")
+
+
+class UnsafeFlexStackerCloseLatchResult(BaseModel):
+    """Result data from a stacker UnsafeFlexStackerCloseLatch command."""
+
+
+class UnsafeFlexStackerCloseLatchImpl(
+    AbstractCommandImpl[
+        UnsafeFlexStackerCloseLatchParams,
+        SuccessData[UnsafeFlexStackerCloseLatchResult],
+    ]
+):
+    """Implementation of a stacker UnsafeFlexStackerCloseLatch command."""
+
+    def __init__(
+        self, state_view: StateView, equipment: EquipmentHandler, **kwargs: object
+    ) -> None:
+        self._state_view = state_view
+        self._equipment = equipment
+
+    async def execute(
+        self, params: UnsafeFlexStackerCloseLatchParams
+    ) -> SuccessData[UnsafeFlexStackerCloseLatchResult]:
+        """Execute the stacker UnsafeFlexStackerCloseLatch command.
+
+        Closing the latch modifies the state of the flex stacker and affects its
+        ability to execute the next command. This command should be used with care
+        outside of a protocol.
+        """
+        stacker_state = self._state_view.modules.get_flex_stacker_substate(
+            params.moduleId
+        )
+        stacker_hw = self._equipment.get_module_hardware_api(stacker_state.module_id)
+
+        if stacker_hw is not None:
+            await stacker_hw.close_latch()
+        return SuccessData(public=UnsafeFlexStackerCloseLatchResult())
+
+
+class UnsafeFlexStackerCloseLatch(
+    BaseCommand[
+        UnsafeFlexStackerCloseLatchParams,
+        UnsafeFlexStackerCloseLatchResult,
+        ErrorOccurrence,
+    ]
+):
+    """A command to UnsafeFlexStackerCloseLatch the Flex Stacker of labware."""
+
+    commandType: UnsafeFlexStackerCloseLatchCommandType = (
+        "unsafe/flexStacker/closeLatch"
+    )
+    params: UnsafeFlexStackerCloseLatchParams
+    result: Optional[UnsafeFlexStackerCloseLatchResult] = None
+
+    _ImplementationCls: Type[
+        UnsafeFlexStackerCloseLatchImpl
+    ] = UnsafeFlexStackerCloseLatchImpl
+
+
+class UnsafeFlexStackerCloseLatchCreate(
+    BaseCommandCreate[UnsafeFlexStackerCloseLatchParams]
+):
+    """A request to execute a Flex Stacker UnsafeFlexStackerCloseLatch command."""
+
+    commandType: UnsafeFlexStackerCloseLatchCommandType = (
+        "unsafe/flexStacker/closeLatch"
+    )
+    params: UnsafeFlexStackerCloseLatchParams
+
+    _CommandCls: Type[UnsafeFlexStackerCloseLatch] = UnsafeFlexStackerCloseLatch

opentrons/protocol_engine/commands/unsafe/unsafe_stacker_manual_retrieve.py

@@ -0,0 +1,295 @@
+"""Command models to manually retrieve a labware from a Flex Stacker in an unsafe situation."""
+
+from __future__ import annotations
+from typing import Literal, TYPE_CHECKING, Any, Union, cast
+from typing_extensions import Type
+
+from pydantic import BaseModel, Field
+from pydantic.json_schema import SkipJsonSchema
+
+from ..command import (
+    AbstractCommandImpl,
+    BaseCommand,
+    BaseCommandCreate,
+    SuccessData,
+    DefinedErrorData,
+)
+from ..flex_stacker.common import (
+    FlexStackerStallOrCollisionError,
+    labware_locations_for_group,
+    build_retrieve_labware_move_updates,
+    primary_location_sequence,
+    adapter_location_sequence,
+    lid_location_sequence,
+)
+from ...errors import (
+    ErrorOccurrence,
+    CannotPerformModuleAction,
+    LocationIsOccupiedError,
+    FlexStackerLabwarePoolNotYetDefinedError,
+)
+from ...resources import ModelUtils
+from ...state import update_types
+from ...types import (
+    ModuleLocation,
+    LabwareLocationSequence,
+    InStackerHopperLocation,
+)
+from opentrons.hardware_control.modules.types import PlatformState
+from opentrons_shared_data.labware.labware_definition import LabwareDefinition
+
+if TYPE_CHECKING:
+    from opentrons.protocol_engine.state.state import StateView
+    from opentrons.protocol_engine.execution import EquipmentHandler
+
+UnsafeFlexStackerManualRetrieveCommandType = Literal[
+    "unsafe/flexStacker/manualRetrieve"
+]
+
+
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
+class UnsafeFlexStackerManualRetrieveParams(BaseModel):
+    """Input parameters for a labware retrieval command."""
+
+    moduleId: str = Field(
+        ...,
+        description="Unique ID of the Flex Stacker.",
+    )
+    labwareId: str | SkipJsonSchema[None] = Field(
+        None,
+        description="Do not use. Present for internal backward compatibility.",
+        json_schema_extra=_remove_default,
+    )
+    displayName: str | SkipJsonSchema[None] = Field(
+        None,
+        description="Do not use. Present for internal backward compatibility.",
+        json_schema_extra=_remove_default,
+    )
+    adapterId: str | SkipJsonSchema[None] = Field(
+        None,
+        description="Do not use. Present for internal backward compatibility.",
+        json_schema_extra=_remove_default,
+    )
+    lidId: str | SkipJsonSchema[None] = Field(
+        None,
+        description="Do not use. Present for internal backward compatibility.",
+        json_schema_extra=_remove_default,
+    )
+
+
+class UnsafeFlexStackerManualRetrieveResult(BaseModel):
+    """Result data from a labware retrieval command."""
+
+    labwareId: str = Field(
+        ...,
+        description="The labware ID of the primary retrieved labware.",
+    )
+    adapterId: str | None = Field(
+        None,
+        description="The optional Adapter Labware ID of the adapter under a primary labware.",
+    )
+    lidId: str | None = Field(
+        None,
+        description="The optional Lid Labware ID of the lid on a primary labware.",
+    )
+    primaryLocationSequence: LabwareLocationSequence = Field(
+        ..., description="The origin location of the primary labware."
+    )
+    lidLocationSequence: LabwareLocationSequence | None = Field(
+        None,
+        description="The origin location of the adapter labware under a primary labware.",
+    )
+    adapterLocationSequence: LabwareLocationSequence | None = Field(
+        None, description="The origin location of the lid labware on a primary labware."
+    )
+    originalPrimaryLocationSequence: LabwareLocationSequence = Field(
+        ..., description="The original location of the just-retrieved primary labware"
+    )
+    originalAdapterLocationSequence: LabwareLocationSequence | None = Field(
+        None, description="The original location of an adapter labware if any"
+    )
+    originalLidLocationSequence: LabwareLocationSequence | None = Field(
+        None, description="The original location of a lid labware if any"
+    )
+    primaryLabwareURI: str = Field(
+        ...,
+        description="The labware definition URI of the primary labware.",
+    )
+    adapterLabwareURI: str | None = Field(
+        None,
+        description="The labware definition URI of the adapter labware.",
+    )
+    lidLabwareURI: str | None = Field(
+        None,
+        description="The labware definition URI of the lid labware.",
+    )
+
+
+_ExecuteReturn = Union[
+    SuccessData[UnsafeFlexStackerManualRetrieveResult],
+    DefinedErrorData[FlexStackerStallOrCollisionError],
+]
+
+
+class UnsafeFlexStackerManualRetrieveImpl(
+    AbstractCommandImpl[UnsafeFlexStackerManualRetrieveParams, _ExecuteReturn]
+):
+    """Implementation of a labware retrieval command."""
+
+    def __init__(
+        self,
+        state_view: StateView,
+        equipment: EquipmentHandler,
+        model_utils: ModelUtils,
+        **kwargs: object,
+    ) -> None:
+        self._state_view = state_view
+        self._equipment = equipment
+        self._model_utils = model_utils
+
+    async def execute(
+        self, params: UnsafeFlexStackerManualRetrieveParams
+    ) -> _ExecuteReturn:
+        """Execute the labware retrieval command."""
+        stacker_state = self._state_view.modules.get_flex_stacker_substate(
+            params.moduleId
+        )
+
+        pool_definitions = stacker_state.get_pool_definition_ordered_list()
+        location = self._state_view.modules.get_location(params.moduleId)
+        if pool_definitions is None:
+            raise FlexStackerLabwarePoolNotYetDefinedError(
+                message=f"The Flex Stacker in {location} has not been configured yet and cannot be filled."
+            )
+
+        if len(stacker_state.contained_labware_bottom_first) == 0:
+            raise CannotPerformModuleAction(
+                message=f"Cannot retrieve labware from Flex Stacker in {location} because it contains no labware"
+            )
+
+        stacker_loc = ModuleLocation(moduleId=params.moduleId)
+        # Allow propagation of ModuleNotAttachedError.
+        stacker_hw = self._equipment.get_module_hardware_api(stacker_state.module_id)
+
+        # Validate that the stacker is fully in the gripper position
+        if stacker_hw:
+            stacker_hw.set_stacker_identify(True)
+            if stacker_hw.platform_state != PlatformState.EXTENDED:
+                raise CannotPerformModuleAction(
+                    f"Cannot manually retrieve a labware from Flex Stacker in {location} if the carriage is not in gripper position."
+                )
+
+        try:
+            # In theory given this is an unsafe manual retrieve this should never raise
+            self._state_view.labware.raise_if_labware_in_location(stacker_loc)
+        except LocationIsOccupiedError:
+            raise CannotPerformModuleAction(
+                f"Cannot retrieve a labware from Flex Stacker in {location} if the carriage is occupied"
+            )
+
+        to_retrieve = stacker_state.contained_labware_bottom_first[0]
+        remaining = stacker_state.contained_labware_bottom_first[1:]
+
+        locations, offsets = build_retrieve_labware_move_updates(
+            to_retrieve, stacker_state, self._state_view
+        )
+
+        # Update the state to reflect the labware is now in the Flex Stacker slot
+        # todo(chb, 2025-02-19): This ModuleLocation piece should probably instead be an AddressableAreaLocation
+        # but that has implications for where labware are set by things like module.load_labware(..) and what
+        # happens when we move labware.
+        stacker_area = (
+            self._state_view.modules.ensure_and_convert_module_fixture_location(
+                deck_slot=self._state_view.modules.get_location(
+                    params.moduleId
+                ).slotName,
+                model=self._state_view.modules.get(params.moduleId).model,
+            )
+        )
+
+        original_locations = labware_locations_for_group(
+            to_retrieve,
+            self._state_view.geometry.get_predicted_location_sequence(
+                InStackerHopperLocation(moduleId=params.moduleId)
+            ),
+        )
+        new_locations = labware_locations_for_group(
+            to_retrieve,
+            self._state_view.geometry.get_predicted_location_sequence(
+                ModuleLocation(moduleId=params.moduleId)
+            ),
+        )
+
+        if stacker_hw is not None:
+            stacker_hw.set_stacker_identify(False)
+
+        return SuccessData(
+            public=UnsafeFlexStackerManualRetrieveResult(
+                labwareId=to_retrieve.primaryLabwareId,
+                adapterId=to_retrieve.adapterLabwareId,
+                lidId=to_retrieve.lidLabwareId,
+                primaryLocationSequence=primary_location_sequence(new_locations),
+                adapterLocationSequence=adapter_location_sequence(new_locations),
+                lidLocationSequence=lid_location_sequence(new_locations),
+                originalPrimaryLocationSequence=primary_location_sequence(
+                    original_locations
+                ),
+                originalAdapterLocationSequence=adapter_location_sequence(
+                    original_locations
+                ),
+                originalLidLocationSequence=lid_location_sequence(original_locations),
+                primaryLabwareURI=self._state_view.labware.get_uri_from_definition_unless_none(
+                    cast(LabwareDefinition, stacker_state.pool_primary_definition)
+                ),
+                adapterLabwareURI=self._state_view.labware.get_uri_from_definition_unless_none(
+                    stacker_state.pool_adapter_definition
+                ),
+                lidLabwareURI=self._state_view.labware.get_uri_from_definition_unless_none(
+                    stacker_state.pool_lid_definition
+                ),
+            ),
+            state_update=(
+                update_types.StateUpdate()
+                .set_batch_labware_location(
+                    new_locations_by_id=locations, new_offset_ids_by_id=offsets
+                )
+                .update_flex_stacker_contained_labware(params.moduleId, remaining)
+                .set_addressable_area_used(stacker_area)
+            ),
+        )
+
+
+class UnsafeFlexStackerManualRetrieve(
+    BaseCommand[
+        UnsafeFlexStackerManualRetrieveParams,
+        UnsafeFlexStackerManualRetrieveResult,
+        ErrorOccurrence,
+    ]
+):
+    """A command to manually retrieve a labware from a Flex Stacker."""
+
+    commandType: UnsafeFlexStackerManualRetrieveCommandType = (
+        "unsafe/flexStacker/manualRetrieve"
+    )
+    params: UnsafeFlexStackerManualRetrieveParams
+    result: UnsafeFlexStackerManualRetrieveResult | None = None
+
+    _ImplementationCls: Type[
+        UnsafeFlexStackerManualRetrieveImpl
+    ] = UnsafeFlexStackerManualRetrieveImpl
+
+
+class UnsafeFlexStackerManualRetrieveCreate(
+    BaseCommandCreate[UnsafeFlexStackerManualRetrieveParams]
+):
+    """A request to execute a Flex Stacker manual retrieve command."""
+
+    commandType: UnsafeFlexStackerManualRetrieveCommandType = (
+        "unsafe/flexStacker/manualRetrieve"
+    )
+    params: UnsafeFlexStackerManualRetrieveParams
+
+    _CommandCls: Type[UnsafeFlexStackerManualRetrieve] = UnsafeFlexStackerManualRetrieve