opentrons 8.2.0a4__py2.py3-none-any.whl → 8.3.0__py2.py3-none-any.whl

opentrons/protocol_runner/legacy_command_mapper.py

@@ -177,11 +177,13 @@ class LegacyCommandMapper:
             completed_command: pe_commands.Command
             if command_error is None:
                 if isinstance(running_command, pe_commands.PickUpTip):
-                    completed_command = running_command.copy(
+                    completed_command = running_command.model_copy(
                         update={
-                            "result": pe_commands.PickUpTipResult.construct(
+                            "result": pe_commands.PickUpTipResult.model_construct(
                                 tipVolume=command["payload"]["location"].max_volume,  # type: ignore[typeddict-item]
-                                tipLength=command["payload"]["instrument"].hw_pipette["tip_length"],  # type: ignore[typeddict-item]
+                                tipLength=command["payload"]["instrument"].hw_pipette[  # type: ignore[typeddict-item]
+                                    "tip_length"
+                                ],
                                 position=pe_types.DeckPoint(x=0, y=0, z=0),
                             ),
                             "status": pe_commands.CommandStatus.SUCCEEDED,
@@ -190,9 +192,9 @@ class LegacyCommandMapper:
                         }
                     )
                 elif isinstance(running_command, pe_commands.DropTip):
-                    completed_command = running_command.copy(
+                    completed_command = running_command.model_copy(
                         update={
-                            "result": pe_commands.DropTipResult.construct(
+                            "result": pe_commands.DropTipResult.model_construct(
                                 position=pe_types.DeckPoint(x=0, y=0, z=0)
                             ),
                             "status": pe_commands.CommandStatus.SUCCEEDED,
@@ -201,9 +203,9 @@ class LegacyCommandMapper:
                         }
                     )
                 elif isinstance(running_command, pe_commands.Aspirate):
-                    completed_command = running_command.copy(
+                    completed_command = running_command.model_copy(
                         update={
-                            # Don't .construct() result, because we want to validate
+                            # Don't .model_construct() result, because we want to validate
                             # volume.
                             "result": pe_commands.AspirateResult(
                                 volume=running_command.params.volume,
@@ -215,9 +217,9 @@ class LegacyCommandMapper:
                         }
                     )
                 elif isinstance(running_command, pe_commands.Dispense):
-                    completed_command = running_command.copy(
+                    completed_command = running_command.model_copy(
                         update={
-                            # Don't .construct() result, because we want to validate
+                            # Don't .model_construct() result, because we want to validate
                             # volume.
                             "result": pe_commands.DispenseResult(
                                 volume=running_command.params.volume,
@@ -229,9 +231,9 @@ class LegacyCommandMapper:
                         }
                     )
                 elif isinstance(running_command, pe_commands.BlowOut):
-                    completed_command = running_command.copy(
+                    completed_command = running_command.model_copy(
                         update={
-                            "result": pe_commands.BlowOutResult.construct(
+                            "result": pe_commands.BlowOutResult.model_construct(
                                 position=pe_types.DeckPoint(x=0, y=0, z=0)
                             ),
                             "status": pe_commands.CommandStatus.SUCCEEDED,
@@ -240,18 +242,18 @@ class LegacyCommandMapper:
                         }
                     )
                 elif isinstance(running_command, pe_commands.Comment):
-                    completed_command = running_command.copy(
+                    completed_command = running_command.model_copy(
                         update={
-                            "result": pe_commands.CommentResult.construct(),
+                            "result": pe_commands.CommentResult.model_construct(),
                             "status": pe_commands.CommandStatus.SUCCEEDED,
                             "completedAt": now,
                             "notes": [],
                         }
                     )
                 elif isinstance(running_command, pe_commands.Custom):
-                    completed_command = running_command.copy(
+                    completed_command = running_command.model_copy(
                         update={
-                            "result": pe_commands.CustomResult.construct(),
+                            "result": pe_commands.CustomResult.model_construct(),
                             "status": pe_commands.CommandStatus.SUCCEEDED,
                             "completedAt": now,
                             "notes": [],
@@ -261,7 +263,7 @@ class LegacyCommandMapper:
                     # TODO(mm, 2024-06-13): This looks potentially wrong.
                     # We're creating a `SUCCEEDED` command that does not have a `result`,
                     # which is not normally possible.
-                    completed_command = running_command.copy(
+                    completed_command = running_command.model_copy(
                         update={
                             "status": pe_commands.CommandStatus.SUCCEEDED,
                             "completedAt": now,
@@ -331,51 +333,51 @@ class LegacyCommandMapper:
         elif command["name"] == legacy_command_types.BLOW_OUT:
             return self._build_blow_out(command=command, command_id=command_id, now=now)
         elif command["name"] == legacy_command_types.PAUSE:
-            wait_for_resume_running = pe_commands.WaitForResume.construct(
+            wait_for_resume_running = pe_commands.WaitForResume.model_construct(
                 id=command_id,
                 key=command_id,
                 status=pe_commands.CommandStatus.RUNNING,
                 createdAt=now,
                 startedAt=now,
-                params=pe_commands.WaitForResumeParams.construct(
+                params=pe_commands.WaitForResumeParams.model_construct(
                     message=command["payload"]["userMessage"],
                 ),
             )
             wait_for_resume_create: pe_commands.CommandCreate = (
-                pe_commands.WaitForResumeCreate.construct(
+                pe_commands.WaitForResumeCreate.model_construct(
                     key=wait_for_resume_running.key,
                     params=wait_for_resume_running.params,
                 )
             )
             return wait_for_resume_create, wait_for_resume_running
         elif command["name"] == legacy_command_types.COMMENT:
-            comment_running = pe_commands.Comment.construct(
+            comment_running = pe_commands.Comment.model_construct(
                 id=command_id,
                 key=command_id,
                 status=pe_commands.CommandStatus.RUNNING,
                 createdAt=now,
                 startedAt=now,
-                params=pe_commands.CommentParams.construct(
+                params=pe_commands.CommentParams.model_construct(
                     message=command["payload"]["text"],
                 ),
             )
-            comment_create = pe_commands.CommentCreate.construct(
+            comment_create = pe_commands.CommentCreate.model_construct(
                 key=comment_running.key, params=comment_running.params
             )
             return comment_create, comment_running
         else:
-            custom_running = pe_commands.Custom.construct(
+            custom_running = pe_commands.Custom.model_construct(
                 id=command_id,
                 key=command_id,
                 status=pe_commands.CommandStatus.RUNNING,
                 createdAt=now,
                 startedAt=now,
-                params=LegacyCommandParams.construct(
+                params=LegacyCommandParams.model_construct(
                     legacyCommandType=command["name"],
                     legacyCommandText=command["payload"]["text"],
                 ),
             )
-            custom_create = pe_commands.CustomCreate.construct(
+            custom_create = pe_commands.CustomCreate.model_construct(
                 key=custom_running.key,
                 params=custom_running.params,
             )
@@ -396,19 +398,19 @@ class LegacyCommandMapper:
         labware_id = self._labware_id_by_slot[slot]
         pipette_id = self._pipette_id_by_mount[mount]
 
-        running = pe_commands.DropTip.construct(
+        running = pe_commands.DropTip.model_construct(
             id=command_id,
             key=command_id,
             status=pe_commands.CommandStatus.RUNNING,
             createdAt=now,
             startedAt=now,
-            params=pe_commands.DropTipParams.construct(
+            params=pe_commands.DropTipParams.model_construct(
                 pipetteId=pipette_id,
                 labwareId=labware_id,
                 wellName=well_name,
             ),
         )
-        create = pe_commands.DropTipCreate.construct(
+        create = pe_commands.DropTipCreate.model_construct(
             key=running.key,
             params=running.params,
         )
@@ -430,19 +432,19 @@ class LegacyCommandMapper:
         labware_id = self._labware_id_by_slot[slot]
         pipette_id = self._pipette_id_by_mount[mount]
 
-        running = pe_commands.PickUpTip.construct(
+        running = pe_commands.PickUpTip.model_construct(
             id=command_id,
             key=command_id,
             status=pe_commands.CommandStatus.RUNNING,
             createdAt=now,
             startedAt=now,
-            params=pe_commands.PickUpTipParams.construct(
+            params=pe_commands.PickUpTipParams.model_construct(
                 pipetteId=pipette_id,
                 labwareId=labware_id,
                 wellName=well_name,
             ),
         )
-        create = pe_commands.PickUpTipCreate.construct(
+        create = pe_commands.PickUpTipCreate.model_construct(
             key=running.key, params=running.params
         )
         return create, running
@@ -482,31 +484,31 @@ class LegacyCommandMapper:
                 # TODO(mm, 2024-03-22): I don't think this has been true since
                 # https://github.com/Opentrons/opentrons/pull/14211. Can we just use
                 # aspirate and dispense commands now?
-                move_to_well_running = pe_commands.MoveToWell.construct(
+                move_to_well_running = pe_commands.MoveToWell.model_construct(
                     id=command_id,
                     key=command_id,
                     status=pe_commands.CommandStatus.RUNNING,
                     createdAt=now,
                     startedAt=now,
-                    params=pe_commands.MoveToWellParams.construct(
+                    params=pe_commands.MoveToWellParams.model_construct(
                         pipetteId=pipette_id,
                         labwareId=labware_id,
                         wellName=well_name,
                     ),
                 )
-                move_to_well_create = pe_commands.MoveToWellCreate.construct(
+                move_to_well_create = pe_commands.MoveToWellCreate.model_construct(
                     key=move_to_well_running.key, params=move_to_well_running.params
                 )
                 return move_to_well_create, move_to_well_running
             elif command["name"] == legacy_command_types.ASPIRATE:
                 flow_rate = command["payload"]["rate"] * pipette.flow_rate.aspirate
-                aspirate_running = pe_commands.Aspirate.construct(
+                aspirate_running = pe_commands.Aspirate.model_construct(
                     id=command_id,
                     key=command_id,
                     status=pe_commands.CommandStatus.RUNNING,
                     createdAt=now,
                     startedAt=now,
-                    # Don't .construct() params, because we want to validate
+                    # Don't .model_construct() params, because we want to validate
                     # volume and flowRate.
                     params=pe_commands.AspirateParams(
                         pipetteId=pipette_id,
@@ -516,19 +518,19 @@ class LegacyCommandMapper:
                         flowRate=flow_rate,
                     ),
                 )
-                aspirate_create = pe_commands.AspirateCreate.construct(
+                aspirate_create = pe_commands.AspirateCreate.model_construct(
                     key=aspirate_running.key, params=aspirate_running.params
                 )
                 return aspirate_create, aspirate_running
             else:
                 flow_rate = command["payload"]["rate"] * pipette.flow_rate.dispense
-                dispense_running = pe_commands.Dispense.construct(
+                dispense_running = pe_commands.Dispense.model_construct(
                     id=command_id,
                     key=command_id,
                     status=pe_commands.CommandStatus.RUNNING,
                     createdAt=now,
                     startedAt=now,
-                    # Don't .construct params, because we want to validate
+                    # Don't .model_construct params, because we want to validate
                     # volume and flowRate.
                     params=pe_commands.DispenseParams(
                         pipetteId=pipette_id,
@@ -538,24 +540,24 @@ class LegacyCommandMapper:
                         flowRate=flow_rate,
                     ),
                 )
-                dispense_create = pe_commands.DispenseCreate.construct(
+                dispense_create = pe_commands.DispenseCreate.model_construct(
                     key=dispense_running.key, params=dispense_running.params
                 )
                 return dispense_create, dispense_running
 
         else:
-            running = pe_commands.Custom.construct(
+            running = pe_commands.Custom.model_construct(
                 id=command_id,
                 key=command_id,
                 status=pe_commands.CommandStatus.RUNNING,
                 createdAt=now,
                 startedAt=now,
-                params=LegacyCommandParams.construct(
+                params=LegacyCommandParams.model_construct(
                     legacyCommandType=command["name"],
                     legacyCommandText=command["payload"]["text"],
                 ),
             )
-            create = pe_commands.CustomCreate.construct(
+            create = pe_commands.CustomCreate.model_construct(
                 key=running.key, params=running.params
             )
             return create, running
@@ -584,13 +586,13 @@ class LegacyCommandMapper:
             well_name = well.well_name
             pipette_id = self._pipette_id_by_mount[mount]
 
-            blow_out_running = pe_commands.BlowOut.construct(
+            blow_out_running = pe_commands.BlowOut.model_construct(
                 id=command_id,
                 key=command_id,
                 status=pe_commands.CommandStatus.RUNNING,
                 createdAt=now,
                 startedAt=now,
-                # Don't .construct() params, because we want to validate flowRate.
+                # Don't .model_construct() params, because we want to validate flowRate.
                 params=pe_commands.BlowOutParams(
                     pipetteId=pipette_id,
                     labwareId=labware_id,
@@ -598,7 +600,7 @@ class LegacyCommandMapper:
                     flowRate=flow_rate,
                 ),
             )
-            blow_out_create = pe_commands.BlowOutCreate.construct(
+            blow_out_create = pe_commands.BlowOutCreate.model_construct(
                 key=blow_out_running.key, params=blow_out_running.params
             )
             return blow_out_create, blow_out_running
@@ -606,18 +608,18 @@ class LegacyCommandMapper:
         #   TODO:(jr, 15.08.2022): blow_out commands with no specified labware get filtered
         #   into custom. Refactor this in followup legacy command mapping
         else:
-            custom_running = pe_commands.Custom.construct(
+            custom_running = pe_commands.Custom.model_construct(
                 id=command_id,
                 key=command_id,
                 status=pe_commands.CommandStatus.RUNNING,
                 createdAt=now,
                 startedAt=now,
-                params=LegacyCommandParams.construct(
+                params=LegacyCommandParams.model_construct(
                     legacyCommandType=command["name"],
                     legacyCommandText=command["payload"]["text"],
                 ),
             )
-            custom_create = pe_commands.CustomCreate.construct(
+            custom_create = pe_commands.CustomCreate.model_construct(
                 key=custom_running.key, params=custom_running.params
             )
             return custom_create, custom_running
@@ -631,23 +633,23 @@ class LegacyCommandMapper:
         slot = labware_load_info.deck_slot
         location: pe_types.LabwareLocation
         if labware_load_info.on_module:
-            location = pe_types.ModuleLocation.construct(
+            location = pe_types.ModuleLocation.model_construct(
                 moduleId=self._module_id_by_slot[slot]
             )
         else:
-            location = pe_types.DeckSlotLocation.construct(slotName=slot)
+            location = pe_types.DeckSlotLocation.model_construct(slotName=slot)
 
         command_id = f"commands.LOAD_LABWARE-{count}"
         labware_id = f"labware-{count}"
 
-        succeeded_command = pe_commands.LoadLabware.construct(
+        succeeded_command = pe_commands.LoadLabware.model_construct(
             id=command_id,
             key=command_id,
             status=pe_commands.CommandStatus.SUCCEEDED,
             createdAt=now,
             startedAt=now,
             completedAt=now,
-            params=pe_commands.LoadLabwareParams.construct(
+            params=pe_commands.LoadLabwareParams.model_construct(
                 location=location,
                 loadName=labware_load_info.labware_load_name,
                 namespace=labware_load_info.labware_namespace,
@@ -655,9 +657,9 @@ class LegacyCommandMapper:
                 displayName=labware_load_info.labware_display_name,
             ),
             notes=[],
-            result=pe_commands.LoadLabwareResult.construct(
+            result=pe_commands.LoadLabwareResult.model_construct(
                 labwareId=labware_id,
-                definition=LabwareDefinition.parse_obj(
+                definition=LabwareDefinition.model_validate(
                     labware_load_info.labware_definition
                 ),
                 offsetId=labware_load_info.offset_id,
@@ -666,7 +668,7 @@ class LegacyCommandMapper:
         queue_action = pe_actions.QueueCommandAction(
             command_id=succeeded_command.id,
             created_at=succeeded_command.createdAt,
-            request=pe_commands.LoadLabwareCreate.construct(
+            request=pe_commands.LoadLabwareCreate.model_construct(
                 key=succeeded_command.key, params=succeeded_command.params
             ),
             request_hash=None,
@@ -714,19 +716,19 @@ class LegacyCommandMapper:
         pipette_id = f"pipette-{count}"
         mount = MountType(str(instrument_load_info.mount).lower())
 
-        succeeded_command = pe_commands.LoadPipette.construct(
+        succeeded_command = pe_commands.LoadPipette.model_construct(
             id=command_id,
             key=command_id,
             status=pe_commands.CommandStatus.SUCCEEDED,
             createdAt=now,
             startedAt=now,
             completedAt=now,
-            params=pe_commands.LoadPipetteParams.construct(
+            params=pe_commands.LoadPipetteParams.model_construct(
                 pipetteName=PipetteNameType(instrument_load_info.instrument_load_name),
                 mount=mount,
             ),
             notes=[],
-            result=pe_commands.LoadPipetteResult.construct(pipetteId=pipette_id),
+            result=pe_commands.LoadPipetteResult.model_construct(pipetteId=pipette_id),
         )
         serial = instrument_load_info.pipette_dict.get("pipette_id", None) or ""
         state_update = StateUpdate()
@@ -749,7 +751,7 @@ class LegacyCommandMapper:
         queue_action = pe_actions.QueueCommandAction(
             command_id=succeeded_command.id,
             created_at=succeeded_command.createdAt,
-            request=pe_commands.LoadPipetteCreate.construct(
+            request=pe_commands.LoadPipetteCreate.model_construct(
                 key=succeeded_command.key, params=succeeded_command.params
             ),
             request_hash=None,
@@ -791,14 +793,14 @@ class LegacyCommandMapper:
             loaded_model
         ) or self._module_data_provider.get_definition(loaded_model)
 
-        succeeded_command = pe_commands.LoadModule.construct(
+        succeeded_command = pe_commands.LoadModule.model_construct(
             id=command_id,
             key=command_id,
             status=pe_commands.CommandStatus.SUCCEEDED,
             createdAt=now,
             startedAt=now,
             completedAt=now,
-            params=pe_commands.LoadModuleParams.construct(
+            params=pe_commands.LoadModuleParams.model_construct(
                 model=requested_model,
                 location=pe_types.DeckSlotLocation(
                     slotName=module_load_info.deck_slot,
@@ -806,7 +808,7 @@ class LegacyCommandMapper:
                 moduleId=module_id,
             ),
             notes=[],
-            result=pe_commands.LoadModuleResult.construct(
+            result=pe_commands.LoadModuleResult.model_construct(
                 moduleId=module_id,
                 serialNumber=module_load_info.module_serial,
                 definition=loaded_definition,
@@ -816,7 +818,7 @@ class LegacyCommandMapper:
         queue_action = pe_actions.QueueCommandAction(
             command_id=succeeded_command.id,
             created_at=succeeded_command.createdAt,
-            request=pe_commands.LoadModuleCreate.construct(
+            request=pe_commands.LoadModuleCreate.model_construct(
                 key=succeeded_command.key, params=succeeded_command.params
             ),
             request_hash=None,

opentrons/protocol_runner/protocol_runner.py

@@ -24,6 +24,7 @@ from opentrons.protocol_engine import (
     Command,
     commands as pe_commands,
 )
+from opentrons.protocol_engine.types import CommandAnnotation
 from opentrons.protocols.parse import PythonParseMode
 from opentrons.util.async_helpers import asyncio_yield
 from opentrons.util.broker import Broker
@@ -56,6 +57,7 @@ class RunResult(NamedTuple):
     commands: List[Command]
     state_summary: StateSummary
     parameters: List[RunTimeParameter]
+    command_annotations: List[CommandAnnotation]
 
 
 class AbstractRunner(ABC):
@@ -93,6 +95,11 @@ class AbstractRunner(ABC):
         """Parameter definitions defined by protocol, if any. Currently only for python protocols."""
         return []
 
+    @property
+    def command_annotations(self) -> List[CommandAnnotation]:
+        """Command annotations defined by protocol, if any. Currently only for json protocols."""
+        return []
+
     def was_started(self) -> bool:
         """Whether the run has been started.
 
@@ -177,7 +184,7 @@ class PythonAndLegacyRunner(AbstractRunner):
 
     @property
     def run_time_parameters(self) -> List[RunTimeParameter]:
-        """Parameter definitions defined by protocol, if any. Will always be empty before execution."""
+        """Parameter definitions defined by protocol, if any."""
         if self._parameter_context is not None:
             return self._parameter_context.export_parameters_for_analysis()
         return []
@@ -278,7 +285,10 @@ class PythonAndLegacyRunner(AbstractRunner):
         commands = self._protocol_engine.state_view.commands.get_all()
         parameters = self.run_time_parameters
         return RunResult(
-            commands=commands, state_summary=run_data, parameters=parameters
+            commands=commands,
+            state_summary=run_data,
+            parameters=parameters,
+            command_annotations=[],
         )
 
 
@@ -313,6 +323,12 @@ class JsonRunner(AbstractRunner):
 
         hardware_api.should_taskify_movement_execution(taskify=False)
         self._queued_commands: List[pe_commands.CommandCreate] = []
+        self._command_annotations: List[CommandAnnotation] = []
+
+    @property
+    def command_annotations(self) -> List[CommandAnnotation]:
+        """Command annotations defined by protocol, if any."""
+        return self._command_annotations
 
     async def load(self, protocol_source: ProtocolSource) -> None:
         """Load a JSONv6+ ProtocolSource into managed ProtocolEngine."""
@@ -355,6 +371,11 @@ class JsonRunner(AbstractRunner):
             )
             await asyncio_yield()
 
+        self._command_annotations = await anyio.to_thread.run_sync(
+            self._json_translator.translate_command_annotations,
+            protocol,
+        )
+
         initial_home_command = pe_commands.HomeCreate(
             params=pe_commands.HomeParams(axes=None)
         )
@@ -382,7 +403,12 @@ class JsonRunner(AbstractRunner):
 
         run_data = self._protocol_engine.state_view.get_summary()
         commands = self._protocol_engine.state_view.commands.get_all()
-        return RunResult(commands=commands, state_summary=run_data, parameters=[])
+        return RunResult(
+            commands=commands,
+            state_summary=run_data,
+            parameters=[],
+            command_annotations=self._command_annotations,
+        )
 
     async def _add_and_execute_commands(self) -> None:
         for command_request in self._queued_commands:
@@ -453,7 +479,12 @@ class LiveRunner(AbstractRunner):
 
         run_data = self._protocol_engine.state_view.get_summary()
         commands = self._protocol_engine.state_view.commands.get_all()
-        return RunResult(commands=commands, state_summary=run_data, parameters=[])
+        return RunResult(
+            commands=commands,
+            state_summary=run_data,
+            parameters=[],
+            command_annotations=[],
+        )
 
 
 AnyRunner = Union[PythonAndLegacyRunner, JsonRunner, LiveRunner]

opentrons/protocol_runner/python_protocol_wrappers.py

@@ -66,7 +66,7 @@ class PythonAndLegacyFileReader:
                 namespace=lw.namespace,
                 load_name=lw.parameters.loadName,
                 version=lw.version,
-            ): cast(LabwareDefinitionTypedDict, lw.dict(exclude_none=True))
+            ): cast(LabwareDefinitionTypedDict, lw.model_dump(exclude_none=True))
             for lw in labware_definitions
         }
         data_file_paths = [

opentrons/protocol_runner/run_orchestrator.py

@@ -1,11 +1,13 @@
 """Engine/Runner provider."""
+
 from __future__ import annotations
 
 import enum
-from typing import Optional, Union, List, Dict, AsyncGenerator
+from typing import Optional, Union, List, Dict, AsyncGenerator, Mapping
 
 from anyio import move_on_after
 
+from opentrons.types import NozzleMapInterface
 from opentrons_shared_data.labware.types import LabwareUri
 from opentrons_shared_data.labware.labware_definition import LabwareDefinition
 from opentrons_shared_data.errors import GeneralError
@@ -14,7 +16,6 @@ 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,
@@ -36,6 +37,7 @@ from ..protocol_engine.types import (
     RunTimeParameter,
     PrimitiveRunTimeParamValuesType,
     CSVRuntimeParamPaths,
+    CommandAnnotation,
 )
 from ..protocol_engine.error_recovery_policy import ErrorRecoveryPolicy
 
@@ -253,6 +255,14 @@ class RunOrchestrator:
             else self._protocol_runner.run_time_parameters
         )
 
+    def get_command_annotations(self) -> List[CommandAnnotation]:
+        """Get the list of command annotations defined in the protocol, if any."""
+        return (
+            []
+            if self._protocol_runner is None
+            else self._protocol_runner.command_annotations
+        )
+
     def get_current_command(self) -> Optional[CommandPointer]:
         """Get the "current" command, if any."""
         return self._protocol_engine.state_view.commands.get_current()
@@ -414,7 +424,7 @@ class RunOrchestrator:
         """Get engine deck type."""
         return self._protocol_engine.state_view.config.deck_type
 
-    def get_nozzle_maps(self) -> Dict[str, NozzleMap]:
+    def get_nozzle_maps(self) -> Mapping[str, NozzleMapInterface]:
         """Get current nozzle maps keyed by pipette id."""
         return self._protocol_engine.state_view.tips.get_pipette_nozzle_maps()
 

opentrons/protocols/advanced_control/common.py

@@ -0,0 +1,38 @@
+"""Common resources for all advanced control functions."""
+import enum
+from typing import NamedTuple, Optional
+
+
+class MixStrategy(enum.Enum):
+    BOTH = enum.auto()
+    BEFORE = enum.auto()
+    AFTER = enum.auto()
+    NEVER = enum.auto()
+
+
+class MixOpts(NamedTuple):
+    """
+    Options to customize behavior of mix.
+
+    These options will be passed to
+    :py:meth:`InstrumentContext.mix` when it is called during the
+    transfer.
+    """
+
+    repetitions: Optional[int] = None
+    volume: Optional[float] = None
+    rate: Optional[float] = None
+
+
+MixOpts.repetitions.__doc__ = ":py:class:`int`"
+MixOpts.volume.__doc__ = ":py:class:`float`"
+MixOpts.rate.__doc__ = ":py:class:`float`"
+
+
+class Mix(NamedTuple):
+    """
+    Options to control mix behavior before aspirate and after dispense.
+    """
+
+    mix_before: MixOpts = MixOpts()
+    mix_after: MixOpts = MixOpts()

opentrons/protocols/advanced_control/mix.py

@@ -1,6 +1,6 @@
 from typing import Any, Dict, Tuple
 
-from opentrons.protocols.advanced_control.transfers import MixStrategy, Mix
+from .common import MixStrategy, Mix
 
 
 def mix_from_kwargs(top_kwargs: Dict[str, Any]) -> Tuple[MixStrategy, Mix]: