opentrons 8.3.0a0__py2.py3-none-any.whl → 8.3.0a2__py2.py3-none-any.whl

opentrons/protocol_engine/state/liquid_classes.py

@@ -0,0 +1,82 @@
+"""A data store of liquid classes."""
+
+from __future__ import annotations
+
+import dataclasses
+from typing import Dict
+from typing_extensions import Optional
+
+from .. import errors
+from ..actions import Action, get_state_updates
+from ..types import LiquidClassRecord
+from . import update_types
+from ._abstract_store import HasState, HandlesActions
+
+
+@dataclasses.dataclass
+class LiquidClassState:
+    """Our state is a bidirectional mapping between IDs <-> LiquidClassRecords."""
+
+    # We use the bidirectional map to see if we've already assigned an ID to a liquid class when the
+    # engine is asked to store a new liquid class.
+    liquid_class_record_by_id: Dict[str, LiquidClassRecord]
+    liquid_class_record_to_id: Dict[LiquidClassRecord, str]
+
+
+class LiquidClassStore(HasState[LiquidClassState], HandlesActions):
+    """Container for LiquidClassState."""
+
+    _state: LiquidClassState
+
+    def __init__(self) -> None:
+        self._state = LiquidClassState(
+            liquid_class_record_by_id={},
+            liquid_class_record_to_id={},
+        )
+
+    def handle_action(self, action: Action) -> None:
+        """Update the state in response to the action."""
+        for state_update in get_state_updates(action):
+            if state_update.liquid_class_loaded != update_types.NO_CHANGE:
+                self._handle_liquid_class_loaded_update(
+                    state_update.liquid_class_loaded
+                )
+
+    def _handle_liquid_class_loaded_update(
+        self, state_update: update_types.LiquidClassLoadedUpdate
+    ) -> None:
+        # We're just a data store. All the validation and ID generation happens in the command implementation.
+        self._state.liquid_class_record_by_id[
+            state_update.liquid_class_id
+        ] = state_update.liquid_class_record
+        self._state.liquid_class_record_to_id[
+            state_update.liquid_class_record
+        ] = state_update.liquid_class_id
+
+
+class LiquidClassView:
+    """Read-only view of the LiquidClassState."""
+
+    _state: LiquidClassState
+
+    def __init__(self, state: LiquidClassState) -> None:
+        self._state = state
+
+    def get(self, liquid_class_id: str) -> LiquidClassRecord:
+        """Get the LiquidClassRecord with the given identifier."""
+        try:
+            return self._state.liquid_class_record_by_id[liquid_class_id]
+        except KeyError as e:
+            raise errors.LiquidClassDoesNotExistError(
+                f"Liquid class ID {liquid_class_id} not found."
+            ) from e
+
+    def get_id_for_liquid_class_record(
+        self, liquid_class_record: LiquidClassRecord
+    ) -> Optional[str]:
+        """See if the given LiquidClassRecord if already in the store, and if so, return its identifier."""
+        return self._state.liquid_class_record_to_id.get(liquid_class_record)
+
+    def get_all(self) -> Dict[str, LiquidClassRecord]:
+        """Get all the LiquidClassRecords in the store."""
+        return self._state.liquid_class_record_by_id.copy()

opentrons/protocol_engine/state/liquids.py

@@ -1,11 +1,11 @@
 """Basic liquid data state and store."""
 from dataclasses import dataclass
 from typing import Dict, List
-from opentrons.protocol_engine.types import Liquid
+from opentrons.protocol_engine.types import Liquid, LiquidId
 
 from ._abstract_store import HasState, HandlesActions
 from ..actions import Action, AddLiquidAction
-from ..errors import LiquidDoesNotExistError
+from ..errors import LiquidDoesNotExistError, InvalidLiquidError
 
 
 @dataclass
@@ -34,7 +34,7 @@ class LiquidStore(HasState[LiquidState], HandlesActions):
         self._state.liquids_by_id[action.liquid.id] = action.liquid
 
 
-class LiquidView(HasState[LiquidState]):
+class LiquidView:
     """Read-only liquid state view."""
 
     _state: LiquidState
@@ -51,11 +51,23 @@ class LiquidView(HasState[LiquidState]):
         """Get all protocol liquids."""
         return list(self._state.liquids_by_id.values())
 
-    def validate_liquid_id(self, liquid_id: str) -> str:
+    def validate_liquid_id(self, liquid_id: LiquidId) -> LiquidId:
         """Check if liquid_id exists in liquids."""
+        is_empty = liquid_id == "EMPTY"
+        if is_empty:
+            return liquid_id
         has_liquid = liquid_id in self._state.liquids_by_id
         if not has_liquid:
             raise LiquidDoesNotExistError(
                 f"Supplied liquidId: {liquid_id} does not exist in the loaded liquids."
             )
         return liquid_id
+
+    def validate_liquid_allowed(self, liquid: Liquid) -> Liquid:
+        """Validate that a liquid is legal to load."""
+        is_empty = liquid.id == "EMPTY"
+        if is_empty:
+            raise InvalidLiquidError(
+                message='Protocols may not define a liquid with the special id "EMPTY".'
+            )
+        return liquid

opentrons/protocol_engine/state/modules.py

@@ -35,6 +35,7 @@ from opentrons.protocol_engine.state.module_substates.absorbance_reader_substate
     AbsorbanceReaderMeasureMode,
 )
 from opentrons.types import DeckSlotName, MountType, StagingSlotName
