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

opentrons/protocol_engine/types.py

@@ -201,6 +201,22 @@ NonStackedLocation = Union[
 class WellOrigin(str, Enum):
     """Origin of WellLocation offset.
 
+    Props:
+        TOP: the top-center of the well
+        BOTTOM: the bottom-center of the well
+        CENTER: the middle-center of the well
+        MENISCUS: the meniscus-center of the well
+    """
+
+    TOP = "top"
+    BOTTOM = "bottom"
+    CENTER = "center"
+    MENISCUS = "meniscus"
+
+
+class PickUpTipWellOrigin(str, Enum):
+    """The origin of a PickUpTipWellLocation offset.
+
     Props:
         TOP: the top-center of the well
         BOTTOM: the bottom-center of the well
@@ -243,6 +259,34 @@ class WellLocation(BaseModel):
 
     origin: WellOrigin = WellOrigin.TOP
     offset: WellOffset = Field(default_factory=WellOffset)
+    volumeOffset: float = Field(
+        default=0.0,
+        description="""A volume of liquid, in µL, to offset the z-axis offset.""",
+    )
+
+
+class LiquidHandlingWellLocation(BaseModel):
+    """A relative location in reference to a well's location.
+
+    To be used with commands that handle liquids.
+    """
+
+    origin: WellOrigin = WellOrigin.TOP
+    offset: WellOffset = Field(default_factory=WellOffset)
+    volumeOffset: Union[float, Literal["operationVolume"]] = Field(
+        default=0.0,
+        description="""A volume of liquid, in µL, to offset the z-axis offset. When "operationVolume" is specified, this volume is pulled from the command volume parameter.""",
+    )
+
+
+class PickUpTipWellLocation(BaseModel):
+    """A relative location in reference to a well's location.
+
+    To be used for picking up tips.
+    """
+
+    origin: PickUpTipWellOrigin = PickUpTipWellOrigin.TOP
+    offset: WellOffset = Field(default_factory=WellOffset)
 
 
 class DropTipWellLocation(BaseModel):
@@ -311,6 +355,48 @@ class CurrentWell:
     well_name: str
 
 
+class LoadedVolumeInfo(BaseModel):
+    """A well's liquid volume, initialized by a LoadLiquid, updated by Aspirate and Dispense."""
+
+    volume: Optional[float] = None
+    last_loaded: datetime
+    operations_since_load: int
+
+
+class ProbedHeightInfo(BaseModel):
+    """A well's liquid height, initialized by a LiquidProbe, cleared by Aspirate and Dispense."""
+
+    height: Optional[float] = None
+    last_probed: datetime
+
+
+class ProbedVolumeInfo(BaseModel):
+    """A well's liquid volume, initialized by a LiquidProbe, updated by Aspirate and Dispense."""
+
+    volume: Optional[float] = None
+    last_probed: datetime
+    operations_since_probe: int
+
+
+class WellInfoSummary(BaseModel):
+    """Payload for a well's liquid info in StateSummary."""
+
+    labware_id: str
+    well_name: str
+    loaded_volume: Optional[float] = None
+    probed_height: Optional[float] = None
+    probed_volume: Optional[float] = None
+
+
+@dataclass
+class WellLiquidInfo:
+    """Tracked and sensed information about liquid in a well."""
+
+    probed_height: Optional[ProbedHeightInfo]
+    loaded_volume: Optional[LoadedVolumeInfo]
+    probed_volume: Optional[ProbedVolumeInfo]
+
+
 @dataclass(frozen=True)
 class CurrentAddressableArea:
     """The latest addressable area the robot has accessed."""
@@ -797,6 +883,7 @@ class AreaType(Enum):
     TEMPERATURE = "temperatureModule"
     MAGNETICBLOCK = "magneticBlock"
     ABSORBANCE_READER = "absorbanceReader"
+    LID_DOCK = "lidDock"
 
 
 @dataclass(frozen=True)
@@ -1071,3 +1158,6 @@ PrimitiveRunTimeParamValuesType = Mapping[
 
 CSVRunTimeParamFilesType = Mapping[StrictStr, StrictStr]
 CSVRuntimeParamPaths = Dict[str, Path]
+
+
+ABSMeasureMode = Literal["single", "multi"]

opentrons/protocol_reader/file_format_validator.py

@@ -1,5 +1,5 @@
 """File format validation interface."""
-
+from __future__ import annotations
 
 from typing import Iterable
 
@@ -29,6 +29,16 @@ from .protocol_files_invalid_error import ProtocolFilesInvalidError
 class FileFormatValidationError(ProtocolFilesInvalidError):
     """Raised when a file does not conform to the format it's supposed to."""
 
+    @classmethod
+    def _generic_json_failure(
+        cls, info: IdentifiedJsonMain, exc: Exception
+    ) -> FileFormatValidationError:
+        return cls(
+            message=f"{info.original_file.name} could not be read as a JSON protocol.",
+            detail={"kind": "bad-json-protocol"},
+            wrapping=[PythonException(exc)],
+        )
+
 
 class FileFormatValidator:
     """File format validation interface."""
@@ -61,22 +71,80 @@ async def _validate_labware_definition(info: IdentifiedLabwareDefinition) -> Non
     await anyio.to_thread.run_sync(validate_sync)
 
 
+def _handle_v8_json_protocol_validation_error(
+    info: IdentifiedJsonMain, pve: PydanticValidationError
+) -> None:
+    for error in pve.errors():
+        if error["loc"] == ("commandSchemaId",) and error["type"] == "type_error.enum":
+            # type_error.enum is for "this entry is not in this enum" and happens if you constrain a field by
+            # annotating it with Enum, as we now do for command schema IDs
+            raise FileFormatValidationError(
+                message=(
+                    f"{info.original_file.name} could not be read as a JSON protocol, in part because its command schema "
+                    "id is unknown. This protocol may have been exported from a future version of authorship software. "
+                    "Updating your Opentrons software may help."
+                ),
+                detail={
+                    "kind": "bad-command-schema-id",
+                    "command-schema-id": info.unvalidated_json.get(
+                        "commandSchemaId", "<unknown>"
+                    ),
+                },
+                wrapping=[PythonException(pve)],
+            ) from pve
+        if (
+            error["loc"] == ("labwareDefinitionSchemaId",)
+            and error["type"] == "value_error.const"
+        ):
+            # value_error.const is for "this entry is not one of these const values", which is different from type_error.enum
+            # for I'm sure a very good reason, and happens if you constrain a field by annotating it with a Literal
+            raise FileFormatValidationError(
+                message=(
+                    f"{info.original_file.name} could not be read as a JSON protocol, in part because its labware schema "
+                    "id is unknown. This protocol may have been exported from a future version of authorship software. "
+                    "Updating your Opentrons software may help."
+                ),
+                detail={
+                    "kind": "bad-labware-schema-id",
+                    "labware-schema-id": info.unvalidated_json.get(
+                        "labwareDefinitionSchemaId", "<unknown>"
+                    ),
+                },
+            )
+        if error["loc"] == ("liquidSchemaId",) and error["type"] == "value_error.const":
+            raise FileFormatValidationError(
+                message=(
+                    f"{info.original_file.name} could not be read as a JSON protocol, in part because its liquid schema "
+                    "id is unknown. This protocol may have been exported from a future version of authorship software. "
+                    "Updating your Opentrons software may help."
+                ),
+                detail={
+                    "kind": "bad-liquid-schema-id",
+                    "liquid-schema-id": info.unvalidated_json.get(
+                        "liquidSchemaId", "<unknown>"
+                    ),
+                },
+            )
+    else:
+        raise FileFormatValidationError._generic_json_failure(info, pve) from pve
+
+
 async def _validate_json_protocol(info: IdentifiedJsonMain) -> None:
     def validate_sync() -> None:
-        try:
-            if info.schema_version == 8:
+        if info.schema_version == 8:
+            try:
                 JsonProtocolV8.parse_obj(info.unvalidated_json)
-            elif info.schema_version == 7:
-                JsonProtocolV7.parse_obj(info.unvalidated_json)
-            elif info.schema_version == 6:
-                JsonProtocolV6.parse_obj(info.unvalidated_json)
-            else:
-                JsonProtocolUpToV5.parse_obj(info.unvalidated_json)
-        except PydanticValidationError as e:
-            raise FileFormatValidationError(
-                message=f"{info.original_file.name} could not be read as a JSON protocol.",
-                detail={"kind": "bad-json-protocol"},
-                wrapping=[PythonException(e)],
-            ) from e
+            except PydanticValidationError as pve:
+                _handle_v8_json_protocol_validation_error(info, pve)
+        else:
+            try:
+                if info.schema_version == 7:
+                    JsonProtocolV7.parse_obj(info.unvalidated_json)
+                elif info.schema_version == 6:
+                    JsonProtocolV6.parse_obj(info.unvalidated_json)
+                else:
+                    JsonProtocolUpToV5.parse_obj(info.unvalidated_json)
+            except PydanticValidationError as e:
+                raise FileFormatValidationError._generic_json_failure(info, e) from e
 
     await anyio.to_thread.run_sync(validate_sync)

opentrons/protocol_runner/json_translator.py

@@ -1,6 +1,6 @@
 """Translation of JSON protocol commands into ProtocolEngine commands."""
-from typing import cast, List, Union
-from pydantic import parse_obj_as
+from typing import cast, List, Union, Iterator
+from pydantic import parse_obj_as, ValidationError as PydanticValidationError
 
 from opentrons_shared_data.pipette.types import PipetteNameType
 from opentrons_shared_data.protocol.models import (
@@ -12,6 +12,7 @@ from opentrons_shared_data.protocol.models import (
     protocol_schema_v8,
 )
 from opentrons_shared_data import command as command_schema
+from opentrons_shared_data.errors.exceptions import InvalidProtocolData, PythonException
 
 from opentrons.types import MountType
 from opentrons.protocol_engine import (
@@ -196,7 +197,7 @@ class JsonTranslator:
     """Class that translates commands/liquids from PD/JSON to ProtocolEngine."""
 
     def translate_liquids(
-        self, protocol: Union[ProtocolSchemaV6, ProtocolSchemaV7]
+        self, protocol: Union[ProtocolSchemaV6, ProtocolSchemaV7, ProtocolSchemaV8]
     ) -> List[Liquid]:
         """Takes json protocol v6 and translates liquids->protocol engine liquids."""
         protocol_liquids = protocol.liquids or {}
@@ -258,7 +259,8 @@ class JsonTranslator:
         self, protocol: ProtocolSchemaV8
     ) -> List[pe_commands.CommandCreate]:
         """Translate commands in json protocol schema v8, which might be of different command schemas."""
-        command_schema_ref = protocol.commandSchemaId
+        command_schema_ref = protocol.commandSchemaId.value
+
         # these calls will raise if the command schema version is invalid or unknown
         command_schema_version = command_schema.schema_version_from_ref(
             command_schema_ref
@@ -267,4 +269,18 @@ class JsonTranslator:
             command_schema_version
         )
 
-        return [_translate_simple_command(command) for command in protocol.commands]
+        def translate_all_commands() -> Iterator[pe_commands.CommandCreate]:
+            for command in protocol.commands:
+                try:
+                    yield _translate_simple_command(command)
+                except PydanticValidationError as pve:
+                    raise InvalidProtocolData(
+                        message=(
+                            "The protocol is invalid because it contains an unknown or malformed command, "
+                            f'"{command.commandType}".'
+                        ),
+                        detail={"kind": "invalid-command"},
+                        wrapping=[PythonException(pve)],
+                    )
+
+        return list(translate_all_commands())

opentrons/protocol_runner/legacy_command_mapper.py

@@ -34,6 +34,9 @@ from opentrons.protocol_engine.resources import (
     ModuleDataProvider,
     pipette_data_provider,
 )
+from opentrons.protocol_engine.state.update_types import (
+    StateUpdate,
+)
 
 from opentrons_shared_data.labware.labware_definition import LabwareDefinition
 from opentrons_shared_data.errors import ErrorCodes, EnumeratedError, PythonException
@@ -267,7 +270,8 @@ class LegacyCommandMapper:
                     )
                 results.append(
                     pe_actions.SucceedCommandAction(
-                        completed_command, private_result=None
+                        completed_command,
+                        state_update=StateUpdate(),
                     )
                 )
 
@@ -672,9 +676,19 @@ class LegacyCommandMapper:
             # We just set this above, so we know it's not None.
             started_at=succeeded_command.startedAt,  # type: ignore[arg-type]
         )
+        state_update = StateUpdate()
+        assert succeeded_command.result is not None
+        state_update.set_loaded_labware(
+            labware_id=labware_id,
+            definition=succeeded_command.result.definition,
+            display_name=labware_load_info.labware_display_name,
+            offset_id=labware_load_info.offset_id,
+            location=location,
+        )
+
         succeed_action = pe_actions.SucceedCommandAction(
             command=succeeded_command,
-            private_result=None,
+            state_update=state_update,
         )
 
         self._command_count["LOAD_LABWARE"] = count + 1
@@ -715,7 +729,14 @@ class LegacyCommandMapper:
             result=pe_commands.LoadPipetteResult.construct(pipetteId=pipette_id),
         )
         serial = instrument_load_info.pipette_dict.get("pipette_id", None) or ""
