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

opentrons/protocol_engine/commands/unsafe/unsafe_drop_tip_in_place.py

@@ -1,5 +1,6 @@
 """Command models to drop tip in place while plunger positions are unknown."""
 from __future__ import annotations
+from opentrons.protocol_engine.state.update_types import StateUpdate
 from pydantic import Field, BaseModel
 from typing import TYPE_CHECKING, Optional, Type
 from typing_extensions import Literal
@@ -14,7 +15,7 @@ from ...resources import ensure_ot3_hardware
 
 if TYPE_CHECKING:
     from ...execution import TipHandler
-    from ...state import StateView
+    from ...state.state import StateView
 
 
 UnsafeDropTipInPlaceCommandType = Literal["unsafe/dropTipInPlace"]
@@ -41,7 +42,7 @@ class UnsafeDropTipInPlaceResult(BaseModel):
 
 class UnsafeDropTipInPlaceImplementation(
     AbstractCommandImpl[
-        UnsafeDropTipInPlaceParams, SuccessData[UnsafeDropTipInPlaceResult, None]
+        UnsafeDropTipInPlaceParams, SuccessData[UnsafeDropTipInPlaceResult]
     ]
 ):
     """Unsafe drop tip in place command implementation."""
@@ -59,7 +60,7 @@ class UnsafeDropTipInPlaceImplementation(
 
     async def execute(
         self, params: UnsafeDropTipInPlaceParams
-    ) -> SuccessData[UnsafeDropTipInPlaceResult, None]:
+    ) -> SuccessData[UnsafeDropTipInPlaceResult]:
         """Drop a tip using the requested pipette, even if the plunger position is not known."""
         ot3_hardware_api = ensure_ot3_hardware(self._hardware_api)
         pipette_location = self._state_view.motion.get_pipette_location(
@@ -72,7 +73,14 @@ class UnsafeDropTipInPlaceImplementation(
             pipette_id=params.pipetteId, home_after=params.homeAfter
         )
 
-        return SuccessData(public=UnsafeDropTipInPlaceResult(), private=None)
+        state_update = StateUpdate()
+        state_update.update_pipette_tip_state(
+            pipette_id=params.pipetteId, tip_geometry=None
+        )
+
+        return SuccessData(
+            public=UnsafeDropTipInPlaceResult(), state_update=state_update
+        )
 
 
 class UnsafeDropTipInPlace(

opentrons/protocol_engine/commands/unsafe/unsafe_engage_axes.py

@@ -32,7 +32,7 @@ class UnsafeEngageAxesResult(BaseModel):
 class UnsafeEngageAxesImplementation(
     AbstractCommandImpl[
         UnsafeEngageAxesParams,
-        SuccessData[UnsafeEngageAxesResult, None],
+        SuccessData[UnsafeEngageAxesResult],
     ]
 ):
     """Enable axes command implementation."""
@@ -48,7 +48,7 @@ class UnsafeEngageAxesImplementation(
 
     async def execute(
         self, params: UnsafeEngageAxesParams
-    ) -> SuccessData[UnsafeEngageAxesResult, None]:
+    ) -> SuccessData[UnsafeEngageAxesResult]:
         """Enable exes."""
         ot3_hardware_api = ensure_ot3_hardware(self._hardware_api)
         await ot3_hardware_api.engage_axes(
@@ -57,7 +57,9 @@ class UnsafeEngageAxesImplementation(
                 for axis in params.axes
             ]
         )
-        return SuccessData(public=UnsafeEngageAxesResult(), private=None)
+        return SuccessData(
+            public=UnsafeEngageAxesResult(),
+        )
 
 
 class 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]
+
+    _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_ungrip_labware.py

@@ -0,0 +1,77 @@
+"""Ungrip labware payload, result, and implementaiton."""
+
+from __future__ import annotations
+
+from opentrons.hardware_control.types import Axis
+from opentrons.protocol_engine.errors.exceptions import GripperNotAttachedError
+from pydantic import BaseModel
+from typing import Optional, Type
+from typing_extensions import Literal
+
+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
+
+
+UnsafeUngripLabwareCommandType = Literal["unsafe/ungripLabware"]
+
+
+class UnsafeUngripLabwareParams(BaseModel):
+    """Payload required for an UngripLabware command."""
+
+
+class UnsafeUngripLabwareResult(BaseModel):
+    """Result data from the execution of an UngripLabware command."""
+
+
+class UnsafeUngripLabwareImplementation(
+    AbstractCommandImpl[
+        UnsafeUngripLabwareParams,
+        SuccessData[UnsafeUngripLabwareResult],
+    ]
+):
+    """Ungrip labware command implementation."""
+
+    def __init__(
+        self,
+        hardware_api: HardwareControlAPI,
+        **kwargs: object,
+    ) -> None:
+        self._hardware_api = hardware_api
+
+    async def execute(
+        self, params: UnsafeUngripLabwareParams
+    ) -> SuccessData[UnsafeUngripLabwareResult]:
+        """Ungrip Labware."""
+        ot3_hardware_api = ensure_ot3_hardware(self._hardware_api)
+        if not ot3_hardware_api.has_gripper():
+            raise GripperNotAttachedError("No gripper found to perform ungrip.")
+        await ot3_hardware_api.home([Axis.G])
+        return SuccessData(
+            public=UnsafeUngripLabwareResult(),
+        )
+
+
+class UnsafeUngripLabware(
+    BaseCommand[UnsafeUngripLabwareParams, UnsafeUngripLabwareResult, ErrorOccurrence]
+):
+    """UnsafeUngripLabware command model."""
+
+    commandType: UnsafeUngripLabwareCommandType = "unsafe/ungripLabware"
+    params: UnsafeUngripLabwareParams
+    result: Optional[UnsafeUngripLabwareResult]
+
+    _ImplementationCls: Type[
+        UnsafeUngripLabwareImplementation
+    ] = UnsafeUngripLabwareImplementation
+
+
+class UnsafeUngripLabwareCreate(BaseCommandCreate[UnsafeUngripLabwareParams]):
+    """UnsafeEngageAxes command request model."""
+
+    commandType: UnsafeUngripLabwareCommandType = "unsafe/ungripLabware"
+    params: UnsafeUngripLabwareParams
+
+    _CommandCls: Type[UnsafeUngripLabware] = UnsafeUngripLabware

opentrons/protocol_engine/commands/unsafe/update_position_estimators.py

@@ -23,7 +23,11 @@ class UpdatePositionEstimatorsParams(BaseModel):
     """Payload required for an UpdatePositionEstimators command."""
 
     axes: List[MotorAxis] = Field(
-        ..., description="The axes for which to update the position estimators."
+        ...,
+        description=(
+            "The axes for which to update the position estimators."
+            " Any axes that are not physically present will be ignored."
+        ),
     )
 
 
@@ -34,7 +38,7 @@ class UpdatePositionEstimatorsResult(BaseModel):
 class UpdatePositionEstimatorsImplementation(
     AbstractCommandImpl[
         UpdatePositionEstimatorsParams,
-        SuccessData[UpdatePositionEstimatorsResult, None],
+        SuccessData[UpdatePositionEstimatorsResult],
     ]
 ):
     """Update position estimators command implementation."""
@@ -50,7 +54,7 @@ class UpdatePositionEstimatorsImplementation(
 
     async def execute(
         self, params: UpdatePositionEstimatorsParams
-    ) -> SuccessData[UpdatePositionEstimatorsResult, None]:
+    ) -> SuccessData[UpdatePositionEstimatorsResult]:
         """Update axis position estimators from their encoders."""
         ot3_hardware_api = ensure_ot3_hardware(self._hardware_api)
         await ot3_hardware_api.update_axis_position_estimations(
@@ -59,7 +63,9 @@ class UpdatePositionEstimatorsImplementation(
                 for axis in params.axes
             ]
         )
-        return SuccessData(public=UpdatePositionEstimatorsResult(), private=None)
+        return SuccessData(
+            public=UpdatePositionEstimatorsResult(),
+        )
 
 
 class UpdatePositionEstimators(

opentrons/protocol_engine/commands/verify_tip_presence.py

@@ -36,9 +36,7 @@ class VerifyTipPresenceResult(BaseModel):
 
 
 class VerifyTipPresenceImplementation(
-    AbstractCommandImpl[
-        VerifyTipPresenceParams, SuccessData[VerifyTipPresenceResult, None]
-    ]
+    AbstractCommandImpl[VerifyTipPresenceParams, SuccessData[VerifyTipPresenceResult]]
 ):
     """VerifyTipPresence command implementation."""
 
@@ -51,7 +49,7 @@ class VerifyTipPresenceImplementation(
 
     async def execute(
         self, params: VerifyTipPresenceParams
-    ) -> SuccessData[VerifyTipPresenceResult, None]:
+    ) -> SuccessData[VerifyTipPresenceResult]:
         """Verify if tip presence is as expected for the requested pipette."""
         pipette_id = params.pipetteId
         expected_state = params.expectedState
@@ -67,7 +65,9 @@ class VerifyTipPresenceImplementation(
             follow_singular_sensor=follow_singular_sensor,
         )
 
-        return SuccessData(public=VerifyTipPresenceResult(), private=None)
+        return SuccessData(
+            public=VerifyTipPresenceResult(),
+        )
 
 
 class VerifyTipPresence(

opentrons/protocol_engine/commands/wait_for_duration.py

@@ -29,7 +29,7 @@ class WaitForDurationResult(BaseModel):
 
 
 class WaitForDurationImplementation(
-    AbstractCommandImpl[WaitForDurationParams, SuccessData[WaitForDurationResult, None]]
+    AbstractCommandImpl[WaitForDurationParams, SuccessData[WaitForDurationResult]]
 ):
     """Wait for duration command implementation."""
 
@@ -38,10 +38,12 @@ class WaitForDurationImplementation(
 
     async def execute(
         self, params: WaitForDurationParams
-    ) -> SuccessData[WaitForDurationResult, None]:
+    ) -> SuccessData[WaitForDurationResult]:
         """Wait for a duration of time."""
         await self._run_control.wait_for_duration(params.seconds)
-        return SuccessData(public=WaitForDurationResult(), private=None)
+        return SuccessData(
+            public=WaitForDurationResult(),
+        )
 
 
 class WaitForDuration(

opentrons/protocol_engine/commands/wait_for_resume.py

@@ -30,7 +30,7 @@ class WaitForResumeResult(BaseModel):
 
 
 class WaitForResumeImplementation(
-    AbstractCommandImpl[WaitForResumeParams, SuccessData[WaitForResumeResult, None]]
+    AbstractCommandImpl[WaitForResumeParams, SuccessData[WaitForResumeResult]]
 ):
     """Wait for resume command implementation."""
 
@@ -39,10 +39,12 @@ class WaitForResumeImplementation(
 
     async def execute(
         self, params: WaitForResumeParams
-    ) -> SuccessData[WaitForResumeResult, None]:
+    ) -> SuccessData[WaitForResumeResult]:
         """Dispatch a PauseAction to the store to pause the protocol."""
         await self._run_control.wait_for_resume()
-        return SuccessData(public=WaitForResumeResult(), private=None)
+        return SuccessData(
+            public=WaitForResumeResult(),
+        )
 
 
 class WaitForResume(

opentrons/protocol_engine/create_protocol_engine.py

@@ -5,13 +5,25 @@ import typing
 
 from opentrons.hardware_control import HardwareControlAPI
 from opentrons.hardware_control.types import DoorState
-from opentrons.protocol_engine.error_recovery_policy import ErrorRecoveryPolicy
+from opentrons.protocol_engine.execution.error_recovery_hardware_state_synchronizer import (
+    ErrorRecoveryHardwareStateSynchronizer,
+)
+from opentrons.protocol_engine.resources.labware_data_provider import (
+    LabwareDataProvider,
+)
 from opentrons.util.async_helpers import async_context_manager_in_thread
+
 from opentrons_shared_data.robot import load as load_robot
 
+from .actions.action_dispatcher import ActionDispatcher
+from .error_recovery_policy import ErrorRecoveryPolicy
+from .execution.door_watcher import DoorWatcher
+from .execution.hardware_stopper import HardwareStopper
+from .plugins import PluginStarter
 from .protocol_engine import ProtocolEngine
-from .resources import DeckDataProvider, ModuleDataProvider
-from .state import Config, StateStore
+from .resources import DeckDataProvider, ModuleDataProvider, FileProvider, ModelUtils
+from .state.config import Config
+from .state.state import StateStore
 from .types import PostRunHardwareState, DeckConfigurationType
 
 from .engine_support import create_run_orchestrator
@@ -25,6 +37,7 @@ async def create_protocol_engine(
     error_recovery_policy: ErrorRecoveryPolicy,
     load_fixed_trash: bool = False,
     deck_configuration: typing.Optional[DeckConfigurationType] = None,
+    file_provider: typing.Optional[FileProvider] = None,
     notify_publishers: typing.Optional[typing.Callable[[], None]] = None,
 ) -> ProtocolEngine:
     """Create a ProtocolEngine instance.
@@ -36,17 +49,18 @@ async def create_protocol_engine(
             See documentation on `ErrorRecoveryPolicy`.
         load_fixed_trash: Automatically load fixed trash labware in engine.
         deck_configuration: The initial deck configuration the engine will be instantiated with.
+        file_provider: Provides access to robot server file writing procedures for protocol output.
         notify_publishers: Notifies robot server publishers of internal state change.
     """
     deck_data = DeckDataProvider(config.deck_type)
     deck_definition = await deck_data.get_deck_definition()
-    deck_fixed_labware = (
-        await deck_data.get_deck_fixed_labware(deck_definition)
-        if load_fixed_trash
-        else []
+    deck_fixed_labware = await deck_data.get_deck_fixed_labware(
+        load_fixed_trash, deck_definition, deck_configuration
     )
+
     module_calibration_offsets = ModuleDataProvider.load_module_calibrations()
     robot_definition = load_robot(config.robot_type)
+
     state_store = StateStore(
         config=config,
         deck_definition=deck_definition,
@@ -58,18 +72,51 @@ async def create_protocol_engine(
         deck_configuration=deck_configuration,
         notify_publishers=notify_publishers,
     )
-
-    return ProtocolEngine(
-        state_store=state_store,
+    hardware_state_synchronizer = ErrorRecoveryHardwareStateSynchronizer(
+        hardware_api, state_store
+    )
+    action_dispatcher = ActionDispatcher(state_store)
+    action_dispatcher.add_handler(hardware_state_synchronizer)
+    plugin_starter = PluginStarter(state_store, action_dispatcher)
+    model_utils = ModelUtils()
+    hardware_stopper = HardwareStopper(hardware_api, state_store)
+    door_watcher = DoorWatcher(state_store, hardware_api, action_dispatcher)
+    module_data_provider = ModuleDataProvider()
+    file_provider = file_provider or FileProvider()
+
+    pe = ProtocolEngine(
         hardware_api=hardware_api,
+        state_store=state_store,
+        action_dispatcher=action_dispatcher,
+        plugin_starter=plugin_starter,
+        model_utils=model_utils,
+        hardware_stopper=hardware_stopper,
+        door_watcher=door_watcher,
+        module_data_provider=module_data_provider,
+        file_provider=file_provider,
     )
 
+    # todo(mm, 2024-11-08): This is a quick hack to support the absorbance reader, which
+    # expects the engine to have this special labware definition available. It would be
+    # cleaner for the `loadModule` command to do this I/O and insert the definition
+    # into state. That gets easier after https://opentrons.atlassian.net/browse/EXEC-756.
+    #
+    # NOTE: This needs to stay in sync with LabwareView.get_absorbance_reader_lid_definition().
+    pe.add_labware_definition(
+        await LabwareDataProvider().get_labware_definition(
+            "opentrons_flex_lid_absorbance_plate_reader_module", "opentrons", 1
+        )
+    )
+
+    return pe
+
 
 @contextlib.contextmanager
 def create_protocol_engine_in_thread(
     hardware_api: HardwareControlAPI,
     config: Config,
     deck_configuration: typing.Optional[DeckConfigurationType],
+    file_provider: typing.Optional[FileProvider],
     error_recovery_policy: ErrorRecoveryPolicy,
     drop_tips_after_run: bool,
     post_run_hardware_state: PostRunHardwareState,
@@ -97,6 +144,7 @@ def create_protocol_engine_in_thread(
     with async_context_manager_in_thread(
         _protocol_engine(
             hardware_api,
+            file_provider,
             config,
             deck_configuration,
             error_recovery_policy,
@@ -114,6 +162,7 @@ def create_protocol_engine_in_thread(
 @contextlib.asynccontextmanager
 async def _protocol_engine(
     hardware_api: HardwareControlAPI,
+    file_provider: typing.Optional[FileProvider],
     config: Config,
     deck_configuration: typing.Optional[DeckConfigurationType],
     error_recovery_policy: ErrorRecoveryPolicy,
@@ -123,6 +172,7 @@ async def _protocol_engine(
 ) -> typing.AsyncGenerator[ProtocolEngine, None]:
     protocol_engine = await create_protocol_engine(
         hardware_api=hardware_api,
+        file_provider=file_provider,
         config=config,
         error_recovery_policy=error_recovery_policy,
         load_fixed_trash=load_fixed_trash,

opentrons/protocol_engine/engine_support.py

@@ -6,7 +6,8 @@ from opentrons.protocol_runner import protocol_runner, RunOrchestrator
 
 
 def create_run_orchestrator(
-    hardware_api: HardwareControlAPI, protocol_engine: ProtocolEngine
+    hardware_api: HardwareControlAPI,
+    protocol_engine: ProtocolEngine,
 ) -> RunOrchestrator:
     """Create a RunOrchestrator instance."""
     return RunOrchestrator(

opentrons/protocol_engine/error_recovery_policy.py

@@ -26,10 +26,20 @@ class ErrorRecoveryType(enum.Enum):
     """
 
     WAIT_FOR_RECOVERY = enum.auto()
-    """Stop and wait for the error to be recovered from manually."""
+    """Enter interactive error recovery mode."""
 
-    IGNORE_AND_CONTINUE = enum.auto()
-    """Continue with the run, as if the command never failed."""
+    CONTINUE_WITH_ERROR = enum.auto()
+    """Continue without interruption, carrying on from whatever error state the failed
+    command left the engine in.
+
+    This is like `ProtocolEngine.resume_from_recovery(reconcile_false_positive=False)`.
+    """
+
+    ASSUME_FALSE_POSITIVE_AND_CONTINUE = enum.auto()
+    """Continue without interruption, acting as if the underlying error was a false positive.
+
+    This is like `ProtocolEngine.resume_from_recovery(reconcile_false_positive=True)`.
+    """
 
 
 class ErrorRecoveryPolicy(Protocol):
@@ -40,6 +50,7 @@ class ErrorRecoveryPolicy(Protocol):
     and return an appropriate `ErrorRecoveryType`.
 
     Args:
+        config: The config of the calling `ProtocolEngine`.
         failed_command: The command that failed, in its final `status=="failed"` state.
         defined_error_data: If the command failed with a defined error, details about
             that error. If the command failed with an undefined error, `None`.