+from .update_types import AbsorbanceReaderStateUpdate
 from ..errors import ModuleNotConnectedError
 
 from ..types import (
@@ -63,7 +64,6 @@ from ..commands import (
     heater_shaker,
     temperature_module,
     thermocycler,
-    absorbance_reader,
 )
 from ..actions import (
     Action,
@@ -296,40 +296,10 @@ class ModuleStore(HasState[ModuleState], HandlesActions):
         ):
             self._handle_thermocycler_module_commands(command)
 
-        if isinstance(
-            command.result,
-            (
-                absorbance_reader.InitializeResult,
-                absorbance_reader.ReadAbsorbanceResult,
-            ),
-        ):
-            self._handle_absorbance_reader_commands(command)
-
     def _handle_state_update(self, state_update: update_types.StateUpdate) -> None:
-        if state_update.absorbance_reader_lid != update_types.NO_CHANGE:
-            module_id = state_update.absorbance_reader_lid.module_id
-            is_lid_on = state_update.absorbance_reader_lid.is_lid_on
-
-            # Get current values:
-            absorbance_reader_substate = self._state.substate_by_module_id[module_id]
-            assert isinstance(
-                absorbance_reader_substate, AbsorbanceReaderSubState
-            ), f"{module_id} is not an absorbance plate reader."
-            configured = absorbance_reader_substate.configured
-            measure_mode = absorbance_reader_substate.measure_mode
-            configured_wavelengths = absorbance_reader_substate.configured_wavelengths
-            reference_wavelength = absorbance_reader_substate.reference_wavelength
-            data = absorbance_reader_substate.data
-
-            self._state.substate_by_module_id[module_id] = AbsorbanceReaderSubState(
-                module_id=AbsorbanceReaderId(module_id),
-                configured=configured,
-                measured=True,
-                is_lid_on=is_lid_on,
-                measure_mode=measure_mode,
-                configured_wavelengths=configured_wavelengths,
-                reference_wavelength=reference_wavelength,
-                data=data,
+        if state_update.absorbance_reader_state_update != update_types.NO_CHANGE:
+            self._handle_absorbance_reader_commands(
+                state_update.absorbance_reader_state_update
             )
 
     def _add_module_substate(
@@ -589,50 +559,61 @@ class ModuleStore(HasState[ModuleState], HandlesActions):
             )
 
     def _handle_absorbance_reader_commands(
-        self,
-        command: Union[
-            absorbance_reader.Initialize,
-            absorbance_reader.ReadAbsorbance,
-        ],
+        self, absorbance_reader_state_update: AbsorbanceReaderStateUpdate
     ) -> None:
-        module_id = command.params.moduleId
+        # Get current values:
+        module_id = absorbance_reader_state_update.module_id
         absorbance_reader_substate = self._state.substate_by_module_id[module_id]
         assert isinstance(
             absorbance_reader_substate, AbsorbanceReaderSubState
         ), f"{module_id} is not an absorbance plate reader."
-
-        # Get current values
+        is_lid_on = absorbance_reader_substate.is_lid_on
+        measured = True
         configured = absorbance_reader_substate.configured
         measure_mode = absorbance_reader_substate.measure_mode
         configured_wavelengths = absorbance_reader_substate.configured_wavelengths
         reference_wavelength = absorbance_reader_substate.reference_wavelength
-        is_lid_on = absorbance_reader_substate.is_lid_on
-
-        if isinstance(command.result, absorbance_reader.InitializeResult):
-            self._state.substate_by_module_id[module_id] = AbsorbanceReaderSubState(
-                module_id=AbsorbanceReaderId(module_id),
-                configured=True,
-                measured=False,
-                is_lid_on=is_lid_on,
-                measure_mode=AbsorbanceReaderMeasureMode(command.params.measureMode),
-                configured_wavelengths=command.params.sampleWavelengths,
-                reference_wavelength=command.params.referenceWavelength,
-                data=None,
+        data = absorbance_reader_substate.data
+        if (
+            absorbance_reader_state_update.absorbance_reader_lid
+            != update_types.NO_CHANGE
+        ):
+            is_lid_on = absorbance_reader_state_update.absorbance_reader_lid.is_lid_on
+        elif (
+            absorbance_reader_state_update.initialize_absorbance_reader_update
+            != update_types.NO_CHANGE
+        ):
+            configured = True
+            measured = False
+            is_lid_on = is_lid_on
+            measure_mode = AbsorbanceReaderMeasureMode(
+                absorbance_reader_state_update.initialize_absorbance_reader_update.measure_mode
             )
-        elif isinstance(command.result, absorbance_reader.ReadAbsorbanceResult):
-            self._state.substate_by_module_id[module_id] = AbsorbanceReaderSubState(
-                module_id=AbsorbanceReaderId(module_id),
-                configured=configured,
-                measured=True,
-                is_lid_on=is_lid_on,
-                measure_mode=measure_mode,
-                configured_wavelengths=configured_wavelengths,
-                reference_wavelength=reference_wavelength,
-                data=command.result.data,
+            configured_wavelengths = (
+                absorbance_reader_state_update.initialize_absorbance_reader_update.sample_wave_lengths
+            )
+            reference_wavelength = (
+                absorbance_reader_state_update.initialize_absorbance_reader_update.reference_wave_length
             )
+            data = None
+        elif (
+            absorbance_reader_state_update.absorbance_reader_data
+            != update_types.NO_CHANGE
+        ):
+            data = absorbance_reader_state_update.absorbance_reader_data.read_result
+        self._state.substate_by_module_id[module_id] = AbsorbanceReaderSubState(
+            module_id=AbsorbanceReaderId(module_id),
+            configured=configured,
+            measured=measured,
+            is_lid_on=is_lid_on,
+            measure_mode=measure_mode,
+            configured_wavelengths=configured_wavelengths,
+            reference_wavelength=reference_wavelength,
+            data=data,
+        )
 
 
-class ModuleView(HasState[ModuleState]):
+class ModuleView:
     """Read-only view of computed module state."""
 
     _state: ModuleState
@@ -654,7 +635,7 @@ class ModuleView(HasState[ModuleState]):
             DeckSlotLocation(slotName=slot_name) if slot_name is not None else None
         )
 
-        return LoadedModule.construct(
+        return LoadedModule.model_construct(
             id=module_id,
             location=location,
             model=attached_module.definition.model,
@@ -860,8 +841,8 @@ class ModuleView(HasState[ModuleState]):
         Labware Position Check offset.
         """
         if (
-            self.state.deck_type == DeckType.OT2_STANDARD
-            or self.state.deck_type == DeckType.OT2_SHORT_TRASH
+            self._state.deck_type == DeckType.OT2_STANDARD
+            or self._state.deck_type == DeckType.OT2_SHORT_TRASH
         ):
             definition = self.get_definition(module_id)
             slot = self.get_location(module_id).slotName.id
@@ -908,7 +889,7 @@ class ModuleView(HasState[ModuleState]):
                     "Module location invalid for nominal module offset calculation."
                 )
             module_addressable_area = self.ensure_and_convert_module_fixture_location(
-                location, self.state.deck_type, module.model
+                location, module.model
             )
             module_addressable_area_position = (
                 addressable_areas.get_addressable_area_offsets_from_cutout(
@@ -1281,13 +1262,14 @@ class ModuleView(HasState[ModuleState]):
     def ensure_and_convert_module_fixture_location(
         self,
         deck_slot: DeckSlotName,
-        deck_type: DeckType,
         model: ModuleModel,
     ) -> str:
         """Ensure module fixture load location is valid.
 
         Also, convert the deck slot to a valid module fixture addressable area.
         """
+        deck_type = self._state.deck_type
+
         if deck_type == DeckType.OT2_STANDARD or deck_type == DeckType.OT2_SHORT_TRASH:
             raise ValueError(
                 f"Invalid Deck Type: {deck_type.name} - Does not support modules as fixtures."

opentrons/protocol_engine/state/motion.py

@@ -327,6 +327,7 @@ class MotionView:
         labware_id: str,
         well_name: str,
         center_point: Point,
+        mm_from_edge: float = 0,
         radius: float = 1.0,
     ) -> List[motion_planning.Waypoint]:
         """Get a list of touch points for a touch tip operation."""
@@ -346,7 +347,11 @@ class MotionView:
         )
 
         positions = _move_types.get_edge_point_list(
-            center_point, x_offset, y_offset, edge_path_type
+            center=center_point,
+            x_radius=x_offset,
+            y_radius=y_offset,
+            mm_from_edge=mm_from_edge,
+            edge_path_type=edge_path_type,
         )
         critical_point: Optional[CriticalPoint] = None
 

opentrons/protocol_engine/state/pipettes.py

@@ -1,28 +1,33 @@
 """Basic pipette data state and store."""
+
 from __future__ import annotations
 
 import dataclasses
+from logging import getLogger
 from typing import (
     Dict,
     List,
     Mapping,
     Optional,
     Tuple,
-    Union,
+    cast,
 )
 
+from typing_extensions import assert_never
+
 from opentrons_shared_data.pipette import pipette_definition
+from opentrons_shared_data.pipette.ul_per_mm import calculate_ul_per_mm
+from opentrons_shared_data.pipette.types import UlPerMmAction
+
 from opentrons.config.defaults_ot2 import Z_RETRACT_DISTANCE
 from opentrons.hardware_control.dev_types import PipetteDict
 from opentrons.hardware_control import CriticalPoint
 from opentrons.hardware_control.nozzle_manager import (
-    NozzleConfigurationType,
     NozzleMap,
 )
-from opentrons.types import MountType, Mount as HwMount, Point
+from opentrons.types import MountType, Mount as HwMount, Point, NozzleConfigurationType
 
-from . import update_types
-from .. import commands
+from . import update_types, fluid_stack
 from .. import errors
 from ..types import (
     LoadedPipette,
@@ -36,13 +41,13 @@ from ..types import (
 )
 from ..actions import (
     Action,
-    FailCommandAction,
     SetPipetteMovementSpeedAction,
-    SucceedCommandAction,
     get_state_updates,
 )
 from ._abstract_store import HasState, HandlesActions
 
+LOG = getLogger(__name__)
+
 
 @dataclasses.dataclass(frozen=True)
 class HardwarePipette:
@@ -98,6 +103,8 @@ class StaticPipetteConfig:
     bounding_nozzle_offsets: BoundingNozzlesOffsets
     default_nozzle_map: NozzleMap  # todo(mm, 2024-10-14): unused, remove?
     lld_settings: Optional[Dict[str, Dict[str, float]]]
+    plunger_positions: Dict[str, float]
+    shaft_ul_per_mm: float
     available_sensors: pipette_definition.AvailableSensorDefinition
 
 
@@ -109,7 +116,7 @@ class PipetteState:
     # attributes are populated at the appropriate times. Refactor to a
     # single dict-of-many-things instead of many dicts-of-single-things.
     pipettes_by_id: Dict[str, LoadedPipette]
-    aspirated_volume_by_id: Dict[str, Optional[float]]
+    pipette_contents_by_id: Dict[str, Optional[fluid_stack.FluidStack]]
     current_location: Optional[CurrentPipetteLocation]
     current_deck_point: CurrentDeckPoint
     attached_tip_by_id: Dict[str, Optional[TipGeometry]]
@@ -129,7 +136,7 @@ class PipetteStore(HasState[PipetteState], HandlesActions):
         """Initialize a PipetteStore and its state."""
         self._state = PipetteState(
             pipettes_by_id={},
-            aspirated_volume_by_id={},
+            pipette_contents_by_id={},
             attached_tip_by_id={},
             current_location=None,
             current_deck_point=CurrentDeckPoint(mount=None, deck_point=None),
@@ -148,11 +155,9 @@ class PipetteStore(HasState[PipetteState], HandlesActions):
             self._update_pipette_config(state_update)
             self._update_pipette_nozzle_map(state_update)
             self._update_tip_state(state_update)
+            self._update_volumes(state_update)
 
-        if isinstance(action, (SucceedCommandAction, FailCommandAction)):
-            self._update_volumes(action)
-
-        elif isinstance(action, SetPipetteMovementSpeedAction):
+        if isinstance(action, SetPipetteMovementSpeedAction):
             self._state.movement_speed_by_id[action.pipette_id] = action.speed
 
     def _set_load_pipette(self, state_update: update_types.StateUpdate) -> None:
@@ -167,7 +172,6 @@ class PipetteStore(HasState[PipetteState], HandlesActions):
             self._state.liquid_presence_detection_by_id[pipette_id] = (
                 state_update.loaded_pipette.liquid_presence_detection or False
             )
-            self._state.aspirated_volume_by_id[pipette_id] = None
             self._state.movement_speed_by_id[pipette_id] = None
             self._state.attached_tip_by_id[pipette_id] = None
 
@@ -178,7 +182,6 @@ class PipetteStore(HasState[PipetteState], HandlesActions):
                 attached_tip = state_update.pipette_tip_state.tip_geometry
 
                 self._state.attached_tip_by_id[pipette_id] = attached_tip
-                self._state.aspirated_volume_by_id[pipette_id] = 0
 
                 static_config = self._state.static_config_by_id.get(pipette_id)
                 if static_config:
@@ -205,7 +208,6 @@ class PipetteStore(HasState[PipetteState], HandlesActions):
 
             else:
                 pipette_id = state_update.pipette_tip_state.pipette_id
-                self._state.aspirated_volume_by_id[pipette_id] = None
                 self._state.attached_tip_by_id[pipette_id] = None
 
                 static_config = self._state.static_config_by_id.get(pipette_id)
@@ -293,6 +295,8 @@ class PipetteStore(HasState[PipetteState], HandlesActions):
                 ),
                 default_nozzle_map=config.nozzle_map,
                 lld_settings=config.pipette_lld_settings,
+                plunger_positions=config.plunger_positions,
+                shaft_ul_per_mm=config.shaft_ul_per_mm,
                 available_sensors=config.available_sensors,
             )
             self._state.flow_rates_by_id[
@@ -310,54 +314,43 @@ class PipetteStore(HasState[PipetteState], HandlesActions):
                 state_update.pipette_nozzle_map.pipette_id
             ] = state_update.pipette_nozzle_map.nozzle_map
 
-    def _update_volumes(
-        self, action: Union[SucceedCommandAction, FailCommandAction]
+    def _update_volumes(self, state_update: update_types.StateUpdate) -> None:
+        if state_update.pipette_aspirated_fluid == update_types.NO_CHANGE:
+            return
+        if state_update.pipette_aspirated_fluid.type == "aspirated":
+            self._update_aspirated(state_update.pipette_aspirated_fluid)
+        elif state_update.pipette_aspirated_fluid.type == "ejected":
+            self._update_ejected(state_update.pipette_aspirated_fluid)
+        elif state_update.pipette_aspirated_fluid.type == "empty":
+            self._update_empty(state_update.pipette_aspirated_fluid)
+        elif state_update.pipette_aspirated_fluid.type == "unknown":
+            self._update_unknown(state_update.pipette_aspirated_fluid)
+        else:
+            assert_never(state_update.pipette_aspirated_fluid.type)
+
+    def _update_aspirated(
+        self, update: update_types.PipetteAspiratedFluidUpdate
     ) -> None:
-        # todo(mm, 2024-10-10): Port these isinstance checks to StateUpdate.
-        # https://opentrons.atlassian.net/browse/EXEC-754
+        self._fluid_stack_log_if_empty(update.pipette_id).add_fluid(update.fluid)
 
-        if isinstance(action, SucceedCommandAction) and isinstance(
-            action.command.result,
-            (commands.AspirateResult, commands.AspirateInPlaceResult),
-        ):
-            pipette_id = action.command.params.pipetteId
-            previous_volume = self._state.aspirated_volume_by_id[pipette_id] or 0
-            # PipetteHandler will have clamped action.command.result.volume for us, so
-            # next_volume should always be in bounds.
-            next_volume = previous_volume + action.command.result.volume
+    def _update_ejected(self, update: update_types.PipetteEjectedFluidUpdate) -> None:
+        self._fluid_stack_log_if_empty(update.pipette_id).remove_fluid(update.volume)
 
-            self._state.aspirated_volume_by_id[pipette_id] = next_volume
+    def _update_empty(self, update: update_types.PipetteEmptyFluidUpdate) -> None:
+        self._state.pipette_contents_by_id[update.pipette_id] = fluid_stack.FluidStack()
 
-        elif isinstance(action, SucceedCommandAction) and isinstance(
-            action.command.result,
-            (commands.DispenseResult, commands.DispenseInPlaceResult),
-        ):
-            pipette_id = action.command.params.pipetteId
-            previous_volume = self._state.aspirated_volume_by_id[pipette_id] or 0
-            # PipetteHandler will have clamped action.command.result.volume for us, so
-            # next_volume should always be in bounds.
-            next_volume = previous_volume - action.command.result.volume
-            self._state.aspirated_volume_by_id[pipette_id] = next_volume
-
-        elif isinstance(action, SucceedCommandAction) and isinstance(
-            action.command.result,
-            (
-                commands.BlowOutResult,
-                commands.BlowOutInPlaceResult,
-                commands.unsafe.UnsafeBlowOutInPlaceResult,
-            ),
-        ):
-            pipette_id = action.command.params.pipetteId
-            self._state.aspirated_volume_by_id[pipette_id] = None
+    def _update_unknown(self, update: update_types.PipetteUnknownFluidUpdate) -> None:
+        self._state.pipette_contents_by_id[update.pipette_id] = None
 
-        elif isinstance(action, SucceedCommandAction) and isinstance(
-            action.command.result, commands.PrepareToAspirateResult
-        ):
-            pipette_id = action.command.params.pipetteId
-            self._state.aspirated_volume_by_id[pipette_id] = 0
+    def _fluid_stack_log_if_empty(self, pipette_id: str) -> fluid_stack.FluidStack:
+        stack = self._state.pipette_contents_by_id[pipette_id]
+        if stack is None:
+            LOG.error("Pipette state tried to alter an unknown-contents pipette")
+            return fluid_stack.FluidStack()
+        return stack
 
 
-class PipetteView(HasState[PipetteState]):
+class PipetteView:
     """Read-only view of computed pipettes state."""
 
     _state: PipetteState
@@ -459,6 +452,10 @@ class PipetteView(HasState[PipetteState]):
     def get_aspirated_volume(self, pipette_id: str) -> Optional[float]:
         """Get the currently aspirated volume of a pipette by ID.
 
+        This is the volume currently displaced by the plunger relative to its bottom position,
+        regardless of whether that volume likely contains liquid or air. This makes it the right
+        function to call to know how much more volume the plunger may displace.
+
         Returns:
             The volume the pipette has aspirated.
             None, after blow-out and the plunger is in an unsafe position.
@@ -470,13 +467,50 @@ class PipetteView(HasState[PipetteState]):
         self.validate_tip_state(pipette_id, True)
 
         try:
-            return self._state.aspirated_volume_by_id[pipette_id]
+            stack = self._state.pipette_contents_by_id[pipette_id]
+            if stack is None:
+                return None
+            return stack.aspirated_volume()
 
         except KeyError as e:
             raise errors.PipetteNotLoadedError(
                 f"Pipette {pipette_id} not found; unable to get current volume."
             ) from e
 
+    def get_liquid_dispensed_by_ejecting_volume(
+        self, pipette_id: str, volume: float
+    ) -> Optional[float]:
+        """Get the amount of liquid (not air) that will be dispensed if the pipette ejects a specified volume.
+
+        For instance, if the pipette contains, in vertical order,
+        10 ul air
+        80 ul liquid
+        5 ul air
+
+        then dispensing 10ul would result in 5ul of liquid; dispensing 85 ul would result in 80ul liquid; dispensing
+        95ul would result in 80ul liquid.
+
+        Returns:
+            The volume of liquid that would be dispensed by the requested volume.
+            None, after blow-out or when the plunger is in an unsafe position.
+
+        Raises:
+            PipetteNotLoadedError: pipette ID does not exist.
+            TipnotAttachedError: No tip is attached to the pipette.
+        """
+        self.validate_tip_state(pipette_id, True)
+
+        try:
+            stack = self._state.pipette_contents_by_id[pipette_id]
+            if stack is None:
+                return None
+            return stack.liquid_part_of_dispense_volume(volume)
+
+        except KeyError as e:
+            raise errors.PipetteNotLoadedError(
+                f"Pipette {pipette_id} not found; unable to get current liquid volume."
+            ) from e
+
     def get_working_volume(self, pipette_id: str) -> float:
         """Get the working maximum volume of a pipette by ID.
 
@@ -643,6 +677,10 @@ class PipetteView(HasState[PipetteState]):
         nozzle_map = self._state.nozzle_configuration_by_id[pipette_id]
         return nozzle_map.starting_nozzle
 
+    def get_nozzle_configuration(self, pipette_id: str) -> NozzleMap:
+        """Get the nozzle map of the pipette."""
+        return self._state.nozzle_configuration_by_id[pipette_id]
+
     def _get_critical_point_offset_without_tip(
         self, pipette_id: str, critical_point: Optional[CriticalPoint]
     ) -> Point:
@@ -740,3 +778,42 @@ class PipetteView(HasState[PipetteState]):
             raise errors.PipetteNotLoadedError(
                 f"Pipette {pipette_id} not found; unable to determine if pipette liquid presence detection enabled."
             ) from e
+
+    def get_nozzle_configuration_supports_lld(self, pipette_id: str) -> bool:
+        """Determine if the current partial tip configuration supports LLD."""
+        nozzle_map = self.get_nozzle_configuration(pipette_id)
+        if (
+            nozzle_map.physical_nozzle_count == 96
+            and nozzle_map.back_left != nozzle_map.full_instrument_back_left
+            and nozzle_map.front_right != nozzle_map.full_instrument_front_right
+        ):
+            return False
+        return True
+
+    def lookup_volume_to_mm_conversion(
+        self, pipette_id: str, volume: float, action: str
+    ) -> float:
+        """Get the volumn to mm conversion for a pipette."""
+        try:
+            lookup_volume = self.get_working_volume(pipette_id)
+        except errors.TipNotAttachedError:
+            lookup_volume = self.get_maximum_volume(pipette_id)
+
+        pipette_config = self.get_config(pipette_id)
+        lookup_table_from_config = pipette_config.tip_configuration_lookup_table
+        try:
+            tip_settings = lookup_table_from_config[lookup_volume]
+        except KeyError:
+            tip_settings = list(lookup_table_from_config.values())[0]
+        return calculate_ul_per_mm(
+            volume,
+            cast(UlPerMmAction, action),
+            tip_settings,
+            shaft_ul_per_mm=pipette_config.shaft_ul_per_mm,
+        )
+
+    def lookup_plunger_position_name(
+        self, pipette_id: str, position_name: str
+    ) -> float:
+        """Get the plunger position provided for the given pipette id."""
+        return self.get_config(pipette_id).plunger_positions[position_name]