-        pipette_config_result = pe_commands.LoadPipettePrivateResult(
+        state_update = StateUpdate()
+        state_update.set_load_pipette(
+            pipette_id=pipette_id,
+            mount=succeeded_command.params.mount,
+            pipette_name=succeeded_command.params.pipetteName,
+            liquid_presence_detection=succeeded_command.params.liquidPresenceDetection,
+        )
+        state_update.update_pipette_config(
             pipette_id=pipette_id,
             serial_number=serial,
             config=pipette_data_provider.get_pipette_static_config(
@@ -738,9 +759,10 @@ class LegacyCommandMapper:
             # We just set this above, so we know it's not None.
             started_at=succeeded_command.startedAt,  # type: ignore[arg-type]
         )
+
         succeed_action = pe_actions.SucceedCommandAction(
             command=succeeded_command,
-            private_result=pipette_config_result,
+            state_update=state_update,
         )
 
         self._command_count["LOAD_PIPETTE"] = count + 1
@@ -805,8 +827,7 @@ class LegacyCommandMapper:
             started_at=succeeded_command.startedAt,  # type: ignore[arg-type]
         )
         succeed_action = pe_actions.SucceedCommandAction(
-            command=succeeded_command,
-            private_result=None,
+            command=succeeded_command, state_update=StateUpdate()
         )
 
         self._command_count["LOAD_MODULE"] = count + 1

opentrons/protocol_runner/legacy_context_plugin.py

@@ -1,9 +1,9 @@
 """Customize the ProtocolEngine to monitor and control legacy (APIv2) protocols."""
 from __future__ import annotations
 
-from asyncio import create_task, Task
+import asyncio
 from contextlib import ExitStack
-from typing import List, Optional
+from typing import Optional
 
 from opentrons.legacy_commands.types import CommandMessage as LegacyCommand
 from opentrons.legacy_broker import LegacyBroker
@@ -12,7 +12,6 @@ from opentrons.protocol_engine import AbstractPlugin, actions as pe_actions
 from opentrons.util.broker import ReadOnlyBroker
 
 from .legacy_command_mapper import LegacyCommandMapper
-from .thread_async_queue import ThreadAsyncQueue
 
 
 class LegacyContextPlugin(AbstractPlugin):
@@ -21,59 +20,36 @@ class LegacyContextPlugin(AbstractPlugin):
     In the legacy ProtocolContext, protocol execution is accomplished
     by direct communication with the HardwareControlAPI, as opposed to an
     intermediate layer like the ProtocolEngine. This plugin wraps up
-    and hides this behavior, so the ProtocolEngine can monitor and control
+    and hides this behavior, so the ProtocolEngine can monitor
     the run of a legacy protocol without affecting the execution of
     the protocol commands themselves.
 
-    This plugin allows a ProtocolEngine to:
-
-    1. Play/pause the protocol run using the HardwareControlAPI, as was done before
-       the ProtocolEngine existed.
-    2. Subscribe to what is being done with the legacy ProtocolContext,
-       and insert matching commands into ProtocolEngine state for
-       purely progress-tracking purposes.
+    This plugin allows a ProtocolEngine to subscribe to what is being done with the
+    legacy ProtocolContext, and insert matching commands into ProtocolEngine state for
+    purely progress-tracking purposes.
     """
 
     def __init__(
         self,
+        engine_loop: asyncio.AbstractEventLoop,
         broker: LegacyBroker,
         equipment_broker: ReadOnlyBroker[LoadInfo],
         legacy_command_mapper: Optional[LegacyCommandMapper] = None,
     ) -> None:
         """Initialize the plugin with its dependencies."""
+        self._engine_loop = engine_loop
+
         self._broker = broker
         self._equipment_broker = equipment_broker
         self._legacy_command_mapper = legacy_command_mapper or LegacyCommandMapper()
 
-        # We use a non-blocking queue to communicate activity
-        # from the APIv2 protocol, which is running in its own thread,
-        # to the ProtocolEngine, which is running in the main thread's async event loop.
-        #
-        # The queue being non-blocking lets the protocol communicate its activity
-        # instantly *even if the event loop is currently occupied by something else.*
-        # Various things can accidentally occupy the event loop for too long.
-        # So if the protocol had to wait for the event loop to be free
-        # every time it reported some activity,
-        # it could visibly stall for a moment, making its motion jittery.
-        #
-        # TODO(mm, 2024-03-22): See if we can remove this non-blockingness now.
-        # It was one of several band-aids introduced in ~v5.0.0 to mitigate performance
-        # problems. v6.3.0 started running some Python protocols directly through
-        # Protocol Engine, without this plugin, and without any non-blocking queue.
-        # If performance is sufficient for those, that probably means the
-        # performance problems have been resolved in better ways elsewhere
-        # and we don't need this anymore.
-        self._actions_to_dispatch = ThreadAsyncQueue[List[pe_actions.Action]]()
-        self._action_dispatching_task: Optional[Task[None]] = None
-
         self._subscription_exit_stack: Optional[ExitStack] = None
 
     def setup(self) -> None:
         """Set up the plugin.
 
-        * Subscribe to the APIv2 context's message brokers to be informed
-          of the APIv2 protocol's activity.
-        * Kick off a background task to inform Protocol Engine of that activity.
+        Subscribe to the APIv2 context's message brokers to be informed
+        of the APIv2 protocol's activity.
         """
         # Subscribe to activity on the APIv2 context,
         # and arrange to unsubscribe when this plugin is torn down.
@@ -97,24 +73,16 @@ class LegacyContextPlugin(AbstractPlugin):
             # to clean up these subscriptions.
             self._subscription_exit_stack = exit_stack.pop_all()
 
-        # Kick off a background task to report activity to the ProtocolEngine.
-        self._action_dispatching_task = create_task(self._dispatch_all_actions())
-
+    # todo(mm, 2024-08-21): This no longer needs to be async.
     async def teardown(self) -> None:
         """Tear down the plugin, undoing the work done in `setup()`.
 
         Called by Protocol Engine.
         At this point, the APIv2 protocol script must have exited.
         """
-        self._actions_to_dispatch.done_putting()
-        try:
-            if self._action_dispatching_task is not None:
-                await self._action_dispatching_task
-                self._action_dispatching_task = None
-        finally:
-            if self._subscription_exit_stack is not None:
-                self._subscription_exit_stack.close()
-                self._subscription_exit_stack = None
+        if self._subscription_exit_stack is not None:
+            self._subscription_exit_stack.close()
+            self._subscription_exit_stack = None
 
     def handle_action(self, action: pe_actions.Action) -> None:
         """React to a ProtocolEngine action."""
@@ -127,7 +95,10 @@ class LegacyContextPlugin(AbstractPlugin):
         Used as a broker callback, so this will run in the APIv2 protocol's thread.
         """
         pe_actions = self._legacy_command_mapper.map_command(command=command)
-        self._actions_to_dispatch.put(pe_actions)
+        future = asyncio.run_coroutine_threadsafe(
+            self._dispatch_action_list(pe_actions), self._engine_loop
+        )
+        future.result()
 
     def _handle_equipment_loaded(self, load_info: LoadInfo) -> None:
         """Handle an equipment load reported by the legacy APIv2 protocol.
@@ -135,26 +106,11 @@ class LegacyContextPlugin(AbstractPlugin):
         Used as a broker callback, so this will run in the APIv2 protocol's thread.
         """
         pe_actions = self._legacy_command_mapper.map_equipment_load(load_info=load_info)
-        self._actions_to_dispatch.put(pe_actions)
-
-    async def _dispatch_all_actions(self) -> None:
-        """Dispatch all actions to the `ProtocolEngine`.
-
-        Exits only when `self._actions_to_dispatch` is closed
-        (or an unexpected exception is raised).
-        """
-        async for action_batch in self._actions_to_dispatch.get_async_until_closed():
-            # It's critical that we dispatch this batch of actions as one atomic
-            # sequence, without yielding to the event loop.
-            # Although this plugin only means to use the ProtocolEngine as a way of
-            # passively exposing the protocol's progress, the ProtocolEngine is still
-            # theoretically active, which means it's constantly watching in the
-            # background to execute any commands that it finds `queued`.
-            #
-            # For example, one of these action batches will often want to
-            # instantaneously create a running command by having a queue action
-            # immediately followed by a run action. We cannot let the
-            # ProtocolEngine's background task see the command in the `queued` state,
-            # or it will try to execute it, which the legacy protocol is already doing.
-            for action in action_batch:
-                self.dispatch(action)
+        future = asyncio.run_coroutine_threadsafe(
+            self._dispatch_action_list(pe_actions), self._engine_loop
+        )
+        future.result()
+
+    async def _dispatch_action_list(self, actions: list[pe_actions.Action]) -> None:
+        for action in actions:
+            self.dispatch(action)

opentrons/protocol_runner/protocol_runner.py

@@ -1,4 +1,5 @@
 """Protocol run control and management."""
+import asyncio
 from typing import List, NamedTuple, Optional, Union
 
 from abc import ABC, abstractmethod
@@ -122,9 +123,9 @@ class AbstractRunner(ABC):
                 post_run_hardware_state=PostRunHardwareState.STAY_ENGAGED_IN_PLACE,
             )
 
-    def resume_from_recovery(self) -> None:
+    def resume_from_recovery(self, reconcile_false_positive: bool) -> None:
         """See `ProtocolEngine.resume_from_recovery()`."""
-        self._protocol_engine.resume_from_recovery()
+        self._protocol_engine.resume_from_recovery(reconcile_false_positive)
 
     @abstractmethod
     async def run(
@@ -220,7 +221,9 @@ class PythonAndLegacyRunner(AbstractRunner):
             equipment_broker = Broker[LoadInfo]()
             self._protocol_engine.add_plugin(
                 LegacyContextPlugin(
-                    broker=self._broker, equipment_broker=equipment_broker
+                    engine_loop=asyncio.get_running_loop(),
+                    broker=self._broker,
+                    equipment_broker=equipment_broker,
                 )
             )
             self._hardware_api.should_taskify_movement_execution(taskify=True)

opentrons/protocol_runner/run_orchestrator.py

@@ -14,6 +14,7 @@ from opentrons_shared_data.robot.types import RobotType
 from . import protocol_runner, RunResult, JsonRunner, PythonAndLegacyRunner
 from ..hardware_control import HardwareControlAPI
 from ..hardware_control.modules import AbstractModule as HardwareModuleAPI
+from ..hardware_control.nozzle_manager import NozzleMap
 from ..protocol_engine import (
     ProtocolEngine,
     CommandCreate,
@@ -204,9 +205,9 @@ class RunOrchestrator:
                 post_run_hardware_state=PostRunHardwareState.STAY_ENGAGED_IN_PLACE,
             )
 
-    def resume_from_recovery(self) -> None:
+    def resume_from_recovery(self, reconcile_false_positive: bool) -> None:
         """Resume the run from recovery."""
-        self._protocol_engine.resume_from_recovery()
+        self._protocol_engine.resume_from_recovery(reconcile_false_positive)
 
     async def finish(
         self,
@@ -256,19 +257,34 @@ class RunOrchestrator:
         """Get the "current" command, if any."""
         return self._protocol_engine.state_view.commands.get_current()
 
+    def get_most_recently_finalized_command(self) -> Optional[CommandPointer]:
+        """Get the most recently finalized command, if any."""
+        most_recently_finalized_command = (
+            self._protocol_engine.state_view.commands.get_most_recently_finalized_command()
+        )
+        return (
+            CommandPointer(
+                command_id=most_recently_finalized_command.command.id,
+                command_key=most_recently_finalized_command.command.key,
+                created_at=most_recently_finalized_command.command.createdAt,
+                index=most_recently_finalized_command.index,
+            )
+            if most_recently_finalized_command
+            else None
+        )
+
     def get_command_slice(
-        self,
-        cursor: Optional[int],
-        length: int,
+        self, cursor: Optional[int], length: int, include_fixit_commands: bool
     ) -> CommandSlice:
         """Get a slice of run commands.
 
         Args:
             cursor: Requested index of first command in the returned slice.
             length: Length of slice to return.
+            include_fixit_commands: Get all command intents.
         """
         return self._protocol_engine.state_view.commands.get_slice(
-            cursor=cursor, length=length
+            cursor=cursor, length=length, include_fixit_commands=include_fixit_commands
         )
 
     def get_command_error_slice(
@@ -398,6 +414,25 @@ class RunOrchestrator:
         """Get engine deck type."""
         return self._protocol_engine.state_view.config.deck_type
 
+    def get_nozzle_maps(self) -> Dict[str, NozzleMap]:
+        """Get current nozzle maps keyed by pipette id."""
+        return self._protocol_engine.state_view.tips.get_pipette_nozzle_maps()
+
+    def get_tip_attached(self) -> Dict[str, bool]:
+        """Get current tip state keyed by pipette id."""
+
+        def has_tip_attached(pipette_id: str) -> bool:
+            return (
+                self._protocol_engine.state_view.pipettes.get_attached_tip(pipette_id)
+                is not None
+            )
+
+        pipette_ids = (
+            pipette.id
+            for pipette in self._protocol_engine.state_view.pipettes.get_all()
+        )
+        return {pipette_id: has_tip_attached(pipette_id) for pipette_id in pipette_ids}
+
     def set_error_recovery_policy(self, policy: ErrorRecoveryPolicy) -> None:
         """Create error recovery policy for the run."""
         self._protocol_engine.set_error_recovery_policy(policy)

opentrons/protocols/advanced_control/mix.py

@@ -1,15 +1,13 @@
-import typing
+from typing import Any, Dict, Tuple
 
 from opentrons.protocols.advanced_control.transfers import MixStrategy, Mix
 
 
-def mix_from_kwargs(
-    top_kwargs: typing.Dict[str, typing.Any]
-) -> typing.Tuple[MixStrategy, Mix]:
+def mix_from_kwargs(top_kwargs: Dict[str, Any]) -> Tuple[MixStrategy, Mix]:
     """A utility function to determine mix strategy from key word arguments
     to InstrumentContext.mix"""
 
-    def _mix_requested(kwargs, opt):
+    def _mix_requested(kwargs: Dict[str, Any], opt: str) -> bool:
         """
         Helper for determining mix options from :py:meth:`transfer` kwargs
         Mixes can be ignored in kwargs by either